From 21b7e664f085ed56ec423020b8352f500d8ede9e Mon Sep 17 00:00:00 2001 From: Fernando Giorgetti Date: Thu, 3 May 2018 18:54:29 -0300 Subject: [PATCH] DISPATCH-963 - Added decorator class that can be used to skip test methods, as unittest2 does not support skipping feature on python 2.6. --- tests/system_test.py | 43 +++++++- tests/system_tests_distribution.py | 156 ++++++++++------------------- 2 files changed, 93 insertions(+), 106 deletions(-) diff --git a/tests/system_test.py b/tests/system_test.py index 504b4e349e..d8baed760f 100755 --- a/tests/system_test.py +++ b/tests/system_test.py @@ -28,7 +28,7 @@ - Sundry other tools. """ -import errno, os, time, socket, random, subprocess, shutil, unittest, __main__, re +import errno, os, time, socket, random, subprocess, shutil, unittest, __main__, re, sys from copy import copy try: import queue as Queue # 3.x @@ -646,6 +646,47 @@ def assertRegexpMatches(self, text, regexp, msg=None): """For python < 2.7: assert re.search(regexp, text)""" assert re.search(regexp, text), msg or "Can't find %r in '%s'" %(regexp, text) + +class SkipIfNeeded(object): + """ + Decorator class that can be used along with test methods + to provide skip test behavior when using both python2.6 or + a greater version. + This decorator can be used with sub-classes of TestCase and the + sub-class must contain a dictionary named "skip" (test_name as key + and 0[run] or 1[skip] as the value). + """ + def __init__(self, test_name, reason): + self.test_name = test_name + self.reason = reason + + def __call__(self, f): + + def wrap(*args, **kwargs): + """ + Wraps original test method's invocation looking for an instance + attribute named "skip" (should be a dictionary composed by + "test_name" as a key and value of 0 [run] or 1 [skip]). + When running test with python < 2.7, if the "skip" dictionary + contains the given test_name with a value of 1, the original + method won't be called. If running python >= 2.7, then + skipTest will be called with given "reason" and original method + will be invoked. + :param args: + :return: + """ + instance = args[0] + if isinstance(instance, TestCase) and hasattr(instance, "skip") and instance.skip[self.test_name]: + if sys.version_info < (2, 7): + print "%s -> skipping (python<2.7) ..." % self.test_name + return + else: + instance.skipTest(self.reason) + return f(*args, **kwargs) + + return wrap + + def main_module(): """ Return the module name of the __main__ module - i.e. the filename with the diff --git a/tests/system_tests_distribution.py b/tests/system_tests_distribution.py index 98c7183324..d6ef781b9a 100644 --- a/tests/system_tests_distribution.py +++ b/tests/system_tests_distribution.py @@ -17,10 +17,9 @@ # under the License. # -import sys import unittest2 as unittest from proton import Message, Timeout -from system_test import TestCase, Qdrouterd, main_module, TIMEOUT +from system_test import TestCase, Qdrouterd, main_module, TIMEOUT, SkipIfNeeded from proton.handlers import MessagingHandler from proton.reactor import Container, LinkOption, ApplicationEvent, EventInjector @@ -525,64 +524,57 @@ def router(name, more_config): + @SkipIfNeeded('test_01', 'Test skipped during development.') def test_01_targeted_sender_AC ( self ): - name = 'test_01' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_01' test = TargetedSenderTest ( name, self.A_addr, self.C_addr, "closest/01" ) test.run() self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_02', 'Test skipped during development.') def test_02_targeted_sender_DC ( self ): - name = 'test_02' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_02' test = TargetedSenderTest ( name, self.D_addr, self.C_addr, "closest/02" ) test.run() self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_03', 'Test skipped during development.') def test_03_anonymous_sender_AC ( self ): - name = 'test_03' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_03' test = AnonymousSenderTest ( name, self.A_addr, self.C_addr ) test.run() self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_04', 'Test skipped during development.') def test_04_anonymous_sender_DC ( self ): - name = 'test_04' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_04' test = AnonymousSenderTest ( name, self.D_addr, self.C_addr ) test.run() self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_05', 'Test skipped during development.') def test_05_dynamic_reply_to_AC ( self ): - name = 'test_05' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_05' test = DynamicReplyTo ( name, self.A_addr, self.C_addr ) test.run() self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_06', 'Test skipped during development.') def test_06_dynamic_reply_to_DC ( self ): - name = 'test_06' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_06' test = DynamicReplyTo ( name, self.D_addr, self.C_addr ) test.run() self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_07', 'Test skipped during development.') def test_07_linkroute ( self ): - name = 'test_07' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_07' test = LinkAttachRouting ( name, self.container_ids[0], self.C_addr, @@ -594,10 +586,9 @@ def test_07_linkroute ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_08', 'Test skipped during development.') def test_08_linkroute_check_only ( self ): - name = 'test_08' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_08' test = LinkAttachRoutingCheckOnly ( name, self.container_ids[0], self.C_addr, @@ -609,10 +600,9 @@ def test_08_linkroute_check_only ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_09', 'Test skipped during development.') def test_09_closest_linear ( self ): - name = 'test_09' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_09' test = ClosestTest ( name, self.A_addr, self.B_addr, @@ -623,10 +613,9 @@ def test_09_closest_linear ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_10', 'Test skipped during development.') def test_10_closest_mesh ( self ): - name = 'test_10' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_10' test = ClosestTest ( name, self.A_addr, self.B_addr, @@ -704,10 +693,9 @@ def test_10_closest_mesh ( self ): # 100 55 33 12 # + @SkipIfNeeded('test_11', 'Test skipped during development.') def test_11_balanced_linear ( self ): - name = 'test_11' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_11' # slop is how much the second two values may diverge from # the expected. But they still must sum to total - A. total = 100 @@ -737,10 +725,9 @@ def test_11_balanced_linear ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_12', 'Test skipped during development.') def test_12_balanced_linear_omit_middle_receiver ( self ): - name = 'test_12' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_12' # If we omit the middle receiver, then router A will count # up to cost ( A, B ) and the keep counting up a further # cost ( B, C ) before it starts to spill over. @@ -834,10 +821,9 @@ def test_12_balanced_linear_omit_middle_receiver ( self ): # 2. B and D sum to 100 - A # 3. B and D are both with 1 of their expected values. # + @SkipIfNeeded('test_13', 'Test skipped during development.') def test_13_balanced_mesh ( self ): - name = 'test_13' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_13' total = 100 expected_A = 54 expected_B = 43 @@ -860,10 +846,9 @@ def test_13_balanced_mesh ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_14', 'Test skipped during development.') def test_14_multicast_linear ( self ): - name = 'test_14' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_14' test = MulticastTest ( name, self.A_addr, self.B_addr, @@ -874,10 +859,9 @@ def test_14_multicast_linear ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_15', 'Test skipped during development.') def test_15_multicast_mesh ( self ): - name = 'test_15' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_15' test = MulticastTest ( name, self.A_addr, self.B_addr, @@ -888,14 +872,9 @@ def test_15_multicast_mesh ( self ): self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_16', 'Test skipped during development.') def test_16_linkroute_linear_all_local ( self ) : - name = 'test_16' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( "" ) + name='test_16' """ This test should route all senders' link-attaches to the local containers on router A. @@ -982,14 +961,9 @@ def test_16_linkroute_linear_all_local ( self ) : + @SkipIfNeeded('test_17', 'Test skipped during development.') def test_17_linkroute_linear_all_B ( self ) : - name = 'test_17' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( "" ) + name='test_17' """ This test should route all senders' link-attaches to the remote connections on router B. @@ -1076,14 +1050,9 @@ def test_17_linkroute_linear_all_B ( self ) : + @SkipIfNeeded('test_18', 'Test skipped during development.') def test_18_linkroute_linear_all_C ( self ) : - name = 'test_18' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( "" ) + name='test_18' """ This test should route all senders' link-attaches to the remote connections on router C. @@ -1169,14 +1138,9 @@ def test_18_linkroute_linear_all_C ( self ) : self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_19', 'Test skipped during development.') def test_19_linkroute_linear_kill ( self ) : - name = 'test_19' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( "" ) + name='test_19' """ Start out as usual, making four senders and seeing their link-attaches routed to router A (local). But then kill the two route-container @@ -1323,14 +1287,9 @@ def test_19_linkroute_linear_kill ( self ) : + @SkipIfNeeded('test_20', 'Test skipped during development.') def test_20_linkroute_mesh_all_local ( self ) : - name = 'test_20' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( '' ) + name='test_20' """ c c senders ---> A --------- B @@ -1430,14 +1389,9 @@ def test_20_linkroute_mesh_all_local ( self ) : self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_21', 'Test skipped during development.') def test_21_linkroute_mesh_nonlocal ( self ) : - name = 'test_21' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( "" ) + name='test_21' """ c senders ---> A --------- B @@ -1539,14 +1493,9 @@ def test_21_linkroute_mesh_nonlocal ( self ) : + @SkipIfNeeded('test_22', 'Test skipped during development.') def test_22_linkroute_mesh_kill ( self ) : - name = 'test_22' - - if sys.version_info < (2, 7): - return - - if self.skip [ name ] : - self.skipTest ( "" ) + name='test_22' """ c c senders ---> A --------- B @@ -1701,10 +1650,9 @@ def test_22_linkroute_mesh_kill ( self ) : self.assertEqual ( None, test.error ) + @SkipIfNeeded('test_23', 'Test skipped during development.') def test_23_waypoint ( self ) : - name = 'test_23' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_23' test = WaypointTest ( name, self.container_ids[1], self.A_addr, @@ -1716,10 +1664,9 @@ def test_23_waypoint ( self ) : self.assertEqual(None, test.error) + @SkipIfNeeded('test_24', 'Test skipped during development.') def test_24_serial_waypoint_test ( self ): - name = 'test_24' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_24' test = SerialWaypointTest ( name, self.container_ids[2], self.A_addr, @@ -1730,10 +1677,9 @@ def test_24_serial_waypoint_test ( self ): test.run() self.assertEqual(None, test.error) + @SkipIfNeeded('test_25', 'Test skipped during development.') def test_25_parallel_waypoint_test ( self ): - name = 'test_25' - if self.skip [ name ] : - self.skipTest ( "Test skipped during development." ) + name='test_25' test = ParallelWaypointTest ( name, self.container_ids[3], self.A_addr,