vhdl-style-guide/tests/diagnostics_json/test_diagnostics_json.py

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()