Python ClientSession.connect方法代码示例

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
    def test_ping(self):
        application = Application()
        with ManagedServerLoop(application, keep_alive_milliseconds=0) as server:
            session = ClientSession(session_id='test_ping',
                                    websocket_url=ws_url(server),
                                    io_loop=server.io_loop)
            session.connect()
            assert session.connected
            assert session.document is None

            connection = next(iter(server._tornado._clients))
            expected_pong = connection._ping_count
            server._tornado.keep_alive() # send ping
            session.force_roundtrip()

            self.assertEqual(expected_pong, connection._socket.latest_pong)

            # check that each ping increments by 1
            server._tornado.keep_alive()
            session.force_roundtrip()

            self.assertEqual(expected_pong + 1, connection._socket.latest_pong)

            session.close()
            session.loop_until_closed()
            assert not session.connected

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
 def test_minimal_connect_and_disconnect(self):
     application = Application()
     with ManagedServerLoop(application) as server:
         # we don't have to start the server because it
         # uses the same main loop as the client, so
         # if we start either one it starts both
         session = ClientSession(io_loop = server.io_loop,
                                 url = ws_url(server))
         session.connect()
         assert session.connected

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
 def test_disconnect_on_error(self):
     application = Application()
     with ManagedServerLoop(application) as server:
         session = ClientSession(url=server.ws_url, io_loop = server.io_loop)
         session.connect()
         assert session.connected
         # send a bogus message using private fields
         session._connection._socket.write_message(b"xx", binary=True)
         # connection should now close on the server side
         # and the client loop should end
         session.loop_until_closed()
         assert not session.connected

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
    def test_host_whitelist_success(self):
        application = Application()

        # succeed no host value with defaults
        with ManagedServerLoop(application, host=None) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert session.connected
            session.close()
            session.loop_until_closed()

        # succeed no host value with port
        with ManagedServerLoop(application, port=8080, host=None) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert session.connected
            session.close()
            session.loop_until_closed()

        # succeed matching host value
        with ManagedServerLoop(application, port=8080, host=["localhost:8080"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert session.connected
            session.close()
            session.loop_until_closed()

        # succeed matching host value one of multiple
        with ManagedServerLoop(application, port=8080, host=["bad_host", "localhost:8080"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert session.connected
            session.close()
            session.loop_until_closed()

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
    def test_request_server_info(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            session = ClientSession(url=server.ws_url, io_loop=server.io_loop)
            session.connect()
            assert session.connected
            assert session.document is None

            info = session.request_server_info()

            from bokeh import __version__

            assert info['version_info']['bokeh'] == __version__
            assert info['version_info']['server'] == __version__

            session.close()
            session.loop_until_closed()
            assert not session.connected

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
    def test_connect_with_prefix(self):
        application = Application()
        with ManagedServerLoop(application, prefix="foo") as server:
            # we don't have to start the server because it
            # uses the same main loop as the client, so
            # if we start either one it starts both
            session = ClientSession(io_loop = server.io_loop,
                                    websocket_url = ws_url(server, "/foo"))
            session.connect()
            assert session.connected
            session.close()
            session.loop_until_closed()

            session = ClientSession(io_loop = server.io_loop,
                                    websocket_url = ws_url(server))
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed()

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
    def test_request_server_info(self):
        application = Application()
        with ManagedServerLoop(application) as server:
            session = ClientSession(session_id='test_request_server_info',
                                    websocket_url=ws_url(server),
                                    io_loop=server.io_loop)
            session.connect()
            assert session.connected
            assert session.document is None

            info = session.request_server_info()

            from bokeh import __version__

            assert info['version_info']['bokeh'] == __version__
            assert info['version_info']['server'] == __version__

            session.close()
            session.loop_until_closed(suppress_warning=True)
            assert not session.connected

# 需要导入模块: from bokeh.client import ClientSession [as 别名]
# 或者: from bokeh.client.ClientSession import connect [as 别名]
    def test_host_whitelist_failure(self):
        application = Application()

        # failure bad host
        with ManagedServerLoop(application, host=["bad_host"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed()

        with ManagedServerLoop(application, host=["bad_host:5006"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed()

        # failure good host, bad port
        with ManagedServerLoop(application, host=["localhost:80"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed()

        # failure good host, bad default port
        with ManagedServerLoop(application, host=["localhost"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed()

        # failure with custom port
        with ManagedServerLoop(application, port=8080, host=["localhost:8081"]) as server:
            session = ClientSession(url=ws_url(server), io_loop = server.io_loop)
            session.connect()
            assert not session.connected
            session.close()
            session.loop_until_closed()