l2: fix tests for learn_limit

Type: fix

Signed-off-by: Jerome Tollet <jtollet@cisco.com>
Change-Id: I7cbbea2205ca7249ba19020b25c8657b42e09562

3 files changed, 236 insertions, 58 deletions

diff --git a/test/test_l2bd_learnlimit.py b/test/test_l2bd_learnlimit.py
index 30224c5bd60..fe798fc2f0d 100644
--- a/test/test_l2bd_learnlimit.py
+++ b/test/test_l2bd_learnlimit.py
@@ -12,7 +12,7 @@ from util import Host, ppp
 
 
 class TestL2LearnLimit(VppTestCase):
-    """ L2 Learn limit Test Case """
+    """ L2 Learn no limit Test Case """
 
     @classmethod
     def setUpClass(self):
@@ -62,7 +62,7 @@ class TestL2LearnLimit(VppTestCase):
         self.logger.info("Sending broadcast eth frames for MAC learning")
         self.pg_start()
 
-    def test_l2bd_learnlimit01(self):
+    def test_l2bd_learnlimit(self):
         """ L2BD test without learn Limit
         """
         hosts = self.create_hosts(self.pg_interfaces[0], 20, 1)
@@ -72,62 +72,6 @@ class TestL2LearnLimit(VppTestCase):
         # check that 20 macs are learned.
         self.assertEqual(len(lfs), 20)
 
-    def test_l2bd_learnlimit02(self):
-        """ L2BD test with learn Limit
-        """
-        self.vapi.want_l2_macs_events(enable_disable=1, learn_limit=10)
-        hosts = self.create_hosts(self.pg_interfaces[0], 20, 1)
-        fhosts = self.create_hosts(self.pg_interfaces[1], 1, 2)
-
-        # inject 20 mac addresses on bd1
-        self.learn_hosts(self.pg_interfaces[0], 1, hosts)
-
-        # inject 1 mac address on bd2
-        self.learn_hosts(self.pg_interfaces[1], 2, fhosts)
-
-        lfs1 = self.vapi.l2_fib_table_dump(1)
-        lfs2 = self.vapi.l2_fib_table_dump(2)
-
-        # check that only 10 macs are learned.
-        self.assertEqual(len(lfs1), 10)
-
-        # check that bd2 was not able to learn
-        self.assertEqual(len(lfs2), 0)
-
-    def test_l2bd_learnlimit03(self):
-        """ L2BD test with bridge domain limit
-        """
-        self.vapi.want_l2_macs_events(enable_disable=1, learn_limit=1000)
-        self.vapi.bridge_domain_set_default_learn_limit(4)
-        self.vapi.bridge_domain_add_del(bd_id=3)
-        self.vapi.sw_interface_set_l2_bridge(
-            self.pg_interfaces[2].sw_if_index, bd_id=3)
-
-        self.vapi.bridge_domain_set_learn_limit(2, 5)
-
-        hosts = self.create_hosts(self.pg_interfaces[1], 20, 2)
-        fhosts = self.create_hosts(self.pg_interfaces[2], 20, 3)
-
-        # inject 20 mac addresses on bd2
-        self.learn_hosts(self.pg_interfaces[1], 2, hosts)
-
-        # inject 20 macs address on bd3
-        self.learn_hosts(self.pg_interfaces[2], 3, fhosts)
-
-        lfs1 = self.vapi.l2_fib_table_dump(2)
-        lfs2 = self.vapi.l2_fib_table_dump(3)
-
-        # check that only 5 macs are learned.
-        self.assertEqual(len(lfs1), 5)
-
-        # check that only 4 macs are learned.
-        self.assertEqual(len(lfs2), 4)
-
-        self.vapi.sw_interface_set_l2_bridge(
-            rx_sw_if_index=self.pg_interfaces[2].sw_if_index,
-            bd_id=3, enable=0)
-        self.vapi.bridge_domain_add_del(is_add=0, bd_id=3)
-
     def setUp(self):
         super(TestL2LearnLimit, self).setUp()
 
