compare two XML in python

test_xmldiff.py

import json
import unittest
import xmltodict


class XmlDiff(object):
    def __init__(self, xml1, xml2):
        self.dict1 = json.loads(json.dumps((xmltodict.parse(xml1))))
        self.dict2 = json.loads(json.dumps((xmltodict.parse(xml2))))

    @staticmethod
    def ignore_in_dict(dict1):
        for i in dict1.values():
            if i == "%%IGNORE%%":
                return True
        return False

    def remove_ignore_field(self, dict_returned, dict_expected):
        for expected_keys, expected_values in dict_expected.items():
            if isinstance(expected_values, dict):
                if self.ignore_in_dict(expected_values):
                    del dict_expected[expected_keys]
                    del dict_returned[expected_keys]
                if expected_keys in dict_returned:
                    self.remove_ignore_field(expected_values, dict_returned[expected_keys])
            elif type(expected_values) is list:
                list1 = []
                list2 = []
                for i, e in enumerate(expected_values):
                    if not self.ignore_in_dict(e):
                        list1.append(dict_expected[expected_keys][i])
                        list2.append(dict_returned[expected_keys][i])
                dict_expected[expected_keys] = list1
                dict_returned[expected_keys] = list2
        return dict_expected, dict_returned

    def equal(self):
        self.remove_ignore_field(self.dict1, self.dict2)
        return self.dict1 == self.dict2


class XMLDiffTestCase(unittest.TestCase):
    def test_xml_equal(self):
        xml1 = """<a></a>"""
        xml2 = """<a></a>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_xml_are_not_equal(self):
        xml1 = "<a></a>"
        xml2 = "<b></b>"
        self.assertFalse(XmlDiff(xml1, xml2).equal())

    def test_parameter_order_doesnt_matter(self):
        xml1 = """<a p1="1" p2="2"></a>"""
        xml2 = """<a p2="2" p1="1"></a>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_newline_doesnt_matter(self):
        xml1 = """<a></a>"""
        xml2 = """<a>
        </a>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_nested_tag(self):
        xml1 = """<a><b></b></a>"""
        xml2 = """
        <a>
            <b></b>
        </a>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_nested_tag_not_equal(self):
        xml1 = """<a><b></b><c><d></d></c><e></e></a>"""
        xml2 = """
        <a>
            <b></b>
        </a>
        """
        self.assertFalse(XmlDiff(xml1, xml2).equal())

    def test_nested_tag_parameter_not_equal(self):
        xml1 = """<t t="r" v="1"><f><p k="a" v="2"/></f></t>"""
        xml2 = """
        <t t="r" v="1">
            <f>
                <p k="a" v="1"/>
            </f>
        </t>"""
        self.assertFalse(XmlDiff(xml1, xml2).equal())

    def test_double_tag_equal(self):
        xml1 = """<t t="r" v="1"><f><p k="a" v="1"/><p k="b" v="2"/></f></t>"""
        xml2 = """
        <t t="r" v="1">
            <f>
                <p k="a" v="1"/>
                <p k="b" v="2"/>
            </f>
        </t>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_xml_equal_with_encoding(self):
        xml1 = """<?xml version='1.0' encoding='utf-8' standalone='yes'?>
        <Stats start="1275955200"   end="1276041599">
        </Stats>"""
        xml2 = """<?xml version='1.0' encoding='utf-8' standalone='yes'?>
        <Stats end="1276041599" start="1275955200" >
        </Stats>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_ignore_field(self):
        xml1 = """<t t="r" v="1"><f><p k="a" v="1"/><p k="b" v="2"/></f></t>"""
        xml2 = """
        <t t="r" v="1">
            <f>
                <p k="a" v="1"/>
                <p k="b" v="%%IGNORE%%"/>
            </f>
        </t>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_ignore_one_field(self):
        xml1 = """<t t="r" v="1"><f><p k="b" v="2"/></f></t>"""
        xml2 = """
        <t t="r" v="1">
            <f>
                <p k="b" v="%%IGNORE%%"/>
            </f>
        </t>"""
        self.assertTrue(XmlDiff(xml1, xml2).equal())

    def test_ignore_three_fields(self):
        xml1 = """<?xml version="1.0" ?><trophy type="result" version="1.0">
<status code="0" message="ok" />
<version>
<parameter key="version" value="%%IGNORE%%" />
<parameter key="build_date" value="%%IGNORE%%" />
<parameter key="type" value="%%IGNORE%%" />
</version>
</trophy>"""
        xml2 = """<?xml version="1.0" ?>
<trophy type="result" version="1.0">
	<status code="0" message="ok"/>
	<version>
		<parameter key="version" value="4.2.1.0"/>
		<parameter key="build_date" value="10/09/2015"/>
		<parameter key="type" value="Lite"/>
	</version>
</trophy>
"""
        self.assertTrue(XmlDiff(xml2, xml1).equal())

    def test_ingore_in_dict(self):
        dict1 = {u'@k': u'b', u'@v': u'%%IGNORE%%'}
        self.assertTrue(XmlDiff.ignore_in_dict(dict1))
        dict2 = {u'@k': u'b', u'@v': u'value'}
        self.assertFalse(XmlDiff.ignore_in_dict(dict2))

xmldiff.py

can u tell the xml comapirson before and after values and output shd be in text or csv file