wireguard: add flag to check hmac for decryption

[vpp.git] / test / test_lisp.py

diff --git a/test/test_lisp.py b/test/test_lisp.py
index 6ca1681..0a6e752 100644 (file)
--- a/test/test_lisp.py
+++ b/test/test_lisp.py
@@ -1,7 +1,6 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 import abc
-import six
 import unittest
 
 from scapy.fields import BitField, ByteField, FlagsField, IntField
@@ -11,8 +10,8 @@ from scapy.layers.inet6 import IPv6
 
 from framework import VppTestCase, VppTestRunner
 from lisp import VppLocalMapping, VppLispAdjacency, VppLispLocator, \
-    VppLispLocatorSet, VppRemoteMapping
-from util import ppp, ForeignAddressFactory
+    VppLispLocatorSet, VppRemoteMapping, LispRemoteLocator
+from util import ppp
 
 # From py_lispnetworking.lisp.py:  # GNU General Public License v2.0
 
@@ -32,8 +31,20 @@ bind_layers(LISP_GPE_Header, IPv6, next_proto=2)
 bind_layers(LISP_GPE_Header, Ether, next_proto=3)
 
 
-@six.add_metaclass(abc.ABCMeta)
-class Driver(object):
+class ForeignAddressFactory(object):
+    count = 0
+    prefix_len = 24
+    net_template = '10.10.10.{}'
+    net = net_template.format(0) + '/' + str(prefix_len)
+
+    def get_ip4(self):
+        if self.count > 255:
+            raise Exception("Network host address exhaustion")
+        self.count += 1
+        return self.net_template.format(self.count)
+
+
+class Driver(metaclass=abc.ABCMeta):
 
     config_order = ['locator-sets',
                     'locators',
@@ -145,17 +156,21 @@ class TestLisp(VppTestCase):
             i.config_ip4()  # configure IPv4 address on the interface
             i.resolve_arp()  # resolve ARP, so that we know VPP MAC
 
+    @classmethod
+    def tearDownClass(cls):
+        super(TestLisp, cls).tearDownClass()
+
     def setUp(self):
         super(TestLisp, self).setUp()
-        self.vapi.lisp_enable_disable(is_enabled=1)
+        self.vapi.lisp_enable_disable(is_enable=1)
 
     def test_lisp_basic_encap(self):
         """Test case for basic encapsulation"""
 
         self.deid_ip4_net = self.faf.net
         self.deid_ip4 = self.faf.get_ip4()
-        self.seid_ip4 = '{}/{}'.format(self.pg0.local_ip4, 32)
-        self.rloc_ip4 = self.pg1.remote_ip4n
+        self.seid_ip4 = '{!s}/{!s}'.format(self.pg0.local_ip4, 32)
+        self.rloc_ip4 = self.pg1.remote_ip4
 
         test_cases = [
             {
@@ -169,12 +184,7 @@ class TestLisp(VppTestCase):
                 ],
                 'remote-mappings': [
                     VppRemoteMapping(self, self.deid_ip4_net,
-                                     [{
-                                         "is_ip4": 1,
-                                         "priority": 1,
-                                         "weight": 1,
-                                         "addr": self.rloc_ip4
-                                     }])
+                                     [LispRemoteLocator(self.rloc_ip4)])
                 ],
                 'adjacencies': [
                     VppLispAdjacency(self, self.seid_ip4, self.deid_ip4_net)
@@ -185,5 +195,25 @@ class TestLisp(VppTestCase):
         self.test_driver.run(self.deid_ip4)
 
 
+class TestLispUT(VppTestCase):
+    """ Lisp UT """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestLispUT, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestLispUT, cls).tearDownClass()
+
+    def test_fib(self):
+        """ LISP Unit Tests """
+        error = self.vapi.cli("test lisp cp")
+
+        if error:
+            self.logger.critical(error)
+        self.assertNotIn("Failed", error)
+
+
 if __name__ == '__main__':
     unittest.main(testRunner=VppTestRunner)