diff --git a/test/test_l2bd_learnlimit_bdenabled.py b/test/test_l2bd_learnlimit_bdenabled.py
new file mode 100644
index 00000000000..b75172bb987
--- /dev/null
+++ b/test/test_l2bd_learnlimit_bdenabled.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+
+import unittest
+import random
+
+from scapy.packet import Raw
+from scapy.layers.l2 import Ether
+from scapy.layers.inet import IP, UDP
+
+from framework import VppTestCase, VppTestRunner, running_extended_tests
+from util import Host, ppp
+
+
+class TestL2LearnLimit(VppTestCase):
+    """ L2 Bridge Domain Learn limit Test Case """
+
+    @classmethod
+    def setUpClass(self):
+        super(TestL2LearnLimit, self).setUpClass()
+        self.create_pg_interfaces(range(3))
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestL2LearnLimit, cls).tearDownClass()
+
+    def create_hosts(self, pg_if, n_hosts_per_if, subnet):
+        """
+        Create required number of host MAC addresses and distribute them among
+        interfaces. Create host IPv4 address for every host MAC address.
+
+        :param int n_hosts_per_if: Number of per interface hosts to
+        create MAC/IPv4 addresses for.
+        """
+
+        hosts = dict()
+        swif = pg_if.sw_if_index
+
+        def mac(j): return "00:00:%02x:ff:%02x:%02x" % (subnet, swif, j)
+
+        def ip(j): return "172.%02u.1%02x.%u" % (subnet, swif, j)
+
+        def h(j): return Host(mac(j), ip(j))
+        hosts[swif] = [h(j) for j in range(n_hosts_per_if)]
+
+        return hosts
+
+    def learn_hosts(self, pg_if, bd_id, hosts):
+        """
+        Create and send per interface L2 MAC broadcast packet stream to
+        let the bridge domain learn these MAC addresses.
+
+        :param int bd_id: BD to teach
+        :param dict hosts: dict of hosts per interface
+        """
+
+        self.vapi.bridge_flags(bd_id=bd_id, is_set=1, flags=1)
+
+        swif = pg_if.sw_if_index
+        packets = [Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac)
+                   for host in hosts[swif]]
+        pg_if.add_stream(packets)
+        self.logger.info("Sending broadcast eth frames for MAC learning")
+        self.pg_start()
+
+    def test_l2bd_learnlimit(self):
+        """ L2BD test with bridge domain limit
+        """
+        self.vapi.want_l2_macs_events(enable_disable=1, learn_limit=1000)
+        self.vapi.bridge_domain_set_default_learn_limit(4)
+        self.vapi.bridge_domain_add_del(bd_id=3)
+        self.vapi.sw_interface_set_l2_bridge(
+            self.pg_interfaces[2].sw_if_index, bd_id=3)
+
+        self.vapi.bridge_domain_set_learn_limit(2, 5)
+
+        hosts = self.create_hosts(self.pg_interfaces[1], 20, 2)
+        fhosts = self.create_hosts(self.pg_interfaces[2], 20, 3)
+
+        # inject 20 mac addresses on bd2
+        self.learn_hosts(self.pg_interfaces[1], 2, hosts)
+
+        # inject 20 macs address on bd3
+        self.learn_hosts(self.pg_interfaces[2], 3, fhosts)
+
+        lfs1 = self.vapi.l2_fib_table_dump(2)
+        lfs2 = self.vapi.l2_fib_table_dump(3)
+
+        # check that only 5 macs are learned.
+        self.assertEqual(len(lfs1), 5)
+
+        # check that only 4 macs are learned.
+        self.assertEqual(len(lfs2), 4)
+
+        self.vapi.sw_interface_set_l2_bridge(
+            rx_sw_if_index=self.pg_interfaces[2].sw_if_index,
+            bd_id=3, enable=0)
+        self.vapi.bridge_domain_add_del(is_add=0, bd_id=3)
+
+    def setUp(self):
+        super(TestL2LearnLimit, self).setUp()
+
+        self.vapi.bridge_domain_add_del(bd_id=1)
+        self.vapi.bridge_domain_add_del(bd_id=2)
+
+        self.vapi.sw_interface_set_l2_bridge(
+            self.pg_interfaces[0].sw_if_index, bd_id=1)
+        self.vapi.sw_interface_set_l2_bridge(
+            self.pg_interfaces[1].sw_if_index, bd_id=2)
+
+    def tearDown(self):
+        super(TestL2LearnLimit, self).tearDown()
+        self.vapi.sw_interface_set_l2_bridge(
+            rx_sw_if_index=self.pg_interfaces[0].sw_if_index,
+            bd_id=1, enable=0)
+        self.vapi.sw_interface_set_l2_bridge(
+            rx_sw_if_index=self.pg_interfaces[1].sw_if_index,
+            bd_id=2, enable=0)
+        self.vapi.bridge_domain_add_del(bd_id=1, is_add=0)
+        self.vapi.bridge_domain_add_del(bd_id=2, is_add=0)
+
+
+if __name__ == '__main__':
+    unittest.main(testRunner=VppTestRunner)
diff --git a/test/test_l2bd_learnlimit_enabled.py b/test/test_l2bd_learnlimit_enabled.py
new file mode 100644
index 00000000000..7fb89597f6a
--- /dev/null
+++ b/test/test_l2bd_learnlimit_enabled.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+
+import unittest
+import random
+
+from scapy.packet import Raw
+from scapy.layers.l2 import Ether
+from scapy.layers.inet import IP, UDP
+
+from framework import VppTestCase, VppTestRunner, running_extended_tests
+from util import Host, ppp
+
+
+class TestL2LearnLimit(VppTestCase):
+    """ L2 Global Learn limit Test Case """
+
+    @classmethod
+    def setUpClass(self):
+        super(TestL2LearnLimit, self).setUpClass()
+        self.create_pg_interfaces(range(3))
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestL2LearnLimit, cls).tearDownClass()
+
+    def create_hosts(self, pg_if, n_hosts_per_if, subnet):
+        """
+        Create required number of host MAC addresses and distribute them among
+        interfaces. Create host IPv4 address for every host MAC address.
+
+        :param int n_hosts_per_if: Number of per interface hosts to
+        create MAC/IPv4 addresses for.
+        """
+
+        hosts = dict()
+        swif = pg_if.sw_if_index
+
+        def mac(j): return "00:00:%02x:ff:%02x:%02x" % (subnet, swif, j)
+
+        def ip(j): return "172.%02u.1%02x.%u" % (subnet, swif, j)
+
+        def h(j): return Host(mac(j), ip(j))
+        hosts[swif] = [h(j) for j in range(n_hosts_per_if)]
+
+        return hosts
+
+    def learn_hosts(self, pg_if, bd_id, hosts):
+        """
+        Create and send per interface L2 MAC broadcast packet stream to
+        let the bridge domain learn these MAC addresses.
+
+        :param int bd_id: BD to teach
+        :param dict hosts: dict of hosts per interface
+        """
+
+        self.vapi.bridge_flags(bd_id=bd_id, is_set=1, flags=1)
+
+        swif = pg_if.sw_if_index
+        packets = [Ether(dst="ff:ff:ff:ff:ff:ff", src=host.mac)
+                   for host in hosts[swif]]
+        pg_if.add_stream(packets)
+        self.logger.info("Sending broadcast eth frames for MAC learning")
+        self.pg_start()
+
+    def test_l2bd_learnlimit01(self):
+        """ L2BD test with learn Limit
+        """
+        self.vapi.want_l2_macs_events(enable_disable=1, learn_limit=10)
+        hosts = self.create_hosts(self.pg_interfaces[0], 20, 1)
+        fhosts = self.create_hosts(self.pg_interfaces[1], 1, 2)
+
+        # inject 20 mac addresses on bd1
+        self.learn_hosts(self.pg_interfaces[0], 1, hosts)
+
+        # inject 1 mac address on bd2
+        self.learn_hosts(self.pg_interfaces[1], 2, fhosts)
+
+        lfs1 = self.vapi.l2_fib_table_dump(1)
+        lfs2 = self.vapi.l2_fib_table_dump(2)
+
+        # check that only 10 macs are learned.
+        self.assertEqual(len(lfs1), 10)
+
+        # check that bd2 was not able to learn
+        self.assertEqual(len(lfs2), 0)
+
+    def setUp(self):
+        super(TestL2LearnLimit, self).setUp()
+
+        self.vapi.bridge_domain_add_del(bd_id=1)
+        self.vapi.bridge_domain_add_del(bd_id=2)
+
+        self.vapi.sw_interface_set_l2_bridge(
+            self.pg_interfaces[0].sw_if_index, bd_id=1)
+        self.vapi.sw_interface_set_l2_bridge(
+            self.pg_interfaces[1].sw_if_index, bd_id=2)
+
+    def tearDown(self):
+        super(TestL2LearnLimit, self).tearDown()
+        self.vapi.sw_interface_set_l2_bridge(
+            rx_sw_if_index=self.pg_interfaces[0].sw_if_index,
+            bd_id=1, enable=0)
+        self.vapi.sw_interface_set_l2_bridge(
+            rx_sw_if_index=self.pg_interfaces[1].sw_if_index,
+            bd_id=2, enable=0)
+        self.vapi.bridge_domain_add_del(bd_id=1, is_add=0)
+        self.vapi.bridge_domain_add_del(bd_id=2, is_add=0)
+
+
+if __name__ == '__main__':
+    unittest.main(testRunner=VppTestRunner)