Add missing unit tests and get them passing (#10)

blms · blms · commit 9839dff33d52 · 2025-04-09T12:51:37.000-04:00
diff --git a/neuxml/schema_data/fixtures/mods-3-4.xsd b/neuxml/schema_data/fixtures/mods-3-4.xsd
diff --git a/pytest.ini b/pytest.ini
@@ -1,2 +1,2 @@
 [pytest]
-python_files = "test/**/*.py"
+python_files = "test/**.py"
diff --git a/test/test_catalog.py b/test/test_catalog.py
@@ -1,4 +1,5 @@
 """Unit Test for Catalog.py. Tests for download of schemas and catalog generation"""
+
 # file test_xmlmap/test_core.py
 #
 #   Copyright 2011 Emory University Libraries
@@ -19,21 +20,47 @@
 
 import os
 import unittest
+from unittest.mock import patch
 import tempfile
 import glob
 import shutil
 from datetime import date
 import neuxml
 from lxml import etree
-from neuxml.catalog import download_schema, refresh_catalog
+from neuxml import catalog
+from requests.exceptions import HTTPError
+
+
+CORRECT_SCHEMA = "http://www.loc.gov/standards/mods/v3/mods-3-4.xsd"
+WRONG_SCHEMA = "http://www.loc.gov/standards/mods/v3/mods34.xsd"
+
+
+def mocked_requests_get(*args, **kwargs):
+    class MockResponse:
+        def __init__(self, status_code):
+            self.status_code = status_code
+
+        def iter_content(self, chunk_size):
+            with open("neuxml/schema_data/fixtures/mods-3-4.xsd", "rb") as file:
+                while True:
+                    chunk = file.read(chunk_size)
+                    if not chunk:
+                        break
+                    yield chunk
+
+        def raise_for_status(self):
+            if self.status_code != 200:
+                raise HTTPError(response=self)
+
+    if args[0] == CORRECT_SCHEMA:
+        return MockResponse(200)
+    return MockResponse(404)
 
 
 class TestGenerateSchema(unittest.TestCase):
     """:class:`TestGenerateSchema` class for Catalog testing"""
 
     def setUp(self):
-        self.correct_schema = "http://www.loc.gov/standards/mods/v3/mods-3-4.xsd"
-        self.wrong_schema = "http://www.loc.gov/standards/mods/v3/mods34.xsd"
         self.comment = "Downloaded by neuxml %s on %s" % (
             neuxml.__version__,
             date.today().isoformat(),
@@ -45,21 +72,24 @@ def tearDown(self):
         if os.path.isdir(self.path):
             shutil.rmtree(self.path)
 
-    def test_download_xml_schemas(self):
+    @patch("requests.get", side_effect=mocked_requests_get)
+    def test_download_xml_schemas(self, mock_get):
         """Check if xsd schemas exist and download fresh copies"""
-        filename = os.path.basename(self.correct_schema)
+        filename = os.path.basename(CORRECT_SCHEMA)
         schema_path = os.path.join(self.path, filename)
         # do files already exist
         check_xsds = len(glob.glob("".join([self.path, "*.xsd"])))
         self.assertEqual(0, check_xsds)
 
         # downloading the wrong schema
-        response_wrong = download_schema(self.wrong_schema, schema_path, comment=None)
+        response_wrong = catalog.download_schema(
+            WRONG_SCHEMA, schema_path, comment=None
+        )
         self.assertFalse(response_wrong)
 
         # downloading the right schemas
-        response_correct = download_schema(
-            self.correct_schema, schema_path, comment=None
+        response_correct = catalog.download_schema(
+            CORRECT_SCHEMA, schema_path, comment=None
         )
         self.assertTrue(response_correct)
 
@@ -70,7 +100,7 @@ def test_download_xml_schemas(self):
         self.assertFalse(b"by neuxml" in schema_string_no_comment)
 
         # Add comment and check if it is there now
-        download_schema(self.correct_schema, schema_path, comment=self.comment)
+        catalog.download_schema(CORRECT_SCHEMA, schema_path, comment=self.comment)
         tree = etree.parse(schema_path)
         schema_string_with_comment = etree.tostring(tree)
         self.assertTrue(b"by neuxml" in schema_string_with_comment)
@@ -85,28 +115,31 @@ def test_generate_xml_catalog(self):
         check_catalog = len(glob.glob("".join([self.path, "/catalog.xml"])))
         self.assertEqual(0, check_catalog)
         catalog_file = os.path.join(self.path, "catalog.xml")
-        filename = os.path.basename(self.correct_schema)
+        filename = os.path.basename(CORRECT_SCHEMA)
         # generate empty catalog xml object
-        catalog = refresh_catalog(
-            xsd_schemas=[self.correct_schema],
-            xmlcatalog_dir=self.path,
-            xmlcatalog_file=catalog_file,
-        )
+        with patch.object(catalog, "download_schema", return_value=True):
+            gen_catalog = catalog.refresh_catalog(
+                xsd_schemas=[CORRECT_SCHEMA],
+                xmlcatalog_dir=self.path,
+                xmlcatalog_file=catalog_file,
+            )
 
         # check if catalog was generated
         check_catalog = len(glob.glob("".join([self.path, "/catalog.xml"])))
         self.assertEqual(1, check_catalog)
 
         # check elements of generated catalog
-        self.assertEqual("catalog", catalog.ROOT_NAME)
-        self.assertEqual("urn:oasis:names:tc:entity:xmlns:xml:catalog", catalog.ROOT_NS)
-        self.assertEqual({"c": catalog.ROOT_NS}, catalog.ROOT_NAMESPACES)
-        self.assertEqual(1, len(catalog.uri_list))
+        self.assertEqual("catalog", gen_catalog.ROOT_NAME)
+        self.assertEqual(
+            "urn:oasis:names:tc:entity:xmlns:xml:catalog", gen_catalog.ROOT_NS
+        )
+        self.assertEqual({"c": gen_catalog.ROOT_NS}, gen_catalog.ROOT_NAMESPACES)
+        self.assertEqual(1, len(gen_catalog.uri_list))
 
         # check correct name attribute
-        self.assertEqual(self.correct_schema, catalog.uri_list[0].name)
+        self.assertEqual(CORRECT_SCHEMA, gen_catalog.uri_list[0].name)
         # check correct uri attribute
-        self.assertEqual(filename, catalog.uri_list[0].uri)
+        self.assertEqual(filename, gen_catalog.uri_list[0].uri)
 
         # check how many uris we have in catalog
-        self.assertEqual(len(catalog.uri_list), 1)
+        self.assertEqual(len(gen_catalog.uri_list), 1)
diff --git a/test/test_xpath.py b/test/test_xpath.py
@@ -18,13 +18,13 @@
 
 import unittest
 
-from neuxml import xpath
-from neuxml.xpath import ast, serialize
+from neuxml.xpath import ast
+from neuxml.xpath.core import parse, serialize
 
 
 class ParseTest(unittest.TestCase):
     def test_nametest_step(self):
-        xp = xpath.parse("""author""")
+        xp = parse("""author""")
         self.assertTrue(isinstance(xp, ast.Step))
         self.assertTrue(xp.axis is None)  # or should this be 'child', the default?
         self.assertTrue(isinstance(xp.node_test, ast.NameTest))
@@ -33,20 +33,20 @@ def test_nametest_step(self):
         self.assertEqual(0, len(xp.predicates))
 
     def test_nodetype_step(self):
-        xp = xpath.parse("""text()""")
+        xp = parse("""text()""")
         self.assertTrue(isinstance(xp, ast.Step))
         self.assertTrue(isinstance(xp.node_test, ast.NodeType))
         self.assertEqual("text", xp.node_test.name)
 
     def test_axis(self):
-        xp = xpath.parse("""ancestor::lib:book""")
+        xp = parse("""ancestor::lib:book""")
         self.assertTrue(isinstance(xp, ast.Step))
         self.assertEqual("ancestor", xp.axis)
         self.assertEqual("lib", xp.node_test.prefix)
         self.assertEqual("book", xp.node_test.name)
 
     def test_relative_path(self):
-        xp = xpath.parse("""book//author/first-name""")
+        xp = parse("""book//author/first-name""")
         self.assertTrue(isinstance(xp, ast.BinaryExpression))
         self.assertTrue(isinstance(xp.left, ast.BinaryExpression))
         self.assertEqual("book", xp.left.left.node_test.name)
@@ -56,19 +56,19 @@ def test_relative_path(self):
         self.assertEqual("first-name", xp.right.node_test.name)
 
     def test_absolute_path(self):
-        xp = xpath.parse("""/book//author""")
+        xp = parse("""/book//author""")
         self.assertTrue(isinstance(xp, ast.AbsolutePath))
         self.assertEqual("/", xp.op)
         self.assertEqual("book", xp.relative.left.node_test.name)
 
     def test_step_predicate(self):
-        xp = xpath.parse("""book[author]""")
+        xp = parse("""book[author]""")
         self.assertEqual("book", xp.node_test.name)
         self.assertEqual(1, len(xp.predicates))
         self.assertEqual("author", xp.predicates[0].node_test.name)
 
     def test_function(self):
-        xp = xpath.parse("""author[position() = 1]""")
+        xp = parse("""author[position() = 1]""")
         self.assertTrue(isinstance(xp.predicates[0], ast.BinaryExpression))
         self.assertEqual("=", xp.predicates[0].op)
         self.assertTrue(isinstance(xp.predicates[0].left, ast.FunctionCall))
@@ -77,7 +77,7 @@ def test_function(self):
         self.assertEqual(1, xp.predicates[0].right)
 
     def test_variable(self):
-        xp = xpath.parse("""title[substring-after(text(), $pre:separator) = "world"]""")
+        xp = parse("""title[substring-after(text(), $pre:separator) = "world"]""")
         self.assertEqual("title", xp.node_test.name)
         self.assertTrue(isinstance(xp.predicates[0], ast.BinaryExpression))
         self.assertEqual("=", xp.predicates[0].op)
@@ -93,7 +93,7 @@ def test_variable(self):
         self.assertEqual(("pre", "separator"), xp.predicates[0].left.args[1].name)
 
     def test_predicated_expression(self):
-        xp = xpath.parse("""(book or article)[author/last-name = "Jones"]""")
+        xp = parse("""(book or article)[author/last-name = "Jones"]""")
         self.assertTrue(isinstance(xp, ast.PredicatedExpression))
         self.assertTrue(isinstance(xp.base, ast.BinaryExpression))
         self.assertEqual("book", xp.base.left.node_test.name)
@@ -110,7 +110,7 @@ def test_predicated_expression(self):
     def test_lex_exceptions(self):
         # http://www.w3.org/TR/xpath/#exprlex describes several unusual
         # lexing rules. Verify them here.
-        xp = xpath.parse("""***""")
+        xp = parse("""***""")
         self.assertTrue(isinstance(xp, ast.BinaryExpression))
         self.assertEqual("*", xp.op)
         self.assertTrue(isinstance(xp.left, ast.Step))
@@ -120,7 +120,7 @@ def test_lex_exceptions(self):
         self.assertTrue(isinstance(xp.right.node_test, ast.NameTest))
         self.assertEqual("*", xp.right.node_test.name)
 
-        xp = xpath.parse("""div div div""")
+        xp = parse("""div div div""")
         self.assertTrue(isinstance(xp, ast.BinaryExpression))
         self.assertEqual("div", xp.op)
         self.assertTrue(isinstance(xp.left, ast.Step))
@@ -130,12 +130,12 @@ def test_lex_exceptions(self):
         self.assertTrue(isinstance(xp.right.node_test, ast.NameTest))
         self.assertEqual("div", xp.right.node_test.name)
 
-        xp = xpath.parse("""div:div""")
+        xp = parse("""div:div""")
         self.assertTrue(isinstance(xp, ast.Step))
         self.assertEqual("div", xp.node_test.prefix)
         self.assertEqual("div", xp.node_test.name)
 
-        xp = xpath.parse("""node/node()""")
+        xp = parse("""node/node()""")
         self.assertTrue(isinstance(xp, ast.BinaryExpression))
         self.assertEqual("/", xp.op)
         self.assertTrue(isinstance(xp.left, ast.Step))
@@ -145,28 +145,28 @@ def test_lex_exceptions(self):
         self.assertTrue(isinstance(xp.right.node_test, ast.NodeType))
         self.assertEqual("node", xp.right.node_test.name)
 
-        xp = xpath.parse("""boolean(boolean)""")
+        xp = parse("""boolean(boolean)""")
         self.assertTrue(isinstance(xp, ast.FunctionCall))
         self.assertEqual("boolean", xp.name)
         self.assertEqual(1, len(xp.args))
         self.assertTrue(isinstance(xp.args[0], ast.Step))
         self.assertEqual("boolean", xp.args[0].node_test.name)
 
-        xp = xpath.parse("""parent::parent/parent:parent""")
+        xp = parse("""parent::parent/parent:parent""")
         self.assertEqual("parent", xp.left.axis)
         self.assertEqual("parent", xp.left.node_test.name)
         self.assertEqual("parent", xp.right.node_test.prefix)
         self.assertEqual("parent", xp.right.node_test.name)
 
     def test_syntax_error(self):
         # try to parse invalid xpath and make sure we get an exception
-        self.assertRaises(RuntimeError, xpath.parse, """bogus-(""")
-        self.assertRaises(RuntimeError, xpath.parse, """/bogus-(""")
+        self.assertRaises(RuntimeError, parse, """bogus-(""")
+        self.assertRaises(RuntimeError, parse, """/bogus-(""")
 
 
 class TestSerializeRoundTrip(unittest.TestCase):
     def round_trip(self, xpath_str):
-        xp = xpath.parse(xpath_str)
+        xp = parse(xpath_str)
         self.assertEqual(xpath_str, serialize(xp))
 
     def test_nametest(self):

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`[pytest]`
`2`		`-python_files = "test/*/.py"`
	`2`	`+python_files = "test/**.py"`