More robust unit tests, less race conditions

bombela · bombela · commit 621af25427a7 · 2014-09-10T01:51:37.000-07:00
- Bump timouts value to avoid false unit test errors: Basically, some
   timeouts are a little bit to short for fast testing.

 - Fix transiant unit test failure on pubsub.
     - you log all msgs
     - you send one msg
     - heartbeat msgs are logged
     - you check for only one msg: bad
     - you check if your msg appars among the heartbeats: good

    This was a beautiful race condition, since most of the time, the
    heartbeat is slower than how fast you send and test your msg.

 -  Wrap in coroutines.

    HeartbeatOnChannel can raises to its parent at any time.
    Encapsulating the code in its own coroutine will reduce race
    conditions.
diff --git a/tests/test_buffered_channel.py b/tests/test_buffered_channel.py
@@ -149,22 +149,28 @@ def test_heartbeat_can_open_channel_client_close():
     client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2)
     client_bufchan = zerorpc.BufferedChannel(client_hbchan)
 
-    event = server.recv()
-    server_channel = server.channel(event)
-    server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2)
-    server_bufchan = zerorpc.BufferedChannel(server_hbchan)
+    def server_fn():
+        event = server.recv()
+        server_channel = server.channel(event)
+        server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2)
+        server_bufchan = zerorpc.BufferedChannel(server_hbchan)
+        try:
+            while True:
+                gevent.sleep(1)
+        finally:
+            server_bufchan.close()
+    server_coro = gevent.spawn(server_fn)
 
     gevent.sleep(TIME_FACTOR * 3)
     print 'CLOSE CLIENT SOCKET!!!'
     client_bufchan.close()
     client.close()
     if sys.version_info < (2, 7):
-        assert_raises(zerorpc.LostRemote, client_bufchan.recv)
+        assert_raises(zerorpc.LostRemote, server_coro.get())
     else:
         with assert_raises(zerorpc.LostRemote):
-            client_bufchan.recv()
+            server_coro.get()
     print 'SERVER LOST CLIENT :)'
-    server_bufchan.close()
     server.close()
 
 
@@ -178,16 +184,11 @@ def test_do_some_req_rep():
     client_events.connect(endpoint)
     client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True)
 
-    client_channel = client.channel()
-    client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2)
-    client_bufchan = zerorpc.BufferedChannel(client_hbchan)
-
-    event = server.recv()
-    server_channel = server.channel(event)
-    server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2)
-    server_bufchan = zerorpc.BufferedChannel(server_hbchan)
 
     def client_do():
+        client_channel = client.channel()
+        client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2)
+        client_bufchan = zerorpc.BufferedChannel(client_hbchan)
         for x in xrange(20):
             client_bufchan.emit('add', (x, x * x))
             event = client_bufchan.recv()
@@ -199,6 +200,11 @@ def client_do():
     coro_pool.spawn(client_do)
 
     def server_do():
+        event = server.recv()
+        server_channel = server.channel(event)
+        server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2)
+        server_bufchan = zerorpc.BufferedChannel(server_hbchan)
+
         for x in xrange(20):
             event = server_bufchan.recv()
             assert event.name == 'add'
@@ -389,18 +395,22 @@ def test_congestion_control_server_pushing():
 
     client_channel = client.channel()
     client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2)
-    client_bufchan = zerorpc.BufferedChannel(client_hbchan)
+    client_bufchan = zerorpc.BufferedChannel(client_hbchan, inqueue_size=100)
 
     event = server.recv()
     server_channel = server.channel(event)
     server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2)
-    server_bufchan = zerorpc.BufferedChannel(server_hbchan)
+    server_bufchan = zerorpc.BufferedChannel(server_hbchan, inqueue_size=100)
+
+    read_cnt = 0
 
     def client_do():
         for x in xrange(200):
             event = client_bufchan.recv()
             assert event.name == 'coucou'
             assert event.args == x
+            read_cnt += 1
+        raise Exception('CLIENT DONE')
 
     coro_pool = gevent.pool.Pool()
     coro_pool.spawn(client_do)
@@ -409,30 +419,37 @@ def server_do():
         if sys.version_info < (2, 7):
             def _do_with_assert_raises():
                 for x in xrange(200):
-                    server_bufchan.emit('coucou', x, timeout=TIME_FACTOR * 0)  # will fail when x == 1
+                    server_bufchan.emit('coucou', x, timeout=0)  # will fail when x == 1
             assert_raises(zerorpc.TimeoutExpired, _do_with_assert_raises)
         else:
             with assert_raises(zerorpc.TimeoutExpired):
                 for x in xrange(200):
-                    server_bufchan.emit('coucou', x, timeout=TIME_FACTOR * 0)  # will fail when x == 1
+                    server_bufchan.emit('coucou', x, timeout=0)  # will fail when x == 1
         server_bufchan.emit('coucou', 1)  # block until receiver is ready
         if sys.version_info < (2, 7):
             def _do_with_assert_raises():
                 for x in xrange(2, 200):
