Typos. A bunch of typos I've been collecting.

[vpp.git] / test / test_flowprobe.py

diff --git a/test/test_flowprobe.py b/test/test_flowprobe.py
index d2fd031..544d3be 100644 (file)
--- a/test/test_flowprobe.py
+++ b/test/test_flowprobe.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-
+from __future__ import print_function
 import binascii
 import random
 import socket
@@ -40,9 +40,11 @@ class VppCFLOW(VppObject):
 
     def add_vpp_config(self):
         self.enable_exporter()
-        self._test.vapi.ppcli("flowprobe params record %s active %s "
-                              "passive %s" % (self._collect, self._active,
-                                              self._passive))
+        self._test.vapi.flowprobe_params(
+            record_l2=1 if 'l2' in self._collect.lower() else 0,
+            record_l3=1 if 'l3' in self._collect.lower() else 0,
+            record_l4=1 if 'l4' in self._collect.lower() else 0,
+            active_timer=self._active, passive_timer=self._passive)
         self.enable_flowprobe_feature()
         self._test.vapi.cli("ipfix flush")
         self._configured = True
@@ -72,7 +74,7 @@ class VppCFLOW(VppObject):
                             (self._intf, self._datapath))
 
     def object_id(self):
-        return "ipfix-collector-%s" % (self._src, self.dst)
+        return "ipfix-collector-%s-%s" % (self._src, self.dst)
 
     def query_vpp_config(self):
         return self._configured
@@ -125,8 +127,10 @@ class MethodHolder(VppTestCase):
             # Create BD with MAC learning and unknown unicast flooding disabled
             # and put interfaces to this BD
             cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
-            cls.vapi.sw_interface_set_l2_bridge(cls.pg1._sw_if_index, bd_id=1)
-            cls.vapi.sw_interface_set_l2_bridge(cls.pg2._sw_if_index, bd_id=1)
+            cls.vapi.sw_interface_set_l2_bridge(
+                rx_sw_if_index=cls.pg1._sw_if_index, bd_id=1)
+            cls.vapi.sw_interface_set_l2_bridge(
+                rx_sw_if_index=cls.pg2._sw_if_index, bd_id=1)
 
             # Set up all interfaces
             for i in cls.pg_interfaces:
@@ -158,6 +162,10 @@ class MethodHolder(VppTestCase):
             super(MethodHolder, cls).tearDownClass()
             raise
 
+    @classmethod
+    def tearDownClass(cls):
+        super(MethodHolder, cls).tearDownClass()
+
     def create_stream(self, src_if=None, dst_if=None, packets=None,
                       size=None, ip_ver='v4'):
         """Create a packet stream to tickle the plugin
@@ -215,18 +223,18 @@ class MethodHolder(VppTestCase):
                                  data_set={1: 'octets', 2: 'packets'},
                                  ip_ver='v4'):
         if self.debug_print:
-            print capture[0].show()
+            print(capture[0].show())
         if cflow.haslayer(Data):
             data = decoder.decode_data_set(cflow.getlayer(Set))
             if self.debug_print:
-                print data
+                print(data)
             if ip_ver == 'v4':
                 ip_layer = capture[0][IP]
             else:
                 ip_layer = capture[0][IPv6]
             if data_set is not None:
                 for record in data:
-                    # skip flow if in/out gress interface is 0
+                    # skip flow if ingress/egress interface is 0
                     if int(binascii.hexlify(record[10]), 16) == 0:
                         continue
                     if int(binascii.hexlify(record[14]), 16) == 0:
@@ -325,6 +333,14 @@ class MethodHolder(VppTestCase):
 class Flowprobe(MethodHolder):
     """Template verification, timer tests"""
 
+    @classmethod
+    def setUpClass(cls):
+        super(Flowprobe, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(Flowprobe, cls).tearDownClass()
+
     def test_0001(self):
         """ timer less than template timeout"""
         self.logger.info("FFP_TEST_START_0001")
@@ -461,6 +477,14 @@ class Flowprobe(MethodHolder):
 class Datapath(MethodHolder):
     """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
 
