Increase cluster-entities request timeout

[integration/test.git] / csit / libraries / XmlComparator.py

diff --git a/csit/libraries/XmlComparator.py b/csit/libraries/XmlComparator.py
index 3b0b829767280d9af96989b16d9f1c8df3f7fa15..6d05e7e9e21aae8272815de4dc090c0dab5b3cea 100644 (file)
--- a/csit/libraries/XmlComparator.py
+++ b/csit/libraries/XmlComparator.py
@@ -1,4 +1,4 @@
-'''
+"""

 Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
 
 This program and the accompanying materials are made available under the
 Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
 
 This program and the accompanying materials are made available under the


@@ -8,17 +8,16 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
 Created on May 21, 2014
 
 @author: <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
 Created on May 21, 2014
 
 @author: <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>

-'''
+"""

 from xml.dom.minidom import Element
 import ipaddr
 import xml.dom.minidom as md
 import copy
 
 from xml.dom.minidom import Element
 import ipaddr
 import xml.dom.minidom as md
 import copy
 

-KEY_NOT_FOUND = '<KEY_NOT_FOUND>'  # KeyNotFound for dictDiff
+KEY_NOT_FOUND = "<KEY_NOT_FOUND>"  # KeyNotFound for dictDiff

 
 
 
 

-class XMLtoDictParserTools():
-
+class XMLtoDictParserTools:

     @staticmethod
     def parseTreeToDict(node, returnedDict=None, ignoreList=[]):
         """
     @staticmethod
     def parseTreeToDict(node, returnedDict=None, ignoreList=[]):
         """


@@ -32,20 +31,24 @@ class XMLtoDictParserTools():
         @return: dict representation for the input DOM Element
         """
         returnedDict = {} if returnedDict is None else returnedDict
         @return: dict representation for the input DOM Element
         """
         returnedDict = {} if returnedDict is None else returnedDict

-        if (node.nodeType == Element.ELEMENT_NODE):
-            nodeKey = (node.localName).encode('utf-8', 'ignore')
+        if node.nodeType == Element.ELEMENT_NODE:
+            nodeKey = node.localName

             if nodeKey not in ignoreList:
                 if node.childNodes is not None:
                     childDict = {}
                     for child in node.childNodes:
                         if child.nodeType == Element.TEXT_NODE:
             if nodeKey not in ignoreList:
                 if node.childNodes is not None:
                     childDict = {}
                     for child in node.childNodes:
                         if child.nodeType == Element.TEXT_NODE:

-                            nodeValue = (child.nodeValue).encode('utf-8', 'ignore')
-                            if (len(nodeValue.strip(' \t\n\r'))) > 0:
-                                XMLtoDictParserTools.addDictValue(returnedDict, nodeKey, nodeValue)
+                            nodeValue = child.nodeValue
+                            if (len(nodeValue.strip(" \t\n\r"))) > 0:
+                                XMLtoDictParserTools.addDictValue(
+                                    returnedDict, nodeKey, nodeValue
+                                )

                                 nodeKey = None
                                 break
                         elif child.nodeType == Element.ELEMENT_NODE:
                                 nodeKey = None
                                 break
                         elif child.nodeType == Element.ELEMENT_NODE:

-                            childDict = XMLtoDictParserTools.parseTreeToDict(child, childDict, ignoreList)
+                            childDict = XMLtoDictParserTools.parseTreeToDict(
+                                child, childDict, ignoreList
+                            )

 
                     XMLtoDictParserTools.addDictValue(returnedDict, nodeKey, childDict)
 
 
                     XMLtoDictParserTools.addDictValue(returnedDict, nodeKey, childDict)
 


@@ -53,41 +56,52 @@ class XMLtoDictParserTools():
 
     @staticmethod
     def addDictValue(m_dict, key, value):
 
     @staticmethod
     def addDictValue(m_dict, key, value):

-

         def _allign_address(value):
             """unifies output"""
             n = ipaddr.IPNetwork(value)
         def _allign_address(value):
             """unifies output"""
             n = ipaddr.IPNetwork(value)

-            return '{0}/{1}'.format(n.network.exploded, n.prefixlen)
+            return "{0}/{1}".format(n.network.exploded, n.prefixlen)

 
         def _convert_numbers(value):
             if value.startswith("0x"):
 
         def _convert_numbers(value):
             if value.startswith("0x"):

-                return str(long(value, 16))
-            return str(long(value))
+                return str(int(value, 16))
+            return str(int(value))

 
         if key is not None:
 
         if key is not None:

-            if (isinstance(value, str)):
+            if isinstance(value, str):

                 # we need to predict possible differences
                 # for same value in upper or lower case
                 value = value.lower()
             if key not in m_dict:
                 # lets add mask for ips withot mask
                 # we need to predict possible differences
                 # for same value in upper or lower case
                 value = value.lower()
             if key not in m_dict:
                 # lets add mask for ips withot mask

-                if key in ['ipv4-destination', 'ipv4-source', 'ipv6-destination', 'ipv6-source', 'ipv6-nd-target']:
+                if key in [
+                    "ipv4-destination",
+                    "ipv4-source",
+                    "ipv6-destination",
+                    "ipv6-source",
+                    "ipv6-nd-target",
+                ]:

                     nvalue = _allign_address(value)
                     m_dict[key] = nvalue
                     nvalue = _allign_address(value)
                     m_dict[key] = nvalue

-                elif key in ['tunnel-mask', 'type', 'metadata-mask', 'out_port', 'out_group']:
+                elif key in [
+                    "tunnel-mask",
+                    "type",
+                    "metadata-mask",
+                    "out_port",
+                    "out_group",
+                ]:

                     nvalue = _convert_numbers(value)
                     m_dict[key] = nvalue
                 else:
                     m_dict[key] = value
             else:
                 exist_value = m_dict.get(key)
                     nvalue = _convert_numbers(value)
                     m_dict[key] = nvalue
                 else:
                     m_dict[key] = value
             else:
                 exist_value = m_dict.get(key)

-                if (type(exist_value) is dict):
+                if type(exist_value) is dict:

                     list_values = [exist_value, value]
                     key_for_sort = XMLtoDictParserTools.searchKey(exist_value)
                     if key_for_sort is not None:
                         list_values = sorted(list_values, key=lambda k: k[key_for_sort])
                     m_dict[key] = list_values
                     list_values = [exist_value, value]
                     key_for_sort = XMLtoDictParserTools.searchKey(exist_value)
                     if key_for_sort is not None:
                         list_values = sorted(list_values, key=lambda k: k[key_for_sort])
                     m_dict[key] = list_values

-                elif (isinstance(exist_value, list)):
+                elif isinstance(exist_value, list):

                     exist_value.append(value)
                     list_values = exist_value
                     key_for_sort = XMLtoDictParserTools.searchKey(value)
                     exist_value.append(value)
                     list_values = exist_value
                     key_for_sort = XMLtoDictParserTools.searchKey(value)


@@ -106,7 +120,7 @@ class XMLtoDictParserTools():
         @param dictionary: dictionary with data
         @return: the array order key
         """
         @param dictionary: dictionary with data
         @return: the array order key
         """

-        subKeyStr = ['-id', 'order']
+        subKeyStr = ["-id", "order"]

         for substr in subKeyStr:
             for key in dictionary:
                 if key == substr:
         for substr in subKeyStr:
             for key in dictionary:
                 if key == substr:


@@ -128,12 +142,12 @@ class XMLtoDictParserTools():
         """
         diff = {}
         # Check all keys in original_dict dict
         """
         diff = {}
         # Check all keys in original_dict dict

-        for key in original_dict.keys():
+        for key in list(original_dict.keys()):

             if key not in responded_dict:
                 # missing key in responded dict
                 diff[key] = (key, KEY_NOT_FOUND)
             # check values of the dictionaries
             if key not in responded_dict:
                 # missing key in responded dict
                 diff[key] = (key, KEY_NOT_FOUND)
             # check values of the dictionaries

-            elif (original_dict[key] != responded_dict[key]):
+            elif original_dict[key] != responded_dict[key]:

                 # values are not the same #
 
                 orig_dict_val = original_dict[key]
                 # values are not the same #
 
                 orig_dict_val = original_dict[key]


@@ -141,26 +155,33 @@ class XMLtoDictParserTools():
 
                 # check value is instance of dictionary
                 if isinstance(orig_dict_val, dict) and isinstance(resp_dict_val, dict):
 
                 # check value is instance of dictionary
                 if isinstance(orig_dict_val, dict) and isinstance(resp_dict_val, dict):

-                    sub_dif = XMLtoDictParserTools.getDifferenceDict(orig_dict_val, resp_dict_val)
+                    sub_dif = XMLtoDictParserTools.getDifferenceDict(
+                        orig_dict_val, resp_dict_val
+                    )

                     if sub_dif:
                         diff[key] = sub_dif
 
                 # check value is instance of list
                 # TODO - > change a basic comparator to compare by id or order
                     if sub_dif:
                         diff[key] = sub_dif
 
                 # check value is instance of list
                 # TODO - > change a basic comparator to compare by id or order

-                elif isinstance(orig_dict_val, list) and isinstance(resp_dict_val, list):
+                elif isinstance(orig_dict_val, list) and isinstance(
+                    resp_dict_val, list
+                ):

                     sub_list_diff = {}
                     # the list lengths
                     orig_i, resp_i = len(orig_dict_val), len(resp_dict_val)
                     # define a max iteration length (less from both)
                     min_index = orig_i if orig_i < resp_i else resp_i
                     for index in range(0, min_index, 1):
                     sub_list_diff = {}
                     # the list lengths
                     orig_i, resp_i = len(orig_dict_val), len(resp_dict_val)
                     # define a max iteration length (less from both)
                     min_index = orig_i if orig_i < resp_i else resp_i
                     for index in range(0, min_index, 1):

-                        if (orig_dict_val[index] != resp_dict_val[index]):
-                            sub_list_diff[index] = (orig_dict_val[index], resp_dict_val[index])
-                    if (orig_i > min_index):
+                        if orig_dict_val[index] != resp_dict_val[index]:
+                            sub_list_diff[index] = (
+                                orig_dict_val[index],
+                                resp_dict_val[index],
+                            )
+                    if orig_i > min_index:

                         # original is longer as responded dict
                         for index in range(min_index, orig_i, 1):
                             sub_list_diff[index] = (orig_dict_val[index], None)
                         # original is longer as responded dict
                         for index in range(min_index, orig_i, 1):
                             sub_list_diff[index] = (orig_dict_val[index], None)

-                    elif (resp_i > min_index):
+                    elif resp_i > min_index:

                         # responded dict is longer as original
                         for index in range(min_index, resp_i, 1):
                             sub_list_diff[index] = (None, resp_dict_val[index])
                         # responded dict is longer as original
                         for index in range(min_index, resp_i, 1):
                             sub_list_diff[index] = (None, resp_dict_val[index])


@@ -171,45 +192,123 @@ class XMLtoDictParserTools():
                     diff[key] = (original_dict[key], responded_dict[key])
 
         # Check all keys in responded_dict dict to find missing
                     diff[key] = (original_dict[key], responded_dict[key])
 
         # Check all keys in responded_dict dict to find missing

-        for key in responded_dict.keys():
+        for key in list(responded_dict.keys()):

             if key not in original_dict:
                 diff[key] = (KEY_NOT_FOUND, key)
         return diff
 
             if key not in original_dict:
                 diff[key] = (KEY_NOT_FOUND, key)
         return diff
 

-IGNORED_TAGS_FOR_OPERATIONAL_COMPARISON = ['id', 'flow-name', 'barrier', 'cookie_mask', 'installHw', 'flags',
-                                           'strict', 'byte-count', 'duration', 'packet-count', 'in-port',
-                                           'vlan-id-present', 'out_group', 'out_port', 'hard-timeout', 'idle-timeout',
-                                           'flow-statistics', 'cookie', 'clear-actions',
-                                           'ipv4-source-address-no-mask', 'ipv4-source-arbitrary-bitmask',
-                                           'ipv4-destination-address-no-mask', 'ipv4-destination-arbitrary-bitmask',
-                                           'ipv6-source-address-no-mask', 'ipv6-source-arbitrary-bitmask',
-                                           'ipv6-destination-address-no-mask', 'ipv6-destination-arbitrary-bitmask']  # noqa
-
-IGNORED_PATHS_FOR_OC = [(['flow', 'instructions', 'instruction', 'apply-actions', 'action', 'controller-action'], True),  # noqa
-                        (['flow', 'instructions', 'instruction', 'clear-actions', 'action'], False),
-                        (['flow', 'instructions', 'instruction', 'apply-actions', 'action', 'push-vlan-action', 'vlan-id'], False),  # noqa
-                        (['flow', 'instructions', 'instruction', 'apply-actions', 'action', 'drop-action'], True),
-                        (['flow', 'instructions', 'instruction', 'apply-actions', 'action', 'flood-action'], True),
-                        ]
-
-TAGS_TO_ADD_FOR_OC = [(['flow', 'instructions', 'instruction', 'apply-actions', 'action', 'output-action'], 'max-length', '0'),  # noqa
-                      ]

 
 

-
-TAGS_TO_MODIFY_FOR_OC = [(['flow', 'match', 'metadata'], 'metadata', 'metadata-mask'),
-                         (['flow', 'match', 'tunnel'], 'tunnel-id', 'tunnel-mask'),
-                         ]
+IGNORED_TAGS_FOR_OPERATIONAL_COMPARISON = [
+    "id",
+    "flow-name",
+    "barrier",
+    "cookie_mask",
+    "installHw",
+    "flags",
+    "strict",
+    "byte-count",
+    "duration",
+    "packet-count",
+    "in-port",
+    "vlan-id-present",
+    "out_group",
+    "out_port",
+    "hard-timeout",
+    "idle-timeout",
+    "flow-statistics",
+    "cookie",
+    "clear-actions",
+    "ipv4-source-address-no-mask",
+    "ipv4-source-arbitrary-bitmask",
+    "ipv4-destination-address-no-mask",
+    "ipv4-destination-arbitrary-bitmask",
+    "ipv6-source-address-no-mask",
+    "ipv6-source-arbitrary-bitmask",
+    "ipv6-destination-address-no-mask",
+    "ipv6-destination-arbitrary-bitmask",
+]  # noqa
+
+IGNORED_PATHS_FOR_OC = [
+    (
+        [
+            "flow",
+            "instructions",
+            "instruction",
+            "apply-actions",
+            "action",
+            "controller-action",
+        ],
+        True,
+    ),  # noqa
+    (["flow", "instructions", "instruction", "clear-actions", "action"], False),
+    (
+        [
+            "flow",
+            "instructions",
+            "instruction",
+            "apply-actions",
+            "action",
+            "push-vlan-action",
+            "vlan-id",
+        ],
+        False,
+    ),  # noqa
+    (
+        [
+            "flow",
+            "instructions",
+            "instruction",
+            "apply-actions",
+            "action",
+            "drop-action",
+        ],
+        True,
+    ),
+    (
+        [
+            "flow",
+            "instructions",
+            "instruction",
+            "apply-actions",
+            "action",
+            "flood-action",
+        ],
+        True,
+    ),
+]
+
+TAGS_TO_ADD_FOR_OC = [
+    (
+        [
+            "flow",
+            "instructions",
+            "instruction",
+            "apply-actions",
+            "action",
+            "output-action",
+        ],
+        "max-length",
+        "0",
+    )  # noqa
+]
+
+
+TAGS_TO_MODIFY_FOR_OC = [
+    (["flow", "match", "metadata"], "metadata", "metadata-mask"),
+    (["flow", "match", "tunnel"], "tunnel-id", "tunnel-mask"),
+]

 
 
 class XmlComparator:
 
 
 class XmlComparator:

-

     def is_flow_configured(self, requested_flow, configured_flows):
 
         orig_tree = md.parseString(requested_flow)
     def is_flow_configured(self, requested_flow, configured_flows):
 
         orig_tree = md.parseString(requested_flow)

-        xml_resp_stream = configured_flows.encode('utf-8', 'ignore')
+        xml_resp_stream = configured_flows

         xml_resp_tree = md.parseString(xml_resp_stream)
         xml_resp_tree = md.parseString(xml_resp_stream)

-        nodeListOperFlows = xml_resp_tree.getElementsByTagNameNS("*", 'flow')
-        origDict = XMLtoDictParserTools.parseTreeToDict(orig_tree._get_documentElement())
+        nodeListOperFlows = xml_resp_tree.getElementsByTagNameNS("*", "flow")
+        origDict = XMLtoDictParserTools.parseTreeToDict(
+            orig_tree._get_documentElement()
+        )

 
         reportDict = {}
         index = 0
 
         reportDict = {}
         index = 0


@@ -217,18 +316,19 @@ class XmlComparator:
             nodeDict = XMLtoDictParserTools.parseTreeToDict(node)
             XMLtoDictParserTools.addDictValue(reportDict, index, nodeDict)
             index += 1
             nodeDict = XMLtoDictParserTools.parseTreeToDict(node)
             XMLtoDictParserTools.addDictValue(reportDict, index, nodeDict)
             index += 1

-            # print nodeDict
-            # print origDict

             if nodeDict == origDict:
             if nodeDict == origDict:

-                return True, ''
-            if nodeDict['flow']['priority'] == origDict['flow']['priority']:
-                return False, 'Flow found with diferences {0}'.format(
-                    XMLtoDictParserTools.getDifferenceDict(nodeDict, origDict))
-        return False, ''
+                return True, ""
+            if nodeDict["flow"]["priority"] == origDict["flow"]["priority"]:
+                return (
+                    False,
+                    "Flow found with diferences {0}".format(
+                        XMLtoDictParserTools.getDifferenceDict(nodeDict, origDict)
+                    ),
+                )
+        return False, ""

 
     def is_flow_operational2(self, requested_flow, oper_resp, check_id=False):
         def _rem_unimplemented_tags(tagpath, recurs, tdict):
 
     def is_flow_operational2(self, requested_flow, oper_resp, check_id=False):
         def _rem_unimplemented_tags(tagpath, recurs, tdict):

-            # print "_rem_unimplemented_tags", tagpath, tdict

             if len(tagpath) > 1 and tagpath[0] in tdict:
                 _rem_unimplemented_tags(tagpath[1:], recurs, tdict[tagpath[0]])
 
             if len(tagpath) > 1 and tagpath[0] in tdict:
                 _rem_unimplemented_tags(tagpath[1:], recurs, tdict[tagpath[0]])
 


@@ -241,54 +341,53 @@ class XmlComparator:
             # when to delete
             if len(tagpath) == 1 and tagpath[0] in tdict:
                 del tdict[tagpath[0]]
             # when to delete
             if len(tagpath) == 1 and tagpath[0] in tdict:
                 del tdict[tagpath[0]]

-            if len(tagpath) > 1 and recurs is True and tagpath[0] in tdict and tdict[tagpath[0]] == {}:
+            if (
+                len(tagpath) > 1
+                and recurs is True
+                and tagpath[0] in tdict
+                and tdict[tagpath[0]] == {}
+            ):

                 del tdict[tagpath[0]]
                 del tdict[tagpath[0]]

-            if tdict.keys() == ['order']:
-                del tdict['order']
-            # print "leaving", tdict
+            if list(tdict.keys()) == ["order"]:
+                del tdict["order"]

 
         def _add_tags(tagpath, newtag, value, tdict):
 
         def _add_tags(tagpath, newtag, value, tdict):

-            '''if whole tagpath exists and the tag is not present, it is added with given value'''
-            # print "_add_tags", tagpath, newtag, value, tdict
+            """if whole tagpath exists and the tag is not present, it is added with given value"""

             if len(tagpath) > 0 and tagpath[0] in tdict:
                 _add_tags(tagpath[1:], newtag, value, tdict[tagpath[0]])
             elif len(tagpath) == 0 and newtag not in tdict:
                 tdict[newtag] = value
 
         def _to_be_modified_tags(tagpath, tag, related_tag, tdict):
             if len(tagpath) > 0 and tagpath[0] in tdict:
                 _add_tags(tagpath[1:], newtag, value, tdict[tagpath[0]])
             elif len(tagpath) == 0 and newtag not in tdict:
                 tdict[newtag] = value
 
         def _to_be_modified_tags(tagpath, tag, related_tag, tdict):

-            '''if whole tagpath exists and the tag is not present, it is added with given value'''
-            # print "_to_be_modified_tags", tagpath, tag, related_tag, tdict
+            """if whole tagpath exists and the tag is not present, it is added with given value"""

             if len(tagpath) > 0 and tagpath[0] in tdict:
                 _to_be_modified_tags(tagpath[1:], tag, related_tag, tdict[tagpath[0]])
             elif len(tagpath) == 0 and tag in tdict and related_tag in tdict:
             if len(tagpath) > 0 and tagpath[0] in tdict:
                 _to_be_modified_tags(tagpath[1:], tag, related_tag, tdict[tagpath[0]])
             elif len(tagpath) == 0 and tag in tdict and related_tag in tdict:

-                tdict[tag] = str(long(tdict[tag]) & long(tdict[related_tag]))
+                tdict[tag] = str(int(tdict[tag]) & int(tdict[related_tag]))

 
         IGNORED_TAGS_LIST = list(IGNORED_TAGS_FOR_OPERATIONAL_COMPARISON)
         if check_id:
 
         IGNORED_TAGS_LIST = list(IGNORED_TAGS_FOR_OPERATIONAL_COMPARISON)
         if check_id:

-            IGNORED_TAGS_LIST.remove('id')
+            IGNORED_TAGS_LIST.remove("id")

         orig_tree = md.parseString(requested_flow)
         orig_tree = md.parseString(requested_flow)

-        xml_resp_stream = oper_resp.encode('utf-8', 'ignore')
+        xml_resp_stream = oper_resp

         xml_resp_tree = md.parseString(xml_resp_stream)
         xml_resp_tree = md.parseString(xml_resp_stream)

-        nodeListOperFlows = xml_resp_tree.getElementsByTagNameNS("*", 'flow')
+        nodeListOperFlows = xml_resp_tree.getElementsByTagNameNS("*", "flow")

         origDict = XMLtoDictParserTools.parseTreeToDict(
         origDict = XMLtoDictParserTools.parseTreeToDict(

-            orig_tree._get_documentElement(),
-            ignoreList=IGNORED_TAGS_LIST)
+            orig_tree._get_documentElement(), ignoreList=IGNORED_TAGS_LIST
+        )

 
         # origDict['flow-statistics'] = origDict.pop( 'flow' )
         reportDict = {}
         index = 0
         for node in nodeListOperFlows:
             nodeDict = XMLtoDictParserTools.parseTreeToDict(
 
         # origDict['flow-statistics'] = origDict.pop( 'flow' )
         reportDict = {}
         index = 0
         for node in nodeListOperFlows:
             nodeDict = XMLtoDictParserTools.parseTreeToDict(

-                node,
-                ignoreList=IGNORED_TAGS_LIST)
+                node, ignoreList=IGNORED_TAGS_LIST
+            )

             XMLtoDictParserTools.addDictValue(reportDict, index, nodeDict)
             index += 1
             XMLtoDictParserTools.addDictValue(reportDict, index, nodeDict)
             index += 1

-            # print nodeDict
-            # print origDict
-            # print reportDict

             if nodeDict == origDict:
             if nodeDict == origDict:

-                return True, ''
-            if nodeDict['flow']['priority'] == origDict['flow']['priority']:
+                return True, ""
+            if nodeDict["flow"]["priority"] == origDict["flow"]["priority"]:

                 for p in IGNORED_PATHS_FOR_OC:
                     td = copy.copy(origDict)
                     _rem_unimplemented_tags(p[0], p[1], td)
                 for p in IGNORED_PATHS_FOR_OC:
                     td = copy.copy(origDict)
                     _rem_unimplemented_tags(p[0], p[1], td)


@@ -297,40 +396,44 @@ class XmlComparator:
                     for (p, t, rt) in TAGS_TO_MODIFY_FOR_OC:
                         _to_be_modified_tags(p, t, rt, td)
 
                     for (p, t, rt) in TAGS_TO_MODIFY_FOR_OC:
                         _to_be_modified_tags(p, t, rt, td)
 

-                    # print "comparing1", nodeDict
-                    # print "comparing2", td

                     if nodeDict == td:
                     if nodeDict == td:

-                        return True, ''
+                        return True, ""

                 if nodeDict == origDict:
                 if nodeDict == origDict:

-                    return True, ''
-                return False, 'Flow found with diferences {0}'.format(
-                    XMLtoDictParserTools.getDifferenceDict(nodeDict, origDict))
-        return False, ''
+                    return True, ""
+                return (
+                    False,
+                    "Flow found with diferences {0}".format(
+                        XMLtoDictParserTools.getDifferenceDict(nodeDict, origDict)
+                    ),
+                )
+        return False, ""

 
     def get_data_for_flow_put_update(self, xml):
         # action only for yet
         xml_dom_input = md.parseString(xml)
 
     def get_data_for_flow_put_update(self, xml):
         # action only for yet
         xml_dom_input = md.parseString(xml)

-        actionList = xml_dom_input.getElementsByTagName('action')
+        actionList = xml_dom_input.getElementsByTagName("action")

         if actionList is not None and len(actionList) > 0:
             action = actionList[0]
             for child in action.childNodes:
                 if child.nodeType == Element.ELEMENT_NODE:
         if actionList is not None and len(actionList) > 0:
             action = actionList[0]
             for child in action.childNodes:
                 if child.nodeType == Element.ELEMENT_NODE:

-                    nodeKey = (child.localName).encode('utf-8', 'ignore')
-                    if nodeKey != 'order':
-                        if nodeKey != 'drop-action':
-                            new_act = child.ownerDocument.createElement('drop-action')
+                    nodeKey = child.localName
+                    if nodeKey != "order":
+                        if nodeKey != "drop-action":
+                            new_act = child.ownerDocument.createElement("drop-action")

                         else:
                         else:

-                            new_act = child.ownerDocument.createElement('output-action')
-                            onc = child.ownerDocument.createElement('output-node-connector')
-                            onc_content = child.ownerDocument.createTextNode('TABLE')
+                            new_act = child.ownerDocument.createElement("output-action")
+                            onc = child.ownerDocument.createElement(
+                                "output-node-connector"
+                            )
+                            onc_content = child.ownerDocument.createTextNode("TABLE")

                             onc.appendChild(onc_content)
                             new_act.appendChild(onc)
                             onc.appendChild(onc_content)
                             new_act.appendChild(onc)

-                            ml = child.ownerDocument.createElement('max-length')
-                            ml_content = child.ownerDocument.createTextNode('60')
+                            ml = child.ownerDocument.createElement("max-length")
+                            ml_content = child.ownerDocument.createTextNode("60")

                             ml.appendChild(ml_content)
                             new_act.appendChild(ml)
                         child.parentNode.replaceChild(new_act, child)
                             ml.appendChild(ml_content)
                             new_act.appendChild(ml)
                         child.parentNode.replaceChild(new_act, child)

-        return xml_dom_input.toxml(encoding='utf-8')
+        return xml_dom_input.toxml(encoding="utf-8")

 
     def get_flow_content(self, tid=1, fid=1, priority=1):
         """Returns an xml flow content identified by given details.
 
     def get_flow_content(self, tid=1, fid=1, priority=1):
         """Returns an xml flow content identified by given details.


@@ -341,7 +444,7 @@ class XmlComparator:
             :param priority: flow priority
         """
 
             :param priority: flow priority
         """
 

-        flow_template = '''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+        flow_template = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>

 <flow xmlns="urn:opendaylight:flow:inventory">
     <strict>false</strict>
     <instructions>
 <flow xmlns="urn:opendaylight:flow:inventory">
     <strict>false</strict>
     <instructions>


@@ -371,7 +474,13 @@ class XmlComparator:
     <flow-name>%s</flow-name>
     <priority>%s</priority>
     <barrier>false</barrier>
     <flow-name>%s</flow-name>
     <priority>%s</priority>
     <barrier>false</barrier>

-</flow>'''
-
-        flow_data = flow_template % (tid, fid, fid, 'TestFlow-{0}'.format(fid), priority)
+</flow>"""
+
+        flow_data = flow_template % (
+            tid,
+            fid,
+            fid,
+            "TestFlow-{0}".format(fid),
+            priority,
+        )

         return flow_data
         return flow_data