CSIT-611: HC Test: Lisp suite updates + LispGPE

 - added LispGPE test suite
 - added IPv6 tests to Lisp suite
 - added traffic tests to Lisp suite

Change-Id: I3b699149cd73ebf5856072d3f26e98a370dbfc4b
Signed-off-by: selias <samelias@cisco.com>

1 files changed, 226 insertions, 18 deletions

diff --git a/resources/libraries/python/honeycomb/Lisp.py b/resources/libraries/python/honeycomb/Lisp.py
index f89ffed0b9..f2fe24caf1 100644
--- a/resources/libraries/python/honeycomb/Lisp.py
+++ b/resources/libraries/python/honeycomb/Lisp.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2016 Cisco and/or its affiliates.
+# Copyright (c) 2017 Cisco and/or its affiliates.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""This module implements keywords to manipulate Lisp data structures using
+"""This module implements keywords to manipulate LISP data structures using
 Honeycomb REST API."""
 
 from resources.libraries.python.HTTPRequest import HTTPCodes
@@ -20,15 +20,16 @@ from resources.libraries.python.honeycomb.HoneycombUtil \
     import HoneycombUtil as HcUtil
 from resources.libraries.python.honeycomb.HoneycombUtil \
     import DataRepresentation
+from resources.libraries.python.topology import Topology
 
 
 class LispKeywords(object):
     """Implementation of keywords which make it possible to:
-    - enable/disable Lisp feature
-    - configure Lisp mappings
+    - enable/disable LISP feature
+    - configure LISP mappings
     - configure locator sets
     - configure map resolver
-    - configure Lisp PITR feature
+    - configure LISP PITR feature
     - read operational data for all of the above
     """
 
@@ -38,7 +39,7 @@ class LispKeywords(object):
 
     @staticmethod
     def _set_lisp_properties(node, path, data=None):
-        """Set Lisp properties and check the return code.
+        """Set LISP properties and check the return code.
 
         :param node: Honeycomb node.
         :param path: Path which is added to the base path to identify the data.
@@ -80,7 +81,7 @@ class LispKeywords(object):
         status_code, resp = HcUtil.get_honeycomb_data(node, "oper_lisp")
 
         if status_code != HTTPCodes.OK:
-            raise HoneycombError("Could not retrieve Lisp operational data."
+            raise HoneycombError("Could not retrieve LISP operational data."
                                  "Status code: {0}.".format(status_code))
         else:
             # get rid of empty vni-table entry
@@ -97,7 +98,7 @@ class LispKeywords(object):
     def verify_map_server_data_from_honeycomb(data, ip_addresses):
         """Verify whether MAP server data from Honeycomb is correct.
 
-        :param data: Lisp operational data containing map server IP addresses.
+        :param data: LISP operational data containing map server IP addresses.
         :param ip_addresses: IP addresses to verify map server data against.
         :type data: dict
         :type ip_addresses: list
@@ -117,7 +118,7 @@ class LispKeywords(object):
     def verify_map_server_data_from_vat(data, ip_addresses):
         """Verify whether MAP server data from VAT is correct.
 
-        :param data: Lisp operational data containing map server IP addresses.
+        :param data: LISP operational data containing map server IP addresses.
         :param ip_addresses: IP addresses to verify map server data against.
         :type data: dict
         :type ip_addresses: list
@@ -132,10 +133,10 @@ class LispKeywords(object):
 
     @staticmethod
     def set_lisp_state(node, state=True):
-        """Enable or disable the Lisp feature.
+        """Enable or disable the LISP feature.
 
         :param node: Honeycomb node.
-        :param state: Enable or disable Lisp.
+        :param state: Enable or disable LISP.
         :type node: dict
         :type state: bool
         :returns: Content of response.
@@ -151,7 +152,7 @@ class LispKeywords(object):
             data = {"lisp": {"enable": bool(state)}}
         else:
             raise HoneycombError("Unexpected return code when getting existing"
-                                 " Lisp configuration.")
+                                 " LISP configuration.")
 
         return LispKeywords._set_lisp_properties(node, '', data)
 
@@ -179,7 +180,7 @@ class LispKeywords(object):
 
     @staticmethod
     def add_locator(node, interface, locator_set, priority=1, weight=1):
-        """Configure a new Lisp locator set.
+        """Configure a new LISP locator set.
 
         :param node: Honeycomb node.
         :param interface: An interface on the node.
