test: expand coverage for cli and APIs

Author: aborruso

tests/test_akoma_utils.py

@@ -0,0 +1,74 @@
+import tempfile
+import unittest
+
+from normattiva2md.akoma_utils import (
+    akoma_uri_to_normattiva_url,
+    extract_akoma_uris_from_xml,
+    extract_cited_laws,
+    parse_article_reference,
+)
+from normattiva2md.constants import AKN_NAMESPACE
+
+
+class TestAkomaUtils(unittest.TestCase):
+    def test_parse_article_reference(self):
+        url = "https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2020-01-01;1~art16bis"
+        self.assertEqual(parse_article_reference(url), "art_16bis")
+        self.assertIsNone(parse_article_reference(123))
+        self.assertIsNone(parse_article_reference("https://www.normattiva.it/"))
+
+    def test_akoma_uri_to_normattiva_url_with_article(self):
+        uri = "/akn/it/act/legge/stato/2003-07-29/229/!main#art_1"
+        url = akoma_uri_to_normattiva_url(uri)
+        self.assertTrue(url.endswith("~art1"))
+        self.assertTrue(url.startswith("https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2003-07-29;229"))
+
+    def test_akoma_uri_to_normattiva_url_ignores_article_for_costituzione(self):
+        uri = "/akn/it/act/costituzione/stato/1948-01-01/1/!main#art_1"
+        url = akoma_uri_to_normattiva_url(uri)
+        self.assertTrue(url.startswith("https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:costituzione:1948-01-01"))
+        self.assertNotIn("~art", url)
+
+    def test_akoma_uri_to_normattiva_url_unknown_type(self):
+        uri = "/akn/it/act/unknown/stato/2003-07-29/229/!main"
+        self.assertIsNone(akoma_uri_to_normattiva_url(uri))
+
+    def test_extract_akoma_uris_from_xml(self):
+        xml = (
+            f"<akn:akomaNtoso xmlns:akn=\"{AKN_NAMESPACE['akn']}\">"
+            "<akn:doc>"
+            "<akn:ref href=\"/akn/it/act/legge/stato/2003-07-29/229/!main#art_1\"/>"
+            "<akn:ref href=\"/akn/it/act/legge/stato/2004-01-01/10/!main\"/>"
+            "<akn:ref href=\"https://example.com\"/>"
+            "</akn:doc>"
+            "</akn:akomaNtoso>"
+        )
+        with tempfile.NamedTemporaryFile("w", suffix=".xml", delete=False) as tmp:
+            tmp.write(xml)
+            tmp_path = tmp.name
+
+        uris = extract_akoma_uris_from_xml(tmp_path)
+        self.assertEqual(len(uris), 2)
+        self.assertTrue(any(uri.startswith("/akn/") for uri in uris))
+
+    def test_extract_cited_laws(self):
+        xml = (
+            f"<akn:akomaNtoso xmlns:akn=\"{AKN_NAMESPACE['akn']}\">"
+            "<akn:doc>"
+            "<akn:ref href=\"/akn/it/act/legge/stato/2003-07-29/229/!main#art_1\"/>"
+            "<akn:ref href=\"/akn/it/act/legge/stato/2003-07-29/229/!main#art_2\"/>"
+            "</akn:doc>"
+            "</akn:akomaNtoso>"
+        )
+        with tempfile.NamedTemporaryFile("w", suffix=".xml", delete=False) as tmp:
+            tmp.write(xml)
+            tmp_path = tmp.name
+
+        cited = extract_cited_laws(tmp_path)
+        self.assertEqual(len(cited), 1)
+        only = next(iter(cited))
+        self.assertTrue(only.startswith("https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2003-07-29;229"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_api_conversion.py

@@ -0,0 +1,97 @@
+import tempfile
+import unittest
+from unittest import mock
+
+from normattiva2md.api import convert_url, convert_xml
+from normattiva2md.exceptions import ConversionError, InvalidURLError, XMLFileNotFoundError
+from normattiva2md.constants import AKN_NAMESPACE
+
+
+class TestApiConversion(unittest.TestCase):
+    def _write_xml(self, content):
+        tmp = tempfile.NamedTemporaryFile("w", suffix=".xml", delete=False)
+        tmp.write(content)
+        tmp.flush()
+        return tmp.name
+
+    def _minimal_xml(self):
+        return (
+            f"<akn:akomaNtoso xmlns:akn=\"{AKN_NAMESPACE['akn']}\" "
+            "xmlns:eli=\"http://data.europa.eu/eli/ontology#\">"
+            "<akn:meta>"
+            "<akn:identification>"
+            "<akn:FRBRWork>"
+            "<akn:FRBRalias name=\"urn:nir\" value=\"urn:nir:stato:legge:2003-07-29;229\"/>"
+            "</akn:FRBRWork>"
+            "<akn:FRBRExpression><akn:FRBRdate date=\"2020-01-01\"/></akn:FRBRExpression>"
+            "<eli:id_local>229</eli:id_local>"
+            "<eli:date_document>2003-07-29</eli:date_document>"
+            "</akn:identification>"
+            "</akn:meta>"
+            "<akn:body>"
+            "<akn:article eId=\"art_1\"><akn:content><akn:p>Testo</akn:p></akn:content></akn:article>"
+            "<akn:ref href=\"/akn/it/act/legge/stato/2004-01-01/10/!main#art_2\"/>"
+            "<akn:ref href=\"https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2005-01-01;11\"/>"
+            "</akn:body>"
+            "</akn:akomaNtoso>"
+        )
+
+    def test_convert_xml_missing_file(self):
+        with self.assertRaises(XMLFileNotFoundError):
+            convert_xml("/tmp/does-not-exist.xml")
+
+    def test_convert_xml_parse_error(self):
+        path = self._write_xml("<akn:akomaNtoso")
+        with self.assertRaises(ConversionError):
+            convert_xml(path)
+
+    def test_convert_url_invalid_domain(self):
+        with self.assertRaises(InvalidURLError):
+            convert_url("https://example.com/not-allowed")
+
+    def test_convert_xml_with_urls_builds_cross_references(self):
+        xml_path = self._write_xml(self._minimal_xml())
+
+        with mock.patch("normattiva2md.api.generate_markdown_text", return_value="MD") as mock_generate:
+            result = convert_xml(xml_path, with_urls=True, quiet=True)
+
+        self.assertIsNotNone(result)
+        cross_references = mock_generate.call_args.kwargs["cross_references"]
+        self.assertIn(
+            "https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2004-01-01;10~art2",
+            cross_references,
+        )
+        self.assertIn(
+            "https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2005-01-01;11",
+            cross_references,
+        )
+
+    def test_convert_xml_merges_metadata(self):
+        xml_path = self._write_xml(self._minimal_xml())
+
+        with mock.patch(
+            "normattiva2md.api.extract_metadata_from_xml",
+            return_value={
+                "dataGU": "20200101",
+                "codiceRedaz": "XYZ",
+                "dataVigenza": "20200102",
+                "url": "xml-url",
+            },
+        ):
+            with mock.patch(
+                "normattiva2md.api.generate_markdown_text", return_value="MD"
+            ) as mock_generate:
+                convert_xml(
+                    xml_path,
+                    metadata={"dataGU": "20221212", "custom": "value"},
+                    quiet=True,
+                )
+
+        merged_metadata = mock_generate.call_args.kwargs["metadata"]
+        self.assertEqual(merged_metadata["dataGU"], "20221212")
+        self.assertEqual(merged_metadata["custom"], "value")
+        self.assertEqual(merged_metadata["codiceRedaz"], "XYZ")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_api_convert_url.py

@@ -0,0 +1,50 @@
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+from normattiva2md.api import convert_url
+
+
+class TestApiConvertUrl(unittest.TestCase):
+    def _write_minimal_xml(self, path):
+        content = (
+            '<akn:akomaNtoso xmlns:akn="http://docs.oasis-open.org/legaldocml/ns/akn/3.0">'
+            "<akn:meta/>"
+            "<akn:body/>"
+            "</akn:akomaNtoso>"
+        )
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def test_convert_url_success(self):
+        params = {
+            "dataGU": "20200101",
+            "codiceRedaz": "X",
+            "dataVigenza": "20200102",
+        }
+        with tempfile.TemporaryDirectory() as tmpdir:
+            xml_path = os.path.join(tmpdir, "doc.xml")
+
+            def fake_download(_params, output_path, _session, quiet=False):
+                self._write_minimal_xml(output_path)
+                return True
+
+            with mock.patch(
+                "normattiva2md.api.extract_params_from_normattiva_url",
+                return_value=(params, object()),
+            ), mock.patch(
+                "normattiva2md.api.download_akoma_ntoso",
+                side_effect=fake_download,
+            ):
+                result = convert_url(
+                    "https://www.normattiva.it/uri-res/N2Ls?urn:nir:stato:legge:2020;1",
+                    quiet=True,
+                )
+        self.assertIsNotNone(result)
+        self.assertEqual(result.metadata["codiceRedaz"], "X")
+        self.assertTrue(result.url.startswith("https://www.normattiva.it/uri-res/N2Ls"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_api_search.py

@@ -0,0 +1,48 @@
+import unittest
+from unittest import mock
+
+from normattiva2md.api import search_law
+from normattiva2md.exceptions import APIKeyError
+
+
+class FakeResponse:
+    def __init__(self, status_code=200, payload=None, text=""):
+        self.status_code = status_code
+        self._payload = payload or {}
+        self.text = text
+
+    def json(self):
+        return self._payload
+
+
+class TestApiSearch(unittest.TestCase):
+    def test_search_law_missing_api_key(self):
+        with mock.patch("normattiva2md.api.load_env_file"), mock.patch(
+            "os.getenv", return_value=None
+        ):
+            with self.assertRaises(APIKeyError):
+                search_law("legge stanca", quiet=True)
+
+    def test_search_law_non_200(self):
+        response = FakeResponse(status_code=500, text="error")
+        with mock.patch("normattiva2md.api.load_env_file"), mock.patch(
+            "os.getenv", return_value="key"
+        ), mock.patch(
+            "requests.post", return_value=response
+        ):
+            results = search_law("test", quiet=True)
+        self.assertEqual(results, [])
+
+    def test_search_law_empty_results(self):
+        response = FakeResponse(status_code=200, payload={"results": []})
+        with mock.patch("normattiva2md.api.load_env_file"), mock.patch(
+            "os.getenv", return_value="key"
+        ), mock.patch(
+            "requests.post", return_value=response
+        ):
+            results = search_law("test", quiet=True)
+        self.assertEqual(results, [])
+
+
+if __name__ == "__main__":
+    unittest.main()