fib: fib api updates

[vpp.git] / test / test_classifier.py

diff --git a/test/test_classifier.py b/test/test_classifier.py
index c0b8546..4892d26 100644 (file)
--- a/test/test_classifier.py
+++ b/test/test_classifier.py
@@ -10,6 +10,8 @@ from scapy.packet import Raw
 from scapy.layers.l2 import Ether
 from scapy.layers.inet import IP, UDP, TCP
 from util import ppp
 from scapy.layers.l2 import Ether
 from scapy.layers.inet import IP, UDP, TCP
 from util import ppp

+from vpp_ip_route import VppIpRoute, VppRoutePath
+from vpp_ip import INVALID_INDEX

 
 
 class TestClassifier(VppTestCase):
 
 
 class TestClassifier(VppTestCase):


@@ -25,6 +27,10 @@ class TestClassifier(VppTestCase):
         super(TestClassifier, cls).setUpClass()
         cls.acl_active_table = ''
 
         super(TestClassifier, cls).setUpClass()
         cls.acl_active_table = ''
 

+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifier, cls).tearDownClass()
+

     def setUp(self):
         """
         Perform test setup before test case.
     def setUp(self):
         """
         Perform test setup before test case.


@@ -71,10 +77,6 @@ class TestClassifier(VppTestCase):
     def tearDown(self):
         """Run standard test teardown and acl related log."""
         if not self.vpp_dead:
     def tearDown(self):
         """Run standard test teardown and acl related log."""
         if not self.vpp_dead:

-            self.logger.info(self.vapi.ppcli("show inacl type ip4"))
-            self.logger.info(self.vapi.ppcli("show outacl type ip4"))
-            self.logger.info(self.vapi.cli("show classify table verbose"))
-            self.logger.info(self.vapi.cli("show ip fib"))

             if self.acl_active_table == 'ip_out':
                 self.output_acl_set_interface(
                     self.pg0, self.acl_tbl_idx.get(self.acl_active_table), 0)
             if self.acl_active_table == 'ip_out':
                 self.output_acl_set_interface(
                     self.pg0, self.acl_tbl_idx.get(self.acl_active_table), 0)


@@ -89,18 +91,11 @@ class TestClassifier(VppTestCase):
 
         super(TestClassifier, self).tearDown()
 
 
         super(TestClassifier, self).tearDown()
 

-    def config_pbr_fib_entry(self, intf, is_add=1):
-        """Configure fib entry to route traffic toward PBR VRF table
-
-        :param VppInterface intf: destination interface to be routed for PBR.
-
-        """
-        addr_len = 24
-        self.vapi.ip_add_del_route(intf.local_ip4n,
-                                   addr_len,
-                                   intf.remote_ip4n,
-                                   table_id=self.pbr_vrfid,
-                                   is_add=is_add)
+    def show_commands_at_teardown(self):
+        self.logger.info(self.vapi.ppcli("show inacl type ip4"))
+        self.logger.info(self.vapi.ppcli("show outacl type ip4"))
+        self.logger.info(self.vapi.cli("show classify table verbose"))
+        self.logger.info(self.vapi.cli("show ip fib"))

 
     def create_stream(self, src_if, dst_if, packet_sizes,
                       proto_l=UDP(sport=1234, dport=5678)):
 
     def create_stream(self, src_if, dst_if, packet_sizes,
                       proto_l=UDP(sport=1234, dport=5678)):


@@ -141,7 +136,7 @@ class TestClassifier(VppTestCase):
             try:
                 ip_received = packet[IP]
                 proto_received = packet[proto_l]
             try:
                 ip_received = packet[IP]
                 proto_received = packet[proto_l]

