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