示例#1
0
    def test_build_class_mixed_content(self):
        element = AnyElement(
            qname="{xsdata}root",
            children=[
                AnyElement(qname="{xsdata}child", text="primitive"),
                AnyElement(qname="something", text="foo", tail="bar"),
            ],
        )

        actual = ElementMapper.build_class(element, None)
        expected = ClassFactory.create(
            tag=Tag.ELEMENT,
            qname="root",
            namespace="xsdata",
            module="",
            mixed=True,
            ns_map={},
            attrs=[
                AttrFactory.native(DataType.STRING,
                                   name="child",
                                   namespace="xsdata",
                                   index=0),
                AttrFactory.native(DataType.STRING, name="something", index=1),
            ],
        )
        self.assertEqual(expected, actual)
示例#2
0
    def test_build_class_complex_type(self):
        element = AnyElement(
            qname="{xsdata}root",
            children=[
                AnyElement(qname="{xsdata}child", text="primitive"),
                AnyElement(qname="{inner}child",
                           attributes={
                               "{foo}bar": "1",
                               "{bar}foo": "2"
                           }),
            ],
        )

        actual = ElementMapper.build_class(element, "target")
        expected = ClassFactory.create(
            tag=Tag.ELEMENT,
            qname="{target}root",
            namespace="xsdata",
            module="",
            ns_map={},
            attrs=[
                AttrFactory.native(
                    DataType.STRING,
                    tag=Tag.ELEMENT,
                    name="child",
                    namespace="xsdata",
                    index=0,
                ),
                AttrFactory.element(
                    name="child",
                    namespace="inner",
                    types=[
                        AttrTypeFactory.create(qname="{target}child",
                                               forward=True)
                    ],
                    index=1,
                ),
            ],
        )
        self.assertEqual(1, len(actual.inner))

        actual.inner.clear()
        self.assertEqual(expected, actual)
示例#3
0
    def test_build_class_simple_type(self):
        element = AnyElement(
            qname="{xsdata}root",
            attributes={
                "{foo}bar": "1",
                "{bar}foo": "2.0"
            },
            text="true",
        )

        actual = ElementMapper.build_class(element, "target")
        expected = ClassFactory.create(
            tag=Tag.ELEMENT,
            qname="{target}root",
            namespace="xsdata",
            module="",
            ns_map={},
            attrs=[
                AttrFactory.native(
                    DataType.INT,
                    tag=Tag.ATTRIBUTE,
                    name="bar",
                    namespace="foo",
                    index=0,
                ),
                AttrFactory.native(
                    DataType.FLOAT,
                    tag=Tag.ATTRIBUTE,
                    name="foo",
                    namespace="bar",
                    index=1,
                ),
                AttrFactory.native(
                    DataType.BOOLEAN,
                    tag=Tag.SIMPLE_TYPE,
                    name="value",
                    namespace=None,
                    index=2,
                ),
            ],
        )
        self.assertEqual(expected, actual)