-                    server_bufchan.emit('coucou', x, timeout=TIME_FACTOR * 0)  # will fail when x == 100
+                    server_bufchan.emit('coucou', x, timeout=0)  # will fail when x == 100
             assert_raises(zerorpc.TimeoutExpired, _do_with_assert_raises)
         else:
             with assert_raises(zerorpc.TimeoutExpired):
                 for x in xrange(2, 200):
-                    server_bufchan.emit('coucou', x, timeout=TIME_FACTOR * 0)  # will fail when x == 100
-        for x in xrange(101, 200):
+                    server_bufchan.emit('coucou', x, timeout=0)  # will fail when x == 100
+        for x in xrange(read_cnt, 200):
             server_bufchan.emit('coucou', x) # block until receiver is ready
+        raise Exception('SERVER DONE')
 
 
     coro_pool.spawn(server_do)
-
-    coro_pool.join()
-    client_bufchan.close()
-    client.close()
-    server_bufchan.close()
-    server.close()
+    try:
+        coro_pool.join()
+    except zerorpc.LostRemote:
+        pass
+    finally:
+        try:
+            client_bufchan.close()
+            client.close()
+            server_bufchan.close()
+            server.close()
+        except Exception:
+            pass
diff --git a/tests/test_client_heartbeat.py b/tests/test_client_heartbeat.py
@@ -60,12 +60,12 @@ def lolita(self):
             gevent.sleep(TIME_FACTOR * 3)
             return 42
 
-    srv = MySrv(heartbeat=TIME_FACTOR * 1)
+    srv = MySrv(heartbeat=TIME_FACTOR * 4)
     srv.bind(endpoint)
     gevent.spawn(srv.run)
-    gevent.sleep(TIME_FACTOR * 0)
+    gevent.sleep(0)
 
-    client = zerorpc.Client(heartbeat=TIME_FACTOR * 1)
+    client = zerorpc.Client(heartbeat=TIME_FACTOR * 4)
     client.connect(endpoint)
 
     assert client.lolita() == 42
@@ -84,11 +84,12 @@ def slow(self):
             gevent.sleep(TIME_FACTOR * 3)
             return 2
 
-    srv = MySrv(heartbeat=TIME_FACTOR * 1)
+    srv = MySrv(heartbeat=TIME_FACTOR * 4)
     srv.bind(endpoint)
     gevent.spawn(srv.run)
+    gevent.sleep(0)
 
-    client = zerorpc.Client(heartbeat=TIME_FACTOR * 1, passive_heartbeat=True)
+    client = zerorpc.Client(heartbeat=TIME_FACTOR * 4, passive_heartbeat=True)
     client.connect(endpoint)
 
     assert client.slow() == 2
diff --git a/tests/test_heartbeat.py b/tests/test_heartbeat.py
@@ -171,11 +171,11 @@ def test_do_some_req_rep():
     client = zerorpc.ChannelMultiplexer(client_events, ignore_broadcast=True)
 
     client_channel = client.channel()
-    client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 2)
+    client_hbchan = zerorpc.HeartBeatOnChannel(client_channel, freq=TIME_FACTOR * 4)
 
     event = server.recv()
     server_channel = server.channel(event)
-    server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 2)
+    server_hbchan = zerorpc.HeartBeatOnChannel(server_channel, freq=TIME_FACTOR * 4)
 
     def client_do():
         for x in xrange(20):
diff --git a/tests/test_middleware.py b/tests/test_middleware.py
@@ -373,20 +373,18 @@ def echo(self, msg):
     trigger.clear()
     # We need this retry logic to wait that the subscriber.run coroutine starts
     # reading (the published messages will go to /dev/null until then).
-    for attempt in xrange(0, 100):
+    while not trigger.is_set():
         c.echo('pub...')
-        if trigger.wait(TIME_FACTOR * 0.2):
+        if trigger.wait(TIME_FACTOR * 1):
             break
 
     subscriber.stop()
     subscriber_task.join()
 
-    assert publisher_tracer._log == [
-            ('new', publisher_tracer.trace_id),
-            ]
-    assert subscriber_tracer._log == [
-            ('load', publisher_tracer.trace_id),
-            ]
+    print publisher_tracer._log
+    assert ('new', publisher_tracer.trace_id) in publisher_tracer._log
+    print subscriber_tracer._log
+    assert ('load', publisher_tracer.trace_id) in subscriber_tracer._log
 
 
 class InspectExceptionMiddleware(Tracer):
diff --git a/tests/test_reqstream.py b/tests/test_reqstream.py
@@ -42,11 +42,11 @@ def range(self, max):
         def xrange(self, max):
             return xrange(max)
 
-    srv = MySrv(heartbeat=TIME_FACTOR * 2)
+    srv = MySrv(heartbeat=TIME_FACTOR * 4)
     srv.bind(endpoint)
     gevent.spawn(srv.run)
 
-    client = zerorpc.Client(heartbeat=TIME_FACTOR * 2)
+    client = zerorpc.Client(heartbeat=TIME_FACTOR * 4)
     client.connect(endpoint)
 
     r = client.range(10)
