def validate_bindings(schema: Path, clazz: Type, output_format: str):
__tracebackhide__ = True
chapter = schema.stem.replace("chapter", "")
sample = here.joinpath(f"samples/chapter{chapter}.xml")
output_xml = here.joinpath(f"output/chapter{chapter}.xsdata.xml")
output_json = here.joinpath(f"output/chapter{chapter}.xsdata.json")
context = XmlContext(class_type=output_format)
obj = XmlParser(context=context).from_path(sample, clazz)
config = SerializerConfig(pretty_print=True)
actual_json = JsonSerializer(context=context, config=config).render(obj)
actual_xml = XmlSerializer(context=context, config=config).render(obj)
if output_json.exists() and chapter != "13":
assert output_json.read_text() == actual_json
assert obj == JsonParser(context=context).from_string(
actual_json, clazz)
else:
output_json.write_text(actual_json, encoding="utf-8")
if output_xml.exists():
assert output_xml.read_text() == actual_xml
else:
output_xml.write_text(actual_xml, encoding="utf-8")
validator = etree.XMLSchema(etree.parse(str(schema)))
validator.assertValid(etree.fromstring(actual_xml.encode()))
def dumps(root_element, *, format=False) -> str:
"""Serialize a SDFormat object to an XML string.
Parameters
----------
root_element : object
An instance of ``skbot.ignition.models.vXX.Sdf``. XX represents the SDFormat
version and can be any version currently supported by scikit-bot.
format : bool
If true, add indentation and linebreaks to the output to increase human
readability. If false (default) the entire XML will appear as a single
line with no spaces between elements.
Returns
-------
sdformat_string : str
A string containing SDFormat XML representing the given input.
Examples
--------
.. minigallery:: skbot.ignition.sdformat.dumps
"""
serializer = XmlSerializer(config=SerializerConfig(pretty_print=format))
return serializer.render(root_element)
def test_render_with_provided_namespaces(self):
serializer = XmlSerializer(pretty_print=True)
namespaces = Namespaces()
namespaces.add("urn:books", "burn")
actual = serializer.render(self.books, namespaces)
expected = (
"<?xml version='1.0' encoding='UTF-8'?>\n"
'<burn:books xmlns:burn="urn:books">\n'
' <book id="bk001" lang="en">\n'
" <author>Hightower, Kim</author>\n"
" <title>The First Book</title>\n"
" <genre>Fiction</genre>\n"
" <price>44.95</price>\n"
" <pub_date>2000-10-01</pub_date>\n"
" <review>An amazing story of nothing.</review>\n"
" </book>\n"
' <book id="bk002" lang="en">\n'
" <author>Nagata, Suanne</author>\n"
" <title>Becoming Somebody</title>\n"
" <genre>Biography</genre>\n"
" <review>A masterpiece of the fine art of gossiping.</review>\n"
" </book>\n"
"</burn:books>\n")
self.assertEqual(expected, actual)
def __init__(self, *, config: Configuration) -> None:
self.config = config
self.serializer = XmlSerializer(config=SerializerConfig(
pretty_print=False))
self.parser = XmlParser(context=XmlContext())
self.requests: WeakValueDictionary[str,
Future] = WeakValueDictionary({})
super().__init__()
def serialize(obj: object, pretty_print: bool = False) -> str:
ns_map = __get_ns_map(obj)
schema_location = __get_ns_schema_location(obj)
config = SerializerConfig(xml_version='1.0',
encoding='UTF-8',
schema_location=schema_location,
pretty_print=pretty_print)
serializer = XmlSerializer(config=config)
return serializer.render(obj, ns_map=ns_map)
def write(cls, output: TextIO, obj: "GeneratorConfig"):
ctx = XmlContext(
element_name_generator=text.pascal_case,
attribute_name_generator=text.camel_case,
)
config = SerializerConfig(pretty_print=True)
serializer = XmlSerializer(context=ctx,
config=config,
writer=XmlEventWriter)
serializer.write(output,
obj,
ns_map={None: "http://pypi.org/project/xsdata"})
def writer(xrnsfile, song):
xrns = XrnsSerializer()
xml_song = xrns.render(song)
config = SerializerConfig(pretty_print=True,
encoding="UTF-8",
xml_version="1.0")
serializer = XmlSerializer(config=config) # , writer=XmlEventWriter)
rendered = serializer.render(xml_song)
with zipfile.ZipFile(xrnsfile, mode="w") as zf:
zf.writestr("Song.xml", rendered)
def test_client_with_soap_fault(self, mock_most):
url = "http://localhost:9999/ws/hello"
request = fixtures_dir.joinpath("hello/HelloRQ.xml").read_text()
response = fixtures_dir.joinpath(
"hello/HelloRS_SoapFault.xml").read_bytes()
headers = {"content-type": "text/xml"}
mock_most.return_value = response
config = Config.from_service(HelloGetHelloAsString)
serializer = XmlSerializer(config=SerializerConfig(pretty_print=True))
client = Client(config=config, serializer=serializer)
result = client.send(
{"body": {
"get_hello_as_string": {
"arg0": "chris"
}
}})
self.assertIsInstance(result, HelloGetHelloAsString.output)
fault = HelloGetHelloAsStringOutput.Body.Fault(
faultcode="S:Server",
faultstring="foobar",
detail=HelloGetHelloAsStringOutput.Body.Fault.Detail(
hello_error=HelloError(message="foobar")),
)
self.assertEqual(fault, result.body.fault)
mock_most.assert_called_once_with(url, data=request, headers=headers)
def test_client(self, mock_most):
url = "http://localhost:9999/ws/hello"
request = fixtures_dir.joinpath("hello/HelloRQ.xml").read_text()
response = fixtures_dir.joinpath("hello/HelloRS.xml").read_bytes()
headers = {"content-type": "text/xml"}
mock_most.return_value = response
config = Config.from_service(HelloGetHelloAsString)
serializer = XmlSerializer(config=SerializerConfig(pretty_print=True))
client = Client(config=config, serializer=serializer)
result = client.send(
{"body": {
"get_hello_as_string": {
"arg0": "chris"
}
}})
self.assertIsInstance(result, HelloGetHelloAsString.output)
body = HelloGetHelloAsStringOutput.Body(
get_hello_as_string_response=GetHelloAsStringResponse(
return_value="Hello chris"))
self.assertEqual(body, result.body)
mock_most.assert_called_once_with(url, data=request, headers=headers)
def assert_xml_bindings(
context: XmlContext,
obj: Any,
ns_map: Dict,
schema_path: Path,
instance_path: Path,
save_path: Optional[Path],
version: str,
):
__tracebackhide__ = True
schema_validator = get_validator(schema_path, version)
if schema_validator is None:
pytest.skip("Schema validator failed on parsing definition")
try:
xsdata_xml = XmlSerializer(context=context, config=config).render(obj, ns_map)
if save_path:
json_document = JsonSerializer(context=context, config=config).render(obj)
save_path.write_text(xsdata_xml)
save_path.with_suffix(".json").write_text(json_document)
return assert_valid(schema_validator, xsdata_xml)
except Exception as e:
try:
original_tree = etree.parse(str(instance_path))
assert_valid(schema_validator, original_tree)
except Exception:
pytest.skip("Original instance failed to validate!")
raise e
def write_file_from_xml(xml_file_path: pathlib.Path,
serialize_clazz: Optional[Type[T]]):
"""
Method to write serialized XML data to a file.
:param xml_file_path: A pathlib.path path object that the data will write to.
:param serialize_clazz: A class Object.
:return: N/A
"""
serializer = XmlSerializer(
config=SerializerConfig(pretty_print=True,
encoding="UTF-8",
xml_version="1.1",
xml_declaration=False,
schema_location="resources/xmltv.xsd",
no_namespace_schema_location=None))
with xml_file_path.open("w") as data:
serializer.write(data, serialize_clazz)
def test_live(self):
config = Config.from_service(HelloGetHelloAsString)
serializer = XmlSerializer(config=SerializerConfig(pretty_print=True))
client = Client(config=config, serializer=serializer)
result = client.send(
{"body": {
"get_hello_as_string": {
"arg0": "chris"
}
}})
print(result)
def validate_bindings(schema: Path, clazz: Type):
__tracebackhide__ = True
obj = XmlParser().from_path(schema.with_suffix(".xml"), clazz)
actual = JsonSerializer(indent=4).render(obj)
expected = schema.with_suffix(".json")
if expected.exists():
assert expected.read_text() == actual
assert obj == JsonParser().from_string(actual, clazz)
else:
expected.write_text(actual)
xml = XmlSerializer(pretty_print=True).render(obj)
validator = etree.XMLSchema(etree.parse(str(schema)))
assert validator.validate(etree.fromstring(
xml.encode())), validator.error_log
expected.with_suffix(".xsdata.xml").write_text(xml)
def setUp(self):
super().setUp()
self.serializer = XmlSerializer(pretty_print=True)
self.namespaces = Namespaces()
self.books = Books(book=[
BookForm(
id="bk001",
author="Hightower, Kim",
title="The First Book",
genre="Fiction",
price=44.95,
pub_date="2000-10-01",
review="An amazing story of nothing.",
),
BookForm(
id="bk002",
author="Nagata, Suanne",
title="Becoming Somebody",
genre="Biography",
review="A masterpiece of the fine art of gossiping.",
),
])
def test_xml_documents():
filepath = fixtures_dir.joinpath("artists")
package = "tests.fixtures.artists"
runner = CliRunner()
result = runner.invoke(cli, [str(filepath), "--package", package])
if result.exception:
raise result.exception
clazz = load_class(result.output, "Metadata")
parser = XmlParser()
serializer = XmlSerializer(writer=XmlEventWriter)
serializer.config.pretty_print = True
serializer.config.xml_declaration = False
ns_map = {None: "http://musicbrainz.org/ns/mmd-2.0#"}
for i in range(1, 4):
ap = filepath.joinpath(f"art00{i}.xml")
obj = parser.from_path(ap, clazz)
actual = serializer.render(obj, ns_map)
assert ap.read_bytes().splitlines() == actual.encode().splitlines()
def test_client(self, mock_most):
url = "http://www.dneonline.com/calculator.asmx"
request = fixtures_dir.joinpath("calculator/AddRQ.xml").read_text()
response = fixtures_dir.joinpath("calculator/AddRS.xml").read_bytes()
headers = {"content-type": "text/xml", "SOAPAction": "http://tempuri.org/Add"}
mock_most.return_value = response
config = Config.from_service(CalculatorSoapAdd)
serializer = XmlSerializer(config=SerializerConfig(pretty_print=True))
client = Client(config=config, serializer=serializer)
result = client.send({"Body": {"Add": {"intA": 1, "intB": 3}}})
self.assertIsInstance(result, CalculatorSoapAddOutput)
mock_most.assert_called_once_with(url, data=request, headers=headers)
class LxmlEventWriterTests(TestCase):
def setUp(self):
config = SerializerConfig(pretty_print=True)
self.serializer = XmlSerializer(config=config, writer=LxmlEventWriter)
def test_render(self):
actual = self.serializer.render(books)
expected = fixtures_dir.joinpath("books/books_auto_ns.xml").read_text()
self.assertEqual(expected, actual)
def test_render_with_provided_namespaces(self):
actual = self.serializer.render(books, {"brk": "urn:books"})
expected = fixtures_dir.joinpath("books/books.xml").read_text()
self.assertEqual(expected, actual)
def test_render_with_default_namespace_prefix(self):
actual = self.serializer.render(books, {None: "urn:books"})
expected = fixtures_dir.joinpath(
"books/books_default_ns.xml").read_text()
xml_declaration, actual = actual.split("\n", 1)
_, expected = expected.split("\n", 1)
self.assertEqual(expected, actual)
def test_encoding(self):
self.serializer.config.encoding = "US-ASCII"
self.serializer.config.xml_version = "1.1"
actual = self.serializer.render(books)
xml_declaration, _ = actual.split("\n", 1)
self.assertEqual('<?xml version="1.1" encoding="US-ASCII"?>',
xml_declaration)
def test_declaration_disabled(self):
self.serializer.config.xml_declaration = False
actual = self.serializer.render(books, {None: "urn:books"})
expected = fixtures_dir.joinpath(
"books/books_default_ns.xml").read_text()
xml_declaration, expected = expected.split("\n", 1)
self.assertEqual(expected, actual)
def test_pretty_print_false(self):
self.serializer.config.pretty_print = False
actual = self.serializer.render(books)
expected = fixtures_dir.joinpath("books/books_auto_ns.xml").read_text()
_, actual = actual.split("\n", 1)
_, expected = expected.split("\n", 1)
self.assertEqual(expected.replace(" ", "").replace("\n", ""), actual)
def __init_serializer(
self, schema_location=None, no_namespace_schema_location=None
):
"""
Inits the internal serializer.
Parameters
----------
schema_location: str
Specify the xsi:schemaLocation attribute value
no_namespace_schema_location: str
Specify the xsi:noNamespaceSchemaLocation attribute value
"""
config = SerializerConfig(
pretty_print=True,
schema_location=schema_location,
no_namespace_schema_location=no_namespace_schema_location,
)
self.serializer = XmlSerializer(config=config)
def test_render_no_dataclass(self):
with self.assertRaises(ModelInspectionError) as cm:
XmlSerializer().render(self)
self.assertEqual(f"Object {self.__class__} is not a dataclass.",
str(cm.exception))
def xml_serializer(xml_context, serializer_config):
return XmlSerializer(context=xml_context, config=serializer_config)
def render(self) -> str:
name = self.__class__.__name__
xml = XmlSerializer(pretty_print=True,
xml_declaration=False).render(self)
start = xml.find(">") + 1
return xml[start:].replace(f"</{name}>", "").strip()
class Application(SIPApplication):
def __init__(self, *, config: Configuration) -> None:
self.config = config
self.serializer = XmlSerializer(config=SerializerConfig(
pretty_print=False))
self.parser = XmlParser(context=XmlContext())
self.requests: WeakValueDictionary[str,
Future] = WeakValueDictionary({})
super().__init__()
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='SIPEngineGotMessage')
notification_center.add_observer(self, name='SIPMessageDidSucceed')
notification_center.add_observer(self, name='SIPMessageDidFail')
notification_center.add_observer(self, name='SIPApplicationDidStart')
super().start(MemoryStorage())
async def send_request(self, arc_name: str, scaip_request: ScaipRequest):
logger.info(f"send_request to {arc_name}: {scaip_request}")
config = self.config
arc_config = config.get_arc_config(arc_name)
if not arc_config:
raise ValueError(f"no configuration found for ARC {arc_name}")
xml_model = scaip_request.to_xml_model()
xml_str = self.serializer.render(xml_model)
result = self.new_result_future(scaip_request.reference)
if scaip_request.caller_id.startswith(
"sip") and scaip_request.caller_id != "sip:":
caller_id = URI(scaip_request.caller_id)
sender = SIPURI(user=caller_id.user,
host=caller_id.host,
port=caller_id.port)
else:
sender = self.get_user_agent_uri()
receiver = SIPURI(user=arc_config.username,
host=arc_config.hostname,
port=arc_config.port)
message = Message(FromHeader(sender), ToHeader(receiver),
RouteHeader(receiver), 'application/scaip+xml',
xml_str)
message.send()
logger.info(f"sent message: {xml_str}")
scaip_response = await result
logger.info(f"received response: {scaip_response}")
return scaip_response
def new_result_future(self, reference: str) -> Future:
loop = asyncio.get_running_loop()
result = loop.create_future()
self.requests[reference] = result
return result
def get_user_agent_uri(self) -> SIPURI:
sip_config = self.config.sip
return SIPURI(user=sip_config.username,
host=sip_config.hostname,
port=sip_config.port)
def _NH_SIPApplicationDidStart(self, notification):
logger.info("SIPApplicationDidStart")
def _NH_SIPMessageDidSucceed(self, notification):
logger.info("SIPMessageDidSucceed")
def _NH_SIPMessageDidFail(self, notification):
logger.info("SIPMessageDidFail")
message = notification.sender
xml_model = self.parser.from_bytes(message.body, Mrq)
result = self.requests.get(xml_model.ref, None)
if result:
# TODO: return proper error
result.set_exception(
HTTPException(status_code=500, detail="SIPMessageDidFail"))
def _NH_SIPEngineGotMessage(self, notification):
logger.info("SIPEngineGotMessage")
logger.info(f"got XML: {notification.data.body}")
xml_model = self.parser.from_bytes(notification.data.body, Mrs)
scaip_response = ScaipResponse.from_xml_model(xml_model)
result = self.requests.get(xml_model.ref, None)
if result:
result.set_result(scaip_response)
def setUp(self):
config = SerializerConfig(pretty_print=True)
self.serializer = XmlSerializer(config=config, writer=LxmlEventWriter)
def save(self):
with self.path.open(mode="w") as file_obj:
serialized = XmlSerializer(pretty_print=True).render(self.nml)
serialized = serialized.split("\n")
serialized = "\n".join(line.lstrip() for line in serialized)
file_obj.write(serialized)
def write(size, obj, writer):
with xsdata_temp_dir.joinpath(f"benchmark_{size}.xml").open("w") as f:
serializer = XmlSerializer(writer=writer, context=context)
serializer.write(f, obj)
class XmlSerializerTests(TestCase):
def setUp(self):
super(XmlSerializerTests, self).setUp()
self.serializer = XmlSerializer(pretty_print=True)
self.namespaces = Namespaces()
self.books = Books(
book=[
BookForm(
id="bk001",
author="Hightower, Kim",
title="The First Book",
genre="Fiction",
price=44.95,
pub_date="2000-10-01",
review="An amazing story of nothing.",
),
BookForm(
id="bk002",
author="Nagata, Suanne",
title="Becoming Somebody",
genre="Biography",
review="A masterpiece of the fine art of gossiping.",
),
]
)
def test_render(self):
actual = self.serializer.render(self.books)
expected = (
"<?xml version='1.0' encoding='UTF-8'?>\n"
'<ns0:books xmlns:ns0="urn:books">\n'
' <book id="bk001" lang="en">\n'
" <author>Hightower, Kim</author>\n"
" <title>The First Book</title>\n"
" <genre>Fiction</genre>\n"
" <price>44.95</price>\n"
" <pub_date>2000-10-01</pub_date>\n"
" <review>An amazing story of nothing.</review>\n"
" </book>\n"
' <book id="bk002" lang="en">\n'
" <author>Nagata, Suanne</author>\n"
" <title>Becoming Somebody</title>\n"
" <genre>Biography</genre>\n"
" <review>A masterpiece of the fine art of gossiping.</review>\n"
" </book>\n"
"</ns0:books>\n"
)
self.assertEqual(expected, actual)
def test_render_with_provided_namespaces(self):
self.namespaces.add("urn:books", "burn")
actual = self.serializer.render(self.books, self.namespaces)
expected = (
"<?xml version='1.0' encoding='UTF-8'?>\n"
'<burn:books xmlns:burn="urn:books">\n'
' <book id="bk001" lang="en">\n'
" <author>Hightower, Kim</author>\n"
" <title>The First Book</title>\n"
" <genre>Fiction</genre>\n"
" <price>44.95</price>\n"
" <pub_date>2000-10-01</pub_date>\n"
" <review>An amazing story of nothing.</review>\n"
" </book>\n"
' <book id="bk002" lang="en">\n'
" <author>Nagata, Suanne</author>\n"
" <title>Becoming Somebody</title>\n"
" <genre>Biography</genre>\n"
" <review>A masterpiece of the fine art of gossiping.</review>\n"
" </book>\n"
"</burn:books>\n"
)
self.assertEqual(expected, actual)
def test_render_no_dataclass(self):
with self.assertRaises(XmlContextError) as cm:
self.serializer.render(self)
self.assertEqual(
f"Object {self.__class__} is not a dataclass.", str(cm.exception)
)
@mock.patch.object(SerializeUtils, "set_nil_attribute")
@mock.patch.object(SerializeUtils, "set_text")
@mock.patch.object(SerializeUtils, "set_attributes")
@mock.patch.object(SerializeUtils, "set_attribute")
@mock.patch.object(XmlSerializer, "render_sub_node")
@mock.patch.object(XmlSerializer, "next_value")
def test_render_node(
self,
mock_next_value,
mock_render_sub_node,
mock_set_attribute,
mock_set_attributes,
mock_set_text,
mock_set_nil_attribute,
):
root = Element("root")
prod_meta = self.serializer.context.build(ProductType)
size_meta = self.serializer.context.build(SizeType)
obj = ProductType()
attribute = prod_meta.find_var("effDate")
attributes = prod_meta.find_var("{!}other_attributes")
text = replace(size_meta.find_var("value"), qname=QName("foo", "bar"))
sub_node = prod_meta.find_var("name")
mock_next_value.return_value = [
(attribute, None),
(attribute, 1),
(attributes, dict(a=1)),
(text, "txt"),
(sub_node, 1),
(sub_node, [2, 3]),
]
self.serializer.render_node(root, obj, self.namespaces)
self.assertEqual({"ns0": "foo"}, self.namespaces.ns_map)
mock_set_attribute.assert_called_once_with(
root, attribute.qname, 1, self.namespaces
)
mock_set_attributes.assert_called_once_with(root, dict(a=1), self.namespaces)
mock_set_text.assert_called_once_with(root, "txt", self.namespaces)
mock_render_sub_node.assert_has_calls(
[
mock.call(root, 1, sub_node, self.namespaces),
mock.call(root, 2, sub_node, self.namespaces),
mock.call(root, 3, sub_node, self.namespaces),
]
)
mock_set_nil_attribute.assert_called_once_with(root, False, self.namespaces)
def test_render_node_without_dataclass(self):
root = Element("root")
self.serializer.render_node(root, 1, self.namespaces)
self.assertEqual("1", root.text)
@mock.patch.object(XmlSerializer, "render_sub_node")
def test_render_sub_nodes(self, mock_render_sub_node):
root = Element("root")
meta = self.serializer.context.build(ProductType)
var = meta.find_var("number")
self.serializer.render_sub_nodes(root, [1, 2, 3], var, self.namespaces)
self.assertEqual(3, mock_render_sub_node.call_count)
mock_render_sub_node.assert_has_calls(
[
mock.call(root, 1, var, self.namespaces),
mock.call(root, 2, var, self.namespaces),
mock.call(root, 3, var, self.namespaces),
]
)
@mock.patch.object(XmlSerializer, "render_wildcard_node")
def test_render_sub_node_with_generic_object(self, mock_render_wildcard_node):
root = Element("root")
value = AnyElement()
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_sub_node(root, value, var, self.namespaces)
self.assertEqual(1, mock_render_wildcard_node.call_count)
mock_render_wildcard_node.assert_called_once_with(
root, value, var, self.namespaces
)
@mock.patch.object(XmlSerializer, "render_element_node")
def test_render_sub_node_with_xml_element(self, mock_render_element_node):
root = Element("root")
value = 1
meta = self.serializer.context.build(ProductType)
var = meta.find_var("number")
self.serializer.render_sub_node(root, value, var, self.namespaces)
self.assertEqual(1, mock_render_element_node.call_count)
mock_render_element_node.assert_called_once_with(
root, value, var, self.namespaces
)
@mock.patch.object(XmlSerializer, "render_element_node")
def test_render_sub_node_with_dataclass_object(self, mock_render_element_node):
root = Element("root")
value = SizeType()
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_sub_node(root, value, var, self.namespaces)
self.assertEqual(1, mock_render_element_node.call_count)
mock_render_element_node.assert_called_once_with(
root, value, var, self.namespaces
)
@mock.patch.object(SerializeUtils, "set_tail")
@mock.patch.object(SerializeUtils, "set_text")
def test_render_sub_node_with_primitive_value_and_not_xml_element(
self, mock_set_text, mock_set_tail
):
root = Element("root")
value = 1
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_sub_node(root, value, var, self.namespaces)
self.assertEqual(1, mock_set_text.call_count)
mock_set_text.assert_called_once_with(root, value, self.namespaces)
root.text = "foo"
self.serializer.render_sub_node(root, value, var, self.namespaces)
self.assertEqual(1, mock_set_tail.call_count)
mock_set_tail.assert_called_once_with(root, value, self.namespaces)
@mock.patch.object(SerializeUtils, "set_nil_attribute")
@mock.patch.object(XmlSerializer, "set_xsi_type")
@mock.patch.object(XmlSerializer, "render_node")
def test_render_element_node(
self, mock_render_node, mock_set_xsi_type, mock_set_nil_attribute
):
root = Element("root")
value = SizeType()
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_element_node(root, value, var, self.namespaces)
child = root[0]
mock_render_node.assert_called_once_with(child, value, self.namespaces)
mock_set_xsi_type.assert_called_once_with(child, value, var, self.namespaces)
mock_set_nil_attribute.assert_called_once_with(
child, var.nillable, self.namespaces
)
self.assertEqual(var.qname, child.tag)
self.assertEqual(
{"ns0": "http://www.w3.org/1999/xhtml"}, self.namespaces.ns_map
)
@mock.patch.object(SerializeUtils, "set_nil_attribute")
@mock.patch.object(XmlSerializer, "render_node")
def test_render_element_node_with_specific_qname(
self, mock_render_node, mock_set_nil_attribute
):
root = Element("root")
value = SizeType()
value.qname = "foo"
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_element_node(root, value, var, self.namespaces)
child = root[0]
mock_render_node.assert_called_once_with(child, value, self.namespaces)
mock_set_nil_attribute.assert_called_once_with(
child, var.nillable, self.namespaces
)
self.assertEqual("foo", child.tag)
self.assertEqual(0, len(self.namespaces.ns_map))
@mock.patch.object(XmlSerializer, "render_sub_node")
@mock.patch.object(SerializeUtils, "set_nil_attribute")
@mock.patch.object(SerializeUtils, "set_attributes")
@mock.patch.object(SerializeUtils, "set_tail")
@mock.patch.object(SerializeUtils, "set_text")
def test_render_wildcard_node(
self,
mock_set_text,
mock_set_tail,
mock_set_attributes,
mock_set_nil_attribute,
mock_render_sub_node,
):
root = Element("root")
value = AnyElement(
text="foo",
tail="bar",
attributes=dict(a=1),
children=[AnyElement(), AnyElement()],
ns_map={"foo": "bar"},
qname="foo",
)
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_wildcard_node(root, value, var, self.namespaces)
child = root[0]
self.assertEqual({"foo": "bar"}, self.namespaces.ns_map)
self.assertEqual(value.qname, child.tag)
mock_set_text.assert_called_once_with(child, value.text, self.namespaces)
mock_set_tail.assert_called_once_with(child, value.tail, self.namespaces)
mock_set_attributes.assert_called_once_with(
child, value.attributes, self.namespaces
)
mock_render_sub_node.assert_has_calls(
[
mock.call(child, value.children[0], var, self.namespaces),
mock.call(child, value.children[1], var, self.namespaces),
]
)
mock_set_nil_attribute.assert_called_once_with(
child, var.nillable, self.namespaces
)
@mock.patch.object(XmlSerializer, "render_sub_node")
@mock.patch.object(SerializeUtils, "set_nil_attribute")
@mock.patch.object(SerializeUtils, "set_attributes")
@mock.patch.object(SerializeUtils, "set_tail")
@mock.patch.object(SerializeUtils, "set_text")
def test_render_wildcard_node_without_qname(
self,
mock_set_text,
mock_set_tail,
mock_set_attributes,
mock_set_nil_attribute,
mock_render_sub_node,
):
root = Element("root")
value = AnyElement(
text="foo", tail="bar", attributes=dict(a=1), children=[AnyElement()]
)
meta = self.serializer.context.build(DescriptionType)
var = meta.find_var(mode=FindMode.WILDCARD)
self.serializer.render_wildcard_node(root, value, var, self.namespaces)
self.assertEqual(0, len(self.namespaces.ns_map))
self.assertEqual(0, len(root))
mock_set_text.assert_called_once_with(root, value.text, self.namespaces)
mock_set_tail.assert_called_once_with(root, value.tail, self.namespaces)
mock_set_attributes.assert_called_once_with(
root, value.attributes, self.namespaces
)
mock_render_sub_node.assert_called_once_with(
root, value.children[0], var, self.namespaces
)
mock_set_nil_attribute.assert_called_once_with(
root, var.nillable, self.namespaces
)
def test_set_xsi_type_with_non_dataclass(self):
elem = Element("foo")
value = 1
meta = self.serializer.context.build(ProductType)
var = meta.find_var("number")
self.serializer.set_xsi_type(elem, value, var, self.namespaces)
self.assertNotIn(QNames.XSI_TYPE, elem.attrib)
def test_set_xsi_type_when_value_type_matches_var_clazz(self):
elem = Element("foo")
value = SizeType()
meta = self.serializer.context.build(ProductType)
var = meta.find_var("size")
self.serializer.set_xsi_type(elem, value, var, self.namespaces)
self.assertNotIn(QNames.XSI_TYPE, elem.attrib)
def test_set_xsi_type_when_value_is_not_derived_from_var_clazz(self):
elem = Element("foo")
value = ColorType()
meta = self.serializer.context.build(ProductType)
var = meta.find_var("size")
with self.assertRaises(SerializerError) as cm:
self.serializer.set_xsi_type(elem, value, var, self.namespaces)
self.assertEqual("ColorType is not derived from SizeType", str(cm.exception))
@mock.patch.object(XmlContext, "is_derived", return_value=True)
def test_set_xsi_type_when_value_is_derived_from_var_clazz(self, *args):
elem = Element("foo")
value = Items()
meta = self.serializer.context.build(ProductType)
items_meta = self.serializer.context.build(Items)
var = meta.find_var("size")
self.serializer.set_xsi_type(elem, value, var, self.namespaces)
self.assertEqual(items_meta.source_qname, elem.attrib[QNames.XSI_TYPE])
def test_next_value(self):
@dataclass
class A:
x0: Optional[int] = field(default=None)
x1: List[int] = field(
default_factory=list, metadata=dict(type="Element", sequential=True)
)
x2: List[int] = field(
default_factory=list, metadata=dict(type="Element", sequential=True)
)
x3: Optional[int] = field(default=None)
obj = A(x0=1, x1=[2, 3, 4], x2=[6, 7], x3=8)
meta = self.serializer.context.build(A)
x0 = meta.find_var("x0")
x1 = meta.find_var("x1")
x2 = meta.find_var("x2")
x3 = meta.find_var("x3")
actual = self.serializer.next_value(meta, obj)
expected = [
(x0, 1),
(x1, 2),
(x2, 6),
(x1, 3),
(x2, 7),
(x1, 4),
(x3, 8),
]
self.assertIsInstance(actual, Iterator)
self.assertEqual(expected, list(actual))
fixtures = here.joinpath("fixtures")
is_travis = "TRAVIS" in os.environ
@dataclass
class Documentation:
title: str
skip_message: str
source: str
target: str
xml_parser = XmlParser()
json_parser = JsonParser()
xml_serializer = XmlSerializer(pretty_print=True)
json_serializer = JsonSerializer(indent=4)
xmls = sorted([
xsd for xsd in fixtures.glob("defxmlschema/*/chapter*.xml")
if not str(xsd).endswith("xsdata.xml")
])
total = 0
skipped = 0
@pytest.mark.parametrize("fixture", xmls, ids=lambda x: x.name)
def test_binding(fixture: Path):
global total, skipped
total += 1
def setUp(self) -> None:
self.serializer = XmlSerializer()
import sys
from pathlib import Path
from xsdata.formats.dataclass.parsers import XmlParser
from xsdata.formats.dataclass.serializers import XmlSerializer
from xsdata.formats.dataclass.serializers.config import SerializerConfig
from reqif.models import ReqIf
here = Path(__file__).parent
xml_fixture = here.joinpath("sample.xml")
parser = XmlParser()
config = SerializerConfig(pretty_print=True, encoding="ascii")
serializer = XmlSerializer(context=parser.context, config=config)
obj = parser.from_path(xml_fixture, ReqIf)
ns_map = {
None: "http://www.omg.org/spec/ReqIF/20110401/reqif.xsd",
"xhtml": "http://www.w3.org/1999/xhtml",
}
serializer.write(sys.stdout, obj, ns_map=ns_map)
class XmlSerializerTests(TestCase):
def setUp(self) -> None:
self.serializer = XmlSerializer()
def test_write_object_with_derived_element(self):
book = BookForm(id="123")
obj = DerivedElement(qname="item", value=book)
result = self.serializer.write_object(obj)
expected = [
(XmlWriterEvent.START, "item"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.ATTR, QNames.XSI_TYPE, "{urn:books}BookForm"),
(XmlWriterEvent.END, "item"),
]
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_dataclass(self):
book = BookForm(id="123",
title="Misterioso: A Crime Novel",
price=19.5)
result = self.serializer.write_object(book)
expected = [
(XmlWriterEvent.START, "BookForm"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.START, "title"),
(XmlWriterEvent.DATA, "Misterioso: A Crime Novel"),
(XmlWriterEvent.END, "title"),
(XmlWriterEvent.START, "price"),
(XmlWriterEvent.DATA, "19.5"),
(XmlWriterEvent.END, "price"),
(XmlWriterEvent.END, "BookForm"),
]
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_dataclass_can_overwrite_params(self):
book = BookForm(id="123",
title="Misterioso: A Crime Novel",
price=19.5)
result = self.serializer.write_dataclass(book, "xsdata", "book", True,
"foo:book")
expected = [
(XmlWriterEvent.START, "book"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.ATTR, QNames.XSI_TYPE, "foo:book"),
(XmlWriterEvent.ATTR, QNames.XSI_NIL, "true"),
(XmlWriterEvent.START, "title"),
(XmlWriterEvent.DATA, "Misterioso: A Crime Novel"),
(XmlWriterEvent.END, "title"),
(XmlWriterEvent.START, "price"),
(XmlWriterEvent.DATA, "19.5"),
(XmlWriterEvent.END, "price"),
(XmlWriterEvent.END, "book"),
]
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_dataclass_with_no_dataclass(self):
with self.assertRaises(XmlContextError) as cm:
next(self.serializer.write_dataclass(1))
self.assertEqual("Object <class 'int'> is not a dataclass.",
str(cm.exception))
def test_write_mixed_content(self):
var = XmlVar(wildcard=True, qname="a", name="a", mixed=True)
book = BookForm(id="123")
ebook = DerivedElement("ebook", BookForm(id="123"))
value = ["text", AnyElement(qname="br"), book, ebook, "tail"]
result = self.serializer.write_value(value, var, "xsdata")
expected = [
(XmlWriterEvent.DATA, "text"),
(XmlWriterEvent.START, "br"),
(XmlWriterEvent.DATA, None),
(XmlWriterEvent.END, "br"),
(XmlWriterEvent.START, "{xsdata}BookForm"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.END, "{xsdata}BookForm"),
(XmlWriterEvent.START, "ebook"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.END, "ebook"),
(XmlWriterEvent.DATA, "tail"),
]
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_data(self):
var = XmlVar(text=True, qname="a", name="a")
expected = [(XmlWriterEvent.DATA, "123")]
result = self.serializer.write_value("123", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_tokens(self):
var = XmlVar(element=True, qname="a", name="a", tokens=True)
result = self.serializer.write_value([], var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(0, len(list(result)))
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, ["1", QName("{a}b"), "3"]),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value([1, QName("{a}b"), 3], var,
"xsdata")
self.assertEqual(expected, list(result))
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, ["1", "2", "3"]),
(XmlWriterEvent.END, "a"),
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, ["4", "5", "6"]),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value([[1, 2, 3], [4, 5, 6]], var,
"xsdata")
self.assertEqual(expected, list(result))
var = XmlVar(element=True,
qname="a",
name="a",
tokens=True,
nillable=True)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, QNames.XSI_NIL, "true"),
(XmlWriterEvent.DATA, []),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value([], var, "xsdata")
self.assertEqual(expected, list(result))
def test_write_any_type_with_primitive(self):
var = XmlVar(wildcard=True, qname="a", name="a")
expected = [(XmlWriterEvent.DATA, "str")]
result = self.serializer.write_value("str", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_any_type_with_primitive_element(self):
var = XmlVar(element=True, qname="a", name="a", types=[object])
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "str"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value("str", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_any_type_with_any_element(self):
var = XmlVar(wildcard=True, qname="a", name="a")
value = AnyElement(
qname="a",
text="b",
tail="c",
attributes={
"d": 1,
"e": 2
},
children=[AnyElement(text="g"), "h"],
)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, "d", 1),
(XmlWriterEvent.ATTR, "e", 2),
(XmlWriterEvent.DATA, "b"),
(XmlWriterEvent.DATA, "g"),
(XmlWriterEvent.DATA, "h"),
(XmlWriterEvent.END, "a"),
(XmlWriterEvent.DATA, "c"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_any_type_with_derived_element_primitive(self):
var = XmlVar(wildcard=True, qname="a", name="a")
value = DerivedElement(qname="a", value=1)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, QNames.XSI_TYPE, QName(str(DataType.SHORT))),
(XmlWriterEvent.DATA, 1),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_any_type_with_derived_element_dataclass(self):
var = XmlVar(wildcard=True, qname="a", name="a")
value = DerivedElement(qname="a",
value=BookForm(title="def"),
substituted=True)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.ATTR, QNames.XSI_TYPE,
QName("{urn:books}BookForm")),
(XmlWriterEvent.START, "title"),
(XmlWriterEvent.DATA, "def"),
(XmlWriterEvent.END, "title"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_xsi_type(self):
var = XmlVar(element=True,
qname="a",
name="a",
dataclass=True,
types=[BookForm])
value = BookForm(id="123")
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_xsi_type_with_derived_class(self):
var = XmlVar(element=True,
qname="a",
name="a",
dataclass=True,
types=[BookForm])
ebook = make_dataclass("eBook", [], bases=(BookForm, ))
value = ebook(id="123")
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, "id", "123"),
(XmlWriterEvent.ATTR, "lang", "en"),
(XmlWriterEvent.ATTR, QNames.XSI_TYPE, QName("eBook")),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_xsi_type_with_illegal_derived_class(self):
var = XmlVar(element=True,
qname="a",
name="a",
dataclass=True,
types=[BookForm])
ebook = make_dataclass("eBook", [])
value = ebook()
result = self.serializer.write_value(value, var, "xsdata")
with self.assertRaises(SerializerError) as cm:
list(result)
self.assertEqual("eBook is not derived from BookForm",
str(cm.exception))
def test_write_element(self):
var = XmlVar(element=True, qname="a", name="a")
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "123"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value("123", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_element_with_nillable_true(self):
var = XmlVar(element=True, qname="a", name="a", nillable=True)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, QNames.XSI_NIL, "true"),
(XmlWriterEvent.DATA, "123"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value("123", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_element_with_any_type_var(self):
var = XmlVar(element=True,
qname="a",
name="a",
types=[object],
any_type=True)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, QNames.XSI_TYPE, QName(str(DataType.SHORT))),
(XmlWriterEvent.DATA, "123"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(123, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_element_with_any_type_var_ignore_xs_string(self):
var = XmlVar(element=True,
qname="a",
name="a",
types=[object],
any_type=True)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, ""),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value("", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "123"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value("123", var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_choice_with_derived_primitive_value(self):
var = XmlVar(
elements=True,
name="compound",
qname="compound",
choices=[XmlVar(element=True, qname="a", name="a", types=[int])],
)
value = DerivedElement(qname="a", value=1)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "1"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_choice_with_derived_dataclass(self):
var = XmlVar(
elements=True,
name="compound",
qname="compound",
choices=[XmlVar(element=True, qname="a", name="a", types=[A])],
)
value = DerivedElement(qname="a", value=A("foo"))
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.ATTR, "a0", "foo"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_choice_with_generic_object(self):
var = XmlVar(
elements=True,
name="compound",
qname="compound",
choices=[XmlVar(element=True, qname="a", name="a", types=[int])],
)
value = AnyElement(qname="a", text="1")
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "1"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_choice_with_raw_value(self):
var = XmlVar(
elements=True,
name="compound",
qname="compound",
choices=[
XmlVar(element=True, qname="a", name="a", types=[int]),
XmlVar(element=True,
qname="b",
name="b",
types=[int],
tokens=True),
],
)
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "1"),
(XmlWriterEvent.END, "a"),
(XmlWriterEvent.START, "b"),
(XmlWriterEvent.DATA, ["1", "2"]),
(XmlWriterEvent.END, "b"),
]
result = self.serializer.write_value([1, [1, 2]], var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_write_choice_when_no_matching_choice_exists(self):
var = XmlVar(
elements=True,
name="compound",
qname="compound",
choices=[XmlVar(element=True, qname="a", name="a", types=[float])],
)
with self.assertRaises(SerializerError) as cm:
result = self.serializer.write_value(1, var, "xsdata")
next(result)
msg = "XmlElements undefined choice: `compound` for `<class 'int'>`"
self.assertEqual(msg, str(cm.exception))
def test_write_value_with_list_value(self):
var = XmlVar(element=True, qname="a", name="a", list_element=True)
value = [True, False]
expected = [
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "true"),
(XmlWriterEvent.END, "a"),
(XmlWriterEvent.START, "a"),
(XmlWriterEvent.DATA, "false"),
(XmlWriterEvent.END, "a"),
]
result = self.serializer.write_value(value, var, "xsdata")
self.assertIsInstance(result, Generator)
self.assertEqual(expected, list(result))
def test_next_value(self):
obj = A(x0=1, x1=[2, 3, 4], x2=[6, 7], x3=[9])
meta = self.serializer.context.build(A)
x0 = meta.find_var("x0")
x1 = meta.find_var("x1")
x2 = meta.find_var("x2")
x3 = meta.find_var("x3")
actual = self.serializer.next_value(obj, meta)
expected = [
(x0, 1),
(x1, 2),
(x2, 6),
(x3, 9),
(x1, 3),
(x2, 7),
(x1, 4),
]
self.assertIsInstance(actual, Generator)
self.assertEqual(expected, list(actual))
def test_next_attribute(self):
obj = A(a0="foo", a1={"b": "c", "d": "e"})
meta = self.serializer.context.build(A)
actual = self.serializer.next_attribute(obj, meta, False, None)
expected = [
("a0", "foo"),
("b", "c"),
("d", "e"),
]
self.assertIsInstance(actual, Generator)
self.assertEqual(expected, list(actual))
actual = self.serializer.next_attribute(obj, meta, True, "xs:bool")
expected.extend([
(QNames.XSI_TYPE, "xs:bool"),
(QNames.XSI_NIL, "true"),
])
self.assertEqual(expected, list(actual))
def test_render_mixed_content(self):
@dataclass
class Span:
class Meta:
name = "span"
content: str
@dataclass
class Example:
class Meta:
name = "p"
content: List[object] = field(
default_factory=list,
metadata=dict(
type="Wildcard",
namespace="##any",
mixed=True,
min_occurs=0,
max_occurs=9223372036854775807,
),
)
obj = Example()
obj.content.append(AnyElement(qname="b", text="Mr."))
obj.content.append(Span("chris"))
obj.content.append("!")
self.serializer.pretty_print = False
result = self.serializer.render(obj).splitlines()
self.assertEqual("<p><b>Mr.</b><span>chris</span>!</p>", result[1])
obj = Example()
obj.content.append("Hi ")
obj.content.append(AnyElement(qname="b", text="Mr."))
obj.content.append(Span("chris"))
obj.content.append("!")
result = self.serializer.render(obj).splitlines()
self.assertEqual("<p>Hi <b>Mr.</b><span>chris</span>!</p>", result[1])