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_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()
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)
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()
