Improve tests cleanup

Author: jguz-pubnub

tests/integrational/asyncio/test_change_uuid.py

@@ -1,4 +1,3 @@
-import asyncio
 import pytest
 
 from pubnub.models.consumer.signal import PNSignalResult
@@ -31,6 +30,8 @@ async def test_change_uuid():
         assert isinstance(envelope.result, PNSignalResult)
         assert isinstance(envelope.status, PNStatus)
 
+        await pn.stop()
+
 
 @pn_vcr.use_cassette('tests/integrational/fixtures/asyncio/signal/uuid_no_lock.json',
                      filter_query_parameters=['seqn', 'pnsdk', 'l_sig'], serializer='pn_json')
@@ -52,25 +53,15 @@ async def test_change_uuid_no_lock():
     assert isinstance(envelope.result, PNSignalResult)
     assert isinstance(envelope.status, PNStatus)
 
-
-@pytest.fixture
-def event_loop():
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        yield loop
-    finally:
-        loop.run_until_complete(asyncio.sleep(0))
-        asyncio.set_event_loop(None)
-        loop.close()
+    await pn.stop()
 
 
-def test_uuid_validation_at_init(event_loop):
+def test_uuid_validation_at_init():
     with pytest.raises(AssertionError) as exception:
         pnconf = PNConfiguration()
         pnconf.publish_key = "demo"
         pnconf.subscribe_key = "demo"
-        PubNubAsyncio(pnconf, custom_event_loop=event_loop)
+        PubNubAsyncio(pnconf)
 
     assert str(exception.value) == 'UUID missing or invalid type'
 

tests/integrational/asyncio/test_heartbeat.py

@@ -3,7 +3,7 @@
 import pytest
 
 import pubnub as pn
-from pubnub.pubnub_asyncio import AsyncioSubscriptionManager, PubNubAsyncio, SubscribeListener
+from pubnub.pubnub_asyncio import PubNubAsyncio, SubscribeListener
 from tests import helper
 from tests.helper import pnconf_env_copy
 
@@ -21,54 +21,54 @@ async def test_timeout_event_on_broken_heartbeat():
     listener_config = pnconf_env_copy(uuid=helper.gen_channel("listener"), enable_subscribe=True)
     pubnub_listener = PubNubAsyncio(listener_config)
 
-    # - connect to :ch-pnpres
-    callback_presence = SubscribeListener()
-    pubnub_listener.add_listener(callback_presence)
-    pubnub_listener.subscribe().channels(ch).with_presence().execute()
-    await callback_presence.wait_for_connect()
+    try:
+        # - connect to :ch-pnpres
+        callback_presence = SubscribeListener()
+        pubnub_listener.add_listener(callback_presence)
+        pubnub_listener.subscribe().channels(ch).with_presence().execute()
+        await callback_presence.wait_for_connect()
 
-    envelope = await callback_presence.wait_for_presence_on(ch)
-    assert ch == envelope.channel
-    assert 'join' == envelope.event
-    assert pubnub_listener.uuid == envelope.uuid
+        envelope = await callback_presence.wait_for_presence_on(ch)
+        assert ch == envelope.channel
+        assert 'join' == envelope.event
+        assert pubnub_listener.uuid == envelope.uuid
 
-    # # - connect to :ch
-    callback_messages = SubscribeListener()
-    pubnub.add_listener(callback_messages)
-    pubnub.subscribe().channels(ch).execute()
+        # # - connect to :ch
+        callback_messages = SubscribeListener()
+        pubnub.add_listener(callback_messages)
+        pubnub.subscribe().channels(ch).execute()
 
-    useless_connect_future = asyncio.ensure_future(callback_messages.wait_for_connect())
-    presence_future = asyncio.ensure_future(callback_presence.wait_for_presence_on(ch))
+        useless_connect_future = asyncio.ensure_future(callback_messages.wait_for_connect())
+        presence_future = asyncio.ensure_future(callback_presence.wait_for_presence_on(ch))
 
