Merge branch 'master' into pytest_fixture_updates

Author: echarles

.github/workflows/main.yml

@@ -24,10 +24,6 @@ jobs:
     - name: Install the Python dependencies
       run: |
         pip install -e .[test]
-    - name: ipykernel fix on windows 3.8
-      if: matrix.os == 'windows-latest' && matrix.python-version == '3.8'
-      run: |
-        pip install --upgrade git+https://github.com/ipython/ipykernel.git
     - name: Run the tests
       run: |
         pytest

.gitignore

@@ -33,6 +33,7 @@ src
 *.swp
 *.map
 .idea/
+.vscode/
 Read the Docs
 config.rst
 

appveyor.yml

@@ -34,8 +34,6 @@ install:
   - cmd: conda create -y -q -n test-env-%CONDA_PY% python=%CONDA_PY_SPEC% pip pyzmq tornado jupyter_client nbformat nbconvert nose
   - cmd: conda activate test-env-%CONDA_PY%
   - cmd: pip install -e .[test]
-# FIXME: Use patch for python 3.8, windows issues (https://github.com/ipython/ipykernel/pull/456) - remove once released
-  - IF %CONDA_PY% == 38 pip install --upgrade git+https://github.com/ipython/ipykernel.git
 
 test_script:
   - pytest -s -v

jupyter_server/extension/application.py

@@ -154,6 +154,7 @@ class method. This method can be set as a entry_point in
         help="Name of extension."
     )
 
+    @default('extension_name')
     def _extension_name_default(self):
         try:
             return self.name
@@ -163,8 +164,8 @@ def _extension_name_default(self):
     INVALID_EXTENSION_NAME_CHARS = [' ', '.', '+', '/']
 
     @validate('extension_name')
-    def _validate_extension_name(self, value):
-        #value = self.extension_name
+    def _validate_extension_name(self, proposal):
+        value = proposal['value']
         if isinstance(value, str):
             # Validate that extension_name doesn't contain any invalid characters.
             for c in ExtensionApp.INVALID_EXTENSION_NAME_CHARS:
@@ -351,6 +352,7 @@ def _prepare_templates(self):
             self.settings.update({
                 "{}_template_paths".format(self.extension_name): self.template_paths
             })
+        self.initialize_templates()
 
     @staticmethod
     def initialize_server(argv=[], load_other_extensions=True, **kwargs):

jupyter_server/pytest_plugin.py

@@ -53,6 +53,7 @@ def mkdir(tmp_path, *parts):
 config_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, "config"))
 runtime_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, "runtime"))
 root_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, "root_dir"))
+template_dir = pytest.fixture(lambda tmp_path: mkdir(tmp_path, "templates"))
 system_jupyter_path = pytest.fixture(
     lambda tmp_path: mkdir(tmp_path, "share", "jupyter")
 )

jupyter_server/services/api/api.yaml

@@ -441,14 +441,19 @@ paths:
       tags:
         - kernels
       parameters:
-        - name: name
+        - name: options
           in: body
-          description: Kernel spec name (defaults to default kernel spec for server)
           schema:
             type: object
+            required:
+              - name
             properties:
               name:
                 type: string
+                description: Kernel spec name (defaults to default kernel spec for server)
+              path:
+                type: string
+                description: API path from root to the cwd of the kernel
       responses:
         201:
           description: Kernel started

jupyter_server/services/kernels/handlers.py

@@ -45,7 +45,8 @@ def post(self):
         else:
             model.setdefault('name', km.default_kernel_name)
 
-        kernel_id = yield maybe_future(km.start_kernel(kernel_name=model['name']))
+        kernel_id = yield maybe_future(km.start_kernel(kernel_name=model['name'],
+                                                       path=model.get('path')))
         model = yield maybe_future(km.kernel_model(kernel_id))
         location = url_path_join(self.base_url, 'api', 'kernels', url_escape(kernel_id))
         self.set_header('Location', location)

setup.py

@@ -92,7 +92,7 @@
     ],
     extras_require = {
         'test': ['nose', 'coverage', 'requests', 'nose_warnings_filters',
-                 'pytest', 'pytest-cov', 'pytest-tornasync', 'pytest-console-scripts'],
+                 'pytest==5.3.2', 'pytest-cov', 'pytest-tornasync', 'pytest-console-scripts'],
         'test:sys_platform == "win32"': ['nose-exclude'],
     },
     python_requires = '>=3.5',

tests/extension/conftest.py

@@ -6,8 +6,8 @@
 from jupyter_core import paths
 from jupyter_server.extension import serverextension
 from jupyter_server.extension.serverextension import _get_config_dir
-from jupyter_server.extension.application import ExtensionApp
-from jupyter_server.extension.handler import ExtensionHandler
+from jupyter_server.extension.application import ExtensionApp, ExtensionAppJinjaMixin
+from jupyter_server.extension.handler import ExtensionHandler, ExtensionHandlerJinjaMixin
 
 # ----------------- Mock Extension App ----------------------
 
