VED-789: improving coverage: test for parsers

Author: Akol125

lambdas/shared/tests/test_common/validator/schemas/Schema.json

@@ -0,0 +1,36 @@
+import unittest
+
+from common.validator.parsers.csv_line_parser import CSVLineParser
+
+
+class TestCSVLineParser(unittest.TestCase):
+    def test_parse_normal(self):
+        p = CSVLineParser()
+        p.parse_csv_line("9011011,Tom,32", "nhs_number,name,age")
+        self.assertEqual(p.csv_file_data, {"nhs_number": "9011011", "name": "Tom", "age": "32"})
+        self.assertEqual(p.get_key_value("name"), ["Tom"])
+
+    def test_extra_values_ignored(self):
+        p = CSVLineParser()
+        p.parse_csv_line("1,2,3", "a,b")
+        self.assertEqual(p.csv_file_data, {"a": "1", "b": "2"})
+        self.assertEqual(p.get_key_value("b"), ["2"])
+
+    def test_fewer_values_missing_key_raises(self):
+        p = CSVLineParser()
+        p.parse_csv_line("alpha,beta", "a,b,c")
+        self.assertIn("a", p.csv_file_data)
+        self.assertIn("b", p.csv_file_data)
+        self.assertNotIn("c", p.csv_file_data)
+        with self.assertRaises(KeyError):
+            _ = p.get_key_value("c")
+
+    def test_get_missing_key_raises(self):
+        p = CSVLineParser()
+        p.parse_csv_line("1,2", "a,b")
+        with self.assertRaises(KeyError):
+            _ = p.get_key_value("z")
+
+
+if __name__ == "__main__":
+    unittest.main()

lambdas/shared/tests/test_common/validator/test_csv_line_parser.py

@@ -0,0 +1,38 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from common.validator.parsers.csv_parser import CSVParser
+
+
+class TestCSVParser(unittest.TestCase):
+    def _write_temp_csv(self, content: str) -> str:
+        fd, path = tempfile.mkstemp(suffix=".csv")
+        Path(path).write_text(content, encoding="utf-8")
+        return path
+
+    def test_parse_file_with_pipe_delimiter(self):
+        csv_content = "nhs|name|age\n9011011|Tom|32\n9011012|Ana|27\n"
+        path = self._write_temp_csv(csv_content)
+        try:
+            p = CSVParser()
+            p.parse_csv_file(path, delimiter="|")
+            self.assertEqual(p.get_key_value("name"), ["Tom", "Ana"])
+            self.assertEqual(p.get_key_value("nhs"), ["9011011", "9011012"])
+        finally:
+            Path(path).unlink(missing_ok=True)
+
+    def test_missing_column_raises_keyerror(self):
+        csv_content = "a|b\n1|2\n"
+        path = self._write_temp_csv(csv_content)
+        try:
+            p = CSVParser()
+            p.parse_csv_file(path, delimiter="|")
+            with self.assertRaises(KeyError):
+                _ = p.get_key_value("c")
+        finally:
+            Path(path).unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

lambdas/shared/tests/test_common/validator/test_csv_parser.py

@@ -0,0 +1,24 @@
+import unittest
+
+from common.validator.lookup_expressions.lookup_data import LookUpData
+
+
+class TestLookUpData(unittest.TestCase):
+    def setUp(self):
+        self.lookup = LookUpData()
+
+    def test_valid_lookup_returns_text(self):
+        self.assertEqual(self.lookup.find_lookup("368208006"), "Left upper arm structure")
+
+    def test_unknown_code_returns_empty_string(self):
+        self.assertEqual(self.lookup.find_lookup("not_a_code"), "")
+
+    def test_none_returns_empty_string(self):
+        self.assertEqual(self.lookup.find_lookup(None), "")
+
+    def test_non_string_input_returns_empty_string(self):
+        self.assertEqual(self.lookup.find_lookup(12345), "")
+
+
+if __name__ == "__main__":
+    unittest.main()

lambdas/shared/tests/test_common/validator/test_lookup_data.py

@@ -0,0 +1,45 @@
+import unittest
+
+from common.validator.parsers.schema_parser import SchemaParser
+
+
+class TestSchemaParser(unittest.TestCase):
+    def test_parse_and_count_expressions(self):
+        schema = {
+            "expressions": [
+                {"expression": "LOOKUP", "field": "route"},
+                {"field": "no-op"},  # missing 'expression' should not be counted
+                {"expression": "KEYCHECK", "field": "site"},
+            ]
+        }
+        p = SchemaParser()
+        p.parse_schema(schema)
+        self.assertEqual(p.expression_count(), 2)
+
+    def test_get_expression_by_index(self):
+        schema = {
+            "expressions": [
+                {"expression": "A", "field": "x"},
+                {"expression": "B", "field": "y"},
+            ]
+        }
+        p = SchemaParser()
+        p.parse_schema(schema)
+        self.assertEqual(p.get_expression(0), {"expression": "A", "field": "x"})
+        self.assertEqual(p.get_expression(1), {"expression": "B", "field": "y"})
+        with self.assertRaises(IndexError):
+            _ = p.get_expression(2)
+
+    def test_get_expressions_returns_all(self):
+        expressions = [
+            {"expression": "A", "field": "x"},
+            {"expression": "B", "field": "y"},
+            {"field": "ignored"},
+        ]
+        p = SchemaParser()
+        p.parse_schema({"expressions": expressions})
+        self.assertEqual(p.get_expressions(), expressions)
+
+
+if __name__ == "__main__":
+    unittest.main()