-    # - assert join event
-    await asyncio.wait([useless_connect_future, presence_future])
+        # - assert join event
+        await asyncio.wait([useless_connect_future, presence_future], return_when=asyncio.ALL_COMPLETED)
 
-    prs_envelope = presence_future.result()
+        prs_envelope = presence_future.result()
 
-    assert ch == prs_envelope.channel
-    assert 'join' == prs_envelope.event
-    assert pubnub.uuid == prs_envelope.uuid
-    # - break messenger heartbeat loop
-    pubnub._subscription_manager._stop_heartbeat_timer()
+        assert ch == prs_envelope.channel
+        assert 'join' == prs_envelope.event
+        assert pubnub.uuid == prs_envelope.uuid
+        # - break messenger heartbeat loop
+        pubnub._subscription_manager._stop_heartbeat_timer()
 
-    # wait for one heartbeat call
-    await asyncio.sleep(8)
+        # wait for one heartbeat call
+        await asyncio.sleep(8)
 
-    # - assert for timeout
-    envelope = await callback_presence.wait_for_presence_on(ch)
-    assert ch == envelope.channel
-    assert 'timeout' == envelope.event
-    assert pubnub.uuid == envelope.uuid
+        # - assert for timeout
+        envelope = await callback_presence.wait_for_presence_on(ch)
+        assert ch == envelope.channel
+        assert 'timeout' == envelope.event
+        assert pubnub.uuid == envelope.uuid
 
-    pubnub.unsubscribe().channels(ch).execute()
-    if isinstance(pubnub._subscription_manager, AsyncioSubscriptionManager):
+        pubnub.unsubscribe().channels(ch).execute()
         await callback_messages.wait_for_disconnect()
 
-    # - disconnect from :ch-pnpres
-    pubnub_listener.unsubscribe().channels(ch).execute()
-    if isinstance(pubnub._subscription_manager, AsyncioSubscriptionManager):
+        # - disconnect from :ch-pnpres
+        pubnub_listener.unsubscribe().channels(ch).execute()
         await callback_presence.wait_for_disconnect()
 
-    await pubnub.stop()
-    await pubnub_listener.stop()
-    await asyncio.sleep(0.5)
+    finally:
+        await pubnub.stop()
+        await pubnub_listener.stop()
+        await asyncio.sleep(0.5)

tests/integrational/asyncio/test_message_count.py

@@ -1,5 +1,5 @@
-import asyncio
 import pytest
+import pytest_asyncio
 
 from pubnub.pubnub_asyncio import PubNubAsyncio
 from pubnub.models.envelopes import AsyncioEnvelope
@@ -9,27 +9,13 @@
 from tests.integrational.vcr_helper import pn_vcr
 
 
-@pytest.fixture
-def event_loop():
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        yield loop
-    finally:
-        loop.run_until_complete(asyncio.sleep(0))
-        asyncio.set_event_loop(None)
-        loop.close()
-
-
-@pytest.fixture
-def pn(event_loop):
+@pytest_asyncio.fixture
+async def pn():
     config = pnconf_mc_copy()
     config.enable_subscribe = False
-    pn = PubNubAsyncio(config, custom_event_loop=event_loop)
-    try:
-        yield pn
-    finally:
-        event_loop.run_until_complete(pn.stop())
+    pn = PubNubAsyncio(config)
+    yield pn
+    await pn.stop()
 
 
 @pn_vcr.use_cassette(

tests/pytest.ini

@@ -6,4 +6,6 @@ filterwarnings =
     ignore:The function .* is deprecated. Use.* Include Object instead:DeprecationWarning
     ignore:The function .* is deprecated. Use.* PNUserMember class instead:DeprecationWarning
 
-asyncio_default_fixture_loop_scope = module
+asyncio_default_fixture_loop_scope = function
+timeout = 60
+timeout_func_only = true