Bugfixes & test coverage (#3)

Author: lexakimov

.gitignore

@@ -6,3 +6,4 @@
 /build/
 /xmlgenerator.egg-info/
 /_schemas/
+/dist_native/

README.md

@@ -218,6 +218,7 @@ In the `value_override` sections, you can specify either a string value or speci
 | `output_filename`                  | String described by the `output_filename_template` configuration parameter                                 |
 | `uuid`                             | Random UUIDv4                                                                                              |
 | `regex("pattern")`                 | Random string value matching the specified regular expression                                              |
+| `any('A', "B", C)`                 | Random value from enumeration                                                                              |
 | `number(A, B)`                     | Random number between A and B                                                                              |
 | `date("2010-01-01", "2025-01-01")` | Random date within the specified range                                                                     |
 | `last_name`                        | Last Name                                                                                                  |

README_RU.md

@@ -218,6 +218,7 @@ specific:
 | `output_filename`                  | Строка, описываемая параметром конфигурации `output_filename`                                              |
 | `uuid`                             | Случайный UUIDv4                                                                                           |
 | `regex("pattern")`                 | Случайное строковое значение по указанному регулярному выражению                                           |
+| `any('A', "B", C)`                 | Случайное значение из перечисленных                                                                        |
 | `number(A, B)`                     | Случайное число от A до B                                                                                  |
 | `date("2010-01-01", "2025-01-01")` | Случайная дата в указанном диапазоне                                                                       |
 | `last_name`                        | Фамилия                                                                                                    |

pytest.ini

@@ -15,4 +15,6 @@ log_cli_date_format = %Y-%m-%d %H:%M:%S
 markers =
     flaky: mark test as flaky (may fail occasionally)
     integration: mark test as integration test
-    slow: mark test as slow (may take longer to run) 
+    slow: mark test as slow (may take longer to run)
+
+disable_test_id_escaping_and_forfeit_all_rights_to_community_support = True

requirements.txt

@@ -7,6 +7,7 @@ shtab
 
 # dev
 pytest==8.3.5
+pytest-repeat
 setuptools==77.0.3
 nuitka
 twine

…ttributes/types_built_in/ggyearmonth.xsd …attributes/types_built_in/gyearmonth.xsdtests/data/complex/attributes/types_built_in/ggyearmonth.xsd renamed to tests/data/complex/attributes/types_built_in/gyearmonth.xsd tests/data/complex/attributes/types_built_in/ggyearmonth.xsd renamed to tests/data/complex/attributes/types_built_in/gyearmonth.xsd

@@ -1,9 +1,11 @@
+import logging
 import os
 
 import tests
 import xmlgenerator.configuration as conf
 
 os.chdir(os.path.dirname(os.path.abspath(tests.__file__)))
+conf.logger.setLevel(logging.DEBUG)
 
 
 def test_load_config_no_file():

…ta/simple/types_built_in/ggyearmonth.xsd …ata/simple/types_built_in/gyearmonth.xsdtests/data/simple/types_built_in/ggyearmonth.xsd renamed to tests/data/simple/types_built_in/gyearmonth.xsd tests/data/simple/types_built_in/ggyearmonth.xsd renamed to tests/data/simple/types_built_in/gyearmonth.xsd

@@ -3,13 +3,14 @@
 from datetime import datetime
 
 import pytest
-import tests
 from lxml import etree
+from xmlschema import XMLSchema
+
+import tests
 from xmlgenerator.configuration import GeneratorConfig
 from xmlgenerator.generator import XmlGenerator
 from xmlgenerator.randomization import Randomizer
 from xmlgenerator.substitution import Substitutor
-from xmlschema import XMLSchema
 
 os.chdir(os.path.dirname(os.path.abspath(tests.__file__)))
 
@@ -75,7 +76,7 @@ def test_string(self, generator, config):
             log_xml(generated_xml)
             generated_value = generated_xml.xpath("/root/text()")
             assert generated_value
-            assert re.match("\\w+", generated_value[0])
+            assert re.match(r"\w+", generated_value[0])
 
         def test_boolean(self, generator, config):
             """Проверяет генерацию булевых значений."""
@@ -84,43 +85,99 @@ def test_boolean(self, generator, config):
             log_xml(generated_xml)
             generated_value = generated_xml.xpath("/root/text()")
             assert generated_value
-            assert re.match("true|false", generated_value[0])
+            assert re.match(r"true|false", generated_value[0])
 
         def test_decimal(self, generator, config):
             xsd_schema = XMLSchema(f"data/simple/types_built_in/decimal.xsd")
             generated_xml = generator.generate_xml(xsd_schema, config)
             log_xml(generated_xml)
             generated_value = generated_xml.xpath("/root/text()")
             assert generated_value
-            assert re.match("[0-9-.]+", generated_value[0])
+            assert re.match(r"[0-9-.]+", generated_value[0])
 
         def test_float(self, generator, config):
             xsd_schema = XMLSchema(f"data/simple/types_built_in/float.xsd")
             generated_xml = generator.generate_xml(xsd_schema, config)
             log_xml(generated_xml)
             generated_value = generated_xml.xpath("/root/text()")
             assert generated_value
-            assert re.match("[0-9-.]+", generated_value[0])
+            assert re.match(r"[0-9-.]+", generated_value[0])
 
         def test_double(self, generator, config):
             xsd_schema = XMLSchema(f"data/simple/types_built_in/double.xsd")
             generated_xml = generator.generate_xml(xsd_schema, config)
             log_xml(generated_xml)
             generated_value = generated_xml.xpath("/root/text()")
             assert generated_value
-            assert re.match("[0-9-.]+", generated_value[0])
+            assert re.match(r"[0-9-.]+", generated_value[0])
+
+        def test_datetime(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/datetime.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"[1,2][9,0]\d\d-\d\d-\d\dT\d\d:\d\d:\d\d$", generated_value[0])
+
+        def test_date(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/date.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"[1,2][9,0]\d\d-\d\d-\d\d$", generated_value[0])
+
+        def test_time(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/time.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"^\d\d:\d\d:\d\d$", generated_value[0])
+
+        def test_gyearmonth(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/gyearmonth.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"^\d\d\d\d-\d\d$", generated_value[0])
+
+        def test_gyear(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/gyear.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"^\d\d\d\d$", generated_value[0])
+
+        def test_gmonthday(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/gmonthday.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"^--\d\d-\d\d$", generated_value[0])
+
+        def test_gday(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/gday.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"^---\d\d$", generated_value[0])
+
+        def test_gmonth(self, generator, config):
+            xsd_schema = XMLSchema(f"data/simple/types_built_in/gmonth.xsd")
+            generated_xml = generator.generate_xml(xsd_schema, config)
+            log_xml(generated_xml)
+            generated_value = generated_xml.xpath("/root/text()")
+            assert generated_value
+            assert re.match(r"^--\d\d--$", generated_value[0])
 
         @pytest.mark.skip(reason="not yet implemented")
         @pytest.mark.parametrize("xsd", [
             'duration.xsd',
-            'datetime.xsd',
-            'time.xsd',
-            'date.xsd',
-            'gyearmonth.xsd',
-            'gyear.xsd',
-            'gmonthday.xsd',
-            'gday.xsd',
-            'gmonth.xsd',
             'hexbinary.xsd',
             'base64binary.xsd',
             'anyuri.xsd',
@@ -146,51 +203,107 @@ def test_string(self, generator, config):
                 log_xml(generated_xml)
                 generated_value = generated_xml.xpath("/root/@attributeValue")
                 assert generated_value
-                assert re.match("\\w+", generated_value[0])
+                assert re.match(r"\w+", generated_value[0])
 
             def test_boolean(self, generator, config):
                 xsd_schema = XMLSchema("data/complex/attributes/types_built_in/boolean.xsd")
                 generated_xml = generator.generate_xml(xsd_schema, config)
                 log_xml(generated_xml)
                 generated_value = generated_xml.xpath("/root/@attributeValue")
                 assert generated_value
-                assert re.match("true|false", generated_value[0])
+                assert re.match(r"true|false", generated_value[0])
 
             def test_decimal(self, generator, config):
                 xsd_schema = XMLSchema("data/complex/attributes/types_built_in/decimal.xsd")
                 generated_xml = generator.generate_xml(xsd_schema, config)
                 log_xml(generated_xml)
                 generated_value = generated_xml.xpath("/root/@attributeValue")
                 assert generated_value
-                assert re.match("[0-9-.]+", generated_value[0])
+                assert re.match(r"[0-9-.]+", generated_value[0])
 
             def test_float(self, generator, config):
                 xsd_schema = XMLSchema("data/complex/attributes/types_built_in/float.xsd")
                 generated_xml = generator.generate_xml(xsd_schema, config)
                 log_xml(generated_xml)
                 generated_value = generated_xml.xpath("/root/@attributeValue")
                 assert generated_value
-                assert re.match("[0-9-.]+", generated_value[0])
+                assert re.match(r"[0-9-.]+", generated_value[0])
 
             def test_double(self, generator, config):
                 xsd_schema = XMLSchema("data/complex/attributes/types_built_in/double.xsd")
                 generated_xml = generator.generate_xml(xsd_schema, config)
                 log_xml(generated_xml)
                 generated_value = generated_xml.xpath("/root/@attributeValue")
                 assert generated_value
-                assert re.match("[0-9-.]+", generated_value[0])
+                assert re.match(r"[0-9-.]+", generated_value[0])
+
+            def test_datetime(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/datetime.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"[1,2][9,0]\d\d-\d\d-\d\dT\d\d:\d\d:\d\d$", generated_value[0])
+
+            def test_date(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/date.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"[1,2][9,0]\d\d-\d\d-\d\d$", generated_value[0])
+
+            def test_time(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/time.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"^\d\d:\d\d:\d\d$", generated_value[0])
+
+            def test_gyearmonth(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/gyearmonth.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"^\d\d\d\d-\d\d$", generated_value[0])
+
+            def test_gyear(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/gyear.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"^\d\d\d\d$", generated_value[0])
+
+            def test_gmonthday(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/gmonthday.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"^--\d\d-\d\d$", generated_value[0])
+
+            def test_gday(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/gday.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"^---\d\d$", generated_value[0])
+
+            def test_gmonth(self, generator, config):
+                xsd_schema = XMLSchema(f"data/complex/attributes/types_built_in/gmonth.xsd")
+                generated_xml = generator.generate_xml(xsd_schema, config)
+                log_xml(generated_xml)
+                generated_value = generated_xml.xpath("/root/@attributeValue")
+                assert generated_value
+                assert re.match(r"^--\d\d--$", generated_value[0])
 
             @pytest.mark.skip(reason="not yet implemented")
             @pytest.mark.parametrize("xsd", [
                 'duration.xsd',
-                'datetime.xsd',
-                'time.xsd',
-                'date.xsd',
-                'gyearmonth.xsd',
-                'gyear.xsd',
-                'gmonthday.xsd',
-                'gday.xsd',
-                'gmonth.xsd',
                 'hexbinary.xsd',
                 'base64binary.xsd',
                 'anyuri.xsd',
@@ -630,7 +743,7 @@ def test_group_1_unbounded__element_1_1__0_1(self, generator, config):
 
             assert min(counts_by_occurs_item_opt) == 0
             assert max(counts_by_occurs_item_opt) <= 10
-            assert len(counts_by_occurs_item_opt) < 10
+            assert len(counts_by_occurs_item_opt) <= 10
 
         def test_group_1_1__element_0_0__0_1(self, generator, config):
             xsd_schema = XMLSchema("data/complex/sequence/scenario_07_forbidden_element.xsd")

tests/unit/test_configuration.py

@@ -0,0 +1,40 @@
+import logging
+
+import pytest
+
+from xmlgenerator import randomization
+from xmlgenerator.randomization import Randomizer
+
+randomization.logger.setLevel(logging.DEBUG)
+
+
+@pytest.mark.repeat(10)
+def test_random_no_seed():
+    randomizer1 = Randomizer()
+    randomizer2 = Randomizer()
+    for _ in range(10):
+        assert randomizer1.rnd.randint(0, 1000) != randomizer2.rnd.randint(0, 1000)
+
+
+@pytest.mark.repeat(10)
+def test_fake_no_seed():
+    randomizer1 = Randomizer()
+    randomizer2 = Randomizer()
+    for _ in range(10):
+        assert randomizer1.fake.name() != randomizer2.fake.name()
+
+
+@pytest.mark.repeat(10)
+def test_random_has_seed():
+    randomizer1 = Randomizer(seed=123)
+    randomizer2 = Randomizer(seed=123)
+    for _ in range(10):
+        assert randomizer1.rnd.randint(0, 1000) == randomizer2.rnd.randint(0, 1000)
+
+
+@pytest.mark.repeat(10)
+def test_fake_has_seed():
+    randomizer1 = Randomizer(seed=123)
+    randomizer2 = Randomizer(seed=123)
+    for _ in range(10):
+        assert randomizer1.fake.name() == randomizer2.fake.name()