def test_resolve_file_to_run_and_root_dir(prefix_path, root_dir, file_to_run, expected_output): # Verify that the Singleton instance is cleared before the test runs. ServerApp.clear_instance() # Setup the file_to_run path, in case the server checks # if the directory exists before initializing the server. file_to_run = prefix_path(file_to_run) if file_to_run.is_absolute(): file_to_run.parent.mkdir(parents=True, exist_ok=True) kwargs = {"file_to_run": str(file_to_run)} # Setup the root_dir path, in case the server checks # if the directory exists before initializing the server. if root_dir: root_dir = prefix_path(root_dir) if root_dir.is_absolute(): root_dir.parent.mkdir(parents=True, exist_ok=True) kwargs["root_dir"] = str(root_dir) # Create the notebook in the given location serverapp = ServerApp.instance(**kwargs) if expected_output is SystemExit: with pytest.raises(SystemExit): serverapp._resolve_file_to_run_and_root_dir() else: relpath = serverapp._resolve_file_to_run_and_root_dir() assert relpath == str(pathlib.Path(expected_output)) # Clear the singleton instance after each run. ServerApp.clear_instance()
def jupyter_server_app(jupyter_server_args, jupyter_server_config): jupyter_server_app = ServerApp.instance() # we monkey patch old_listen = httpserver.HTTPServer.listen httpserver.HTTPServer.listen = lambda *x, **y: None # NOTE: in voila's conftest.py we call config after initialize jupyter_server_config(jupyter_server_app) jupyter_server_app.initialize(jupyter_server_args) yield jupyter_server_app httpserver.HTTPServer.listen = old_listen ServerApp.clear_instance()
def test_urls(config, public_url, local_url, connection_url): # Verify we're working with a clean instance. ServerApp.clear_instance() serverapp = ServerApp.instance(**config) # If a token is generated (not set by config), update # expected_url with token. if serverapp._token_generated: public_url = public_url.replace("<generated>", serverapp.token) local_url = local_url.replace("<generated>", serverapp.token) connection_url = connection_url.replace("<generated>", serverapp.token) assert serverapp.public_url == public_url assert serverapp.local_url == local_url assert serverapp.connection_url == connection_url # Cleanup singleton after test. ServerApp.clear_instance()
def configurable_serverapp( environ, server_config, argv, http_port, tmp_path, root_dir, io_loop, ): ServerApp.clear_instance() def _configurable_serverapp(config=server_config, argv=argv, environ=environ, http_port=http_port, tmp_path=tmp_path, root_dir=root_dir, **kwargs): c = Config(config) c.NotebookNotary.db_file = ":memory:" token = hexlify(os.urandom(4)).decode("ascii") url_prefix = "/" app = ServerApp.instance( # Set the log level to debug for testing purposes log_level='DEBUG', port=http_port, port_retries=0, open_browser=False, root_dir=str(root_dir), base_url=url_prefix, config=c, allow_root=True, token=token, **kwargs) app.init_signal = lambda: None app.log.propagate = True app.log.handlers = [] # Initialize app without httpserver app.initialize(argv=argv, new_httpserver=False) app.log.propagate = True app.log.handlers = [] # Start app without ioloop app.start_app() return app return _configurable_serverapp
def configurable_serverapp( environ, http_port, tmp_path, home_dir, data_dir, config_dir, runtime_dir, root_dir, io_loop ): def serverapp( config={}, argv=[], environ=environ, http_port=http_port, tmp_path=tmp_path, home_dir=home_dir, data_dir=data_dir, config_dir=config_dir, runtime_dir=runtime_dir, root_dir=root_dir, **kwargs ): c = Config(config) c.NotebookNotary.db_file = ":memory:" token = hexlify(os.urandom(4)).decode("ascii") url_prefix = "/" app = ServerApp.instance( port=http_port, port_retries=0, open_browser=False, config_dir=str(config_dir), data_dir=str(data_dir), runtime_dir=str(runtime_dir), root_dir=str(root_dir), base_url=url_prefix, config=c, allow_root=True, token=token, **kwargs ) app.init_signal = lambda: None app.log.propagate = True app.log.handlers = [] # Initialize app without httpserver app.initialize(argv=argv, new_httpserver=False) app.log.propagate = True app.log.handlers = [] # Start app without ioloop app.start_app() return app yield serverapp ServerApp.clear_instance()
def jp_configurable_serverapp( jp_nbconvert_templates, # this fixture must preceed jp_environ jp_environ, jp_server_config, jp_argv, jp_http_port, jp_base_url, tmp_path, jp_root_dir, io_loop, ): """Starts a Jupyter Server instance based on the provided configuration values. The fixture is a factory; it can be called like a function inside a unit test. Here's a basic example of how use this fixture: .. code-block:: python def my_test(jp_configurable_serverapp): app = jp_configurable_serverapp(...) ... """ ServerApp.clear_instance() def _configurable_serverapp(config=jp_server_config, base_url=jp_base_url, argv=jp_argv, environ=jp_environ, http_port=jp_http_port, tmp_path=tmp_path, root_dir=jp_root_dir, **kwargs): c = Config(config) c.NotebookNotary.db_file = ":memory:" token = hexlify(os.urandom(4)).decode("ascii") app = ServerApp.instance( # Set the log level to debug for testing purposes log_level='DEBUG', port=http_port, port_retries=0, open_browser=False, root_dir=str(root_dir), base_url=base_url, config=c, allow_root=True, token=token, **kwargs) app.init_signal = lambda: None app.log.propagate = True app.log.handlers = [] # Initialize app without httpserver app.initialize(argv=argv, new_httpserver=False) app.log.propagate = True app.log.handlers = [] # Start app without ioloop app.start_app() return app return _configurable_serverapp
def jp_server_cleanup(): yield ServerApp.clear_instance()
def jp_server_cleanup(io_loop): yield app: ServerApp = ServerApp.instance() loop = io_loop.asyncio_loop loop.run_until_complete(app._cleanup()) ServerApp.clear_instance()
def jp_configurable_serverapp( jp_nbconvert_templates, # this fixture must preceed jp_environ jp_environ, jp_server_config, jp_argv, jp_http_port, jp_base_url, tmp_path, jp_root_dir, io_loop, jp_logging_stream, ): """Starts a Jupyter Server instance based on the provided configuration values. The fixture is a factory; it can be called like a function inside a unit test. Here's a basic example of how use this fixture: .. code-block:: python def my_test(jp_configurable_serverapp): app = jp_configurable_serverapp(...) ... """ ServerApp.clear_instance() # Inject jupyter_server_terminals into config unless it was # explicitly put in config. serverapp_config = jp_server_config.setdefault("ServerApp", {}) exts = serverapp_config.setdefault("jpserver_extensions", {}) if "jupyter_server_terminals" not in exts: exts["jupyter_server_terminals"] = True def _configurable_serverapp( config=jp_server_config, base_url=jp_base_url, argv=jp_argv, environ=jp_environ, http_port=jp_http_port, tmp_path=tmp_path, root_dir=jp_root_dir, **kwargs, ): c = Config(config) c.NotebookNotary.db_file = ":memory:" token = hexlify(os.urandom(4)).decode("ascii") # Allow tests to configure root_dir via a file, argv, or its # default (cwd) by specifying a value of None. if root_dir is not None: kwargs["root_dir"] = str(root_dir) app = ServerApp.instance( # Set the log level to debug for testing purposes log_level="DEBUG", port=http_port, port_retries=0, open_browser=False, base_url=base_url, config=c, allow_root=True, token=token, **kwargs, ) app.init_signal = lambda: None app.log.propagate = True app.log.handlers = [] # Initialize app without httpserver app.initialize(argv=argv, new_httpserver=False) # Reroute all logging StreamHandlers away from stdin/stdout since pytest hijacks # these streams and closes them at unfortunate times. stream_handlers = [h for h in app.log.handlers if isinstance(h, logging.StreamHandler)] for handler in stream_handlers: handler.setStream(jp_logging_stream) app.log.propagate = True app.log.handlers = [] # Start app without ioloop app.start_app() return app return _configurable_serverapp