class TestChannelSubscription(AsyncTestCase, SubscriptionTest): 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) @tornado.testing.gen_test async def test_subscribe_publish_unsubscribe(self): ch = helper.gen_channel("subscribe-test") message = "hey" callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() await callback_messages.wait_for_connect() sub_env, pub_env = await tornado.gen.multi([ callback_messages.wait_for_message_on(ch), self.pubnub.publish().channel(ch).message(message).future()]) assert pub_env.status.original_response[0] == 1 assert pub_env.status.original_response[1] == 'Sent' assert sub_env.channel == ch assert sub_env.subscription is None assert sub_env.message == message self.pubnub.unsubscribe().channels(ch).execute() await callback_messages.wait_for_disconnect()
class TestChannelSubscription(AsyncTestCase, SubscriptionTest): 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) @tornado.testing.gen_test async def test_subscribe_publish_unsubscribe(self): ch = helper.gen_channel("subscribe-test") message = "hey" callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() await callback_messages.wait_for_connect() sub_env, pub_env = await tornado.gen.multi([ callback_messages.wait_for_message_on(ch), self.pubnub.publish().channel(ch).message(message).future() ]) assert pub_env.status.original_response[0] == 1 assert pub_env.status.original_response[1] == 'Sent' assert sub_env.channel == ch assert sub_env.subscription is None assert sub_env.message == message self.pubnub.unsubscribe().channels(ch).execute() await callback_messages.wait_for_disconnect()
class BitcoinTickServer(): def __init__(self, fxevents, tick_interval): self.fxevents = fxevents self.tick_interval = tick_interval self.instruments = 'lightning_ticker_BTC_JPY' config = PNConfiguration() config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' config.reconnect_policy = PNReconnectionPolicy.LINEAR self.pubnub = PubNubTornado(config) self.run = True def get_ticks(self): ticks = self.listener.get_ticks() return ticks def get_time(self): time = self.listener.get_time() return time @gen.coroutine def thread(self): self.listener = BitflyerSubscriberCallback(self.tick_interval) self.pubnub.add_listener(self.listener) self.pubnub.subscribe().channels(self.instruments).execute() self.pubnub.start() try: while self.run: self.do_unsubscribe() except: print('@BitcoinTickServerThread : exception raised.') traceback.print_exc() self.fxevents.put(event_thread.EventContainer(name='exception', value=[])) def thread_close(self): self.run = False def do_unsubscribe(self): if self.run==False: self.pubnub.unsubscribe({'channel': self.instruments}) raise Exception
class TestChannelSubscription(AsyncTestCase, SubscriptionTest): 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) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/heartbeat/timeout.yaml', filter_query_parameters=['uuid', 'pnsdk'], match_on=['method', 'scheme', 'host', 'port', 'string_list_in_path', 'query'], match_on_kwargs={ 'string_list_in_path': { 'positions': [4] } }) @tornado.testing.gen_test(timeout=20) def test_timeout_event_on_broken_heartbeat(self): ch = "heartbeat-tornado-ch" # - connect to :ch-pnpres callback_presence = SubscribeListener() self.pubnub_listener.add_listener(callback_presence) self.pubnub_listener.subscribe().channels(ch).with_presence().execute() yield callback_presence.wait_for_connect() envelope = yield callback_presence.wait_for_presence_on(ch) assert ch == envelope.channel assert 'join' == envelope.event assert self.pubnub_listener.uuid == envelope.uuid # - connect to :ch callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() # - assert join event useless, prs_envelope = yield [ callback_messages.wait_for_connect(), callback_presence.wait_for_presence_on(ch)] assert ch == prs_envelope.channel assert 'join' == prs_envelope.event assert self.pubnub.uuid == prs_envelope.uuid # wait for one heartbeat call yield gen.sleep(8) # - break messenger heartbeat loop self.pubnub._subscription_manager._stop_heartbeat_timer() # - assert for timeout envelope = yield callback_presence.wait_for_presence_on(ch) assert ch == envelope.channel assert 'timeout' == envelope.event assert self.pubnub.uuid == envelope.uuid # - disconnect from :ch-pnpres self.pubnub_listener.unsubscribe().channels(ch).execute() yield callback_presence.wait_for_disconnect()
class TestChannelSubscription(AsyncTestCase, SubscriptionTest): 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) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/sub_unsub.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=300) def test_subscribe_unsubscribe(self): ch = "subscribe-tornado-ch" callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() assert ch in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 1 yield callback_messages.wait_for_connect() assert ch in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 1 self.pubnub.unsubscribe().channels(ch).execute() assert ch not in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 0 yield callback_messages.wait_for_disconnect() assert ch not in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 0 self.pubnub.stop() self.stop() @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/sub_pub_unsub.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=30) def test_subscribe_publish_unsubscribe(self): ch = "subscribe-tornado-ch" message = "hey" callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() yield callback_messages.wait_for_connect() sub_env, pub_env = yield [ callback_messages.wait_for_message_on(ch), self.pubnub.publish().channel(ch).message(message).future() ] assert pub_env.status.original_response[0] == 1 assert pub_env.status.original_response[1] == 'Sent' assert sub_env.channel == ch assert sub_env.subscription is None assert sub_env.message == message self.pubnub.unsubscribe().channels(ch).execute() yield callback_messages.wait_for_disconnect() @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/join_leave.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=15) def test_join_leave(self): ch = "subscribe-tornado-ch" self.pubnub.config.uuid = "subscribe-tornado-messenger" self.pubnub_listener.config.uuid = "subscribe-tornado-listener" callback_presence = SubscribeListener() self.pubnub_listener.add_listener(callback_presence) self.pubnub_listener.subscribe().channels(ch).with_presence().execute() yield callback_presence.wait_for_connect() envelope = yield callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == self.pubnub_listener.uuid callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() yield callback_messages.wait_for_connect() envelope = yield callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == self.pubnub.uuid self.pubnub.unsubscribe().channels(ch).execute() yield callback_messages.wait_for_disconnect() envelope = yield callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'leave' assert envelope.uuid == self.pubnub.uuid self.pubnub_listener.unsubscribe().channels(ch).execute() yield callback_presence.wait_for_disconnect() self.pubnub.stop() self.stop()
class TestChannelGroupSubscription(AsyncTestCase, SubscriptionTest): def setUp(self): super(TestChannelGroupSubscription, 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) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/group_sub_unsub.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=60) def test_group_subscribe_unsubscribe(self): ch = "subscribe-unsubscribe-channel" gr = "subscribe-unsubscribe-group" envelope = yield self.pubnub.add_channel_to_channel_group( ).channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield gen.sleep(1) callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channel_groups(gr).execute() yield callback_messages.wait_for_connect() self.pubnub.unsubscribe().channel_groups(gr).execute() yield callback_messages.wait_for_disconnect() envelope = yield self.pubnub.remove_channel_from_channel_group( ).channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/group_sub_pub_unsub.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=60) def test_group_subscribe_publish_unsubscribe(self): ch = "subscribe-unsubscribe-channel" gr = "subscribe-unsubscribe-group" message = "hey" envelope = yield self.pubnub.add_channel_to_channel_group( ).channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield gen.sleep(1) callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channel_groups(gr).execute() yield callback_messages.wait_for_connect() sub_envelope, pub_envelope = yield [ callback_messages.wait_for_message_on(ch), self.pubnub.publish().channel(ch).message(message).future() ] 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 self.pubnub.unsubscribe().channel_groups(gr).execute() yield callback_messages.wait_for_disconnect() envelope = yield self.pubnub.remove_channel_from_channel_group( ).channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/group_join_leave.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=60) def test_group_join_leave(self): self.pubnub.config.uuid = "test-subscribe-messenger" self.pubnub_listener.config.uuid = "test-subscribe-listener" ch = "subscribe-test-channel" gr = "subscribe-test-group" envelope = yield self.pubnub.add_channel_to_channel_group( ).channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield gen.sleep(1) callback_messages = SubscribeListener() callback_presence = SubscribeListener() self.pubnub_listener.add_listener(callback_presence) self.pubnub_listener.subscribe().channel_groups( gr).with_presence().execute() yield callback_presence.wait_for_connect() prs_envelope = yield callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == self.pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channel_groups(gr).execute() useless, prs_envelope = yield [ callback_messages.wait_for_connect(), callback_presence.wait_for_presence_on(ch) ] assert prs_envelope.event == 'join' assert prs_envelope.uuid == self.pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr self.pubnub.unsubscribe().channel_groups(gr).execute() useless, prs_envelope = yield [ callback_messages.wait_for_disconnect(), callback_presence.wait_for_presence_on(ch) ] assert prs_envelope.event == 'leave' assert prs_envelope.uuid == self.pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr self.pubnub_listener.unsubscribe().channel_groups(gr).execute() yield callback_presence.wait_for_disconnect() envelope = yield self.pubnub.remove_channel_from_channel_group( ).channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/subscribe_tep_by_step.yaml', filter_query_parameters=['uuid', 'seqn']) @tornado.testing.gen_test(timeout=30) def test_subscribe_step_by_step(self): ch1 = 'test-here-now-channel1' ch2 = 'test-here-now-channel2' ch3 = 'test-here-now-channel3' self.pubnub.config.uuid = 'test-here-now-uuid' callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) print("connecting to the first...") self.pubnub.subscribe().channels(ch1).execute() yield callback_messages.wait_for_connect() print("...connected to the first") yield gen.sleep(1) print("connecting to the second...") self.pubnub.subscribe().channels(ch2).execute() self.pubnub.subscribe().channels(ch3).execute() self.pubnub.subscribe().channels(ch3).execute() self.pubnub.subscribe().channels(ch2).execute() print("...connected to the second") yield gen.sleep(5) env = yield self.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 == self.pubnub.uuid assert channels[1].occupancy >= 1 assert channels[1].occupants[0].uuid == self.pubnub.uuid self.pubnub.unsubscribe().channels([ch1, ch2]).execute() yield callback_messages.wait_for_disconnect() self.pubnub.unsubscribe().channels(ch3).execute() self.pubnub.stop() self.stop()
class TestChannelSubscription(AsyncTestCase, SubscriptionTest): 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) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/heartbeat/timeout.yaml', filter_query_parameters=['uuid'], match_on=['method', 'scheme', 'host', 'port', 'string_list_in_path', 'query'], match_on_kwargs={ 'string_list_in_path': { 'positions': [4] } }) @tornado.testing.gen_test(timeout=20) def test_timeout_event_on_broken_heartbeat(self): ch = "heartbeat-tornado-ch" # - connect to :ch-pnpres callback_presence = SubscribeListener() self.pubnub_listener.add_listener(callback_presence) self.pubnub_listener.subscribe().channels(ch).with_presence().execute() yield callback_presence.wait_for_connect() envelope = yield callback_presence.wait_for_presence_on(ch) assert ch == envelope.channel assert 'join' == envelope.event assert self.pubnub_listener.uuid == envelope.uuid # - connect to :ch callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() # - assert join event useless, prs_envelope = yield [ callback_messages.wait_for_connect(), callback_presence.wait_for_presence_on(ch)] assert ch == prs_envelope.channel assert 'join' == prs_envelope.event assert self.pubnub.uuid == prs_envelope.uuid # wait for one heartbeat call yield gen.sleep(8) # - break messenger heartbeat loop self.pubnub._subscription_manager._stop_heartbeat_timer() # - assert for timeout envelope = yield callback_presence.wait_for_presence_on(ch) assert ch == envelope.channel assert 'timeout' == envelope.event assert self.pubnub.uuid == envelope.uuid # - disconnect from :ch-pnpres self.pubnub_listener.unsubscribe().channels(ch).execute() yield callback_presence.wait_for_disconnect()
class TestChannelSubscription(AsyncTestCase, SubscriptionTest): 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) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/sub_unsub.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=300) def test_subscribe_unsubscribe(self): ch = "subscribe-tornado-ch" callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() assert ch in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 1 yield callback_messages.wait_for_connect() assert ch in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 1 self.pubnub.unsubscribe().channels(ch).execute() assert ch not in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 0 yield callback_messages.wait_for_disconnect() assert ch not in self.pubnub.get_subscribed_channels() assert len(self.pubnub.get_subscribed_channels()) == 0 self.pubnub.stop() self.stop() @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/sub_pub_unsub.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=30) def test_subscribe_publish_unsubscribe(self): ch = "subscribe-tornado-ch" message = "hey" callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() yield callback_messages.wait_for_connect() sub_env, pub_env = yield [ callback_messages.wait_for_message_on(ch), self.pubnub.publish().channel(ch).message(message).future()] assert pub_env.status.original_response[0] == 1 assert pub_env.status.original_response[1] == 'Sent' assert sub_env.channel == ch assert sub_env.subscription is None assert sub_env.message == message self.pubnub.unsubscribe().channels(ch).execute() yield callback_messages.wait_for_disconnect() @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/join_leave.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=30) def test_join_leave(self): ch = "subscribe-tornado-ch" # HINT: use random generated uuids to test without VCR # rnd = gen_string(4) # self.pubnub.config.uuid = "subscribe-tornado-messenger-%s" % rnd # self.pubnub_listener.config.uuid = "subscribe-tornado-listener-%s" % rnd self.pubnub.config.uuid = "subscribe-tornado-messenger-3" self.pubnub_listener.config.uuid = "subscribe-tornado-listener-3" callback_presence = SubscribeListener() self.pubnub_listener.add_listener(callback_presence) self.pubnub_listener.subscribe().channels(ch).with_presence().execute() yield callback_presence.wait_for_connect() envelope = yield callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == self.pubnub_listener.uuid callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channels(ch).execute() yield callback_messages.wait_for_connect() envelope = yield callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == self.pubnub.uuid self.pubnub.unsubscribe().channels(ch).execute() yield callback_messages.wait_for_disconnect() envelope = yield callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'leave' assert envelope.uuid == self.pubnub.uuid self.pubnub_listener.unsubscribe().channels(ch).execute() yield callback_presence.wait_for_disconnect() self.pubnub.stop() self.stop()
class TestChannelGroupSubscription(AsyncTestCase, SubscriptionTest): def setUp(self): super(TestChannelGroupSubscription, 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) @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/group_sub_unsub.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=60) def test_group_subscribe_unsubscribe(self): ch = "subscribe-unsubscribe-channel" gr = "subscribe-unsubscribe-group" envelope = yield self.pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield gen.sleep(1) callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channel_groups(gr).execute() yield callback_messages.wait_for_connect() self.pubnub.unsubscribe().channel_groups(gr).execute() yield callback_messages.wait_for_disconnect() envelope = yield self.pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/group_sub_pub_unsub.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=60) def test_group_subscribe_publish_unsubscribe(self): ch = "subscribe-unsubscribe-channel" gr = "subscribe-unsubscribe-group" message = "hey" envelope = yield self.pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield gen.sleep(1) callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channel_groups(gr).execute() yield callback_messages.wait_for_connect() sub_envelope, pub_envelope = yield [ callback_messages.wait_for_message_on(ch), self.pubnub.publish().channel(ch).message(message).future()] 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 self.pubnub.unsubscribe().channel_groups(gr).execute() yield callback_messages.wait_for_disconnect() envelope = yield self.pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/group_join_leave.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=60) def test_group_join_leave(self): self.pubnub.config.uuid = "test-subscribe-messenger" self.pubnub_listener.config.uuid = "test-subscribe-listener" ch = "subscribe-test-channel" gr = "subscribe-test-group" envelope = yield self.pubnub.add_channel_to_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 yield gen.sleep(1) callback_messages = SubscribeListener() callback_presence = SubscribeListener() self.pubnub_listener.add_listener(callback_presence) self.pubnub_listener.subscribe().channel_groups(gr).with_presence().execute() yield callback_presence.wait_for_connect() prs_envelope = yield callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == self.pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr self.pubnub.add_listener(callback_messages) self.pubnub.subscribe().channel_groups(gr).execute() useless, prs_envelope = yield [ callback_messages.wait_for_connect(), callback_presence.wait_for_presence_on(ch) ] assert prs_envelope.event == 'join' assert prs_envelope.uuid == self.pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr self.pubnub.unsubscribe().channel_groups(gr).execute() useless, prs_envelope = yield [ callback_messages.wait_for_disconnect(), callback_presence.wait_for_presence_on(ch) ] assert prs_envelope.event == 'leave' assert prs_envelope.uuid == self.pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr self.pubnub_listener.unsubscribe().channel_groups(gr).execute() yield callback_presence.wait_for_disconnect() envelope = yield self.pubnub.remove_channel_from_channel_group().channel_group(gr).channels(ch).future() assert envelope.status.original_response['status'] == 200 @use_cassette_and_stub_time_sleep( 'tests/integrational/fixtures/tornado/subscribe/subscribe_tep_by_step.yaml', filter_query_parameters=['uuid', 'seqn', 'pnsdk']) @tornado.testing.gen_test(timeout=30) def test_subscribe_step_by_step(self): ch1 = 'test-here-now-channel1' ch2 = 'test-here-now-channel2' ch3 = 'test-here-now-channel3' self.pubnub.config.uuid = 'test-here-now-uuid' callback_messages = SubscribeListener() self.pubnub.add_listener(callback_messages) print("connecting to the first...") self.pubnub.subscribe().channels(ch1).execute() yield callback_messages.wait_for_connect() print("...connected to the first") yield gen.sleep(1) print("connecting to the second...") self.pubnub.subscribe().channels(ch2).execute() self.pubnub.subscribe().channels(ch3).execute() self.pubnub.subscribe().channels(ch3).execute() self.pubnub.subscribe().channels(ch2).execute() print("...connected to the second") yield gen.sleep(5) env = yield self.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 == self.pubnub.uuid assert channels[1].occupancy >= 1 assert channels[1].occupants[0].uuid == self.pubnub.uuid self.pubnub.unsubscribe().channels([ch1, ch2]).execute() yield callback_messages.wait_for_disconnect() self.pubnub.unsubscribe().channels(ch3).execute() self.pubnub.stop() self.stop()