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