def test_render(
self, mock_render_module, mock_render_package,
):
classes = ClassFactory.list(3)
mock_render_module.return_value = "module"
mock_render_package.return_value = "package"
iterator = DataclassGenerator().render(classes)
actual = [out for out in iterator]
self.assertEqual(2, len(actual))
self.assertEqual(3, len(actual[0]))
self.assertEqual("init", actual[0][1])
self.assertEqual("foo/__init__.py", str(actual[0][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_package.return_value, actual[0][2])
mock_render_package.assert_called_once_with(classes)
self.assertEqual(3, len(actual[1]))
self.assertIsInstance(actual[1][0], Path)
self.assertTrue(actual[1][0].is_absolute())
self.assertEqual("foo.tests", actual[1][1])
self.assertEqual("foo/tests.py", str(actual[1][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_module.return_value, actual[1][2])
mock_render_module.assert_called_once_with(mock.ANY, classes)
def test_children_extensions(self):
complex_type = ComplexType.create(
attributes=[Attribute.create(index=i) for i in range(2)],
simple_content=SimpleContent.create(
restriction=Restriction.create(base="bk:b", index=4)
),
complex_content=ComplexContent.create(
extension=Extension.create(base="bk:ext", index=7)
),
)
item = ClassFactory.create()
children = self.builder.children_extensions(complex_type, item)
expected = list(
map(
ExtensionFactory.create,
[
AttrTypeFactory.create(name="bk:b", index=4),
AttrTypeFactory.create(name="bk:ext", index=7),
],
)
)
self.assertIsInstance(children, GeneratorType)
self.assertEqual(expected, list(children))
def test_process_attribute_default_with_optional_field(self):
target = ClassFactory.create()
attr = AttrFactory.create(fixed=True, default=2)
attr.restrictions.min_occurs = 0
self.sanitizer.process_attribute_default(target, attr)
self.assertFalse(attr.fixed)
self.assertIsNone(attr.default)
def test_process_dependency_extension_with_simple_type(
self,
mock_find_dependency,
mock_process_simple_extension,
mock_process_complex_extension,
):
extension = ExtensionFactory.create()
target = ClassFactory.create(extensions=[extension])
source = ClassFactory.create(type=SimpleType)
mock_find_dependency.return_value = source
self.processor.process_extension(target, extension)
self.assertEqual(0, mock_process_complex_extension.call_count)
mock_process_simple_extension.assert_called_once_with(
source, target, extension)
def test_process(self, mock_create_substitutions, mock_process_attribute):
def init_substitutions():
self.processor.substitutions = {}
mock_create_substitutions.side_effect = init_substitutions
target = ClassFactory.create(attrs=[
AttrFactory.enumeration(),
AttrFactory.any(),
AttrFactory.element()
])
self.processor.process(target)
self.processor.process(ClassFactory.create())
mock_process_attribute.assert_called_once_with(target, target.attrs[2])
mock_create_substitutions.assert_called_once()
def test_process_dependency_type_with_simple_type(
self,
mock_find_dependency,
mock_process_simple_dependency,
):
simple = ClassFactory.create(type=SimpleType)
mock_find_dependency.return_value = simple
target = ClassFactory.create()
attr = AttrFactory.create()
attr_type = attr.types[0]
self.processor.process_dependency_type(target, attr, attr_type)
mock_process_simple_dependency.assert_called_once_with(
simple, target, attr, attr_type)
def test_process_attribute(self, mock_find):
target = ClassFactory.elements(2)
mock_find.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_name = first_attr.name
attr_qname = target.source_qname(attr_name)
reference_attrs = AttrFactory.list(2)
self.processor.create_substitutions()
self.processor.substitutions[attr_qname] = reference_attrs
self.processor.process_attribute(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
self.processor.process_attribute(target, second_attr)
self.assertEqual(4, len(target.attrs))
def test_handle_duplicate_classes(
self,
mock_remove_invalid_classes,
mock_merge_redefined_classes,
mock_update_abstract_classes,
):
first = ClassFactory.create()
second = first.clone()
third = ClassFactory.create()
self.analyzer.create_class_index([first, second, third])
self.analyzer.handle_duplicate_classes()
mock_remove_invalid_classes.assert_called_once_with([first, second])
mock_merge_redefined_classes.assert_called_once_with([first, second])
mock_update_abstract_classes.assert_called_once_with([first, second])
def test_render(
self,
mock_prepare_imports,
mock_render_classes,
mock_render_module,
mock_resolver_process,
):
classes = ClassFactory.list(3)
mock_render_module.return_value = "module"
mock_prepare_imports.return_value = [
PackageFactory.create(name="foo", source="bar")
]
mock_render_classes.return_value = "classes"
iterator = DataclassGenerator().render(classes)
actual = [out for out in iterator]
self.assertEqual(1, len(actual))
self.assertEqual(3, len(actual[0]))
self.assertIsInstance(actual[0][0], Path)
self.assertTrue(actual[0][0].is_absolute())
self.assertEqual("foo.tests", actual[0][1])
self.assertEqual("foo/tests.py",
str(actual[0][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_module.return_value, actual[0][2])
mock_resolver_process.assert_called_once_with(classes)
mock_prepare_imports.assert_called_once()
mock_prepare_imports.render_classes()
mock_render_module.assert_called_once_with(
imports=mock_prepare_imports.return_value,
output=mock_render_classes.return_value,
)
def test_print(self, mock_print):
classes = ClassFactory.list(2)
writer.register_format(self.FAKE_NAME, FakeGenerator())
writer.print(classes, "fake")
mock_print.assert_has_calls(
[mock.call(obj.name, end="") for obj in classes])
def test_analyze_classes(self, mock_process):
classes = ClassFactory.list(2)
mock_process.return_value = classes[1:]
result = self.transformer.analyze_classes(classes)
self.assertEqual(1, len(result))
mock_process.assert_called_once_with(classes)
def test_find_package(self):
class_a = ClassFactory.create()
self.resolver.packages[class_a.qname] = "foo.bar"
self.assertEqual("foo.bar", self.resolver.find_package(class_a.qname))
with self.assertRaises(ResolverValueError):
self.resolver.find_package("nope")
def test_resolve_imports(
self, mock_import_classes, mock_find_package, mock_add_import
):
class_life = ClassFactory.create(qname="life")
import_names = [
"foo", # cool
"bar", # cool
"{another}foo", # another foo
"{thug}life", # life class exists add alias
"{common}type", # type class doesn't exist add just the name
]
self.resolver.class_map = {class_life.qname: class_life}
mock_import_classes.return_value = import_names
mock_find_package.side_effect = ["first", "second", "third", "forth", "fifth"]
self.resolver.resolve_imports()
mock_add_import.assert_has_calls(
[
mock.call(qname=import_names[0], package="first", exists=False),
mock.call(qname=import_names[1], package="second", exists=False),
mock.call(qname=import_names[2], package="third", exists=True),
mock.call(qname=import_names[3], package="forth", exists=True),
mock.call(qname=import_names[4], package="fifth", exists=False),
]
)
def test_map_port(
self, mock_find_binding, mock_find_port_type, mock_attributes, mock_map_binding
):
definitions = Definitions()
service_port = ServicePort(binding="zaa:port", extended=[AnyElement()])
port_type = PortType(name="Calc")
binding = Binding(
type="zaa:zoo",
extended=[AnyElement()],
operations=[BindingOperation(name="ADD"), BindingOperation(name="SUB")],
)
classes = ClassFactory.list(2)
cfg = {
"style": "document",
"location": "http://endpoint.stub/action",
"transport": "public",
}
mock_find_binding.return_value = binding
mock_find_port_type.return_value = port_type
mock_map_binding.return_value = classes
mock_attributes.return_value = cfg
result = DefinitionsMapper.map_port(definitions, service_port)
self.assertIsInstance(result, Generator)
self.assertEqual(classes, list(result))
mock_find_binding.assert_called_once_with("port")
mock_find_port_type.assert_called_once_with("zoo")
self.assertEqual(2, len(list(mock_attributes.call_args[0][0])))
self.assertEqual(1, mock_attributes.call_count)
mock_map_binding.assert_called_once_with(definitions, binding, port_type, cfg)
def test_process_extension_native(self, mock_create_default_attribute):
extension = ExtensionFactory.create()
target = ClassFactory.elements(1)
self.processor.process_native_extension(target, extension)
mock_create_default_attribute.assert_called_once_with(
target, extension)
def test_flatten_extension_native_and_target_enumeration(
self, mock_create_default_attribute):
extension = ExtensionFactory.create()
target = ClassFactory.enumeration(1)
self.analyzer.flatten_extension_native(target, extension)
self.assertEqual(0, mock_create_default_attribute.call_count)
def test_process_native_extension_with_enumeration_target(
self, mock_copy_extension_type):
extension = ExtensionFactory.create()
target = ClassFactory.enumeration(1)
self.processor.process_native_extension(target, extension)
mock_copy_extension_type.assert_called_once_with(target, extension)
def test_add_substitution_attrs(self, mock_find_attribute):
target = ClassFactory.elements(2)
mock_find_attribute.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_name = first_attr.name
attr_qname = target.source_qname(attr_name)
reference_attrs = AttrFactory.list(2)
self.analyzer.substitutions_index[attr_qname] = reference_attrs
self.analyzer.add_substitution_attrs(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
self.analyzer.add_substitution_attrs(target, second_attr)
self.assertEqual(4, len(target.attrs))
self.analyzer.add_substitution_attrs(target, AttrFactory.enumeration())
self.assertEqual(4, len(target.attrs))
def test_process_complex_extension_when_source_has_suffix_attr(
self, mock_compare_attributes, mock_copy_attributes):
mock_compare_attributes.return_value = ClassExtensionHandler.INCLUDES_NONE
extension = ExtensionFactory.create()
target = ClassFactory.create()
source = ClassFactory.create()
source.attrs.append(AttrFactory.create(index=sys.maxsize))
self.processor.process_complex_extension(source, target, extension)
self.assertEqual(0, len(target.attrs))
target.attrs.append(AttrFactory.create())
self.processor.process_complex_extension(source, target, extension)
self.assertEqual(2, mock_compare_attributes.call_count)
mock_copy_attributes.assert_called_once_with(source, target, extension)
def test_process_attribute(self, mock_find):
target = ClassFactory.create(attrs=[
AttrFactory.create(types=[AttrTypeFactory.create("foo")]),
AttrFactory.create(types=[AttrTypeFactory.create("bar")]),
])
mock_find.side_effect = [-1, 2]
first_attr = target.attrs[0]
second_attr = target.attrs[1]
first_attr.restrictions.max_occurs = 2
attr_qname = first_attr.types[0].qname
reference_attrs = AttrFactory.list(2)
self.processor.create_substitutions()
self.processor.substitutions[attr_qname] = reference_attrs
self.processor.process_attribute(target, first_attr)
self.assertEqual(4, len(target.attrs))
self.assertEqual(reference_attrs[0], target.attrs[0])
self.assertIsNot(reference_attrs[0], target.attrs[0])
self.assertEqual(reference_attrs[1], target.attrs[3])
self.assertIsNot(reference_attrs[1], target.attrs[3])
self.assertEqual(2, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, target.attrs[3].restrictions.max_occurs)
self.processor.process_attribute(target, second_attr)
self.assertEqual(4, len(target.attrs))
def test_create_default_attribute_with_any_type(self):
extension = ExtensionFactory.create(
type=AttrTypeFactory.xs_any(),
restrictions=Restrictions(min_occurs=1,
max_occurs=1,
required=True),
)
item = ClassFactory.create(extensions=[extension])
ClassExtensionHandler.create_default_attribute(item, extension)
expected = AttrFactory.create(
name="any_element",
index=0,
default=None,
types=[extension.type.clone()],
tag=Tag.ANY,
namespace="##any",
restrictions=Restrictions(min_occurs=1,
max_occurs=1,
required=True),
)
self.assertEqual(1, len(item.attrs))
self.assertEqual(0, len(item.extensions))
self.assertEqual(expected, item.attrs[0])
def test_sanitize_attribute_sequence(self):
def len_sequential(target: Class):
return len([
attr for attr in target.attrs if attr.restrictions.sequential
])
restrictions = Restrictions(max_occurs=2, sequential=True)
target = ClassFactory.create(attrs=[
AttrFactory.create(restrictions=restrictions.clone()),
AttrFactory.create(restrictions=restrictions.clone()),
])
attrs_clone = [attr.clone() for attr in target.attrs]
self.sanitizer.process_attribute_sequence(target, target.attrs[0])
self.assertEqual(2, len_sequential(target))
target.attrs[0].restrictions.sequential = False
self.sanitizer.process_attribute_sequence(target, target.attrs[0])
self.assertEqual(1, len_sequential(target))
self.sanitizer.process_attribute_sequence(target, target.attrs[1])
self.assertEqual(0, len_sequential(target))
target.attrs = attrs_clone
target.attrs[1].restrictions.sequential = False
self.sanitizer.process_attribute_sequence(target, target.attrs[0])
self.assertEqual(0, len_sequential(target))
target.attrs[0].restrictions.sequential = True
target.attrs[0].restrictions.max_occurs = 0
target.attrs[1].restrictions.sequential = True
self.sanitizer.process_attribute_sequence(target, target.attrs[0])
self.assertEqual(1, len_sequential(target))
def test_build_inner_classes(self, mock_build_class):
inner_classes = ClassFactory.list(2)
mock_build_class.side_effect = inner_classes
simple_type = SimpleType.create()
complex_type = ComplexType.create()
enumeration = SimpleType.create(
restriction=Restriction.create(enumerations=[Enumeration.create(value="a")])
)
element = Element.create(
alternatives=[
Alternative.create(complex_type=complex_type, id="a"),
Alternative.create(simple_type=simple_type, id="b"),
Alternative.create(simple_type=enumeration, id="c"),
]
)
result = self.builder.build_inner_classes(element)
self.assertIsInstance(result, Iterator)
self.assertEqual(inner_classes, list(result))
self.assertEqual("a", complex_type.name)
self.assertEqual("c", enumeration.name)
mock_build_class.assert_has_calls(
[mock.call(complex_type), mock.call(enumeration)]
)
def test_build_envelope_fault_raises_error_if_missing_inner_body(self):
target = ClassFactory.create()
operation = PortTypeOperation()
definitions = Definitions()
with self.assertRaises(StopIteration):
DefinitionsMapper.build_envelope_fault(definitions, operation, target)
def test_write_skip_empty_output(self):
cls = ClassFactory.create()
cls.name = ""
with TemporaryDirectory() as tmpdir:
writer.register_format(self.FAKE_NAME, FakeGenerator(tmpdir))
writer.write([cls], "fake")
self.assertFalse(Path(f"{tmpdir}/{cls.name}.txt").exists())
def test_process_attributes_prevent_duplicates(self):
a = AttrFactory.create(name="a")
a_a = AttrFactory.create(name="a")
b = AttrFactory.create(name="b")
obj = ClassFactory.create(attrs=[a, a_a, b])
generator.process_attributes(obj, [])
self.assertEqual([a, b], obj.attrs)
def test_process_attribute_default_with_enumeration(self):
target = ClassFactory.create()
attr = AttrFactory.enumeration()
attr.restrictions.max_occurs = 2
attr.fixed = True
self.sanitizer.process_attribute_default(target, attr)
self.assertTrue(attr.fixed)
def test_resolve_conflicts(self, mock_rename_classes):
classes = [
ClassFactory.create(qname="{foo}A"),
ClassFactory.create(qname="{foo}a"),
ClassFactory.create(qname="a"),
ClassFactory.create(qname="b"),
ClassFactory.create(qname="b"),
]
self.sanitizer.container.extend(classes)
self.sanitizer.resolve_conflicts()
mock_rename_classes.assert_has_calls(
[
mock.call(classes[:2]),
mock.call(classes[3:]),
]
)
def test_process(self, mock_process_class, mock_resolve_conflicts):
classes = ClassFactory.list(2)
self.sanitizer.container.extend(classes)
ClassSanitizer.process(self.container, self.config)
mock_process_class.assert_has_calls(list(map(mock.call, classes)))
mock_resolve_conflicts.assert_called_once_with()
def test_process_attribute_default_with_xsi_type(self):
target = ClassFactory.create()
attr = AttrFactory.create(
fixed=True, default=2, name="type", namespace=Namespace.XSI.uri
)
self.sanitizer.process_attribute_default(target, attr)
self.assertFalse(attr.fixed)
self.assertIsNone(attr.default)
