import six
from framework import VppTestCase, VppTestRunner, running_extended_tests
+from framework import tag_run_solo
from vpp_neighbor import VppNeighbor
from vpp_ip_route import find_route, VppIpTable
from util import mk_ll_addr
DHCP6_SERVER_PORT = 546
+@tag_run_solo
class TestDHCP(VppTestCase):
""" DHCP Test Case """
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(TestDHCP, cls).setUpClass()
from scapy.utils6 import in6_mactoifaceid
from framework import VppTestCase
+from framework import tag_run_solo
from vpp_papi import VppEnum
import util
import os
self.vapi.dhcp6_clients_enable_disable(enable=0)
+@tag_run_solo
class TestDHCPv6IANAControlPlane(VppTestCase):
""" DHCPv6 IA NA Control Plane Test Case """
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(TestDHCPv6IANAControlPlane, cls).setUpClass()
from scapy.layers.inet6 import IPv6
from framework import VppTestCase, VppTestRunner, running_extended_tests
+from framework import tag_run_solo
from vpp_object import VppObject
from vpp_pg_interface import CaptureTimeoutError
from util import ppp
return p
+@tag_run_solo
class Flowprobe(MethodHolder):
"""Template verification, timer tests"""
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(Flowprobe, cls).setUpClass()
from scapy.layers.inet import IP, ICMP
from framework import VppTestCase, VppTestRunner, running_extended_tests
+from framework import tag_run_solo
from remote_test import RemoteClass, RemoteVppTestCase
from vpp_memif import remove_all_memif_vpp_config, \
VppSocketFilename, VppMemif
from vpp_papi import VppEnum
+@tag_run_solo
class TestMemif(VppTestCase):
""" Memif Test Case """
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
# fork new process before client connects to VPP
from bfd import VppBFDAuthKey, BFD, BFDAuthType, VppBFDUDPSession, \
BFDDiagCode, BFDState, BFD_vpp_echo
from framework import VppTestCase, VppTestRunner, running_extended_tests
+from framework import tag_run_solo
from util import ppp
from vpp_ip import DpoProto
from vpp_ip_route import VppIpRoute, VppRoutePath
return p
+@tag_run_solo
class BFD4TestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD)"""
vpp_session = None
test_session = None
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(BFD4TestCase, cls).setUpClass()
self.assertFalse(vpp_session.query_vpp_config())
+@tag_run_solo
class BFD6TestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (IPv6) """
vpp_session = None
test_session = None
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(BFD6TestCase, cls).setUpClass()
self.assertFalse(vpp_session.query_vpp_config())
+@tag_run_solo
class BFDFIBTestCase(VppTestCase):
""" BFD-FIB interactions (IPv6) """
vpp_session = None
test_session = None
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(BFDFIBTestCase, cls).setUpClass()
bfd_session_down(self)
+@tag_run_solo
class BFDSHA1TestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (SHA1 auth) """
vpp_session = None
test_session = None
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(BFDSHA1TestCase, cls).setUpClass()
bfd_session_up(self)
+@tag_run_solo
class BFDAuthOnOffTestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (changing auth) """
vpp_session = None
test_session = None
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(BFDAuthOnOffTestCase, cls).setUpClass()
"number of bfd events")
+@tag_run_solo
class BFDCLITestCase(VppTestCase):
"""Bidirectional Forwarding Detection (BFD) (CLI) """
pg0 = None
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(BFDCLITestCase, cls).setUpClass()
from inspect import getdoc, isclass
from traceback import format_exception
from logging import FileHandler, DEBUG, Formatter
+from enum import Enum
import scapy.compat
from scapy.packet import Raw
self.pipe.send((desc, test.vpp_bin, test.tempdir, test.vpp.pid))
+class TestCaseTag(Enum):
+ RUN_SOLO = 1
+
+
+def create_tag_decorator(e):
+ def decorator(cls):
+ try:
+ cls.test_tags.append(e)
+ except AttributeError:
+ cls.test_tags = [e]
+ return cls
+ return decorator
+
+tag_run_solo = create_tag_decorator(TestCaseTag.RUN_SOLO)
+
+
class VppTestCase(unittest.TestCase):
"""This subclass is a base class for VPP test cases that are implemented as
classes. It provides methods to create and run test case.
return 0
@classmethod
- def force_solo(cls):
- """ if the test case class is timing-sensitive - return true """
+ def has_tag(cls, tag):
+ """ if the test case has a given tag - return true """
+ try:
+ return tag in cls.test_tags
+ except AttributeError:
+ pass
return False
+ @classmethod
+ def is_tagged_run_solo(cls):
+ """ if the test case class is timing-sensitive - return true """
+ return cls.has_tag(TestCaseTag.RUN_SOLO)
+
@classmethod
def instance(cls):
"""Return the instance of this testcase"""
raise Exception("No doc string for test '%s'" % test.id())
test_title = test_doc.splitlines()[0]
test_title_colored = colorize(test_title, GREEN)
- if test.force_solo():
+ if test.is_tagged_run_solo():
# long live PEP-8 and 80 char width limitation...
c = YELLOW
test_title_colored = colorize("SOLO RUN: " + test_title, c)
while total_test_runners < concurrent_tests:
if testcase_suites:
a_suite = testcase_suites.pop(0)
- if a_suite.force_solo:
+ if a_suite.is_tagged_run_solo:
solo_testcase_suites.append(a_suite)
continue
wrapped_testcase_suite = TestCaseWrapper(a_suite,
results.append(TestResult(testcase_suites.pop(0)))
elif testcase_suites:
a_testcase = testcase_suites.pop(0)
- while a_testcase and a_testcase.force_solo:
+ while a_testcase and a_testcase.is_tagged_run_solo:
solo_testcase_suites.append(a_testcase)
if testcase_suites:
a_testcase = testcase_suites.pop(0)
self.suite_name = file_name + cls.__name__
if self.suite_name not in self.suites:
self.suites[self.suite_name] = unittest.TestSuite()
- self.suites[self.suite_name].force_solo = False
+ self.suites[self.suite_name].is_tagged_run_solo = False
self.suites[self.suite_name].addTest(test_method)
- if test_method.force_solo():
- self.suites[self.suite_name].force_solo = True
+ if test_method.is_tagged_run_solo():
+ self.suites[self.suite_name].is_tagged_run_solo = True
else:
self.filtered.addTest(test_method)
in6_mactoifaceid
from six import moves
-from framework import VppTestCase, VppTestRunner
+from framework import VppTestCase, VppTestRunner, tag_run_solo
from util import ppp, ip6_normalize, mk_ll_addr
from vpp_papi import VppEnum
from vpp_ip import DpoProto, VppIpPuntPolicer, VppIpPuntRedirect
self.assertEqual(ip.dst, dip)
+@tag_run_solo
class TestIPv6(TestIPv6ND):
""" IPv6 Test Case """
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(TestIPv6, cls).setUpClass()
import unittest
from framework import VppTestCase, VppTestRunner
+from framework import tag_run_solo
from vpp_ip_route import VppIpTable, VppIpRoute, VppRoutePath
self.vapi.session_enable_disable(is_enable=0)
+@tag_run_solo
class TestSvmFifoUnitTests(VppTestCase):
""" SVM Fifo Unit Tests Case """
- @classmethod
- def force_solo(cls):
- return True
-
@classmethod
def setUpClass(cls):
super(TestSvmFifoUnitTests, cls).setUpClass()
""" Test framework utility tests """
@classmethod
- def force_solo(cls):
+ def is_tagged_run_solo(cls):
""" if the test case class is timing-sensitive - return true """
return False
Code Review / vpp.git / commitdiff