Python pubnub_tornado.PubNubTornado類代碼示例

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

    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'}))

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

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