make sure we know the order of expected subscribe/unsubscribe messages

Author: andymccurdy

tests/conftest.py

@@ -1,6 +1,8 @@
 import pytest
 import redis
 
+from distutils.version import StrictVersion
+
 
 _REDIS_VERSIONS = {}
 
@@ -30,9 +32,8 @@ def teardown():
 
 
 def skip_if_server_version_lt(min_version):
-    version = get_version()
-    c = "StrictVersion('%s') < StrictVersion('%s')" % (version, min_version)
-    return pytest.mark.skipif(c)
+    check = StrictVersion(get_version()) < StrictVersion(min_version)
+    return pytest.mark.skipif(check, reason="")
 
 
 @pytest.fixture()

tests/test_commands.py

@@ -11,8 +11,6 @@
 from redis import exceptions
 
 from .conftest import skip_if_server_version_lt
-# won't need this after next version of pytest
-from distutils.version import StrictVersion
 
 
 # RESPONSE CALLBACKS

tests/test_connection_pool.py

@@ -9,9 +9,6 @@
 from redis._compat import Queue
 from .conftest import skip_if_server_version_lt
 
-# won't need this after next version of pytest
-from distutils.version import StrictVersion
-
 
 class DummyConnection(object):
     description_format = "DummyConnection<>"

tests/test_pubsub.py

@@ -54,13 +54,15 @@ class TestPubSubSubscribeUnsubscribe(object):
 
     def _test_subscribe_unsubscribe(self, p, sub_type, unsub_type, sub_func,
                                     unsub_func, keys):
-        assert sub_func(*keys) is None
+        assert sub_func(keys[0]) is None
+        assert sub_func(keys[1]) is None
 
         # should be 2 messages indicating that we've subscribed
         assert wait_for_message(p) == make_message(sub_type, keys[0], 1)
         assert wait_for_message(p) == make_message(sub_type, keys[1], 2)
 
-        assert unsub_func(*keys) is None
+        assert unsub_func(keys[0]) is None
+        assert unsub_func(keys[1]) is None
 
         # should be 2 messages indicating that we've unsubscribed
         assert wait_for_message(p) == make_message(unsub_type, keys[0], 1)
@@ -76,19 +78,28 @@ def test_pattern_subscribe_unsubscribe(self, r):
 
     def _test_resubscribe_on_reconnection(self, p, sub_type, unsub_type,
                                           sub_func, unsub_func, keys):
-        assert sub_func(*keys) is None
+        assert sub_func(keys[0]) is None
+        assert sub_func(keys[1]) is None
 
-        for i, key in enumerate(keys):
-            i += 1  # enumerate is 0 index, but we want 1 based indexing
-            assert wait_for_message(p) == make_message(sub_type, key, i)
+        # should be 2 messages indicating that we've subscribed
+        assert wait_for_message(p) == make_message(sub_type, keys[0], 1)
+        assert wait_for_message(p) == make_message(sub_type, keys[1], 2)
 
         # manually disconnect
         p.connection.disconnect()
 
         # calling get_message again reconnects and resubscribes
-        for i, key in enumerate(keys):
-            i += 1  # enumerate is 0 index, but we want 1 based indexing
-            assert wait_for_message(p) == make_message(sub_type, key, i)
+        # note, we may not re-subscribe to channels in exactly the same order
+        message1 = wait_for_message(p)
+        message2 = wait_for_message(p)
+
+        assert message1['type'] == sub_type
+        assert message1['channel'] in keys
+        assert message1['data'] == 1
+        assert message2['type'] == sub_type
+        assert message2['channel'] in keys
+        assert message2['data'] == 2
+        assert message1['channel'] != message2['channel']
 
     def test_resubscribe_to_channels_on_reconnection(self, r):
         kwargs = make_subscribe_test_data(r.pubsub(), 'channel')