def assertXmlEqual(self, got, want):
""" fail if the two objects are not equal XML serializations
In case of a failure, both serializations are pretty printed
with differences marked.
There is not check well-formedness or against any schema, only
slightly intelligent matching of the tested string to the reference
string.
'...' can be used as a wildcard instead of nodes or attribute values.
Wildcard Examples:
<foo>...</foo>
<foo bar="..." />
Arguments:
got -- string to check, as unicode string
want -- reference string, as unicode string
Usage Example:
self.assertXmlEqual(etree.tounicode(...), reference)
"""
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assert_xml_equal(got, want):
got = lxml.html.tostring(got)
want = lxml.html.tostring(want)
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def test_encodeEntities(self):
doc = xtree('testdata/test_data.xml')
doc.parse(False)
r = xtree('testdata/r_test_encode.xml')
r.parse(False)
checker = LXMLOutputChecker()
self.assertTrue(checker.compare_docs(r.tree.getroot(),doc.tree.getroot()))
def assertXmlEqual(self, got, want):
""" fail if the two objects are not equal XML serializations
In case of a failure, both serializations are pretty printed
with differences marked.
There is not check well-formedness or against any schema, only
slightly intelligent matching of the tested string to the reference
string.
'...' can be used as a wildcard instead of nodes or attribute values.
Wildcard Examples:
<foo>...</foo>
<foo bar="..." />
Arguments:
got -- string to check, as unicode string
want -- reference string, as unicode string
Usage Example:
self.assertXmlEqual(etree.tounicode(...), reference)
"""
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assertXmlEqual(result, expect):
from doctest import Example
from lxml.doctestcompare import LXMLOutputChecker
checker = LXMLOutputChecker()
if not checker.check_output(expect, result, 0):
message = checker.output_difference(Example("", expect), result, 0)
raise AssertionError(message)
def assertXmlEqual(self, want, got):
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
for line in difflib.unified_diff(want.splitlines(1), got.splitlines(1), fromfile='want.xml', tofile='got.xml'):
print line
raise AssertionError(message)
def test_encodeEntities(self):
doc = xtree('testdata/test_data.xml')
doc.parse(False)
r = xtree('testdata/r_test_encode.xml')
r.parse(False)
checker = LXMLOutputChecker()
self.assertTrue(
checker.compare_docs(r.tree.getroot(), doc.tree.getroot()))
def assert_xml_equal(expected_xml, got_xml, context_explanation=""):
checker = LXMLOutputChecker()
if not checker.check_output(expected_xml, got_xml, 0):
raise AssertionError("{context_explanation}{xml_diff}".format(
context_explanation=("" if not context_explanation else
"\n{0}\n".format(context_explanation)),
xml_diff=checker.output_difference(
doctest.Example("", expected_xml), got_xml, 0)))
def assert_xml_equal(got, want):
assert want is not None, 'Wanted XML cannot be None'
if got is None:
raise AssertionError('Got input to validate was None')
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assertXmlEqual(self, want, got):
# snippet from http://stackoverflow.com/questions/321795/comparing-xml-in-a-unit-test-in-python/7060342#7060342
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = "XML mismatch\n\n"
for line in difflib.unified_diff(want.splitlines(1), got.splitlines(1), fromfile='want.xml', tofile='got.xml'):
message += line + '\n'
raise AssertionError(message)
def assert_xml_equal(expected_xml, got_xml):
checker = LXMLOutputChecker()
if not checker.check_output(expected_xml, got_xml, 0):
raise AssertionError(checker.output_difference(
doctest.Example("", expected_xml),
got_xml,
0
))
def assert_xml_equal(got, want):
assert want is not None, 'Wanted XML cannot be None'
if got is None:
raise AssertionError('Got input to validate was None')
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assertXmlEqual(got, want):
from lxml.doctestcompare import LXMLOutputChecker
from doctest import Example
checker = LXMLOutputChecker()
if checker.check_output(want, got, 0):
return
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assertXmlEqual(self, got, want):
if isinstance(got, (et._Element, et._ElementTree)):
got = et.tostring(got).decode()
if isinstance(want, (et._Element, et._ElementTree)):
want = et.tostring(want).decode()
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assertXmlEqual(self, got, want):
from lxml.doctestcompare import LXMLOutputChecker
from doctest import Example
checker = LXMLOutputChecker()
if checker.check_output(want, got, 0):
return
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def test_insertPIBefore(self):
doc = xtree('testdata/test_wrap.xml')
doc.parse(False)
for text in doc.tree.xpath('//text'):
pi = etree.ProcessingInstruction('PI', 'Pb')
doc.insert_node(text,'stuff',pi,True)
r = xtree('testdata/r_test_insertPIBefore.xml')
r.parse(False)
checker = LXMLOutputChecker()
self.assertTrue(checker.compare_docs(r.tree.getroot(),doc.tree.getroot()))
def assertXmlFilesEqual(self, result_filename, expected_filename):
with open(result_filename) as rf:
got = rf.read()
with open(expected_filename) as ef:
want = ef.read()
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", got), want, 0)
raise AssertionError(message)
def test_insertPIBefore(self):
doc = xtree('testdata/test_wrap.xml')
doc.parse(False)
for text in doc.tree.xpath('//text'):
pi = etree.ProcessingInstruction('PI', 'Pb')
doc.insert_node(text, 'stuff', pi, True)
r = xtree('testdata/r_test_insertPIBefore.xml')
r.parse(False)
checker = LXMLOutputChecker()
self.assertTrue(
checker.compare_docs(r.tree.getroot(), doc.tree.getroot()))
def assert_xml_equal(got: Union[bytes, str], want: str):
"""Compare two XML strings."""
checker = LXMLOutputChecker()
if isinstance(got, str) and got.startswith("<?"):
# Strip <?xml version='1.0' encoding="UTF-8" ?>
got = got[got.index("?>") + 3 :]
if not checker.check_output(want, got, PARSE_XML):
example = Example("", "")
example.want = want # unencoded, avoid doctest for bytes type.
message = checker.output_difference(example, got, PARSE_XML)
raise AssertionError(message)
def assertXmlEquivalent(self, got, expect):
"""Asserts both xml parse to the same results
`got` may be an XML string or lxml Element
"""
checker = LXMLOutputChecker()
if isinstance(got, etree._Element):
got = etree.tostring(got)
if not checker.check_output(expect, got, PARSE_XML):
message = checker.output_difference(doctest.Example("", expect), got, PARSE_XML)
self.fail(message)
def assertXmlEquivalent(self, got, expect):
"""Asserts both xml parse to the same results
`got` may be an XML string or lxml Element
"""
checker = LXMLOutputChecker()
if isinstance(got, etree._Element):
got = etree.tostring(got)
if not checker.check_output(expect, got, PARSE_XML):
message = checker.output_difference(doctest.Example("", expect),
got, PARSE_XML)
self.fail(message)
def test_wrap(self):
doc = xtree('testdata/test_wrap.xml')
doc.parse(False)
if not doc.is_valid:
if not doc.errors is None: print(doc.errors)
for text in doc.tree.xpath('//text'):
el = etree.Element('EL')
el.set('atr', 'test')
doc.wrap_text(text,'text',el)
r = xtree('testdata/r_test_wrap.xml')
r.parse(False)
checker = LXMLOutputChecker()
self.assertTrue(checker.compare_docs(r.tree.getroot(),doc.tree.getroot()))
def assertEqualXML(test, expected):
output_checker = LXMLOutputChecker()
if not output_checker.check_output(expected, test, PARSE_XML):
diff = output_checker.output_difference(Example("", expected), test, PARSE_XML)
msg = diff
for line in diff.split("\n"):
if msg == diff:
msg = msg + "\nDiff summary:\n"
if "got:" in line or line.strip().startswith(('+', '-')):
msg = msg + line + "\n"
if msg == "":
msg = diff
raise AssertionError(msg)
def assertEqualXML(test, expected):
output_checker = LXMLOutputChecker()
if not output_checker.check_output(expected, test, PARSE_XML):
diff = output_checker.output_difference(Example("", expected), test,
PARSE_XML)
msg = diff
for line in diff.split("\n"):
if msg == diff:
msg = msg + "\nDiff summary:\n"
if "got:" in line or line.strip().startswith(('+', '-')):
msg = msg + line + "\n"
if msg == "":
msg = diff
raise AssertionError(msg)
def compare_xml(generated, expected):
"""Use doctest checking from lxml for comparing XML trees. Returns diff if the two are not the same"""
checker = LXMLOutputChecker()
class DummyDocTest():
pass
ob = DummyDocTest()
ob.want = generated
check = checker.check_output(expected, generated, PARSE_XML)
if check is False:
diff = checker.output_difference(ob, expected, PARSE_XML)
return diff
def compare_xml(generated, expected):
"""Use doctest checking from lxml for comparing XML trees. Returns diff if the two are not the same"""
checker = LXMLOutputChecker()
class DummyDocTest():
pass
ob = DummyDocTest()
ob.want = expected
check = checker.check_output(expected, generated, PARSE_XML)
if check is False:
diff = checker.output_difference(ob, generated, PARSE_XML)
return diff
def assertXmlEquivalentOutputs(self, data, expected):
"""Asserts both XML outputs are equivalent.
This assertion use the powerful but dangerous feature of
LXMLOutputChecker. Powerful because one can compare two XML document
in their meaning, but dangerous because sometimes there is more to
check than just a kind of output.
See LXMLOutputChecker documentation for more information.
"""
checker = LXMLOutputChecker()
if not checker.check_output(expected, data, PARSE_XML):
self.fail("Output are not equivalent:\n" "Given: %s\n" "Expected: %s" % (data, expected))
def test_wrap(self):
doc = xtree('testdata/test_wrap.xml')
doc.parse(False)
if not doc.is_valid:
if not doc.errors is None: print(doc.errors)
for text in doc.tree.xpath('//text'):
el = etree.Element('EL')
el.set('atr', 'test')
doc.wrap_text(text, 'text', el)
r = xtree('testdata/r_test_wrap.xml')
r.parse(False)
checker = LXMLOutputChecker()
self.assertTrue(
checker.compare_docs(r.tree.getroot(), doc.tree.getroot()))
def assert_xml_equal(expected_xml, got_xml, context_explanation=""):
checker = LXMLOutputChecker()
if not checker.check_output(expected_xml, got_xml, 0):
raise AssertionError(
"{context_explanation}{xml_diff}".format(
context_explanation=(
"" if not context_explanation
else "\n{0}\n".format(context_explanation)
),
xml_diff=checker.output_difference(
doctest.Example("", expected_xml),
got_xml,
0
)
)
)
def assertXmlEquivalentOutputs(self, data, expected):
"""Asserts both XML outputs are equivalent.
This assertion use the powerful but dangerous feature of
LXMLOutputChecker. Powerful because one can compare two XML document
in their meaning, but dangerous because sometimes there is more to
check than just a kind of output.
See LXMLOutputChecker documentation for more information.
"""
checker = LXMLOutputChecker()
if not checker.check_output(expected, data, PARSE_XML):
self.fail('Output are not equivalent:\n'
'Given: %s\n'
'Expected: %s' % (data, expected))
def test_fault_generation(self):
class SoapException(ServiceBase):
@srpc()
def soap_exception():
raise Fault("Client.Plausible", "A plausible fault",
'http://faultactor.example.com')
app = Application([SoapException],
'tns',
in_protocol=Soap12(),
out_protocol=Soap12())
req = b"""
<soap12env:Envelope
xmlns:soap12env="http://www.w3.org/2003/05/soap-envelope"
xmlns:tns="tns">
<soap12env:Body>
<tns:soap_exception/>
</soap12env:Body>
</soap12env:Envelope>
"""
server = WsgiApplication(app)
response = etree.fromstring(b''.join(
server(
{
'QUERY_STRING': '',
'PATH_INFO': '/call',
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': 'text/xml; charset=utf8',
'wsgi.input': BytesIO(req)
}, start_response, "http://null")))
response_str = etree.tostring(response, pretty_print=True)
print(response_str)
expected = b"""
<soap12env:Envelope xmlns:soap12env="http://www.w3.org/2003/05/soap-envelope">
<soap12env:Body>
<soap12env:Fault>
<soap12env:Reason>
<soap12env:Text xml:lang="en">A plausible fault</soap12env:Text>
</soap12env:Reason>
<soap12env:Role>http://faultactor.example.com</soap12env:Role>
<soap12env:Code>
<soap12env:Value>soap12env:Sender</soap12env:Value>
<soap12env:Subcode>
<soap12env:Value>Plausible</soap12env:Value>
</soap12env:Subcode>
</soap12env:Code>
</soap12env:Fault>
</soap12env:Body>
</soap12env:Envelope>"""
if not LXMLOutputChecker().check_output(expected, response_str,
PARSE_XML):
raise Exception("Got: %s but expected: %s" %
(response_str, expected))
def assertXmlEqual(self, expected, actual, normalize=True):
if normalize:
expected = parse_normalize(expected)
actual = parse_normalize(actual)
# snippet from http://stackoverflow.com/questions/321795/comparing-xml-in-a-unit-test-in-python/7060342#7060342
checker = LXMLOutputChecker()
if not checker.check_output(expected, actual, 0):
message = "XML mismatch\n\n"
diff = difflib.unified_diff(
expected.splitlines(1),
actual.splitlines(1),
fromfile='want.xml',
tofile='got.xml'
)
for line in diff:
message += line
raise AssertionError(message)
class DoctestCompareTest(HelperTestCase):
_checker = LXMLOutputChecker()
def compare(self, want, got, html=False):
if html:
options = PARSE_HTML
else:
options = PARSE_XML
parse = self._checker.get_parser(want, got, options)
want_doc = parse(want)
got_doc = parse(got)
return self._checker.collect_diff(
want_doc, got_doc, html, indent=0).lstrip()
def assert_diff(self, want, got, diff, html=False):
self.assertEqual(self.compare(want, got, html), diff)
def assert_nodiff(self, want, got, html=False):
root = etree.fromstring(want)
root.tail = '\n'
indent(root)
diff = etree.tostring(
root, encoding='unicode', method=html and 'html' or 'xml')
self.assert_diff(want, got, diff, html=html)
def test_equal_input(self):
self.assert_nodiff(
'<p title="expected">Expected</p>',
'<p title="expected">Expected</p>')
def test_differing_tags(self):
self.assert_diff(
'<p title="expected">Expected</p>',
'<b title="expected">Expected</b>',
'<p (got: b) title="expected">Expected</p (got: b)>\n')
def test_tags_upper_lower_case(self):
self.assert_diff(
'<p title="expected">Expected</p>',
'<P title="expected">Expected</P>',
'<p (got: P) title="expected">Expected</p (got: P)>\n')
def test_tags_upper_lower_case_html(self):
self.assert_nodiff(
'<html><body><p title="expected">Expected</p></body></html>',
'<HTML><BODY><P title="expected">Expected</P></BODY></HTML>',
html=True)
def test_differing_attributes(self):
self.assert_diff(
'<p title="expected">Expected</p>',
'<p title="actual">Actual</p>',
'<p title="expected (got: actual)">Expected (got: Actual)</p>\n')
def assertXmlEqual(self, expected, actual, normalize=True):
if normalize:
parser = lxml.etree.XMLParser(remove_blank_text=True)
parse = lambda *args: normalize_attributes(lxml.etree.XML(*args))
expected = lxml.etree.tostring(parse(expected, parser), pretty_print=True)
actual = lxml.etree.tostring(parse(actual, parser), pretty_print=True)
# snippet from http://stackoverflow.com/questions/321795/comparing-xml-in-a-unit-test-in-python/7060342#7060342
checker = LXMLOutputChecker()
if not checker.check_output(expected, actual, 0):
message = "XML mismatch\n\n"
diff = difflib.unified_diff(
expected.splitlines(1),
actual.splitlines(1),
fromfile='want.xml',
tofile='got.xml'
)
for line in diff:
message += line
raise AssertionError(message)
def check_etree(self, conv, tostring=tostring, fromstring=fromstring):
'Returns method(obj, xmlstring) that converts obj to XML and compares'
checker = LXMLOutputChecker()
eq = checker.compare_docs
def compare(obj, *strings):
tree = conv.etree(obj)
self.assertEqual(len(tree), len(strings))
for left, right in zip(tree, strings):
if not eq(left, fromstring(right)):
raise AssertionError('%s != %s' % (decode(tostring(left)), right))
return compare
def assert_xml_equals(reference, result):
"""Compare if XML documents are equal except formatting."""
checker = LXMLOutputChecker()
if not checker.check_output(reference, result, 0):
message = checker.output_difference(Example("", reference), result, 0)
pytest.fail(message)
def setUp(self):
self.checker = LXMLOutputChecker()
class TestXform(unittest.TestCase):
def setUp(self):
self.checker = LXMLOutputChecker()
def test_should_return_list_of_required_forms(self):
form_tuples = [("name", "id", False), ("name2", "id2", False)]
base_url = "baseURL"
self.assertEqual(list_all_forms(form_tuples, base_url),
unicode(expected_response_for_get_all_forms))
def mock_constraint(self):
mock_constraint = Mock()
mock_constraint.xform_constraint.return_value = 'constraint'
return mock_constraint
def test_should_return_specific_form_for_project_without_unique_id(self):
dbm = Mock()
questionnaire_mock = Mock()
field1 = Field(type='text',
name='name',
label='name',
code='code',
instruction='instruction',
constraints=[(self.mock_constraint())])
questionnaire_mock.name = 'name'
questionnaire_mock.fields = [field1]
questionnaire_mock.form_code = 'form_code'
questionnaire_mock.id = 'id'
questionnaire_mock.unique_id_field = None
questionnaire_mock.activeLanguages = ["en"]
questionnaire_mock.xform = None
with patch("mangrove.transport.xforms.xform.FormModel"
) as form_model_mock:
form_model_mock.get.return_value = questionnaire_mock
actual_response = xform_for(dbm, "someFormId", 'rep1')
self.assertTrue(
self.checker.check_output(
actual_response,
unicode(expected_xform_for_project_on_reporter), 0),
actual_response)
def text_field(self, code):
return Field(type='text',
name='name',
label='name',
code=code,
instruction='instruction',
constraints=[(self.mock_constraint())])
def test_should_return_specific_form_for_project_with_unique_id(self):
dbm = Mock(spec=DatabaseManager)
questionnaire_mock = MagicMock()
field1 = self.text_field(code='code')
questionnaire_mock.name = 'name'
unique_id_field = UniqueIdField("clinic",
"cl",
"cl",
"Clinic",
instruction="")
questionnaire_mock.fields = [field1, unique_id_field]
questionnaire_mock.form_code = 'form_code'
questionnaire_mock.id = 'id'
questionnaire_mock.activeLanguages = ["en"]
questionnaire_mock.entity_questions = [
self.text_field(code='entity_question_code')
]
questionnaire_mock.xform = None
entity1 = Entity(dbm, short_code="shortCode1", entity_type="someType")
entity1._doc.data['name'] = {'value': 'nameOfEntity'}
entities = [entity1, entity1]
with patch("mangrove.transport.xforms.xform.FormModel"
) as form_model_mock:
with patch("mangrove.form_model.field.get_all_entities"
) as get_all_entities_mock:
get_all_entities_mock.return_value = entities
form_model_mock.get.return_value = questionnaire_mock
actual_response = xform_for(dbm, "someFormId", 'rep1')
self.assertTrue(
self.checker.check_output(
actual_response,
unicode(expected_xform_for_project_with_unique_id), 0),
actual_response)
def test_should_escape_special_characters_from_requested_form(self):
dbm = Mock()
questionnaire_mock = Mock()
field1 = SelectField(name='name&',
label='name&',
code='selectcode',
instruction='instruction&',
options=[{
'text': 'option1&',
'val': 'o1'
}])
questionnaire_mock.name = '<mock_name'
questionnaire_mock.fields = [field1]
questionnaire_mock.form_code = 'form_code'
questionnaire_mock.id = 'id'
questionnaire_mock.unique_id_field = None
questionnaire_mock.xform = None
with patch("mangrove.transport.xforms.xform.FormModel"
) as form_model_mock:
form_model_mock.get.return_value = questionnaire_mock
one_of_unicode_unknown_ = xform_for(dbm, "someFormId", 'rep1')
expected = unicode(expected_xform_with_escaped_characters)
self.assertTrue(
self.checker.check_output(one_of_unicode_unknown_, expected,
0))
def assertXmlEqual(self, want, got):
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def test_receiveItemBarCode_soap():
from io import BytesIO
from lxml import etree
from lxml.doctestcompare import LXMLOutputChecker, PARSE_XML
from spyne import srpc, Array, Integer, ServiceBase
from spyne.protocol.soap import Soap11
from spyne.server.wsgi import WsgiApplication
from soapser import NAMESPACE
req = b"""
<soap11env:Envelope
xmlns:soap11env="http://schemas.xmlsoap.org/soap/envelope/">
<soap11env:Body>
<s0:receiveItemBarCode xmlns:s0="Flow/Services/Custom">
<s0:tXml>
<s0:Header>
<s0:Message_Type>mt</s0:Message_Type>
<s0:Company_ID>ci</s0:Company_ID>
<s0:Version>v</s0:Version>
<s0:Source>s</s0:Source>
<s0:Destination>d</s0:Destination>
<s0:Action_Type>read</s0:Action_Type>
<s0:Sequence_Number>1</s0:Sequence_Number>
<s0:Batch_ID>bi</s0:Batch_ID>
<s0:Reference_ID>ri</s0:Reference_ID>
<s0:Msg_Locale>ml</s0:Msg_Locale>
<s0:Msg_Time_Zone>mtz</s0:Msg_Time_Zone>
<s0:Internal_Date_Time_Stamp>idts</s0:Internal_Date_Time_Stamp>
</s0:Header>
<s0:Message>
<s0:ItemBarCodeList>
<s0:ItemBarCode>
<s0:IsPrimary>ip</s0:IsPrimary>
<s0:ItemCode>ic</s0:ItemCode>
<s0:Barcode>b</s0:Barcode>
<s0:Quantity>q</s0:Quantity>
<s0:ActionType>at</s0:ActionType>
<s0:BarcodeType>bt</s0:BarcodeType>
<s0:Extensions>
<s0:FieldCode>fc</s0:FieldCode>
<s0:FieldCodeDesc>fcd</s0:FieldCodeDesc>
<s0:FieldValue>fv</s0:FieldValue>
</s0:Extensions>
<s0:Extensions>
<s0:FieldCode>fc</s0:FieldCode>
<s0:FieldCodeDesc>fcd</s0:FieldCodeDesc>
<s0:FieldValue>fv</s0:FieldValue>
</s0:Extensions>
</s0:ItemBarCode>
<s0:ItemBarCode>
<s0:IsPrimary>ip</s0:IsPrimary>
<s0:ItemCode>ic</s0:ItemCode>
<s0:Barcode>b</s0:Barcode>
<s0:Quantity>q</s0:Quantity>
<s0:ActionType>at</s0:ActionType>
<s0:BarcodeType>bt</s0:BarcodeType>
<s0:Extensions>
<s0:FieldCode>fc</s0:FieldCode>
<s0:FieldCodeDesc>fcd</s0:FieldCodeDesc>
<s0:FieldValue>fv</s0:FieldValue>
</s0:Extensions>
<s0:Extensions>
<s0:FieldCode>fc</s0:FieldCode>
<s0:FieldCodeDesc>fcd</s0:FieldCodeDesc>
<s0:FieldValue>fv</s0:FieldValue>
</s0:Extensions>
</s0:ItemBarCode>
</s0:ItemBarCodeList>
</s0:Message>
</s0:tXml>
</s0:receiveItemBarCode>
</soap11env:Body>
</soap11env:Envelope>
"""
app = Application([rpc.receiveItemBarCodeService],
NAMESPACE,
in_protocol=Soap11(validator='lxml'),
out_protocol=Soap11(validator='lxml'))
server = WsgiApplication(app)
response = b''.join(
server(
{
#'QUERY_STRING': '',
#'PATH_INFO': '/call',
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': 'text/xml',
'wsgi.input': BytesIO(req)
},
lambda a, b: None,
"http://null"))
expected = b"""
<soap11env:Envelope
xmlns:soap11env="http://schemas.xmlsoap.org/soap/envelope/">
<soap11env:Body>
<s0:receiveItemBarCodeResponse xmlns:s0="Flow/Services/Custom">
<s0:receiveItemBarCodeResult>true</s0:receiveItemBarCodeResult>
<s0:responseHeader>
<s0:ReturnType>ItemCrossReference</s0:ReturnType>
<s0:ReturnCode>Success</s0:ReturnCode>
<s0:ReturnMessage>
ItemCrossReference Interface Process Completed Successfully
</s0:ReturnMessage>
</s0:responseHeader>
</s0:receiveItemBarCodeResponse>
</soap11env:Body>
</soap11env:Envelope>"""
if not LXMLOutputChecker().check_output(expected, response, PARSE_XML):
raise Exception("Got: %s but expected: %s" % (response, expected))
def test_receiveItemMaster_soap():
from io import BytesIO
from lxml import etree
from lxml.doctestcompare import LXMLOutputChecker, PARSE_XML
from spyne import srpc, Array, Integer, ServiceBase
from spyne.protocol.soap import Soap11
from spyne.server.wsgi import WsgiApplication
from soapser import NAMESPACE
req = b"""
<soap11env:Envelope
xmlns:soap11env="http://schemas.xmlsoap.org/soap/envelope/">
<soap11env:Body>
<s0:receiveItemMaster xmlns:s0="Flow/Services/Custom">
<s0:tXml>
<s0:Header>
<s0:Message_Type>mt</s0:Message_Type>
<s0:Company_ID>ci</s0:Company_ID>
<s0:Version>v</s0:Version>
<s0:Source>s</s0:Source>
<s0:Destination>d</s0:Destination>
<s0:Action_Type>read</s0:Action_Type>
<s0:Sequence_Number>1</s0:Sequence_Number>
<s0:Batch_ID>bi</s0:Batch_ID>
<s0:Reference_ID>ri</s0:Reference_ID>
<s0:Msg_Locale>ml</s0:Msg_Locale>
<s0:Msg_Time_Zone>mtz</s0:Msg_Time_Zone>
<s0:Internal_Date_Time_Stamp>idts</s0:Internal_Date_Time_Stamp>
</s0:Header>
<s0:Message>
<s0:Item>
<s0:ItemCode>ic</s0:ItemCode>
<s0:IsStyle>is</s0:IsStyle>
<s0:ActionType>at</s0:ActionType>
<s0:ActivationDate>ad</s0:ActivationDate>
<s0:TargetExclusive>te</s0:TargetExclusive>
<s0:OnlineExclusive>oe</s0:OnlineExclusive>
<s0:EssentialItem>ei</s0:EssentialItem>
<s0:LongDescription>ld</s0:LongDescription>
<s0:ShortDescription>sd</s0:ShortDescription>
<s0:PrimaryBarcode>pb</s0:PrimaryBarcode>
<s0:HazmatCode>hc</s0:HazmatCode>
<s0:BulkyItem>bi</s0:BulkyItem>
<s0:ItemWeight>iw</s0:ItemWeight>
<s0:ItemHeight>ih</s0:ItemHeight>
<s0:ItemLength>il</s0:ItemLength>
<s0:ItemWidth>iw</s0:ItemWidth>
<s0:ItemVolume>iv</s0:ItemVolume>
<s0:WeightUOM>wu</s0:WeightUOM>
<s0:DimensionUOM>du</s0:DimensionUOM>
<s0:VolumeUOM>vu</s0:VolumeUOM>
<s0:IsPerishable>ip</s0:IsPerishable>
<s0:ItemPackageList>
<s0:ItemPackage>
<s0:PackageType>pt</s0:PackageType>
<s0:Description>d</s0:Description>
<s0:Quantity>q</s0:Quantity>
<s0:UnitWeight>uw</s0:UnitWeight>
<s0:UnitWidth>uw</s0:UnitWidth>
<s0:UnitLength>ul</s0:UnitLength>
<s0:UnitHeight>uh</s0:UnitHeight>
<s0:UnitVolume>uv</s0:UnitVolume>
<s0:WeigthUOM>wu</s0:WeigthUOM>
<s0:DimensionUOM>du</s0:DimensionUOM>
<s0:VolumeUOM>vu</s0:VolumeUOM>
<s0:IsPrimary>ip</s0:IsPrimary>
<s0:BusinessPartnerNumber>bpn</s0:BusinessPartnerNumber>
<s0:Ti>ti</s0:Ti>
<s0:Hi>hi</s0:Hi>
</s0:ItemPackage>
</s0:ItemPackageList>
<s0:ProductHeirarchy>
<s0:Variant>v</s0:Variant>
<s0:Product>p</s0:Product>
<s0:MerchandiseStyle>ms</s0:MerchandiseStyle>
<s0:Range>r</s0:Range>
<s0:MajorClass>mc</s0:MajorClass>
<s0:ClassGroup>cg</s0:ClassGroup>
<s0:Department>d</s0:Department>
<s0:BusinessGroup>bg</s0:BusinessGroup>
<s0:Section>s</s0:Section>
<s0:Company>c</s0:Company>
</s0:ProductHeirarchy>
<s0:ItemBarCodeList>
<s0:ItemBarCode>
<s0:IsPrimary>ip</s0:IsPrimary>
<s0:Barcode>b</s0:Barcode>
<s0:Quantity>q</s0:Quantity>
<s0:ActionType>at</s0:ActionType>
<s0:BarcodeType>bt</s0:BarcodeType>
</s0:ItemBarCode>
<s0:ItemBarCode>
<s0:IsPrimary>ip</s0:IsPrimary>
<s0:Barcode>b</s0:Barcode>
<s0:Quantity>q</s0:Quantity>
<s0:ActionType>at</s0:ActionType>
<s0:BarcodeType>bt</s0:BarcodeType>
</s0:ItemBarCode>
</s0:ItemBarCodeList>
<s0:PerishableAttribute>
<s0:ShelfDays>sd</s0:ShelfDays>
<s0:ExpireDateReqd>edr</s0:ExpireDateReqd>
<s0:MinReceivedToExpireDays>mrted</s0:MinReceivedToExpireDays>
<s0:MaxReceivedToExpireDays>mrted</s0:MaxReceivedToExpireDays>
</s0:PerishableAttribute>
<s0:WarehouseAttributes>
<s0:SecureProduct>sp</s0:SecureProduct>
<s0:Conveyable>c</s0:Conveyable>
<s0:PutawayType>pt</s0:PutawayType>
<s0:CrushCode>cc</s0:CrushCode>
<s0:VolatilityCode>vc</s0:VolatilityCode>
</s0:WarehouseAttributes>
<s0:Slotting>
<s0:LocationCode>lc</s0:LocationCode>
<s0:SlottingRequired>sr</s0:SlottingRequired>
</s0:Slotting>
<s0:Slotting>
<s0:LocationCode>lc</s0:LocationCode>
<s0:SlottingRequired>sr</s0:SlottingRequired>
</s0:Slotting>
<s0:ItemPromotion>
<s0:OnPromo>op</s0:OnPromo>
<s0:PromoStartWeek>psw</s0:PromoStartWeek>
</s0:ItemPromotion>
<s0:ItemAttributes>
<s0:AttributeTypeId>ati</s0:AttributeTypeId>
<s0:AttributeTypeDesc>atd</s0:AttributeTypeDesc>
<s0:AttributeHeaderId>ahi</s0:AttributeHeaderId>
<s0:AttributeHeaderDesc>ahd</s0:AttributeHeaderDesc>
<s0:AttributeCodeId>aci</s0:AttributeCodeId>
<s0:AttributeCode>ac</s0:AttributeCode>
<s0:AttributeCodeDesc>acd</s0:AttributeCodeDesc>
</s0:ItemAttributes>
<s0:ItemAttributes>
<s0:AttributeTypeId>ati</s0:AttributeTypeId>
<s0:AttributeTypeDesc>atd</s0:AttributeTypeDesc>
<s0:AttributeHeaderId>ahi</s0:AttributeHeaderId>
<s0:AttributeHeaderDesc>ahd</s0:AttributeHeaderDesc>
<s0:AttributeCodeId>aci</s0:AttributeCodeId>
<s0:AttributeCode>ac</s0:AttributeCode>
<s0:AttributeCodeDesc>acd</s0:AttributeCodeDesc>
</s0:ItemAttributes>
<s0:Extensions>
<s0:FieldCode>fc</s0:FieldCode>
<s0:FieldCodeDesc>fcd</s0:FieldCodeDesc>
<s0:FieldValue>fv</s0:FieldValue>
</s0:Extensions>
<s0:Extensions>
<s0:FieldCode>fc</s0:FieldCode>
<s0:FieldCodeDesc>fcd</s0:FieldCodeDesc>
<s0:FieldValue>fv</s0:FieldValue>
</s0:Extensions>
</s0:Item>
</s0:Message>
</s0:tXml>
</s0:receiveItemMaster>
</soap11env:Body>
</soap11env:Envelope>
"""
app = Application([rpc.receiveItemMasterService],
NAMESPACE,
in_protocol=Soap11(validator='lxml'),
out_protocol=Soap11(validator='lxml'))
server = WsgiApplication(app)
response = b''.join(
server(
{
#'QUERY_STRING': '',
#'PATH_INFO': '/call',
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': 'text/xml',
'wsgi.input': BytesIO(req)
},
lambda a, b: None,
"http://null"))
expected = b"""
<soap11env:Envelope
xmlns:soap11env="http://schemas.xmlsoap.org/soap/envelope/">
<soap11env:Body>
<s0:receiveItemMasterResponse xmlns:s0="Flow/Services/Custom">
<s0:receiveItemMasterResult>true</s0:receiveItemMasterResult>
<s0:responseHeader>
<s0:ReturnType>Item Master</s0:ReturnType>
<s0:ReturnCode>Success</s0:ReturnCode>
<s0:ReturnMessage>
Item Master Interface Process Completed Successfully
</s0:ReturnMessage>
</s0:responseHeader>
</s0:receiveItemMasterResponse>
</soap11env:Body>
</soap11env:Envelope>"""
if not LXMLOutputChecker().check_output(expected, response, PARSE_XML):
raise Exception("Got: %s but expected: %s" % (response, expected))
def compare_xml(expected, given, diff_format=PARSE_XML):
checker = LXMLOutputChecker()
if not checker.check_output(expected.strip(), given.strip(), PARSE_XML):
raise AssertionError(checker.output_difference(Example('', expected), given.decode('utf8'), diff_format))
def assertXmlEqual(self, want, got):
checker = LXMLOutputChecker()
if not checker.check_output(want, got, 0):
message = checker.output_difference(Example("", want), got, 0)
raise AssertionError(message)
def assertXmlEqual(self, expected, actual, normalize=True):
if normalize:
expected = parse_normalize(expected)
actual = parse_normalize(actual)
_check_shared(expected, actual, LXMLOutputChecker(), "xml")
class DoctestCompareTest(HelperTestCase):
_checker = LXMLOutputChecker()
def compare(self, want, got, html=False):
if html:
options = PARSE_HTML
else:
options = PARSE_XML
parse = self._checker.get_parser(want, got, options)
want_doc = parse(want)
got_doc = parse(got)
return self._checker.collect_diff(want_doc, got_doc, html,
indent=0).lstrip()
def assert_diff(self, want, got, diff, html=False):
self.assertEqual(self.compare(want, got, html), diff)
def assert_nodiff(self, want, got, html=False):
root = etree.fromstring(want)
root.tail = '\n'
indent(root)
diff = etree.tostring(root,
encoding='unicode',
method=html and 'html' or 'xml')
self.assert_diff(want, got, diff, html=html)
def test_equal_input(self):
self.assert_nodiff('<p title="expected">Expected</p>',
'<p title="expected">Expected</p>')
def test_differing_tags(self):
self.assert_diff(
'<p title="expected">Expected</p>',
'<b title="expected">Expected</b>',
'<p (got: b) title="expected">Expected</p (got: b)>\n')
def test_tags_upper_lower_case(self):
self.assert_diff(
'<p title="expected">Expected</p>',
'<P title="expected">Expected</P>',
'<p (got: P) title="expected">Expected</p (got: P)>\n')
def test_tags_upper_lower_case_html(self):
self.assert_nodiff(
'<html><body><p title="expected">Expected</p></body></html>',
'<HTML><BODY><P title="expected">Expected</P></BODY></HTML>',
html=True)
def test_differing_attributes(self):
self.assert_diff(
'<p title="expected">Expected</p>', '<p title="actual">Actual</p>',
'<p title="expected (got: actual)">Expected (got: Actual)</p>\n')
def test_extra_children(self):
# https://bugs.launchpad.net/lxml/+bug/1238503
self.assert_diff(
'<p><span>One</span></p>',
'<p><span>One</span><b>Two</b><em>Three</em></p>', '<p>\n'
' <span>One</span>\n'
' +<b>Two</b>\n'
' +<em>Three</em>\n'
'</p>\n')
def test_missing_children(self):
self.assert_diff(
'<p><span>One</span><b>Two</b><em>Three</em></p>',
'<p><span>One</span></p>', '<p>\n'
' <span>One</span>\n'
' -<b>Two</b>\n'
' -<em>Three</em>\n'
'</p>\n')
def test_extra_attributes(self):
self.assert_diff(
'<p><span class="foo">Text</span></p>',
'<p><span class="foo" id="bar">Text</span></p>', '<p>\n'
' <span class="foo" +id="bar">Text</span>\n'
'</p>\n')
def test_missing_attributes(self):
self.assert_diff(
'<p><span class="foo" id="bar">Text</span></p>',
'<p><span class="foo">Text</span></p>', '<p>\n'
' <span class="foo" -id="bar">Text</span>\n'
'</p>\n')
