211 lines
8.7 KiB
Python
211 lines
8.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
import json
|
|
import pathlib
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from contextlib import redirect_stderr, redirect_stdout
|
|
from io import StringIO
|
|
from unittest import mock
|
|
|
|
from tests import utils
|
|
from vsg import diagnostic_runtime
|
|
|
|
BAD_ENTITY = "entity bad is end entity bad;\n"
|
|
CLEAN_ENTITY = "entity THING is\nend entity THING;\n"
|
|
WARNING_CONFIGURATION = "tests/diagnostics_json/warning.yaml"
|
|
|
|
|
|
def run_vsg(source, *arguments):
|
|
return subprocess.run(
|
|
[*utils.vsg_exec(), "--stdin", "--diagnostics_json", *arguments],
|
|
input=source,
|
|
text=True,
|
|
capture_output=True,
|
|
check=False,
|
|
)
|
|
|
|
|
|
class testDiagnosticsJson(unittest.TestCase):
|
|
def assert_incomplete_document(self, oActual):
|
|
self.assertNotEqual(oActual.returncode, 0)
|
|
self.assertEqual(oActual.stdout.count("\n"), 1)
|
|
dActual = json.loads(oActual.stdout)
|
|
self.assertEqual(dActual["schema"], "vsg.diagnostics")
|
|
self.assertEqual(dActual["schema_version"], 1)
|
|
self.assertFalse(dActual["complete"])
|
|
self.assertEqual(dActual["rules"], {})
|
|
self.assertEqual(dActual["diagnostics"], [])
|
|
self.assertGreater(len(dActual["errors"]), 0)
|
|
|
|
def test_requires_stdin(self):
|
|
oActual = subprocess.run(
|
|
[*utils.vsg_exec(), "--diagnostics_json"],
|
|
text=True,
|
|
capture_output=True,
|
|
check=False,
|
|
)
|
|
|
|
self.assert_incomplete_document(oActual)
|
|
self.assertIn("--diagnostics_json argument requires --stdin argument", oActual.stderr)
|
|
|
|
def test_rejects_conflicting_arguments(self):
|
|
with tempfile.TemporaryDirectory() as sDirectory:
|
|
dConflicts = {
|
|
"--stdout": ["--stdout"],
|
|
"--debug": ["--debug"],
|
|
"--fix": ["--fix"],
|
|
"--json": ["--json", str(pathlib.Path(sDirectory) / "report.json")],
|
|
"--quality_report": ["--quality_report", str(pathlib.Path(sDirectory) / "quality.json")],
|
|
"--output_configuration": ["--output_configuration", str(pathlib.Path(sDirectory) / "configuration.json")],
|
|
"--rule_configuration": ["--rule_configuration", "entity_008"],
|
|
"--version": ["--version"],
|
|
}
|
|
|
|
for sConflict, lArguments in dConflicts.items():
|
|
with self.subTest(argument=sConflict):
|
|
oActual = run_vsg(CLEAN_ENTITY, *lArguments)
|
|
self.assert_incomplete_document(oActual)
|
|
self.assertIn("--diagnostics_json argument cannot be used with " + sConflict, oActual.stderr)
|
|
|
|
def test_emits_versioned_deterministic_document(self):
|
|
oFirst = run_vsg(BAD_ENTITY, "--style", "jcl", "--all_phases", "--no-failure")
|
|
oSecond = run_vsg(BAD_ENTITY, "--style", "jcl", "--all_phases", "--no-failure")
|
|
|
|
self.assertEqual(oFirst.returncode, 0)
|
|
self.assertEqual(oFirst.stderr, "")
|
|
self.assertEqual(oFirst.stdout, oSecond.stdout)
|
|
self.assertEqual(oFirst.stdout.count("\n"), 1)
|
|
|
|
dActual = json.loads(oFirst.stdout)
|
|
self.assertEqual(dActual["schema"], "vsg.diagnostics")
|
|
self.assertEqual(dActual["schema_version"], 1)
|
|
self.assertTrue(dActual["complete"])
|
|
self.assertEqual(dActual["errors"], [])
|
|
self.assertEqual(dActual["tool"]["name"], "vsg")
|
|
self.assertTrue(dActual["tool"]["version"])
|
|
self.assertEqual(dActual["source"], {"name": "stdin"})
|
|
|
|
lDiagnosticRules = [dDiagnostic["rule"] for dDiagnostic in dActual["diagnostics"]]
|
|
self.assertEqual(lDiagnosticRules, sorted(lDiagnosticRules))
|
|
self.assertEqual(set(dActual["rules"]), set(lDiagnosticRules))
|
|
self.assertGreater(len(lDiagnosticRules), 1)
|
|
|
|
for dDiagnostic in dActual["diagnostics"]:
|
|
self.assertEqual(dDiagnostic["location"], {"start_line": 1, "end_line": 1})
|
|
self.assertIsInstance(dDiagnostic["message"], str)
|
|
|
|
dRule = dActual["rules"]["entity_008"]
|
|
self.assertEqual(dRule["severity"], {"name": "Error", "type": "error"})
|
|
self.assertTrue(dRule["fixable"])
|
|
self.assertEqual(dRule["configuration"]["severity"], "Error")
|
|
self.assertEqual(dRule["configuration"]["phase"], dRule["phase"])
|
|
self.assertEqual(
|
|
dRule["documentation"]["rule"],
|
|
"https://vhdl-style-guide.readthedocs.io/en/latest/entity_rules.html#entity-008",
|
|
)
|
|
self.assertTrue(dRule["documentation"]["configuration"].startswith("https://"))
|
|
|
|
def test_findings_preserve_failure_status_without_no_failure(self):
|
|
oActual = run_vsg(BAD_ENTITY, "--style", "jcl", "--all_phases")
|
|
|
|
self.assertEqual(oActual.returncode, 1)
|
|
self.assertEqual(oActual.stderr, "")
|
|
self.assertGreater(len(json.loads(oActual.stdout)["diagnostics"]), 0)
|
|
|
|
def test_clean_source_emits_empty_collections(self):
|
|
oActual = run_vsg(CLEAN_ENTITY, "--style", "jcl", "--all_phases")
|
|
|
|
self.assertEqual(oActual.returncode, 0)
|
|
self.assertEqual(oActual.stderr, "")
|
|
dActual = json.loads(oActual.stdout)
|
|
self.assertEqual(dActual["rules"], {})
|
|
self.assertEqual(dActual["diagnostics"], [])
|
|
|
|
def test_reports_configured_warning_and_unicode_message(self):
|
|
oActual = run_vsg(
|
|
BAD_ENTITY,
|
|
"--configuration",
|
|
WARNING_CONFIGURATION,
|
|
"--all_phases",
|
|
)
|
|
|
|
self.assertEqual(oActual.returncode, 0)
|
|
self.assertEqual(oActual.stderr, "")
|
|
self.assertIn("Réparer 🚀", oActual.stdout)
|
|
dActual = json.loads(oActual.stdout)
|
|
self.assertEqual(set(dActual["rules"]), {"entity_008"})
|
|
self.assertEqual(dActual["rules"]["entity_008"]["severity"], {"name": "Advisory", "type": "warning"})
|
|
self.assertIn("Réparer 🚀", dActual["diagnostics"][0]["message"])
|
|
|
|
def test_reports_non_fixable_rule(self):
|
|
oActual = run_vsg("", "--all_phases", "--no-failure")
|
|
|
|
self.assertEqual(oActual.returncode, 0)
|
|
dActual = json.loads(oActual.stdout)
|
|
self.assertFalse(dActual["rules"]["source_file_001"]["fixable"])
|
|
self.assertEqual(dActual["diagnostics"][0]["location"], {"start_line": 1, "end_line": 1})
|
|
|
|
def test_local_rule_has_no_guessed_documentation(self):
|
|
sSource = pathlib.Path("tests/vsg/entity_architecture.vhd").read_text(encoding="utf-8")
|
|
oActual = run_vsg(
|
|
sSource,
|
|
"--style",
|
|
"jcl",
|
|
"--local_rules",
|
|
"tests/vsg/local_rules",
|
|
"--all_phases",
|
|
"--no-failure",
|
|
)
|
|
|
|
self.assertEqual(oActual.returncode, 0)
|
|
dDocumentation = json.loads(oActual.stdout)["rules"]["None_001"]["documentation"]
|
|
self.assertEqual(dDocumentation, {"rule": None, "configuration": None})
|
|
|
|
def test_invalid_configuration_emits_incomplete_document(self):
|
|
oActual = run_vsg(
|
|
CLEAN_ENTITY,
|
|
"--configuration",
|
|
"tests/vsg/config_error.json",
|
|
)
|
|
|
|
self.assert_incomplete_document(oActual)
|
|
self.assertIn("ERROR: Invalid configuration file", oActual.stderr)
|
|
|
|
def test_invalid_vhdl_emits_incomplete_document(self):
|
|
oActual = run_vsg("entity incomplete is\n", "--all_phases", "--no-failure")
|
|
|
|
self.assert_incomplete_document(oActual)
|
|
self.assertIn("Error while processing stdin", oActual.stderr)
|
|
dError = json.loads(oActual.stdout)["errors"][0]
|
|
self.assertEqual(dError["kind"], "syntax")
|
|
self.assertEqual(dError["location"], {"line": 1, "column": 1})
|
|
self.assertIn("Unexpected token while parsing entity_declaration", dError["message"])
|
|
self.assertIn("expected `end`", dError["message"])
|
|
|
|
def test_guard_replaces_invalid_json_and_unexpected_exceptions(self):
|
|
def invalid_json():
|
|
print("not JSON")
|
|
|
|
def unexpected_exception():
|
|
raise RuntimeError("unexpected failure")
|
|
|
|
for fMain, sKind in ((invalid_json, "protocol"), (unexpected_exception, "internal")):
|
|
with self.subTest(kind=sKind):
|
|
oStdout = StringIO()
|
|
oStderr = StringIO()
|
|
with mock.patch.object(sys, "argv", ["vsg", "--diagnostics_json"]):
|
|
with redirect_stdout(oStdout), redirect_stderr(oStderr):
|
|
with self.assertRaises(SystemExit) as oExit:
|
|
diagnostic_runtime.run(fMain)
|
|
|
|
self.assertEqual(oExit.exception.code, 1)
|
|
dActual = json.loads(oStdout.getvalue())
|
|
self.assertFalse(dActual["complete"])
|
|
self.assertEqual(dActual["errors"][0]["kind"], sKind)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|