def test_subscribe_cg_join_leave(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") pubnub = PubNub(pnconf_sub_copy()) pubnub_listener = PubNub(pnconf_sub_copy()) non_subscribe_listener = NonSubscribeListener() pubnub.add_channel_to_channel_group() \ .channel_group(gr) \ .channels(ch) \ .async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsAddChannelResult) time.sleep(1) callback_messages = SubscribeListener() callback_presence = SubscribeListener() pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channel_groups(gr).with_presence().execute() callback_presence.wait_for_connect() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.unsubscribe().channel_groups(gr).execute() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'leave' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub_listener.unsubscribe().channel_groups(gr).execute() callback_presence.wait_for_disconnect() pubnub.remove_channel_from_channel_group() \ .channel_group(gr) \ .channels(ch) \ .async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop() pubnub_listener.stop()
def setUp(self): super(TestChannelSubscription, self).setUp() messenger_config = pnconf_sub_copy() messenger_config.set_presence_timeout(8) messenger_config.uuid = "heartbeat-tornado-messenger" listener_config = pnconf_sub_copy() listener_config.uuid = "heartbeat-tornado-listener" self.pubnub = PubNubTornado(messenger_config, custom_ioloop=self.io_loop) self.pubnub_listener = PubNubTornado(listener_config, custom_ioloop=self.io_loop)
def test_join_leave(event_loop): channel = "test-subscribe-asyncio-join-leave-ch" pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub_listener = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) patch_pubnub(pubnub) patch_pubnub(pubnub_listener) pubnub.config.uuid = "test-subscribe-asyncio-messenger" pubnub_listener.config.uuid = "test-subscribe-asyncio-listener" callback_presence = VCR599Listener(1) callback_messages = VCR599Listener(1) pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channels(channel).with_presence().execute() yield from callback_presence.wait_for_connect() envelope = yield from callback_presence.wait_for_presence_on(channel) assert envelope.channel == channel assert envelope.event == 'join' assert envelope.uuid == pubnub_listener.uuid pubnub.add_listener(callback_messages) pubnub.subscribe().channels(channel).execute() yield from callback_messages.wait_for_connect() envelope = yield from callback_presence.wait_for_presence_on(channel) assert envelope.channel == channel assert envelope.event == 'join' assert envelope.uuid == pubnub.uuid pubnub.unsubscribe().channels(channel).execute() yield from callback_messages.wait_for_disconnect() envelope = yield from callback_presence.wait_for_presence_on(channel) assert envelope.channel == channel assert envelope.event == 'leave' assert envelope.uuid == pubnub.uuid pubnub_listener.unsubscribe().channels(channel).execute() yield from callback_presence.wait_for_disconnect() pubnub.stop() pubnub_listener.stop()
def test_publish_futurex(self): pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) envelope = yield pubnub.publish().message('hey').channel('blah').future() assert isinstance(envelope, TornadoEnvelope) assert not envelope.is_error() pubnub.stop()
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = "state-native-sync-ch-1" ch2 = "state-native-sync-ch-2" pubnub.config.uuid = "state-native-sync-uuid" uuid = pubnub.config.uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.where_now() \ .uuid(uuid) \ .pn_async(where_now_listener.callback) if where_now_listener.pn_await() is False: self.fail("WhereNow operation timeout") result = where_now_listener.result channels = result.channels assert len(channels) == 2 assert ch1 in channels assert ch2 in channels pubnub.unsubscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("wherenow-asyncio-channel") uuid = helper.gen_channel("wherenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.where_now() \ .uuid(uuid) \ .pn_async(where_now_listener.callback) if where_now_listener.pn_await() is False: self.fail("WhereNow operation timeout") result = where_now_listener.result channels = result.channels assert len(channels) == 1 assert channels[0] == ch pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_multiple_channels(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) ch1 = 'test-where-now-asyncio-ch1' ch2 = 'test-where-now-asyncio-ch2' uuid = 'test-where-now-asyncio-uuid' pubnub.config.uuid = uuid callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels([ch1, ch2]).execute() yield from callback.wait_for_connect() yield from sleeper(7) env = yield from pubnub.where_now() \ .uuid(uuid) \ .future() channels = env.result.channels assert len(channels) == 2 assert ch1 in channels assert ch2 in channels pubnub.unsubscribe().channels([ch1, ch2]).execute() yield from callback.wait_for_disconnect() pubnub.stop()
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("herenow-asyncio-channel") uuid = helper.gen_channel("herenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.here_now() \ .channels(ch) \ .include_uuids(True) \ .pn_async(here_now_listener.callback) if here_now_listener.pn_await() is False: self.fail("HereNow operation timeout") result = here_now_listener.result channels = result.channels assert len(channels) == 1 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_subscribe_unsubscribe(event_loop): channel = "test-subscribe-asyncio-ch" pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) callback = SubscribeListener() pubnub.add_listener(callback) pubnub.subscribe().channels(channel).execute() assert channel in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 1 yield from callback.wait_for_connect() assert channel in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 1 pubnub.unsubscribe().channels(channel).execute() assert channel not in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 0 yield from callback.wait_for_disconnect() assert channel not in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 0 pubnub.stop()
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = helper.gen_channel("here-now-native-sync-ch1") ch2 = helper.gen_channel("here-now-native-sync-ch2") pubnub.config.uuid = "here-now-native-sync-uuid" subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(5) pubnub.here_now() \ .channels([ch1, ch2]) \ .pn_async(here_now_listener.callback) if here_now_listener.pn_await() is False: self.fail("HereNow operation timeout") result = here_now_listener.result channels = result.channels assert len(channels) == 2 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid assert channels[1].occupancy == 1 assert channels[1].occupants[0].uuid == pubnub.uuid pubnub.unsubscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_subscribe_pub_unsubscribe(self): ch = helper.gen_channel("test-subscribe-sub-pub-unsub") pubnub = PubNub(pnconf_sub_copy()) subscribe_listener = SubscribeListener() publish_operation = NonSubscribeListener() message = "hey" try: pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() pubnub.publish().channel(ch).message(message).async(publish_operation.callback) if publish_operation.await() is False: self.fail("Publish operation timeout") publish_result = publish_operation.result assert isinstance(publish_result, PNPublishResult) assert publish_result.timetoken > 0 result = subscribe_listener.wait_for_message_on(ch) assert isinstance(result, PNMessageResult) assert result.channel == ch assert result.subscription is None assert result.timetoken > 0 assert result.message == message pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect()
def test_subscribe_unsubscribe(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("test-subscribe-sub-unsub") try: listener = SubscribeListener() pubnub.add_listener(listener) pubnub.subscribe().channels(ch).execute() assert ch in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 1 listener.wait_for_connect() assert ch in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 1 pubnub.unsubscribe().channels(ch).execute() assert ch not in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 0 listener.wait_for_disconnect() assert ch not in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 0 except PubNubException as e: self.fail(e) finally: pubnub.stop()
def test_cg_subscribe_unsubscribe(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") pubnub = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() cg_operation = NonSubscribeListener() pubnub.add_channel_to_channel_group()\ .channel_group(gr)\ .channels(ch)\ .async(cg_operation.callback) result = cg_operation.await_result() assert isinstance(result, PNChannelGroupsAddChannelResult) cg_operation.reset() time.sleep(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages.wait_for_connect() pubnub.unsubscribe().channel_groups(gr).execute() callback_messages.wait_for_disconnect() pubnub.remove_channel_from_channel_group()\ .channel_group(gr)\ .channels(ch)\ .async(cg_operation.callback) result = cg_operation.await_result() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop()
def test_single_channel_with_subscription(event_loop, sleeper=asyncio.sleep): pnconf = pnconf_sub_copy() pnconf.set_presence_timeout(12) pubnub = PubNubAsyncio(pnconf, custom_event_loop=event_loop) ch = "test-state-asyncio-ch" pubnub.config.uuid = "test-state-asyncio-uuid" state = {"name": "Alex", "count": 5} callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels(ch).execute() yield from callback.wait_for_connect() yield from sleeper(20) env = yield from pubnub.set_state().channels(ch).state(state).future() assert env.result.state["name"] == "Alex" assert env.result.state["count"] == 5 env = yield from pubnub.get_state().channels(ch).future() assert env.result.channels[ch]["name"] == "Alex" assert env.result.channels[ch]["count"] == 5 pubnub.unsubscribe().channels(ch).execute() yield from callback.wait_for_disconnect() pubnub.stop()
def test_join_leave(self): ch = helper.gen_channel("test-subscribe-join-leave") pubnub = PubNub(pnconf_sub_copy()) pubnub_listener = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() callback_presence = SubscribeListener() pubnub.config.uuid = helper.gen_channel("messenger") pubnub_listener.config.uuid = helper.gen_channel("listener") try: pubnub.add_listener(callback_messages) pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channels(ch).with_presence().execute() callback_presence.wait_for_connect() envelope = callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == pubnub_listener.uuid pubnub.subscribe().channels(ch).execute() callback_messages.wait_for_connect() envelope = callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == pubnub.uuid pubnub.unsubscribe().channels(ch).execute() callback_messages.wait_for_disconnect() envelope = callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'leave' assert envelope.uuid == pubnub.uuid pubnub_listener.unsubscribe().channels(ch).execute() callback_presence.wait_for_disconnect() except PubNubException as e: self.fail(e) finally: pubnub.stop() pubnub_listener.stop()
def test_subscribe_publish_unsubscribe(event_loop): pubnub_sub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub_pub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) patch_pubnub(pubnub_sub) patch_pubnub(pubnub_pub) pubnub_sub.config.uuid = 'test-subscribe-asyncio-uuid-sub' pubnub_pub.config.uuid = 'test-subscribe-asyncio-uuid-pub' callback = VCR599Listener(1) channel = "test-subscribe-asyncio-ch" message = "hey" pubnub_sub.add_listener(callback) pubnub_sub.subscribe().channels(channel).execute() yield from callback.wait_for_connect() publish_future = asyncio.ensure_future(pubnub_pub.publish().channel(channel).message(message).future()) subscribe_message_future = asyncio.ensure_future(callback.wait_for_message_on(channel)) yield from asyncio.wait([ publish_future, subscribe_message_future ]) publish_envelope = publish_future.result() subscribe_envelope = subscribe_message_future.result() assert isinstance(subscribe_envelope, PNMessageResult) assert subscribe_envelope.channel == channel assert subscribe_envelope.subscription is None assert subscribe_envelope.message == message assert subscribe_envelope.timetoken > 0 assert isinstance(publish_envelope, AsyncioEnvelope) assert publish_envelope.result.timetoken > 0 assert publish_envelope.status.original_response[0] == 1 pubnub_sub.unsubscribe().channels(channel).execute() yield from callback.wait_for_disconnect() pubnub_pub.stop() pubnub_sub.stop()
def xtest_publish_result_raises_lower_level_error(self): pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) # TODO: find a better way ot emulate broken connection pubnub.http.close() with self.assertRaises(Exception) as context: yield pubnub.publish().message('hey').channel('blah').result() assert 'fetch() called on closed AsyncHTTPClient' in str(context.exception.message) pubnub.stop()
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = helper.gen_channel("here-now-native-sync-ch1") ch2 = helper.gen_channel("here-now-native-sync-ch2") pubnub.config.uuid = "here-now-native-sync-uuid" subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(5) pubnub.here_now().channels([ch1, ch2]).async(here_now_listener.callback) if here_now_listener.await() is False: self.fail("HereNow operation timeout")
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("herenow-asyncio-channel") uuid = helper.gen_channel("herenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.here_now().channels(ch).include_uuids(True).async(here_now_listener.callback) if here_now_listener.await() is False: self.fail("HereNow operation timeout")
async def test_multiple_channels(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = 'test-here-now-asyncio-uuid1' ch1 = "test-here-now-asyncio-ch1" ch2 = "test-here-now-asyncio-ch2" callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels([ch1, ch2]).execute() await callback.wait_for_connect() await sleeper(5) env = await pubnub.here_now() \ .channels([ch1, ch2]) \ .future() assert env.result.total_channels == 2 assert env.result.total_occupancy >= 1 channels = env.result.channels assert len(channels) == 2 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid assert channels[1].occupancy == 1 assert channels[1].occupants[0].uuid == pubnub.uuid result = await pubnub.here_now() \ .channels([ch1, ch2]) \ .include_state(True) \ .result() assert result.total_channels == 2 pubnub.unsubscribe().channels([ch1, ch2]).execute() await callback.wait_for_disconnect() await pubnub.stop()
def test_unsubscribe_all(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = "test-subscribe-asyncio-messenger" ch = "test-subscribe-asyncio-unsubscribe-all-ch" ch1 = "test-subscribe-asyncio-unsubscribe-all-ch1" ch2 = "test-subscribe-asyncio-unsubscribe-all-ch2" ch3 = "test-subscribe-asyncio-unsubscribe-all-ch3" gr1 = "test-subscribe-asyncio-unsubscribe-all-gr1" gr2 = "test-subscribe-asyncio-unsubscribe-all-gr2" envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr1).channels(ch).future() assert envelope.status.original_response['status'] == 200 envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr2).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield from sleeper(1) callback_messages = SubscribeListener() pubnub.add_listener(callback_messages) pubnub.subscribe().channels([ch1, ch2, ch3]).channel_groups([gr1, gr2]).execute() yield from callback_messages.wait_for_connect() assert len(pubnub.get_subscribed_channels()) == 3 assert len(pubnub.get_subscribed_channel_groups()) == 2 pubnub.unsubscribe_all() yield from callback_messages.wait_for_disconnect() assert len(pubnub.get_subscribed_channels()) == 0 assert len(pubnub.get_subscribed_channel_groups()) == 0 envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr1).channels(ch).future() assert envelope.status.original_response['status'] == 200 envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr2).channels(ch).future() assert envelope.status.original_response['status'] == 200 pubnub.stop()
def test_blah(): pnconf = pnconf_sub_copy() assert isinstance(pnconf, PNConfiguration) pnconf.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL pubnub = PubNubAsyncio(pnconf) time_until_open_again = 8 @asyncio.coroutine def close_soon(): yield from asyncio.sleep(2) pubnub._connector.close() print(">>> connection is broken") @asyncio.coroutine def open_again(): yield from asyncio.sleep(time_until_open_again) pubnub.set_connector(aiohttp.TCPConnector(conn_timeout=pubnub.config.connect_timeout, verify_ssl=True)) print(">>> connection is open again") @asyncio.coroutine def countdown(): asyncio.sleep(2) opened = False count = time_until_open_again while not opened: print(">>> %ds to open again" % count) count -= 1 if count <= 0: break yield from asyncio.sleep(1) my_listener = MySubscribeCallback() pubnub.add_listener(my_listener) pubnub.subscribe().channels("my_channel").execute() asyncio.ensure_future(close_soon()) asyncio.ensure_future(open_again()) asyncio.ensure_future(countdown()) yield from asyncio.sleep(1000)
def test_blah(): pnconf = pnconf_sub_copy() assert isinstance(pnconf, PNConfiguration) pnconf.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL pubnub = PubNubAsyncio(pnconf) time_until_open_again = 8 @asyncio.coroutine def close_soon(): yield from asyncio.sleep(2) pubnub._connector.close() print(">>> connection is broken") @asyncio.coroutine def open_again(): yield from asyncio.sleep(time_until_open_again) pubnub.set_connector(aiohttp.TCPConnector(conn_timeout=pubnub.config.connect_timeout, verify_ssl=True)) print(">>> connection is open again") @asyncio.coroutine def countdown(): asyncio.sleep(2) opened = False count = time_until_open_again while not opened: print(">>> %ds to open again" % count) count -= 1 if count <= 0: break yield from asyncio.sleep(1) my_listener = MySubscribeCallback() pubnub.add_listener(my_listener) pubnub.subscribe().channels('my_channel').execute() asyncio.ensure_future(close_soon()) asyncio.ensure_future(open_again()) asyncio.ensure_future(countdown()) yield from asyncio.sleep(1000)
def test_unsubscribe_all(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = "test-subscribe-asyncio-messenger" ch = "test-subscribe-asyncio-unsubscribe-all-ch" ch1 = "test-subscribe-asyncio-unsubscribe-all-ch1" ch2 = "test-subscribe-asyncio-unsubscribe-all-ch2" ch3 = "test-subscribe-asyncio-unsubscribe-all-ch3" gr1 = "test-subscribe-asyncio-unsubscribe-all-gr1" gr2 = "test-subscribe-asyncio-unsubscribe-all-gr2" envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr1).channels(ch).future() assert envelope.status.original_response['status'] == 200 envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr2).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield from sleeper(1) callback_messages = VCR599Listener(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channels([ch1, ch2, ch3]).channel_groups([gr1, gr2]).execute() yield from callback_messages.wait_for_connect() assert len(pubnub.get_subscribed_channels()) == 3 assert len(pubnub.get_subscribed_channel_groups()) == 2 pubnub.unsubscribe_all() yield from callback_messages.wait_for_disconnect() assert len(pubnub.get_subscribed_channels()) == 0 assert len(pubnub.get_subscribed_channel_groups()) == 0 envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr1).channels(ch).future() assert envelope.status.original_response['status'] == 200 envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr2).channels(ch).future() assert envelope.status.original_response['status'] == 200 pubnub.stop()
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("wherenow-asyncio-channel") uuid = helper.gen_channel("wherenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.where_now() \ .uuid(uuid) \ .async(where_now_listener.callback) if where_now_listener.await() is False: self.fail("WhereNow operation timeout")
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = helper.gen_channel("here-now-native-sync-ch1") ch2 = helper.gen_channel("here-now-native-sync-ch2") pubnub.config.uuid = "here-now-native-sync-uuid" subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(5) pubnub.here_now() \ .channels([ch1, ch2]) \ .async(here_now_listener.callback) if here_now_listener. await () is False: self.fail("HereNow operation timeout")
def test_multiple_channels(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = 'test-here-now-asyncio-uuid1' ch1 = "test-here-now-asyncio-ch1" ch2 = "test-here-now-asyncio-ch2" callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels([ch1, ch2]).execute() yield from callback.wait_for_connect() yield from sleeper(5) env = yield from pubnub.here_now() \ .channels([ch1, ch2]) \ .future() assert env.result.total_channels == 2 assert env.result.total_occupancy >= 1 channels = env.result.channels assert len(channels) == 2 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid assert channels[1].occupancy == 1 assert channels[1].occupants[0].uuid == pubnub.uuid result = yield from pubnub.here_now() \ .channels([ch1, ch2]) \ .include_state(True) \ .result() assert result.total_channels == 2 pubnub.unsubscribe().channels([ch1, ch2]).execute() yield from callback.wait_for_disconnect() pubnub.stop()
def test_subscribe_cg_publish_unsubscribe(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") message = "hey" pubnub = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() non_subscribe_listener = NonSubscribeListener() pubnub.add_channel_to_channel_group() \ .channel_group(gr) \ .channels(ch) \ .pn_async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsAddChannelResult) time.sleep(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages.wait_for_connect() pubnub.publish().message(message).channel(ch).pn_async( non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNPublishResult) assert result.timetoken > 0 pubnub.unsubscribe().channel_groups(gr).execute() callback_messages.wait_for_disconnect() pubnub.remove_channel_from_channel_group() \ .channel_group(gr) \ .channels(ch) \ .pn_async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop()
def test_single_channel(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = 'test-here-now-asyncio-uuid1' ch = "test-here-now-asyncio-ch" callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels(ch).execute() yield from callback.wait_for_connect() yield from sleeper(5) env = yield from pubnub.here_now() \ .channels(ch) \ .include_uuids(True) \ .future() assert env.result.total_channels == 1 assert env.result.total_occupancy >= 1 channels = env.result.channels assert len(channels) == 1 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid result = yield from pubnub.here_now() \ .channels(ch) \ .include_state(True) \ .result() assert result.total_channels == 1 assert result.total_occupancy == 1 pubnub.unsubscribe().channels(ch).execute() yield from callback.wait_for_disconnect() pubnub.stop()
def test_subscribe_cg_publish_unsubscribe(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") message = "hey" pubnub = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() non_subscribe_listener = NonSubscribeListener() pubnub.add_channel_to_channel_group() \ .channel_group(gr) \ .channels(ch) \ .async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsAddChannelResult) time.sleep(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages.wait_for_connect() pubnub.publish().message(message).channel(ch).async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNPublishResult) assert result.timetoken > 0 pubnub.unsubscribe().channel_groups(gr).execute() callback_messages.wait_for_disconnect() pubnub.remove_channel_from_channel_group() \ .channel_group(gr) \ .channels(ch) \ .async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop()
def test_cg_subscribe_publish_unsubscribe(event_loop, sleeper=asyncio.sleep): ch = "test-subscribe-asyncio-channel" gr = "test-subscribe-asyncio-group" message = "hey" pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield from sleeper(1) callback_messages = VCR599Listener(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() yield from callback_messages.wait_for_connect() subscribe_future = asyncio.ensure_future(callback_messages.wait_for_message_on(ch)) publish_future = asyncio.ensure_future(pubnub.publish().channel(ch).message(message).future()) yield from asyncio.wait([subscribe_future, publish_future]) sub_envelope = subscribe_future.result() pub_envelope = publish_future.result() assert pub_envelope.status.original_response[0] == 1 assert pub_envelope.status.original_response[1] == 'Sent' assert sub_envelope.channel == ch assert sub_envelope.subscription == gr assert sub_envelope.message == message pubnub.unsubscribe().channel_groups(gr).execute() yield from callback_messages.wait_for_disconnect() envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 pubnub.stop()
def test_cg_subscribe_publish_unsubscribe(event_loop, sleeper=asyncio.sleep): ch = "test-subscribe-asyncio-channel" gr = "test-subscribe-asyncio-group" message = "hey" pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield from sleeper(1) callback_messages = SubscribeListener() pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() yield from callback_messages.wait_for_connect() subscribe_future = asyncio.ensure_future(callback_messages.wait_for_message_on(ch)) publish_future = asyncio.ensure_future(pubnub.publish().channel(ch).message(message).future()) yield from asyncio.wait([subscribe_future, publish_future]) sub_envelope = subscribe_future.result() pub_envelope = publish_future.result() assert pub_envelope.status.original_response[0] == 1 assert pub_envelope.status.original_response[1] == 'Sent' assert sub_envelope.channel == ch assert sub_envelope.subscription == gr assert sub_envelope.message == message pubnub.unsubscribe().channel_groups(gr).execute() yield from callback_messages.wait_for_disconnect() envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 pubnub.stop()
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = "state-native-sync-ch-1" ch2 = "state-native-sync-ch-2" pubnub.config.uuid = "state-native-sync-uuid" uuid = pubnub.config.uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.where_now() \ .uuid(uuid) \ .async(where_now_listener.callback) if where_now_listener.await() is False: self.fail("WhereNow operation timeout")
def test_cg_subscribe_unsubscribe(event_loop, sleeper=asyncio.sleep): ch = "test-subscribe-asyncio-channel" gr = "test-subscribe-asyncio-group" pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield from sleeper(3) callback_messages = SubscribeListener() pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() yield from callback_messages.wait_for_connect() pubnub.unsubscribe().channel_groups(gr).execute() yield from callback_messages.wait_for_disconnect() envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 pubnub.stop()
def test_global(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = 'test-here-now-asyncio-uuid1' ch1 = "test-here-now-asyncio-ch1" ch2 = "test-here-now-asyncio-ch2" callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels([ch1, ch2]).execute() yield from callback.wait_for_connect() yield from sleeper(5) env = yield from pubnub.here_now().future() assert env.result.total_channels >= 2 assert env.result.total_occupancy >= 1 pubnub.unsubscribe().channels([ch1, ch2]).execute() yield from callback.wait_for_disconnect() pubnub.stop()
async def test_subscribe_publish_unsubscribe(event_loop): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) callback = SubscribeListener() channel = helper.gen_channel("test-sub-pub-unsub") message = "hey" pubnub.add_listener(callback) pubnub.subscribe().channels(channel).execute() await callback.wait_for_connect() publish_future = asyncio.ensure_future(pubnub.publish().channel(channel).message(message).future()) subscribe_message_future = asyncio.ensure_future(callback.wait_for_message_on(channel)) await asyncio.wait([ publish_future, subscribe_message_future ]) publish_envelope = publish_future.result() subscribe_envelope = subscribe_message_future.result() assert isinstance(subscribe_envelope, PNMessageResult) assert subscribe_envelope.channel == channel assert subscribe_envelope.subscription is None assert subscribe_envelope.message == message assert subscribe_envelope.timetoken > 0 assert isinstance(publish_envelope, AsyncioEnvelope) assert publish_envelope.result.timetoken > 0 assert publish_envelope.status.original_response[0] == 1 pubnub.unsubscribe().channels(channel).execute() await callback.wait_for_disconnect() pubnub.stop()
def test_subscribe_pub_unsubscribe(self): ch = helper.gen_channel("test-subscribe-sub-pub-unsub") pubnub = PubNub(pnconf_sub_copy()) subscribe_listener = SubscribeListener() publish_operation = NonSubscribeListener() message = "hey" try: pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() pubnub.publish().channel(ch).message(message).pn_async( publish_operation.callback) if publish_operation.pn_await() is False: self.fail("Publish operation timeout") publish_result = publish_operation.result assert isinstance(publish_result, PNPublishResult) assert publish_result.timetoken > 0 result = subscribe_listener.wait_for_message_on(ch) assert isinstance(result, PNMessageResult) assert result.channel == ch assert result.subscription is None assert result.timetoken > 0 assert result.message == message pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect() except PubNubException as e: self.fail(e) finally: pubnub.stop()
async def test_global(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = 'test-here-now-asyncio-uuid1' ch1 = "test-here-now-asyncio-ch1" ch2 = "test-here-now-asyncio-ch2" callback = VCR599Listener(1) pubnub.add_listener(callback) pubnub.subscribe().channels([ch1, ch2]).execute() await callback.wait_for_connect() await sleeper(5) env = await pubnub.here_now().future() assert env.result.total_channels >= 2 assert env.result.total_occupancy >= 1 pubnub.unsubscribe().channels([ch1, ch2]).execute() await callback.wait_for_disconnect() pubnub.stop()
def test_cg_join_leave(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub_listener = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = "test-subscribe-asyncio-messenger" pubnub_listener.config.uuid = "test-subscribe-asyncio-listener" ch = "test-subscribe-asyncio-join-leave-cg-channel" gr = "test-subscribe-asyncio-join-leave-cg-group" envelope = yield from pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield from sleeper(1) callback_messages = VCR599Listener(1) callback_presence = VCR599Listener(1) pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channel_groups(gr).with_presence().execute() yield from callback_presence.wait_for_connect() prs_envelope = yield from callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages_future = asyncio.ensure_future(callback_messages.wait_for_connect()) presence_messages_future = asyncio.ensure_future(callback_presence.wait_for_presence_on(ch)) yield from asyncio.wait([callback_messages_future, presence_messages_future]) prs_envelope = presence_messages_future.result() assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.unsubscribe().channel_groups(gr).execute() callback_messages_future = asyncio.ensure_future(callback_messages.wait_for_disconnect()) presence_messages_future = asyncio.ensure_future(callback_presence.wait_for_presence_on(ch)) yield from asyncio.wait([callback_messages_future, presence_messages_future]) prs_envelope = presence_messages_future.result() assert prs_envelope.event == 'leave' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub_listener.unsubscribe().channel_groups(gr).execute() yield from callback_presence.wait_for_disconnect() envelope = yield from pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 pubnub.stop() pubnub_listener.stop()
def test_subscribe_cg_join_leave(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") pubnub = PubNub(pnconf_sub_copy()) pubnub_listener = PubNub(pnconf_sub_copy()) non_subscribe_listener = NonSubscribeListener() pubnub.add_channel_to_channel_group() \ .channel_group(gr) \ .channels(ch) \ .pn_async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsAddChannelResult) time.sleep(1) callback_messages = SubscribeListener() callback_presence = SubscribeListener() pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channel_groups( gr).with_presence().execute() callback_presence.wait_for_connect() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.unsubscribe().channel_groups(gr).execute() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'leave' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub_listener.unsubscribe().channel_groups(gr).execute() callback_presence.wait_for_disconnect() pubnub.remove_channel_from_channel_group() \ .channel_group(gr) \ .channels(ch) \ .pn_async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop() pubnub_listener.stop()
def setUp(self): super(TestChannelSubscription, self).setUp() self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) self.pubnub_listener = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)
import logging import asyncio import pytest import pubnub as pn from pubnub.pubnub_asyncio import PubNubAsyncio, SubscribeListener from tests import helper from tests.helper import pnconf_sub_copy pn.set_stream_logger('pubnub', logging.DEBUG) messenger_config = pnconf_sub_copy() messenger_config.set_presence_timeout(8) messenger_config.uuid = helper.gen_channel("messenger") listener_config = pnconf_sub_copy() listener_config.uuid = helper.gen_channel("listener") @pytest.mark.asyncio async def test_timeout_event_on_broken_heartbeat(event_loop): ch = helper.gen_channel("heartbeat-test") pubnub = PubNubAsyncio(messenger_config, custom_event_loop=event_loop) pubnub_listener = PubNubAsyncio(listener_config, custom_event_loop=event_loop) pubnub.config.uuid = helper.gen_channel("messenger") pubnub_listener.config.uuid = helper.gen_channel("listener") # - connect to :ch-pnpres
def setUp(self): super(TestPubNubAsyncHereNow, self).setUp() self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)
def test_publish_resultx(self): pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) result = yield pubnub.publish().message('hey').channel('blah').result() assert isinstance(result, PNPublishResult) pubnub.stop()
async def test_cg_join_leave(event_loop, sleeper=asyncio.sleep): pubnub = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub_listener = PubNubAsyncio(pnconf_sub_copy(), custom_event_loop=event_loop) pubnub.config.uuid = "test-subscribe-asyncio-messenger" pubnub_listener.config.uuid = "test-subscribe-asyncio-listener" ch = "test-subscribe-asyncio-join-leave-cg-channel" gr = "test-subscribe-asyncio-join-leave-cg-group" envelope = await pubnub.add_channel_to_channel_group().channel_group( gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 await sleeper(1) callback_messages = VCR599Listener(1) callback_presence = VCR599Listener(1) pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channel_groups(gr).with_presence().execute() await callback_presence.wait_for_connect() prs_envelope = await callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages_future = asyncio.ensure_future( callback_messages.wait_for_connect()) presence_messages_future = asyncio.ensure_future( callback_presence.wait_for_presence_on(ch)) await asyncio.wait([callback_messages_future, presence_messages_future]) prs_envelope = presence_messages_future.result() assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.unsubscribe().channel_groups(gr).execute() callback_messages_future = asyncio.ensure_future( callback_messages.wait_for_disconnect()) presence_messages_future = asyncio.ensure_future( callback_presence.wait_for_presence_on(ch)) await asyncio.wait([callback_messages_future, presence_messages_future]) prs_envelope = presence_messages_future.result() assert prs_envelope.event == 'leave' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub_listener.unsubscribe().channel_groups(gr).execute() await callback_presence.wait_for_disconnect() envelope = await pubnub.remove_channel_from_channel_group().channel_group( gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 await pubnub.stop() pubnub_listener.stop()