def setUp(self):
AsyncTestCase.setUp(self)
pnconf = PNConfiguration()
pnconf.publish_key = 'demo'
pnconf.subscribe_key = 'demo'
pnconf.enable_subscribe = False
self.pn = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
class TestPubNubAsyncPublish(AsyncTestCase): # pylint: disable=W0612
def setUp(self):
AsyncTestCase.setUp(self)
self.env = None
def callback(self, tornado_res):
self.env = tornado_res.result()
self.pubnub.stop()
self.stop()
def assert_success(self, pub):
pub.future().add_done_callback(self.callback)
self.pubnub.start()
self.wait()
if self.env.status.error:
raise AssertionError()
def test_success(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(
self.pubnub.delete_messages().channel("my-ch").start(123).end(456))
def test_super_call(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.delete_messages().channel(
"my-ch- |.* $").start(123).end(456))
def test_publish_with_meta(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(
self.pubnub.publish().channel(ch).message("hey").meta({'a': 2, 'b': 'qwer'}))
self.assert_success_yield(
self.pubnub.publish().channel(ch).message("hey").meta({'a': 2, 'b': 'qwer'}))
def test_super_call(self):
ch1 = "state-tornado-ch1"
ch2 = "state-tornado-ch2"
pnconf = pnconf_pam_copy()
pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
pubnub.config.uuid = 'test-state-tornado-uuid-|.*$'
state = {"name": "Alex", "count": 5}
env = yield pubnub.set_state() \
.channels([ch1, ch2]) \
.state(state) \
.future()
assert env.result.state['name'] == "Alex"
assert env.result.state['count'] == 5
env = yield pubnub.get_state() \
.channels([ch1, ch2]) \
.future()
assert env.result.channels[ch1]['name'] == "Alex"
assert env.result.channels[ch2]['name'] == "Alex"
assert env.result.channels[ch1]['count'] == 5
assert env.result.channels[ch2]['count'] == 5
pubnub.stop()
self.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_publish_do_not_store(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(
self.pubnub.publish().channel(ch).message("hey").should_store(False))
self.assert_success_yield(
self.pubnub.publish().channel(ch).message("hey").should_store(False))
def test_error_non_serializable(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
def method():
pass
self.assert_client_side_error(self.pubnub.publish().channel(ch).message(method), "not JSON serializable")
class RealtimeData(Settings):
last_price = 0
def __init__(self):
super().__init__()
self.c = PNConfiguration()
self.c.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
self.c.reconnect_policy = PNReconnectionPolicy.LINEAR
self.pubnub = PubNubTornado(self.c)
channels = [
self.realtime_product,
]
self.main(channels)
self.pubnub.start()
@gen.coroutine
def main(self, channels):
class Callback(SubscribeCallback):
def message(self, pubnub, message):
RealtimeData.last_price = message.message['ltp']
pubnub.stop() # 必要なデータを取得したら一度停止する
s = Callback()
self.pubnub.add_listener(s)
self.pubnub.subscribe().channels(channels).execute()
def stop(self):
self.pubnub.stop()
def get_current_data(self):
self.pubnub.start()
def test_publish_future_raises(self):
pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop)
e = yield pubnub.publish().message('hey').channel('blah').future()
assert isinstance(e, PubNubTornadoException)
assert e.is_error()
assert 400 == e.value()._status_code
pubnub.stop()
def test_publish_future_raises(self):
pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop)
e = yield pubnub.publish().message('hey').channel('blah').future()
assert isinstance(e, PubNubTornadoException)
assert e.is_error()
assert 400 == e.value()._status_code
pubnub.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_error_invalid_key(self):
conf = PNConfiguration()
conf.publish_key = "fake"
conf.subscribe_key = "demo"
self.pubnub = PubNubTornado(conf, custom_ioloop=self.io_loop)
self.assert_server_side_error(self.pubnub.publish().channel(ch).message("hey"), "Invalid Key")
self.assert_server_side_error_yield(self.pubnub.publish().channel(ch).message("hey"), "Invalid Key")
def test_error_not_permitted_403(self):
my_pnconf = pnconf_pam_copy()
my_pnconf.secret_key = None
self.pubnub = PubNubTornado(my_pnconf, custom_ioloop=self.io_loop)
self.assert_server_side_error(
self.pubnub.publish().channel("not_permitted_channel").message("hey"), "HTTP Client Error (403)")
self.assert_server_side_error_yield(
self.pubnub.publish().channel("not_permitted_channel").message("hey"), "HTTP Client Error (403)")
def test_publish_result_raises_pubnub_error(self):
pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop)
with pytest.raises(PubNubException) as exinfo:
yield pubnub.publish().message('hey').channel('blah').result()
assert 'Invalid Subscribe Key' in str(exinfo.value)
assert 400 == exinfo.value._status_code
pubnub.stop()
def test_publish_result_raises_pubnub_error(self):
pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop)
with pytest.raises(PubNubException) as exinfo:
yield pubnub.publish().message('hey').channel('blah').result()
assert 'Invalid Subscribe Key' in str(exinfo.value)
assert 400 == exinfo.value._status_code
pubnub.stop()
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 xtest_publish_future_raises_lower_level_error(self):
pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop)
pubnub.http.close()
e = yield pubnub.publish().message('hey').channel('blah').future()
assert isinstance(e, PubNubTornadoException)
assert str(e) == "fetch() called on closed AsyncHTTPClient"
pubnub.stop()
def xtest_publish_future_raises_lower_level_error(self):
pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop)
pubnub.http.close()
e = yield pubnub.publish().message('hey').channel('blah').future()
assert isinstance(e, PubNubTornadoException)
assert str(e) == "fetch() called on closed AsyncHTTPClient"
pubnub.stop()
def __init__(self):
super().__init__()
self.c = PNConfiguration()
self.c.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
self.c.reconnect_policy = PNReconnectionPolicy.LINEAR
self.pubnub = PubNubTornado(self.c)
channels = [
self.realtime_product,
]
self.main(channels)
self.pubnub.start()
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 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 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 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 sfd_process(sfd):
FX_CHANNEL = "lightning_ticker_FX_BTC_JPY"
BTC_CHANNEL = "lightning_ticker_BTC_JPY"
class BitflyerSubscriberCallback(SubscribeCallback):
def message(self, pubnub, message):
tick = message.message
timestamp = dateutil.parser.parse(tick["timestamp"])
with sfd.lock:
changed = False
if message.channel == FX_CHANNEL:
if sfd.fx_ltp != tick["ltp"]:
sfd.fx_ltp = tick["ltp"]
changed = True
elif message.channel == BTC_CHANNEL:
if sfd.btc_ltp != tick["ltp"]:
sfd.btc_ltp = tick["ltp"]
changed = True
if sfd.ready and changed:
sfd.disparity = (sfd.fx_ltp / sfd.btc_ltp) * 100 - 100
if (sfd.fx_ltp > sfd.btc_ltp and sfd.disparity >= 10.0) or \
(sfd.fx_ltp < sfd.btc_ltp and sfd.disparity <= -10.0):
sfd.last_sfd_at = timestamp
sfd.updated_at = timestamp
sfd.event.set()
config = PNConfiguration()
config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
config.reconnect_policy = PNReconnectionPolicy.LINEAR
config.ssl = False
config.set_presence_timeout(60)
pubnub = PubNubTornado(config)
listener = BitflyerSubscriberCallback()
pubnub.add_listener(listener)
pubnub.subscribe().channels([FX_CHANNEL, BTC_CHANNEL]).execute()
pubnub.start()
def test_publish_ssl(self):
print(sys.version_info)
pubnub = PubNubTornado(pnconf_ssl_copy(), custom_ioloop=self.io_loop)
msg = "hey"
pub = pubnub.publish().channel(ch).message(msg)
envelope = yield pub.future()
assert isinstance(envelope, TornadoEnvelope)
assert isinstance(envelope.result, PNPublishResult)
assert isinstance(envelope.status, PNStatus)
assert envelope.result.timetoken > 0
assert len(envelope.status.original_response) > 0
pubnub.stop()
def test_publish_ssl(self):
print(sys.version_info)
pubnub = PubNubTornado(pnconf_ssl_copy(), custom_ioloop=self.io_loop)
msg = "hey"
pub = pubnub.publish().channel(ch).message(msg)
envelope = yield pub.future()
assert isinstance(envelope, TornadoEnvelope)
assert isinstance(envelope.result, PNPublishResult)
assert isinstance(envelope.status, PNStatus)
assert envelope.result.timetoken > 0
assert len(envelope.status.original_response) > 0
pubnub.stop()
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 TestMessageCount(AsyncTestCase):
def setUp(self):
AsyncTestCase.setUp(self)
config = pnconf_copy()
self.pn = PubNubTornado(config, custom_ioloop=self.io_loop)
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/fire_get.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk'])
@tornado.testing.gen_test
def test_single_channel(self):
chan = 'unique_sync'
envelope = yield self.pn.fire().channel(chan).message('bla').future()
assert (isinstance(envelope, TornadoEnvelope))
assert not envelope.status.is_error()
assert isinstance(envelope.result, PNFireResult)
assert isinstance(envelope.status, PNStatus)
self.pn.stop()
class BfAsyncSubscriber:
def __init__(self, channels):
self.channels = channels
pnc = PNConfiguration()
pnc.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
pnc.reconnect_policy = PNReconnectionPolicy.LINEAR
self.pubnub = PubNubTornado(pnc)
@gen.coroutine
def subscribe(self):
return self.pubnub.subscribe().channels(self.channels).execute()
def test_reconnection(self):
pnconf = PNConfiguration()
pnconf.publish_key = "demo"
pnconf.subscribe_key = "demo"
pnconf.origin = "localhost:8089"
pnconf.subscribe_request_timeout = 10
pnconf.reconnect_policy = PNReconnectionPolicy.LINEAR
pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
time_until_open_again = 10
@gen.coroutine
def close_soon():
yield gen.sleep(3)
pubnub.http.close()
pubnub.http = None
print(">>> connection is broken")
@gen.coroutine
def open_again():
yield gen.sleep(time_until_open_again)
pubnub.http = tornado.httpclient.AsyncHTTPClient(max_clients=PubNubTornado.MAX_CLIENTS)
print(">>> connection is open again")
@gen.coroutine
def countdown():
yield gen.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 gen.sleep(1)
my_listener = MySubscribeCallback()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels('my_channel').execute()
yield gen.sleep(1000)
def test_super_call(self):
ch1 = "state-tornado-ch1"
ch2 = "state-tornado-ch2"
pnconf = pnconf_pam_copy()
pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
pubnub.config.uuid = 'test-state-tornado-uuid-|.*$'
state = {"name": "Alex", "count": 5}
env = yield pubnub.set_state() \
.channels([ch1, ch2]) \
.state(state) \
.future()
assert env.result.state['name'] == "Alex"
assert env.result.state['count'] == 5
env = yield pubnub.get_state() \
.channels([ch1, ch2]) \
.future()
assert env.result.channels[ch1]['name'] == "Alex"
assert env.result.channels[ch2]['name'] == "Alex"
assert env.result.channels[ch1]['count'] == 5
assert env.result.channels[ch2]['count'] == 5
pubnub.stop()
self.stop()
class TestMessageCount(AsyncTestCase):
def setUp(self):
AsyncTestCase.setUp(self)
config = pnconf_mc_copy()
config.enable_subscribe = False
self.pn = PubNubTornado(config, custom_ioloop=self.io_loop)
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/message_count/single.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_cg', 'l_pub'])
@tornado.testing.gen_test
def test_single_channel(self):
chan = 'unique_tornado'
envelope = yield self.pn.publish().channel(chan).message(
'bla').future()
time = envelope.result.timetoken - 10
envelope = yield self.pn.message_counts().channel(
chan).channel_timetokens([time]).future()
assert (isinstance(envelope, TornadoEnvelope))
assert not envelope.status.is_error()
assert envelope.result.channels[chan] == 1
assert isinstance(envelope.result, PNMessageCountResult)
assert isinstance(envelope.status, PNStatus)
self.pn.stop()
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/message_count/multi.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_cg', 'l_pub'])
@tornado.testing.gen_test
def test_multiple_channels(self):
chan_1 = 'unique_asyncio_1'
chan_2 = 'unique_asyncio_2'
chans = ','.join([chan_1, chan_2])
envelope = yield self.pn.publish().channel(chan_1).message(
'something').future()
time = envelope.result.timetoken - 10
envelope = yield self.pn.message_counts().channel(
chans).channel_timetokens([time, time]).future()
assert (isinstance(envelope, TornadoEnvelope))
assert not envelope.status.is_error()
assert envelope.result.channels[chan_1] == 1
assert envelope.result.channels[chan_2] == 0
assert isinstance(envelope.result, PNMessageCountResult)
assert isinstance(envelope.status, PNStatus)
self.pn.stop()
class TestSignal(AsyncTestCase):
def setUp(self):
AsyncTestCase.setUp(self)
pnconf = PNConfiguration()
pnconf.publish_key = 'demo'
pnconf.subscribe_key = 'demo'
pnconf.enable_subscribe = False
self.pn = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
@pn_vcr.use_cassette('tests/integrational/fixtures/tornado/signal/single.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk'])
@tornado.testing.gen_test
def test_single_channel(self):
chan = 'unique_sync'
envelope = yield self.pn.signal().channel(chan).message('test').future()
assert(isinstance(envelope, TornadoEnvelope))
assert not envelope.status.is_error()
assert envelope.result.timetoken == '15640051976283377'
assert isinstance(envelope.result, PNSignalResult)
assert isinstance(envelope.status, PNStatus)
self.pn.stop()
class TestMessageCount(AsyncTestCase):
def setUp(self):
AsyncTestCase.setUp(self)
config = pnconf_mc_copy()
config.enable_subscribe = False
self.pn = PubNubTornado(config, custom_ioloop=self.io_loop)
@pn_vcr.use_cassette('tests/integrational/fixtures/tornado/message_count/single.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_cg', 'l_pub'])
@tornado.testing.gen_test
def test_single_channel(self):
chan = 'unique_tornado'
envelope = yield self.pn.publish().channel(chan).message('bla').future()
time = envelope.result.timetoken - 10
envelope = yield self.pn.message_counts().channel(chan).channel_timetokens([time]).future()
assert(isinstance(envelope, TornadoEnvelope))
assert not envelope.status.is_error()
assert envelope.result.channels[chan] == 1
assert isinstance(envelope.result, PNMessageCountResult)
assert isinstance(envelope.status, PNStatus)
self.pn.stop()
@pn_vcr.use_cassette('tests/integrational/fixtures/tornado/message_count/multi.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_cg', 'l_pub'])
@tornado.testing.gen_test
def test_multiple_channels(self):
chan_1 = 'unique_asyncio_1'
chan_2 = 'unique_asyncio_2'
chans = ','.join([chan_1, chan_2])
envelope = yield self.pn.publish().channel(chan_1).message('something').future()
time = envelope.result.timetoken - 10
envelope = yield self.pn.message_counts().channel(chans).channel_timetokens([time, time]).future()
assert(isinstance(envelope, TornadoEnvelope))
assert not envelope.status.is_error()
assert envelope.result.channels[chan_1] == 1
assert envelope.result.channels[chan_2] == 0
assert isinstance(envelope.result, PNMessageCountResult)
assert isinstance(envelope.status, PNStatus)
self.pn.stop()
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
def test_reconnection(self):
pnconf = PNConfiguration()
pnconf.publish_key = "demo"
pnconf.subscribe_key = "demo"
pnconf.origin = "localhost:8089"
pnconf.subscribe_request_timeout = 10
pnconf.reconnect_policy = PNReconnectionPolicy.LINEAR
pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
time_until_open_again = 10
@gen.coroutine
def close_soon():
yield gen.sleep(3)
pubnub.http.close()
pubnub.http = None
print(">>> connection is broken")
@gen.coroutine
def open_again():
yield gen.sleep(time_until_open_again)
pubnub.http = tornado.httpclient.AsyncHTTPClient(
max_clients=PubNubTornado.MAX_CLIENTS)
print(">>> connection is open again")
@gen.coroutine
def countdown():
yield gen.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 gen.sleep(1)
my_listener = MySubscribeCallback()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels('my_channel').execute()
yield gen.sleep(1000)
def executionsProcess(self):
"""
pubnubで価格を取得する場合の処理（基本的に不要．）
"""
channels = ["lightning_executions_FX_BTC_JPY"]
executions = self.executions
class BFSubscriberCallback(SubscribeCallback):
def message(self, pubnub, message):
execution = message.message
for i in execution:
executions.append(i)
config = PNConfiguration()
config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
config.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL
config.ssl = False
config.set_presence_timeout(60)
pubnub = PubNubTornado(config)
listener = BFSubscriberCallback()
pubnub.add_listener(listener)
pubnub.subscribe().channels(channels).execute()
pubnubThread = threading.Thread(target=pubnub.start)
pubnubThread.start()
class TestPubNubAsyncPublish(AsyncTestCase):
def setUp(self):
AsyncTestCase.setUp(self)
self.env = None
def callback(self, tornado_res):
self.env = tornado_res.result()
self.pubnub.stop()
self.stop()
def assert_success(self, pub):
pub.future().add_done_callback(self.callback)
self.pubnub.start()
self.wait()
assert isinstance(self.env, TornadoEnvelope)
assert isinstance(self.env.result, PNPublishResult)
assert isinstance(self.env.status, PNStatus)
assert self.env.result.timetoken > 0
assert len(self.env.status.original_response) > 0
@tornado.testing.gen_test
def assert_success_yield(self, pub):
envelope = yield pub.future()
assert isinstance(envelope, TornadoEnvelope)
assert isinstance(envelope.result, PNPublishResult)
assert isinstance(envelope.status, PNStatus)
assert envelope.result.timetoken > 0
assert len(envelope.status.original_response) > 0
def assert_success_publish_get(self, msg):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.publish().channel(ch).message(msg))
self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg))
def assert_success_publish_post(self, msg):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.publish().channel(ch).message(msg).use_post(True))
self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg).use_post(True))
def assert_success_publish_get_encrypted(self, msg):
self.pubnub = PubNubTornado(pnconf_enc, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.publish().channel(ch).message(msg))
self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg))
def assert_success_publish_post_encrypted(self, msg):
self.pubnub = PubNubTornado(pnconf_enc, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.publish().channel(ch).message(msg).use_post(True))
self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg).use_post(True))
def assert_client_side_error(self, pub, expected_err_msg):
try:
yield pub.future()
self.pubnub.start()
self.wait()
except PubNubException as e:
assert expected_err_msg in str(e)
self.pubnub.stop()
self.stop()
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/mixed_via_get.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'])
def test_publish_mixed_via_get(self):
self.assert_success_publish_get("hi")
self.assert_success_publish_get(5)
self.assert_success_publish_get(True)
self.assert_success_publish_get(["hi", "hi2", "hi3"])
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/object_via_get.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['method', 'scheme', 'host', 'port', 'object_in_path', 'query'])
def test_publish_object_via_get(self):
self.assert_success_publish_get({"name": "Alex", "online": True})
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/mixed_via_post.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['method', 'scheme', 'host', 'port', 'path', 'query'])
def test_publish_mixed_via_post(self):
self.assert_success_publish_post("hi")
self.assert_success_publish_post(5)
self.assert_success_publish_post(True)
self.assert_success_publish_post(["hi", "hi2", "hi3"])
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/object_via_post.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['host', 'method', 'path', 'query', 'object_in_body'])
def test_publish_object_via_post(self):
self.assert_success_publish_post({"name": "Alex", "online": True})
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/mixed_via_get_encrypted.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'])
def test_publish_mixed_via_get_encrypted(self):
self.assert_success_publish_get_encrypted("hi")
self.assert_success_publish_get_encrypted(5)
self.assert_success_publish_get_encrypted(True)
self.assert_success_publish_get_encrypted(["hi", "hi2", "hi3"])
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/object_via_get_encrypted.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['host', 'method', 'query', 'object_in_path'],
match_on_kwargs={'object_in_path': {
'decrypter': gen_decrypt_func('testKey')}})
def test_publish_object_via_get_encrypted(self):
self.assert_success_publish_get_encrypted({"name": "Alex", "online": True})
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/mixed_via_post_encrypted.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['method', 'path', 'query', 'body'])
def test_publish_mixed_via_post_encrypted(self):
self.assert_success_publish_post_encrypted("hi")
self.assert_success_publish_post_encrypted(5)
self.assert_success_publish_post_encrypted(True)
self.assert_success_publish_post_encrypted(["hi", "hi2", "hi3"])
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/object_via_post_encrypted.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['method', 'path', 'query', 'object_in_body'],
match_on_kwargs={'object_in_body': {
'decrypter': gen_decrypt_func('testKey')}})
def test_publish_object_via_post_encrypted(self):
self.assert_success_publish_post_encrypted({"name": "Alex", "online": True})
def test_error_missing_message(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_client_side_error(self.pubnub.publish().channel(ch).message(None), "Message missing")
def test_error_missing_channel(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_client_side_error(self.pubnub.publish().channel("").message("hey"), "Channel missing")
def test_error_non_serializable(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
def method():
pass
self.assert_client_side_error(self.pubnub.publish().channel(ch).message(method), "not JSON serializable")
def sserr_cb(self, env):
assert isinstance(env, Future)
exception = env.exception()
self.pubnub.stop()
# this kind of assertion will not fail the test if'll be moved below `self.stop()` call
# but also not raises correct exception, timeout exception will be raised on fail instead
assert self.expected_err_msg in str(exception)
self.stop()
def assert_server_side_error(self, pub, expected_err_msg):
self.expected_err_msg = expected_err_msg
pub.result().add_done_callback(self.sserr_cb)
self.pubnub.start()
self.wait()
@tornado.testing.gen_test
def assert_server_side_error_yield(self, pub, expected_err_msg):
try:
yield pub.result()
self.pubnub.start()
self.wait()
except PubNubException as e:
assert expected_err_msg in str(e)
self.pubnub.stop()
self.stop()
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/invalid_key.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'])
def test_error_invalid_key(self):
conf = PNConfiguration()
conf.publish_key = "fake"
conf.subscribe_key = "demo"
self.pubnub = PubNubTornado(conf, custom_ioloop=self.io_loop)
self.assert_server_side_error(self.pubnub.publish().channel(ch).message("hey"), "Invalid Key")
self.assert_server_side_error_yield(self.pubnub.publish().channel(ch).message("hey"), "Invalid Key")
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/not_permitted.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'])
def test_error_not_permitted_403(self):
my_pnconf = pnconf_pam_copy()
my_pnconf.secret_key = None
self.pubnub = PubNubTornado(my_pnconf, custom_ioloop=self.io_loop)
self.assert_server_side_error(
self.pubnub.publish().channel("not_permitted_channel").message("hey"), "HTTP Client Error (403)")
self.assert_server_side_error_yield(
self.pubnub.publish().channel("not_permitted_channel").message("hey"), "HTTP Client Error (403)")
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/meta_object.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'],
match_on=['host', 'method', 'path', 'meta_object_in_query'])
def test_publish_with_meta(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(
self.pubnub.publish().channel(ch).message("hey").meta({'a': 2, 'b': 'qwer'}))
self.assert_success_yield(
self.pubnub.publish().channel(ch).message("hey").meta({'a': 2, 'b': 'qwer'}))
@pn_vcr.use_cassette(
'tests/integrational/fixtures/tornado/publish/do_not_store.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pub'])
def test_publish_do_not_store(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(
self.pubnub.publish().channel(ch).message("hey").should_store(False))
self.assert_success_yield(
self.pubnub.publish().channel(ch).message("hey").should_store(False))
class TestPubNubAsyncHereNow(AsyncTestCase):
def setUp(self):
super(TestPubNubAsyncHereNow, self).setUp()
self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/here_now/single.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pres'])
@tornado.testing.gen_test(timeout=15)
def test_here_now_single_channel(self):
ch = 'test-here-now-channel'
self.pubnub.config.uuid = 'test-here-now-uuid'
yield connect_to_channel(self.pubnub, ch)
yield tornado.gen.sleep(10)
env = yield self.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 == self.pubnub.uuid
yield disconnect_from_channel(self.pubnub, ch)
self.pubnub.stop()
self.stop()
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/here_now/multiple.yaml',
filter_query_parameters=['uuid', 'tt', 'tr', 'pnsdk', 'l_pres'])
@tornado.testing.gen_test(timeout=120)
def test_here_now_multiple_channels(self):
ch1 = 'test-here-now-channel1'
ch2 = 'test-here-now-channel2'
self.pubnub.config.uuid = 'test-here-now-uuid'
# print("connecting to the first...")
yield connect_to_channel(self.pubnub, ch1)
# print("...connected to the first")
yield gen.sleep(1)
# print("connecting to the second...")
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
yield disconnect_from_channel(self.pubnub, [ch1, ch2])
self.pubnub.stop()
self.stop()
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/here_now/global.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk', 'l_pres'])
@tornado.testing.gen_test(timeout=15)
def test_here_now_global(self):
ch1 = 'test-here-now-channel1'
ch2 = 'test-here-now-channel2'
self.pubnub.config.uuid = 'test-here-now-uuid'
callback_messages = SubscribeListener()
self.pubnub.add_listener(callback_messages)
self.pubnub.subscribe().channels(ch1).execute()
yield callback_messages.wait_for_connect()
self.pubnub.subscribe().channels(ch2).execute()
yield gen.sleep(6)
env = yield self.pubnub.here_now().future()
assert env.result.total_channels >= 2
assert env.result.total_occupancy >= 1
yield disconnect_from_channel(self.pubnub, [ch1, ch2])
self.pubnub.stop()
self.stop()
class TestPubNubState(AsyncTestCase):
def setUp(self):
super(TestPubNubState, self).setUp()
self.pubnub = PubNubTornado(pnconf_copy(), custom_ioloop=self.io_loop)
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/state/single_channel.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk'],
match_on=['method', 'host', 'path', 'state_object_in_query'])
@tornado.testing.gen_test
def test_state_single_channel(self):
ch = "state-tornado-ch"
self.pubnub.config.uuid = 'state-tornado-uuid'
state = {"name": "Alex", "count": 5}
env = yield self.pubnub.set_state() \
.channels(ch) \
.state(state) \
.future()
assert env.result.state['name'] == "Alex"
assert env.result.state['count'] == 5
env = yield self.pubnub.get_state() \
.channels(ch) \
.future()
assert env.result.channels[ch]['name'] == "Alex"
assert env.result.channels[ch]['count'] == 5
self.pubnub.stop()
self.stop()
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/state/multiple_channel.yaml',
filter_query_parameters=['uuid', 'seqn', 'pnsdk'],
match_on=['method', 'host', 'path', 'state_object_in_query'])
@tornado.testing.gen_test
def test_multiple_channels(self):
ch1 = "state-tornado-ch1"
ch2 = "state-tornado-ch2"
self.pubnub.config.uuid = 'state-tornado-uuid'
state = {"name": "Alex", "count": 5}
env = yield self.pubnub.set_state() \
.channels([ch1, ch2]) \
.state(state) \
.future()
assert env.result.state['name'] == "Alex"
assert env.result.state['count'] == 5
env = yield self.pubnub.get_state() \
.channels([ch1, ch2]) \
.future()
assert env.result.channels[ch1]['name'] == "Alex"
assert env.result.channels[ch2]['name'] == "Alex"
assert env.result.channels[ch1]['count'] == 5
assert env.result.channels[ch2]['count'] == 5
self.pubnub.stop()
self.stop()
def test_error_missing_message(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_client_side_error(self.pubnub.publish().channel(ch).message(None), "Message missing")
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()
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()
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)
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 TestPubNubAsyncWhereNow(AsyncTestCase):
def setUp(self):
super(TestPubNubAsyncWhereNow, self).setUp()
self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/where_now/single_channel.yaml',
filter_query_parameters=['uuid', 'pnsdk'])
@tornado.testing.gen_test(timeout=15)
def test_where_now_single_channel(self):
ch = "where-now-tornado-ch"
uuid = "where-now-tornado-uuid"
self.pubnub.config.uuid = uuid
yield connect_to_channel(self.pubnub, ch)
yield gen.sleep(10)
env = yield self.pubnub.where_now() \
.uuid(uuid) \
.future()
channels = env.result.channels
assert len(channels) == 1
assert channels[0] == ch
yield disconnect_from_channel(self.pubnub, ch)
self.pubnub.stop()
self.stop()
@use_cassette_and_stub_time_sleep(
'tests/integrational/fixtures/tornado/where_now/multiple_channels.yaml',
filter_query_parameters=['uuid', 'pnsdk'])
@tornado.testing.gen_test(timeout=15)
def test_multiple_channels(self):
ch1 = "where-now-tornado-ch1"
ch2 = "where-now-tornado-ch2"
uuid = "where-now-tornado-uuid"
self.pubnub.config.uuid = uuid
callback_messages = SubscribeListener()
self.pubnub.add_listener(callback_messages)
self.pubnub.subscribe().channels(ch1).execute()
yield callback_messages.wait_for_connect()
self.pubnub.subscribe().channels(ch2).execute()
yield gen.sleep(5)
env = yield self.pubnub.where_now() \
.uuid(uuid) \
.future()
channels = env.result.channels
assert len(channels) == 2
assert ch1 in channels
assert ch2 in channels
yield disconnect_from_channel(self.pubnub, [ch1, ch2])
self.pubnub.stop()
self.stop()
def assert_success_publish_get(self, msg):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.publish().channel(ch).message(msg))
self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg))
def assert_success_publish_post_encrypted(self, msg):
self.pubnub = PubNubTornado(pnconf_enc, custom_ioloop=self.io_loop)
self.assert_success(self.pubnub.publish().channel(ch).message(msg).use_post(True))
self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg).use_post(True))
def test_error_missing_channel(self):
self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
self.assert_client_side_error(self.pubnub.publish().channel("").message("hey"), "Channel missing")
def setUp(self):
super(TestPubNubState, self).setUp()
self.pubnub = PubNubTornado(pnconf_copy(), custom_ioloop=self.io_loop)
def setUp(self):
super(TestPubNubAsyncHereNow, self).setUp()
self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)