+    @classmethod
+    def setUpClass(cls):
+        super(Datapath, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(Datapath, cls).tearDownClass()
+
     def test_templatesL2(self):
         """ verify template on L2 datapath"""
         self.logger.info("FFP_TEST_START_0000")
@@ -824,10 +848,18 @@ class Datapath(MethodHolder):
         self.logger.info("FFP_TEST_FINISH_0002")
 
 
-@unittest.skipUnless(running_extended_tests(), "part of extended tests")
+@unittest.skipUnless(running_extended_tests, "part of extended tests")
 class DisableIPFIX(MethodHolder):
     """Disable IPFIX"""
 
+    @classmethod
+    def setUpClass(cls):
+        super(DisableIPFIX, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(DisableIPFIX, cls).tearDownClass()
+
     def test_0001(self):
         """ disable IPFIX after first packets"""
         self.logger.info("FFP_TEST_START_0001")
@@ -849,7 +881,7 @@ class DisableIPFIX(MethodHolder):
         self.wait_for_cflow_packet(self.collector, templates[1])
         self.collector.get_capture(4)
 
-        # disble IPFIX
+        # disable IPFIX
         ipfix.disable_exporter()
         self.pg_enable_capture([self.collector])
 
@@ -865,10 +897,18 @@ class DisableIPFIX(MethodHolder):
         self.logger.info("FFP_TEST_FINISH_0001")
 
 
-@unittest.skipUnless(running_extended_tests(), "part of extended tests")
+@unittest.skipUnless(running_extended_tests, "part of extended tests")
 class ReenableIPFIX(MethodHolder):
     """Re-enable IPFIX"""
 
+    @classmethod
+    def setUpClass(cls):
+        super(ReenableIPFIX, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ReenableIPFIX, cls).tearDownClass()
+
     def test_0011(self):
         """ disable IPFIX after first packets and re-enable after few packets
         """
@@ -891,7 +931,7 @@ class ReenableIPFIX(MethodHolder):
         self.wait_for_cflow_packet(self.collector, templates[1])
         self.collector.get_capture(4)
 
-        # disble IPFIX
+        # disable IPFIX
         ipfix.disable_exporter()
         self.vapi.cli("ipfix flush")
         self.pg_enable_capture([self.collector])
@@ -926,10 +966,18 @@ class ReenableIPFIX(MethodHolder):
         self.logger.info("FFP_TEST_FINISH_0001")
 
 
-@unittest.skipUnless(running_extended_tests(), "part of extended tests")
+@unittest.skipUnless(running_extended_tests, "part of extended tests")
 class DisableFP(MethodHolder):
     """Disable Flowprobe feature"""
 
+    @classmethod
+    def setUpClass(cls):
+        super(DisableFP, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(DisableFP, cls).tearDownClass()
+
     def test_0001(self):
         """ disable flowprobe feature after first packets"""
         self.logger.info("FFP_TEST_START_0001")
@@ -950,7 +998,7 @@ class DisableFP(MethodHolder):
         self.wait_for_cflow_packet(self.collector, templates[1])
         self.collector.get_capture(4)
 
-        # disble IPFIX
+        # disable IPFIX
         ipfix.disable_flowprobe_feature()
         self.pg_enable_capture([self.collector])
 
@@ -966,10 +1014,18 @@ class DisableFP(MethodHolder):
         self.logger.info("FFP_TEST_FINISH_0001")
 
 
-@unittest.skipUnless(running_extended_tests(), "part of extended tests")
+@unittest.skipUnless(running_extended_tests, "part of extended tests")
 class ReenableFP(MethodHolder):
     """Re-enable Flowprobe feature"""
 
+    @classmethod
+    def setUpClass(cls):
+        super(ReenableFP, cls).setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        super(ReenableFP, cls).tearDownClass()
+
     def test_0001(self):
         """ disable flowprobe feature after first packets and re-enable
         after few packets """
@@ -993,7 +1049,7 @@ class ReenableFP(MethodHolder):
         self.wait_for_cflow_packet(self.collector, templates[1], 5)
         self.collector.get_capture(4)
 
-        # disble FPP feature
+        # disable FPP feature
         ipfix.disable_flowprobe_feature()
         self.pg_enable_capture([self.collector])