@@ -17,14 +17,21 @@ def get(self):
         self.finish(self.config.mock_trait)
 
 
-class MockExtensionApp(ExtensionApp):
+class MockExtensionTemplateHandler(ExtensionHandlerJinjaMixin, ExtensionHandler):
+
+    def get(self):
+        self.write(self.render_template("index.html"))
+
+
+class MockExtensionApp(ExtensionAppJinjaMixin, ExtensionApp):
     extension_name = 'mockextension'
     mock_trait = Unicode('mock trait', config=True)
 
     loaded = False
 
     def initialize_handlers(self):
         self.handlers.append(('/mock', MockExtensionHandler))
+        self.handlers.append(('/mock_template', MockExtensionTemplateHandler))
         self.loaded = True
 
     @staticmethod
@@ -33,6 +40,36 @@ def _jupyter_server_extension_paths():
             'module': '_mockdestination/index'
         }]
 
+@pytest.fixture
+def make_mock_extension_app(template_dir):
+    def _make_mock_extension_app(**kwargs):
+        kwargs.setdefault('template_paths', [str(template_dir)])
+        return MockExtensionApp(**kwargs)
+
+    # TODO Should the index template creation be only be done only once?
+    index = template_dir.joinpath("index.html")    
+    index.write_text("""
+<!DOCTYPE HTML>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>{% block title %}Jupyter Server 1{% endblock %}</title>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    {% block meta %}
+    {% endblock %}
+</head>
+<body>
+  <div id="site">
+    {% block site %}
+    {% endblock site %}
+  </div>
+  {% block after_site %}
+  {% endblock after_site %}
+</body>
+</html>""")
+    return _make_mock_extension_app
+
 
 @pytest.fixture
 def config_file(config_dir):
@@ -43,21 +80,21 @@ def config_file(config_dir):
 
 
 @pytest.fixture
-def extended_serverapp(serverapp):
+def extended_serverapp(serverapp, make_mock_extension_app):
     """"""
-    m = MockExtensionApp()
+    m = make_mock_extension_app()
     m.initialize(serverapp)
     return m
 
 
 @pytest.fixture
-def inject_mock_extension(environ, extension_environ):
+def inject_mock_extension(environ, extension_environ, make_mock_extension_app):
     """Fixture that can be used to inject a mock Jupyter Server extension into the tests namespace.
 
         Usage: inject_mock_extension({'extension_name': ExtensionClass})
     """
     def ext(modulename="mockextension"):
-        sys.modules[modulename] = e = MockExtensionApp()
+        sys.modules[modulename] = e = make_mock_extension_app()
         return e
 
     return ext

tests/extension/test_app.py

@@ -3,19 +3,17 @@
 from jupyter_server.serverapp import ServerApp
 from jupyter_server.extension.application import ExtensionApp
 
-from .conftest import MockExtensionApp
 
-
-def test_instance_creation():
-    mock_extension = MockExtensionApp()
+def test_instance_creation(make_mock_extension_app, template_dir):
+    mock_extension = make_mock_extension_app()
     assert mock_extension.static_paths == []
-    assert mock_extension.template_paths == []
+    assert mock_extension.template_paths == [str(template_dir)]
     assert mock_extension.settings == {}
-    assert mock_extension.handlers == [] 
+    assert mock_extension.handlers == []
 
 
-def test_initialize(serverapp):
-    mock_extension = MockExtensionApp()
+def test_initialize(serverapp, make_mock_extension_app):
+    mock_extension = make_mock_extension_app()
     mock_extension.initialize(serverapp)
     # Check that settings and handlers were added to the mock extension.
     assert isinstance(mock_extension.serverapp, ServerApp)
@@ -35,24 +33,24 @@ def test_initialize(serverapp):
     'trait_name,trait_value',
     traits
 )
-def test_instance_creation_with_instance_args(trait_name, trait_value):
+def test_instance_creation_with_instance_args(trait_name, trait_value, make_mock_extension_app):
     kwarg = {}
     kwarg.setdefault(trait_name, trait_value)
-    mock_extension = MockExtensionApp(**kwarg)
+    mock_extension = make_mock_extension_app(**kwarg)
     assert getattr(mock_extension, trait_name) == trait_value
 
 
 @pytest.mark.parametrize(
     'trait_name,trait_value',
     traits
 )
-def test_instance_creation_with_argv(serverapp, trait_name, trait_value):
+def test_instance_creation_with_argv(serverapp, trait_name, trait_value, make_mock_extension_app):
     kwarg = {}
     kwarg.setdefault(trait_name, trait_value)
     argv = [
         '--MockExtensionApp.{name}={value}'.format(name=trait_name, value=trait_value)
     ]
-    mock_extension = MockExtensionApp()
+    mock_extension = make_mock_extension_app()
     mock_extension.initialize(serverapp, argv=argv)
     assert getattr(mock_extension, trait_name) == trait_value