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_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_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. 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_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 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_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)\ .pn_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)\ .pn_async(cg_operation.callback) result = cg_operation.await_result() assert isinstance(result, PNChannelGroupsRemoveChannelResult) 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(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_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_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 get(self, request): pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-c7c2aa20-b56f-11e8-b6ef-c2e67adadb66" pnconfig.publish_key = "pub-c-fdd957cd-be31-427f-9e91-9c2bed852ba9" pnconfig.ssl = True pubnub = PubNub(pnconfig) my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels("test_channel").execute() my_listener.wait_for_connect() print('connected') pubnub.publish().channel('test_channel').message({ 'order': 16, 'owner': 1 }).sync() info = my_listener.wait_for_message_on('test_channel') print(info.message) print(pubnub.time()) print(pubnub.timestamp()) pubnub.unsubscribe().channels('test_channel').execute() my_listener.wait_for_disconnect() print('unsubscribe') envelope = pubnub.history().channel('test_channel').count(100).sync() print(envelope) return Response(dict(info.message))
def test_timeout_event_on_broken_heartbeat(self): ch = helper.gen_channel("heartbeat-test") pubnub = PubNub(messenger_config) pubnub_listener = PubNub(listener_config) pubnub.config.uuid = helper.gen_channel("messenger") pubnub_listener.config.uuid = helper.gen_channel("listener") callback_presence = SubscribeListener() callback_messages = SubscribeListener() # - connect to :ch-pnpres pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channels(ch).with_presence().execute() callback_presence.wait_for_connect() presence_message = callback_presence.wait_for_presence_on(ch) assert ch == presence_message.channel assert 'join' == presence_message.event assert pubnub_listener.uuid == presence_message.uuid # - connect to :ch pubnub.add_listener(callback_messages) pubnub.subscribe().channels(ch).execute() callback_messages.wait_for_connect() prs_envelope = callback_presence.wait_for_presence_on(ch) assert ch == prs_envelope.channel assert 'join' == prs_envelope.event assert pubnub.uuid == prs_envelope.uuid # wait for one heartbeat call time.sleep(6) # - break messenger heartbeat loop pubnub._subscription_manager._stop_heartbeat_timer() # - assert for timeout presence_message = callback_presence.wait_for_presence_on(ch) assert ch == presence_message.channel assert 'timeout' == presence_message.event assert pubnub.uuid == presence_message.uuid pubnub.unsubscribe().channels(ch).execute() callback_messages.wait_for_disconnect() # - disconnect from :ch-pnpres pubnub_listener.unsubscribe().channels(ch).execute() callback_presence.wait_for_disconnect() pubnub.stop() pubnub_listener.stop()
def get_data_from_pubnub(): my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels(my_channel).execute() my_listener.wait_for_connect() result = my_listener.wait_for_message_on('awesomeChannel') print(result.message) pubnub.unsubscribe().channels('awesomeChannel').execute() my_listener.wait_for_disconnect() print('unsubscribed')
def subscribe_pub(channel, msg): my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels(channel).execute() my_listener.wait_for_connect() print('connected') pubnub.publish().channel(channel).message(msg).sync() result = my_listener.wait_for_message_on(channel) print(result.message) # Unsubscribe pubnub.unsubscribe().channels(channel).execute() my_listener.wait_for_disconnect() print('unsubscribed')
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_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()
class BitflyerPubnub(object): """docstring for BitflyerPubnub""" def __init__(self, channel): pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f" self.pubnub = PubNub(pnconfig) self.listener = SubscribeListener() self.channel = channel def __enter__(self): self.pubnub.add_listener(self.listener) self.pubnub.subscribe().channels([self.channel]).execute() self.listener.wait_for_connect() return self def listen(self, key): return self.listener.wait_for_message_on(self.channel).message[key] def __exit__(self, type, value, traceback): self.pubnub.unsubscribe().channels([self.channel]).execute() self.listener.wait_for_disconnect()
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_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_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()
from pubnub.enums import PNStatusCategory from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub, SubscribeListener pnconfig = PNConfiguration() pnconfig.publish_key = 'pub-c-c408ce7d-fe0d-4f9a-aae9-e67d5c9b6bd9' pnconfig.subscribe_key = 'sub-c-efaf056a-75c7-11e9-b68a-fa5eae84dea0' pubnub = PubNub(pnconfig) my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels('awesomeChannel').execute() my_listener.wait_for_connect() print('connected') result = my_listener.wait_for_message_on('awesomeChannel') print(result.message) pubnub.unsubscribe().channels('awesomeChannel').execute() my_listener.wait_for_disconnect() print('unsubscribed') exit(0)