@@ -195,6 +196,9 @@ class LispKeywords(object):
         :rtype: bytearray
         """
 
+        interface = Topology.convert_interface_reference(
+            node, interface, "name")
+
         path = "/lisp-feature-data/locator-sets/locator-set" \
                "/{0}".format(locator_set)
 
@@ -216,7 +220,7 @@ class LispKeywords(object):
         """Modify eid-table configuration to the data provided.
 
         :param node: Honeycomb node.
-        :param data: Settings for the Lisp mappings.
+        :param data: Settings for the LISP mappings.
         :type node: dict
         :type data: dict
         :returns: Content of response.
@@ -228,10 +232,10 @@ class LispKeywords(object):
 
     @staticmethod
     def configure_lisp_map_request_mode(node, option):
-        """Modify Lisp Map Request Mode configuration to the data provided.
+        """Modify LISP Map Request Mode configuration to the data provided.
 
         :param node: Honeycomb node.
-        :param option: Settings for the Lisp map request mode.
+        :param option: Settings for the LISP map request mode.
         :type node: dict
         :type option: str
         :returns: Content of response.
@@ -249,7 +253,7 @@ class LispKeywords(object):
 
     @staticmethod
     def add_lisp_adjacency(node, vni_id, map_name, adjacency_name, data):
-        """Add an adjacency to an existing Lisp mapping.
+        """Add an adjacency to an existing LISP mapping.
 
         :param node: Honeycomb node.
         :param vni_id: vni_id of the mapping.
@@ -452,7 +456,7 @@ class LispKeywords(object):
 
     @staticmethod
     def disable_lisp(node):
-        """Remove all Lisp settings on the node.
+        """Remove all LISP settings on the node.
 
         :param node: Honeycomb node.
         :type node: dict
