CSIT-423: HC Test: delete VxLAN interface

[csit.git] / resources / libraries / python / honeycomb / HcAPIKwInterfaces.py

diff --git a/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py b/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
index 506db69..035016c 100644 (file)
--- a/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
+++ b/resources/libraries/python/honeycomb/HcAPIKwInterfaces.py
@@ -16,6 +16,8 @@
 The keywords make possible to put and get configuration data and to get
 operational data.
 """
 The keywords make possible to put and get configuration data and to get
 operational data.
 """

+from robot.api import logger
+

 from resources.libraries.python.topology import Topology
 from resources.libraries.python.HTTPRequest import HTTPCodes
 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
 from resources.libraries.python.topology import Topology
 from resources.libraries.python.HTTPRequest import HTTPCodes
 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError


@@ -162,6 +164,33 @@ class InterfaceKeywords(object):
         except (KeyError, TypeError):
             return []
 
         except (KeyError, TypeError):
             return []
 

+    @staticmethod
+    def get_disabled_interfaces_oper_data(node):
+        """Get operational data about all disabled interfaces from Honeycomb.
+
+        :param node: Honeycomb node.
+        :type node: dict
+        :return: Operational data about disabled interfaces.
+        :rtype: list
+        :raises HoneycombError: If it is not possible to get operational data.
+        """
+
+        status_code, resp = HcUtil. \
+            get_honeycomb_data(node, "oper_disabled_interfaces")
+        if status_code == HTTPCodes.NOT_FOUND:
+            raise HoneycombError(
+                "No disabled interfaces present on node."
+            )
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError(
+                "Not possible to get operational information about the "
+                "interfaces. Status code: {0}.".format(status_code))
+        try:
+            return resp["disabled-interfaces"]["disabled-interface-index"]
+
+        except (KeyError, TypeError):
+            return []
+

     @staticmethod
     def get_interface_oper_data(node, interface):
         """Get operational data about the given interface from Honeycomb.
     @staticmethod
     def get_interface_oper_data(node, interface):
         """Get operational data about the given interface from Honeycomb.


@@ -342,13 +371,16 @@ class InterfaceKeywords(object):
 
         path = "/interface/{0}/v3po:l2".format(intf)
 
 
         path = "/interface/{0}/v3po:l2".format(intf)
 

-        status_code, _ = HcUtil.delete_honeycomb_data(
+        status_code, response = HcUtil.delete_honeycomb_data(

             node, "config_vpp_interfaces", path)
 
         if status_code != HTTPCodes.OK:
             node, "config_vpp_interfaces", path)
 
         if status_code != HTTPCodes.OK:

-            raise HoneycombError(
-                "Could not remove bridge domain assignment from interface "
-                "'{0}'. Status code: {1}.".format(interface, status_code))
+            if '"error-tag":"data-missing"' in response:
+                logger.debug("Data does not exist in path.")
+            else:
+                raise HoneycombError(
+                    "Could not remove bridge domain assignment from interface "
+                    "'{0}'. Status code: {1}.".format(interface, status_code))

 
     @staticmethod
     def get_bd_oper_data_from_interface(node, interface):
 
     @staticmethod
     def get_bd_oper_data_from_interface(node, interface):


@@ -1283,15 +1315,19 @@ class InterfaceKeywords(object):
             node, super_interface, path, None)
 
     @staticmethod
             node, super_interface, path, None)
 
     @staticmethod

-    def compare_data_structures(data, ref, ignore=()):
+    def compare_data_structures(data, ref, ignore=(), list_order=True):

         """Checks if data obtained from UUT is as expected.
 
         :param data: Data to be checked.
         :param ref: Referential data used for comparison.
         :param ignore: Dictionary keys to be ignored.
         """Checks if data obtained from UUT is as expected.
 
         :param data: Data to be checked.
         :param ref: Referential data used for comparison.
         :param ignore: Dictionary keys to be ignored.

+        :param list_order: Whether to consider the order of list items\
+        in comparison.

         :type data: dict
         :type ref: dict
         :type ignore: iterable
         :type data: dict
         :type ref: dict
         :type ignore: iterable

+        :type list_order: bool
+

         :raises HoneycombError: If a parameter from referential data is not
         present in operational data or if it has different value.
         """
         :raises HoneycombError: If a parameter from referential data is not
         present in operational data or if it has different value.
         """


@@ -1303,10 +1339,13 @@ class InterfaceKeywords(object):
                 continue
             try:
                 if data[key] != item:
                 continue
             try:
                 if data[key] != item:

-                    errors += ("\nThe value of parameter '{0}' is "
-                               "incorrect. It should be "
-                               "'{1}' but it is '{2}'".
-                               format(key, item, data[key]))
+                    if not list_order and sorted(data[key]) == sorted(item):
+                        pass
+                    else:
+                        errors += ("\nThe value of parameter '{0}' is "
+                                   "incorrect. It should be "
+                                   "'{1}' but it is '{2}'".
+                                   format(key, item, data[key]))

             except KeyError:
                 errors += ("\nThe parameter '{0}' is not present in "
                            "operational data".format(key))
             except KeyError:
                 errors += ("\nThe parameter '{0}' is not present in "
                            "operational data".format(key))


@@ -1394,11 +1433,13 @@ class InterfaceKeywords(object):
 
         data = {
             "v3po:acl": {
 
         data = {
             "v3po:acl": {

-                "l2-acl": {
-                    "classify-table": table_name
-                },
-                "ip4-acl": {
-                    "classify-table": table_name
+                "ingress": {
+                    "ip4-acl": {
+                        "classify-table": table_name
+                    },
+                    "l2-acl": {
+                        "classify-table": table_name
+                    }

                 }
             }
         }
                 }
             }
         }


@@ -1518,3 +1559,27 @@ class InterfaceKeywords(object):
 
         interface = "{0}.{1}".format(intf, sub_if_id)
         return InterfaceKeywords.get_interface_oper_data(node, interface)
 
         interface = "{0}.{1}".format(intf, sub_if_id)
         return InterfaceKeywords.get_interface_oper_data(node, interface)

+
+    @staticmethod
+    def check_disabled_interface(node, interface):
+        """Retrieves list of disabled interface indices from Honeycomb,
+        and matches with the provided interface by index.
+
+        :param node: Honeycomb node.
+        :param interface: Index number of an interface on the node.
+        :type node: dict
+        :type interface: int
+        :return: True if the interface exists in disabled interfaces.
+        :rtype: bool
+        :raises HoneycombError: If the interface is not present
+         in retrieved list of disabled interfaces.
+         """
+        data = InterfaceKeywords.get_disabled_interfaces_oper_data(node)
+        # decrement by one = conversion from HC if-index to VPP sw_if_index
+        interface -= 1
+
+        for item in data:
+            if item["index"] == interface:
+                return True
+        raise HoneycombError("Interface index {0} not present in list"
+                             " of disabled interfaces.".format(interface))