Fix for issue #19 (as discussed) and added generate_xml method

setup.py

@@ -12,7 +12,7 @@
     long_description_content_type="text/markdown",
     package_dir={"": "src"},
     packages=setuptools.find_packages("src", exclude=["tests"]),
-    install_requires=["rstr", "faker", "smart_open", "jsonschema", "typer", "pydantic"],
+    install_requires=["rstr", "faker", "smart_open", "jsonschema", "typer", "pydantic", "defusedxml", "requests", "json2xml"],
     url="https://github.com/ghandic/jsf",
     classifiers=[
         "Programming Language :: Python :: 3",

src/jsf/parser.py

@@ -5,9 +5,10 @@
 from datetime import datetime
 from itertools import count
 from typing import Any, Dict, List, Optional, Tuple, Union
+from json2xml import json2xml
 
 from faker import Faker
-from jsonschema import validate
+from jsonschema import validate as val
 from pydantic import conlist
 from smart_open import open as s_open
 
@@ -126,22 +127,42 @@ def _parse(self, schema: Dict[str, Any]) -> AllTypes:
     def context(self):
         return {**self.base_context, "state": deepcopy(self.base_state)}
 
-    def generate(self, n: Optional[int] = None) -> Any:
+    def generate(self, n: Optional[int] = None, validate:Optional[bool] = False) -> Any:
         if n is None or n == 1:
+            if validate:
+                data = self.root.generate(context=self.context)
+                val(instance=data,schema=self.root_schema)
+                return data
             return self.root.generate(context=self.context)
-        return [self.root.generate(context=self.context) for _ in range(n)]
+        else:
+            data_arr = []
+            for _ in range(n):
+                if validate:
+                    data = self.root.generate(context=self.context)
+                    val(instance=data,schema=self.root_schema)
+                    data_arr.append(data)
+                else:
+                    data = self.root.generate(context=self.context)
+                    data_arr.append(data)
+            return data_arr
+
 
     def pydantic(self):
         return self.root.model(context=self.context)[0]
 
-    def generate_and_validate(self) -> None:
+    def validate(self) -> None:
         fake = self.root.generate(context=self.context)
-        validate(instance=fake, schema=self.root_schema)
+        val(instance=fake, schema=self.root_schema)
 
     def to_json(self, path: str) -> None:
         with open(path, "w") as f:
             json.dump(self.generate(), f, indent=2)
 
+    def generate_xml(self):
+        data = self.generate()
+        data = json2xml.Json2xml(data, pretty=True).to_xml()
+        return data
+
     @staticmethod
     def from_json(path: str) -> "JSF":
         with open(path, "r") as f:

src/tests/data/validate.json

@@ -0,0 +1,38 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "title": "Employee Json Template Spec",
+    "type": "object",
+    "properties": {
+      "EmpID": {
+        "type": "string",
+        "maximum": 255
+      },
+      "UserID": {
+        "type": "number",
+        "maximum": 255
+      },
+      "Name": {
+        "type": "string",
+        "minimum": 2
+      },
+      "Email": {
+        "type": "string",
+        "minLength": 6,
+        "maxLength": 255
+      },
+      "Phone": {
+        "type": "string",
+        "maxLength": 10
+      },
+      "Salary": {
+        "type": "number"
+      },
+      "Hiredate": {
+        "type": "string",
+        "format": "date"
+      },
+      "RemainingHolidays": {
+        "type": "number"
+      }
+    }
+  }

src/tests/test_default_fake.py

@@ -1,7 +1,9 @@
 import json
 import re
-
+import json2xml
+import pytest
 from ..jsf.parser import JSF
+import re
 
 
 def test_fake_boolean(TestData):
@@ -229,7 +231,7 @@ def test_const(TestData):
         assert isinstance(f["country"], str)
         assert f["country"] == "United States of America"
 
-
+#@pytest.mark.xfail(reason="Always failing with "no such file or dir" error!!")
 def test_external_ref(TestData):
     with open(TestData / f"external-ref.json", "r") as file:
         schema = json.load(file)
@@ -245,8 +247,36 @@ def test_external_ref(TestData):
         assert all(isinstance(t, str) for t in f["ReferenceToExternalSchema"]["src"])
 
 
-def test_gen_and_validate(TestData):
-    with open(TestData / f"custom.json", "r") as file:
+def test_validate(TestData):
+    with open(TestData / f"validate.json", "r") as file:
         schema = json.load(file)
     p = JSF(schema)
-    [p.generate_and_validate() for _ in range(50)]
+    [p.validate() for _ in range(50)]
+
+def test_validate_and_generate_single_record(TestData):
+    """validate and generate data from schema"""
+    with open(TestData / f"validate.json", "r") as file:
+        schema = json.load(file)
+    p = JSF(schema)
+    fake_data = p.generate(validate=True)
+    assert(isinstance(fake_data,dict))
+
+def test_validate_and_generate__multiple_records(TestData):
+    """validate and generate data from schema"""
+    with open(TestData / f"validate.json", "r") as file:
+        schema = json.load(file)
+    p = JSF(schema)
+    fake_data = p.generate(validate=True,n=100)
+    assert(isinstance(fake_data,list))
+    assert(len(fake_data)==100)
+    for x in fake_data:
+        assert(isinstance(x,dict))
+
+def test_generate_xml(TestData):
+    """validate and generate data from schema"""
+    with open(TestData / f"validate.json", "r") as file:
+        schema = json.load(file)
+    p = JSF(schema)
+    p.generate_xml()
+
+