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)