@@ -461,3 +465,207 @@ class LispKeywords(object):
         """
 
         return LispKeywords._set_lisp_properties(node, "")
+
+
+class LispGPEKeywords(object):
+    """Implementation of keywords which make it possible to:
+    - enable/disable LISP GPE feature
+    - configure LISP GPE forwarding entries
+    - read operational data for all of the above
+    """
+
+    def __init__(self):
+        """Initializer."""
+        pass
+
+    @staticmethod
+    def _set_lispgpe_properties(node, path, data=None):
+        """Set LISP GPE properties and check the return code.
+
+        :param node: Honeycomb node.
+        :param path: Path which is added to the base path to identify the data.
+        :param data: The new data to be set. If None, the item will be removed.
+        :type node: dict
+        :type path: str
+        :type data: dict
+        :returns: Content of response.
+        :rtype: bytearray
+        :raises HoneycombError: If the status code in response to PUT is not
+        200 = OK or 201 = ACCEPTED.
+        """
+
+        if data:
+            status_code, resp = HcUtil.\
+                put_honeycomb_data(node, "config_lisp_gpe", data, path,
+                                   data_representation=DataRepresentation.JSON)
+        else:
+            status_code, resp = HcUtil.\
+                delete_honeycomb_data(node, "config_lisp_gpe", path)
+
+        if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
+            raise HoneycombError(
+                "Lisp GPE configuration unsuccessful. "
+                "Status code: {0}.".format(status_code))
+        else:
+            return resp
+
+    @staticmethod
+    def get_lispgpe_operational_data(node):
+        """Retrieve LISP GPE properties from Honeycomb operational data.
+
+        :param node: Honeycomb node.
+        :type node: dict
+        :returns: LISP GPE operational data.
+        :rtype: bytearray
+        :raises HoneycombError: If the status code in response to GET is not
+        200 = OK.
+        """
+
+        status_code, resp = HcUtil.get_honeycomb_data(node, "oper_lisp_gpe")
+
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError("Could not retrieve Lisp GPE operational data."
+                                 "Status code: {0}.".format(status_code))
+        else:
+            return resp
+
+    @staticmethod
+    def get_lispgpe_mapping(node, name):
+        """Retrieve LISP GPE operational data and parse for a specific mapping.
+
+        :param node: Honeycomb node.
+        :param name: Name of the mapping to look for.
+        :type node: dict
+        :type name: str
+        :returns: LISP GPE mapping.
+        :rtype: dict
+        :raises HoneycombError: If the mapping is not present in operational
+        data.
+        """
+
+        data = LispGPEKeywords.get_lispgpe_operational_data(node)
+        try:
+            data = data["gpe-state"]["gpe-feature-data"]["gpe-entry-table"] \
+                ["gpe-entry"]
+        except KeyError:
+            raise HoneycombError("No mappings present in operational data.")
+        for item in data:
+            if item["id"] == name:
+                mapping = item
+                break
+        else:
+            raise HoneycombError("Mapping with name {name} not found in "
+                                 "operational data.".format(name=name))
+
+        return mapping
+
+    @staticmethod
+    def get_lispgpe_config_data(node):
+        """Retrieve LISP GPE properties from Honeycomb config data.
+
+        :param node: Honeycomb node.
+        :type node: dict
+        :returns: LISP GPE config data.
+        :rtype: bytearray
+        :raises HoneycombError: If the status code in response to GET is not
+        200 = OK.
+        """
+
+        status_code, resp = HcUtil.get_honeycomb_data(node, "config_lisp_gpe")
+
+        if status_code != HTTPCodes.OK:
+            raise HoneycombError("Could not retrieve Lisp GPE config data."
+                                 "Status code: {0}.".format(status_code))
+        else:
+            return resp
+
+    @staticmethod
+    def set_lispgpe_state(node, state=True):
+        """Enable or disable the LISP GPE feature.
+
+        :param node: Honeycomb node.
+        :param state: Enable or disable LISP.
+        :type node: dict
+        :type state: bool
+        :returns: Content of response.
+        :rtype: bytearray
+        :raises HoneycombError: If the return code is not 200:OK
+        or 404:NOT FOUND.
+        """
+
+        ret_code, data = HcUtil.get_honeycomb_data(node, "config_lisp_gpe")
+        if ret_code == HTTPCodes.OK:
+            data["gpe"]["gpe-feature-data"]["enable"] = bool(state)
+        elif ret_code == HTTPCodes.NOT_FOUND:
+            data = {"gpe": {"gpe-feature-data": {"enable": bool(state)}}}
+        else:
+            raise HoneycombError("Unexpected return code when getting existing"
+                                 " Lisp GPE configuration.")
+
+        return LispGPEKeywords._set_lispgpe_properties(node, '', data)
+
+    @staticmethod
+    def configure_lispgpe_mapping(node, data=None):
+        """Modify LISP GPE mapping configuration to the data provided.
+
+        :param node: Honeycomb node.
+        :param data: Settings for the LISP GPE mappings.
+        :type node: dict
+        :type data: dict
+        :returns: Content of response.
+        :rtype: bytearray
+        """
+
+        path = "/gpe-feature-data/gpe-entry-table"
+        if data:
+            data = {"gpe-entry-table": {"gpe-entry": data}}
+            return LispGPEKeywords._set_lispgpe_properties(node, path, data)
+        else:
+            return LispGPEKeywords._set_lispgpe_properties(node, path)
+
+    @staticmethod
+    def add_lispgpe_mapping(node, name, data):
+        """Add the specified LISP GPE mapping.
+
+        :param node: Honeycomb node.
+        :param name: Name for the mapping.
+        :param data: Mapping details.
+        :type node: dict
+        :type name: str
+        :type data: dict
+        :returns: Content of response.
+        :rtype: bytearray
+        """
+
+        path = "/gpe-feature-data/gpe-entry-table/gpe-entry/{name}".format(
+            name=name)
+
+        data = {"gpe-entry": data}
+        return LispGPEKeywords._set_lispgpe_properties(node, path, data)
+
+    @staticmethod
+    def delete_lispgpe_mapping(node, mapping):
+        """Delete the specified LISP GPE mapping from configuration.
+
+        :param node: Honeycomb node.
+        :param mapping: Name of the mapping to remove.
+        :type node: dict
+        :type mapping: str
+        :returns: Content of response.
+        :rtype: bytearray
+        """
+
+        path = "/gpe-feature-data/gpe-entry-table/gpe-entry/{0}".format(mapping)
+        return LispGPEKeywords._set_lispgpe_properties(node, path)
+
+    @staticmethod
+    def disable_lispgpe(node):
+        """Remove all LISP GPE settings on the node.
+
+        :param node: Honeycomb node.
+        :type node: dict
+        :returns: Content of response.
+        :rtype: bytearray
+        """
+
+        return LispGPEKeywords._set_lispgpe_properties(node, "")