Пример #1
0
    def test_build_inner_classes(self, mock_build_class):
        inner_classes = ClassFactory.list(2)
        mock_build_class.side_effect = inner_classes

        simple_type = SimpleType()
        complex_type = ComplexType()
        enumeration = SimpleType(restriction=Restriction(
            enumerations=[Enumeration(value="a")]))

        element = Element(alternatives=[
            Alternative(complex_type=complex_type, id="a"),
            Alternative(simple_type=simple_type, id="b"),
            Alternative(simple_type=enumeration, id="c"),
        ])
        result = SchemaMapper.build_inner_classes(element, "module",
                                                  "target_ns")
        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, Tag.ALTERNATIVE, "module", "target_ns"),
            mock.call(enumeration, Tag.ALTERNATIVE, "module", "target_ns"),
        ])
Пример #2
0
    def test_build_inner_classes_with_enumeration(self, mock_build_class):
        inner = ClassFactory.enumeration(2)
        mock_build_class.return_value = inner

        enumeration = SimpleType(restriction=Restriction(
            enumerations=[Enumeration(value="a")]))

        result = SchemaMapper.build_inner_classes(enumeration, "module",
                                                  "target_ns")
        self.assertIsInstance(result, Iterator)
        self.assertEqual([inner], list(result))
        self.assertIsNone(enumeration.name)

        mock_build_class.assert_called_once_with(enumeration, Tag.SIMPLE_TYPE,
                                                 "module", "target_ns")