tests: misc. improvements (#503)

Mainly reduce warnings during tests.

Author: thiell

tests/DefaultsTest.py

@@ -113,7 +113,7 @@ class OutOfTreeWorker(object):
         sys.path.append(dname)
         self.defaults.distant_workername = 'OutOfTree'
         task = task_self(self.defaults)
-        self.assertTrue(task.default("distant_worker").__name__ is 'OutOfTreeWorker')
+        self.assertEqual(task.default("distant_worker").__name__, 'OutOfTreeWorker')
         task_terminate()
         shutil.rmtree(dname, ignore_errors=True)
 

tests/MisusageTest.py

@@ -18,7 +18,7 @@ class MisusageTest(unittest.TestCase):
     def testTaskResumedTwice(self):
         """test library misusage (task_self resumed twice)"""
         class ResumeAgainHandler(EventHandler):
-            def ev_read(self, worker):
+            def ev_read(self, worker, node, sname, msg):
                 worker.task.resume()
         task = task_self()
         task.shell("/bin/echo OK", handler=ResumeAgainHandler())

tests/StreamWorkerTest.py

@@ -42,18 +42,13 @@ def __init__(self, testcase):
                 self.snames = set()
                 self.testcase = testcase
 
-            def ev_error(self, worker):
-                # test that ev_error is called in case of 'stderr' stream name
-                self.testcase.assertEqual(worker.current_sname, "stderr")
-                self.recv_msg(worker.current_errmsg)
+            def ev_read(self, worker, node, sname, msg):
+                self.recv_msg(sname, msg)
 
-            def ev_read(self, worker):
-                self.recv_msg(worker.current_msg)
-
-            def recv_msg(self, msg):
+            def recv_msg(self, sname, msg):
                 self.testcase.assertTrue(len(self.snames) < len(streams))
-                self.testcase.assertEqual(streams[worker.current_sname], msg)
-                self.snames.add(worker.current_sname)
+                self.testcase.assertEqual(streams[sname], msg)
+                self.snames.add(sname)
                 if len(self.snames) == len(streams):
                     # before finishing, try to add another pipe at
                     # runtime: this is NOT allowed
@@ -93,25 +88,25 @@ def __init__(self, testcase):
                 self.pickup_count = 0
                 self.hup_count = 0
 
-            def ev_pickup(self, worker):
+            def ev_pickup(self, worker, node):
                 self.pickup_count += 1
 
-            def ev_read(self, worker):
-                self.testcase.assertEqual(worker.current_sname, "pipe1")
-                worker.write(worker.current_msg, "pipe2")
+            def ev_read(self, worker, node, sname, msg):
+                self.testcase.assertEqual(sname, "pipe1")
+                worker.write(msg, "pipe2")
 
             def ev_timer(self, timer):
                 # call set_write_eof on specific stream after some delay
                 worker = self.worker
                 self.worker = 'DONE'
                 worker.set_write_eof("pipe2")
 
-            def ev_hup(self, worker):
+            def ev_hup(self, worker, node, rc):
                 # ev_hup called at the end (after set_write_eof is called)
                 self.hup_count += 1
                 self.testcase.assertEqual(self.worker, 'DONE')
                 # no rc code should be set
-                self.testcase.assertEqual(worker.current_rc, None)
+                self.testcase.assertEqual(rc, None)
 
         # create a StreamWorker instance bound to several pipes
         hdlr = TestH(self)
@@ -172,21 +167,22 @@ def __init__(self, testcase):
                 self.ev_hup_called = False
                 self.ev_timeout_called = False
 
-            def ev_pickup(self, worker):
+            def ev_pickup(self, worker, node):
                 self.ev_pickup_called = True
 
-            def ev_read(self, worker):
+            def ev_read(self, worker, node, sname, msg):
                 self.ev_read_called = True
-                self.testcase.assertEqual(worker.current_sname, "pipe1")
-                self.testcase.assertEqual(worker.current_msg, b"Some data")
+                self.testcase.assertEqual(sname, "pipe1")
+                self.testcase.assertEqual(msg, b"Some data")
 
-            def ev_hup(self, worker):
+            def ev_hup(self, worker, node, rc):
                 # ev_hup is called but no rc code should be set
                 self.ev_hup_called = True
-                self.testcase.assertEqual(worker.current_rc, None)
+                self.testcase.assertEqual(rc, None)
 
-            def ev_timeout(self, worker):
-                self.ev_timeout_called = True
+            def ev_close(self, worker, timedout):
+                if timedout:
+                    self.ev_timeout_called = True
 
         hdlr = TestH(self)
         worker = StreamWorker(handler=hdlr, timeout=0.5)
@@ -284,7 +280,7 @@ def __init__(self, testcase, rfd):
                 self.check_hup = 0
                 self.check_written = 0
 
-            def ev_hup(self, worker):
+            def ev_hup(self, worker, node, rc):
                 self.check_hup += 1
 
             def ev_written(self, worker, node, sname, size):

tests/TaskEventTest.py

@@ -136,11 +136,6 @@ def ev_close(self, worker, did_timeout):
             assert worker.read().startswith(b"abcdefghijklmnopqrstuvwxyz")
 
 
-class AbortOnReadHandler(EventHandler):
-    def ev_read(self, worker):
-        worker.abort()
-
-
 class TaskEventTest(unittest.TestCase):
 
     def run_task_and_catch_warnings(self, task, expected_warn_cnt=0,

tests/TaskLocalMixin.py

@@ -436,15 +436,15 @@ def ev_start(self, worker):
 
     def testEscape(self):
         task = task_self()
-        worker = task.shell("export CSTEST=foobar; /bin/echo \$CSTEST | sed 's/\ foo/bar/'")
+        worker = task.shell(r"export CSTEST=foobar; /bin/echo \$CSTEST | sed 's/\ foo/bar/'")
         # execute
         task.resume()
         # read result
         self.assertEqual(worker.read(), b"$CSTEST")
 
     def testEscape2(self):
         task = task_self()
-        worker = task.shell("export CSTEST=foobar; /bin/echo $CSTEST | sed 's/\ foo/bar/'")
+        worker = task.shell(r"export CSTEST=foobar; /bin/echo $CSTEST | sed 's/\ foo/bar/'")
         # execute
         task.resume()
         # read result

tests/TaskTimerTest.py

@@ -179,11 +179,10 @@ def ev_written(self, worker, node, sname, size):
         def ev_hup(self, worker, node, rc):
             self.test.assertTrue(self.flags & EV_START)
             self.flags |= EV_HUP
-        def ev_timeout(self, worker):
-            self.test.assertTrue(self.flags & EV_START)
-            self.flags |= EV_TIMEOUT
         def ev_close(self, worker, timedout):
             self.test.assertTrue(self.flags & EV_START)
+            if timedout:
+                self.flags |= EV_TIMEOUT
             self.flags |= EV_CLOSE
         def ev_timer(self, timer):
             self.flags |= EV_TIMER
@@ -222,11 +221,10 @@ def ev_written(self, worker):
         def ev_hup(self, worker, node, rc):
             self.test.assertTrue(self.flags & EV_START)
             self.flags |= EV_HUP
-        def ev_timeout(self, worker):
-            self.test.assertTrue(self.flags & EV_START)
-            self.flags |= EV_TIMEOUT
         def ev_close(self, worker, timedout):
             self.test.assertTrue(self.flags & EV_START)
+            if timedout:
+                self.flags |= EV_TIMEOUT
             self.flags |= EV_CLOSE
         def ev_timer(self, timer):
             self.flags |= EV_TIMER
@@ -266,11 +264,10 @@ def ev_written(self, worker):
         def ev_hup(self, worker, node, rc):
             self.test.assertTrue(self.flags & EV_START)
             self.flags |= EV_HUP
-        def ev_timeout(self, worker):
-            self.test.assertTrue(self.flags & EV_START)
-            self.flags |= EV_TIMEOUT
         def ev_close(self, worker, timedout):
             self.test.assertTrue(self.flags & EV_START)
+            if timedout:
+                self.flags |= EV_TIMEOUT
             self.flags |= EV_CLOSE
         def ev_timer(self, timer):
             self.flags |= EV_TIMER
@@ -335,11 +332,10 @@ def ev_written(self, worker):
         def ev_hup(self, worker, node, rc):
             self.test.assertTrue(self.flags & EV_START)
             self.flags |= EV_HUP
-        def ev_timeout(self, worker):
-            self.test.assertTrue(self.flags & EV_START)
-            self.flags |= EV_TIMEOUT
         def ev_close(self, worker, timedout):
             self.test.assertTrue(self.flags & EV_START)
+            if timedout:
+                self.flags |= EV_TIMEOUT
             self.flags |= EV_CLOSE
             # set next fire delay, also disable previously setup interval
             # (timer will not repeat anymore)

tests/TreeTopologyTest.py

@@ -49,8 +49,8 @@ def testAddingSeveralRoutes(self):
         # Add the same dst nodeset twice (no error)
         g.add_route(ns0, ns2)
 
-        self.assertEquals(g.dest(admin), ns0)
-        self.assertEquals(g.dest(ns0), ns1 | ns2)
+        self.assertEqual(g.dest(admin), ns0)
+        self.assertEqual(g.dest(ns0), ns1 | ns2)
 
     def testBadLink(self):
         """test detecting bad links in graph"""
@@ -216,7 +216,7 @@ def testNodeString(self):
         ns_tree = NodeSet()
         for nodegroup in tree:
             ns_tree.add(nodegroup.nodeset)
-        self.assertEquals(ns, ns_tree)
+        self.assertEqual(ns, ns_tree)
 
     def testConfigurationParser(self):
         """test configuration parsing"""
@@ -384,7 +384,7 @@ def testPrintingTree(self):
         display = str(tree)
         self.assertTrue(display == display_ref1 or display == display_ref2)
 
-        self.assertEquals(str(TopologyTree()), '<TopologyTree instance (empty)>')
+        self.assertEqual(str(TopologyTree()), '<TopologyTree instance (empty)>')
 
     def testAddingInvalidChildren(self):
         """test detecting invalid children"""
@@ -393,46 +393,46 @@ def testAddingInvalidChildren(self):
         t1 = TopologyNodeGroup(NodeSet('node[10-19]'))
 
         t0.add_child(t1)
-        self.assertEquals(t0.children_ns(), t1.nodeset)
+        self.assertEqual(t0.children_ns(), t1.nodeset)
         t0.add_child(t1)
-        self.assertEquals(t0.children_ns(), t1.nodeset)
+        self.assertEqual(t0.children_ns(), t1.nodeset)
 
     def testRemovingChild(self):
         """test child removal operation"""
         t0 = TopologyNodeGroup(NodeSet('node[0-9]'))
         t1 = TopologyNodeGroup(NodeSet('node[10-19]'))
 
         t0.add_child(t1)
-        self.assertEquals(t0.children_ns(), t1.nodeset)
+        self.assertEqual(t0.children_ns(), t1.nodeset)
         t0.clear_child(t1)
-        self.assertEquals(t0.children_ns(), None)
+        self.assertEqual(t0.children_ns(), None)
 
         t0.clear_child(t1) # error discarded
         self.assertRaises(ValueError, t0.clear_child, t1, strict=True)
 
         t2 = TopologyNodeGroup(NodeSet('node[20-29]'))
         t0.add_child(t1)
         t0.add_child(t2)
-        self.assertEquals(t0.children_ns(), t1.nodeset | t2.nodeset)
+        self.assertEqual(t0.children_ns(), t1.nodeset | t2.nodeset)
         t0.clear_children()
-        self.assertEquals(t0.children_ns(), None)
-        self.assertEquals(t0.children_len(), 0)
+        self.assertEqual(t0.children_ns(), None)
+        self.assertEqual(t0.children_len(), 0)
 
     def testStrConversions(self):
         """test str() casts"""
         t = TopologyNodeGroup(NodeSet('admin0'))
-        self.assertEquals(str(t), '<TopologyNodeGroup (admin0)>')
+        self.assertEqual(str(t), '<TopologyNodeGroup (admin0)>')
 
         t = TopologyRoutingTable()
         r0 = TopologyRoute(NodeSet('src[0-9]'), NodeSet('dst[5-8]'))
         r1 = TopologyRoute(NodeSet('src[10-19]'), NodeSet('dst[15-18]'))
 
-        self.assertEquals(str(r0), 'src[0-9] -> dst[5-8]')
+        self.assertEqual(str(r0), 'src[0-9] -> dst[5-8]')
 
         t.add_route(r0)
         t.add_route(r1)
-        self.assertEquals(str(t), 'src[0-9] -> dst[5-8]\nsrc[10-19] -> dst[15-18]')
+        self.assertEqual(str(t), 'src[0-9] -> dst[5-8]\nsrc[10-19] -> dst[15-18]')
 
         g = TopologyGraph()
         # XXX: Actually if g is not empty other things will be printed out...
-        self.assertEquals(str(g), '<TopologyGraph>\n')
+        self.assertEqual(str(g), '<TopologyGraph>\n')

tests/TreeWorkerTest.py

@@ -15,6 +15,7 @@
 from os.path import basename, join
 import shutil
 import unittest
+import warnings
 
 from ClusterShell.NodeSet import NodeSet
 from ClusterShell.Task import task_self, task_terminate, task_wait
@@ -133,7 +134,10 @@ def tearDown(self):
     def test_tree_run_event_legacy(self):
         """test simple tree run with legacy EventHandler"""
         teh = TEventHandlerLegacy()
-        self.task.run('echo Lorem Ipsum', nodes=NODE_DISTANT, handler=teh)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.task.run('echo Lorem Ipsum', nodes=NODE_DISTANT, handler=teh)
+            self.assertEqual(len(w), 4)
         self.assertEqual(teh.ev_start_cnt, 1)
         self.assertEqual(teh.ev_pickup_cnt, 1)
         self.assertEqual(teh.ev_read_cnt, 1)
@@ -146,7 +150,10 @@ def test_tree_run_event_legacy(self):
     def test_tree_run_event_legacy_timeout(self):
         """test simple tree run with legacy EventHandler with timeout"""
         teh = TEventHandlerLegacy()
-        self.task.run('sleep 10', nodes=NODE_DISTANT, handler=teh, timeout=0.5)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.task.run('sleep 10', nodes=NODE_DISTANT, handler=teh, timeout=0.5)
+            self.assertEqual(len(w), 2)
         self.assertEqual(teh.ev_start_cnt, 1)
         self.assertEqual(teh.ev_pickup_cnt, 1)
         self.assertEqual(teh.ev_read_cnt, 0)      # nothing to read