-                payload_info = self.payload_to_info(str(packet[Raw]))
+                payload_info = self.payload_to_info(packet[Raw])

                 packet_index = payload_info.index
                 self.assertEqual(payload_info.dst, dst_sw_if_index)
                 self.logger.debug(
                 packet_index = payload_info.index
                 self.assertEqual(payload_info.dst, dst_sw_if_index)
                 self.logger.debug(


@@ -178,11 +173,9 @@ class TestClassifier(VppTestCase):
         :param int vrf_id: The FIB table / VRF ID to be verified.
         :return: 1 if the FIB table / VRF ID is configured, otherwise return 0.
         """
         :param int vrf_id: The FIB table / VRF ID to be verified.
         :return: 1 if the FIB table / VRF ID is configured, otherwise return 0.
         """

-        ip_fib_dump = self.vapi.ip_fib_dump()
-        vrf_count = 0
-        for ip_fib_details in ip_fib_dump:
-            if ip_fib_details[2] == vrf_id:
-                vrf_count += 1
+        ip_fib_dump = self.vapi.ip_route_dump(vrf_id, False)
+        vrf_count = len(ip_fib_dump)
+

         if vrf_count == 0:
             self.logger.info("IPv4 VRF ID %d is not configured" % vrf_id)
             return 0
         if vrf_count == 0:
             self.logger.info("IPv4 VRF ID %d is not configured" % vrf_id)
             return 0


@@ -324,6 +317,14 @@ class TestClassifier(VppTestCase):
 class TestClassifierIP(TestClassifier):
     """ Classifier IP Test Case """
 
 class TestClassifierIP(TestClassifier):
     """ Classifier IP Test Case """
 

+    @classmethod
+    def setUpClass(cls):
+        super(TestClassifierIP, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifierIP, cls).tearDownClass()
+

     def test_iacl_src_ip(self):
         """ Source IP iACL test
 
     def test_iacl_src_ip(self):
         """ Source IP iACL test
 


@@ -420,6 +421,14 @@ class TestClassifierIP(TestClassifier):
 class TestClassifierUDP(TestClassifier):
     """ Classifier UDP proto Test Case """
 
 class TestClassifierUDP(TestClassifier):
     """ Classifier UDP proto Test Case """
 

+    @classmethod
+    def setUpClass(cls):
+        super(TestClassifierUDP, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifierUDP, cls).tearDownClass()
+

     def test_iacl_proto_udp(self):
         """ UDP protocol iACL test
 
     def test_iacl_proto_udp(self):
         """ UDP protocol iACL test
 


@@ -560,6 +569,14 @@ class TestClassifierUDP(TestClassifier):
 class TestClassifierTCP(TestClassifier):
     """ Classifier TCP proto Test Case """
 
 class TestClassifierTCP(TestClassifier):
     """ Classifier TCP proto Test Case """
 

+    @classmethod
+    def setUpClass(cls):
+        super(TestClassifierTCP, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifierTCP, cls).tearDownClass()
+

     def test_iacl_proto_tcp(self):
         """ TCP protocol iACL test
 
     def test_iacl_proto_tcp(self):
         """ TCP protocol iACL test
 


@@ -701,6 +718,14 @@ class TestClassifierTCP(TestClassifier):
 class TestClassifierIPOut(TestClassifier):
     """ Classifier output IP Test Case """
 
 class TestClassifierIPOut(TestClassifier):
     """ Classifier output IP Test Case """
 

+    @classmethod
+    def setUpClass(cls):
+        super(TestClassifierIPOut, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifierIPOut, cls).tearDownClass()
+

     def test_acl_ip_out(self):
         """ Output IP ACL test
 
     def test_acl_ip_out(self):
         """ Output IP ACL test
 


@@ -736,6 +761,14 @@ class TestClassifierIPOut(TestClassifier):
 class TestClassifierMAC(TestClassifier):
     """ Classifier MAC Test Case """
 
 class TestClassifierMAC(TestClassifier):
     """ Classifier MAC Test Case """
 

+    @classmethod
+    def setUpClass(cls):
+        super(TestClassifierMAC, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifierMAC, cls).tearDownClass()
+

     def test_acl_mac(self):
         """ MAC ACL test
 
     def test_acl_mac(self):
         """ MAC ACL test
 


@@ -771,6 +804,14 @@ class TestClassifierMAC(TestClassifier):
 class TestClassifierPBR(TestClassifier):
     """ Classifier PBR Test Case """
 
 class TestClassifierPBR(TestClassifier):
     """ Classifier PBR Test Case """
 

+    @classmethod
+    def setUpClass(cls):
+        super(TestClassifierPBR, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestClassifierPBR, cls).tearDownClass()
+

     def test_acl_pbr(self):
         """ IP PBR test
 
     def test_acl_pbr(self):
         """ IP PBR test
 


@@ -793,7 +834,12 @@ class TestClassifierPBR(TestClassifier):
             self.build_ip_match(src_ip=self.pg0.remote_ip4),
             pbr_option, self.pbr_vrfid)
         self.assertTrue(self.verify_vrf(self.pbr_vrfid))
             self.build_ip_match(src_ip=self.pg0.remote_ip4),
             pbr_option, self.pbr_vrfid)
         self.assertTrue(self.verify_vrf(self.pbr_vrfid))

-        self.config_pbr_fib_entry(self.pg3)
+        r = VppIpRoute(self, self.pg3.local_ip4, 24,
+                       [VppRoutePath(self.pg3.remote_ip4,
+                                     INVALID_INDEX)],
+                       table_id=self.pbr_vrfid)
+        r.add_vpp_config()
+

         self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get(key))
 
         self.pg_enable_capture(self.pg_interfaces)
         self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get(key))
 
         self.pg_enable_capture(self.pg_interfaces)


@@ -807,7 +853,7 @@ class TestClassifierPBR(TestClassifier):
         self.pg2.assert_nothing_captured(remark="packets forwarded")
 
         # remove the classify session and the route
         self.pg2.assert_nothing_captured(remark="packets forwarded")
 
         # remove the classify session and the route

-        self.config_pbr_fib_entry(self.pg3, is_add=0)
+        r.remove_vpp_config()

         self.create_classify_session(
             self.acl_tbl_idx.get(key),
             self.build_ip_match(src_ip=self.pg0.remote_ip4),
         self.create_classify_session(
             self.acl_tbl_idx.get(key),
             self.build_ip_match(src_ip=self.pg0.remote_ip4),