basic testing of server launching

Author: bollwyvl

anaconda-project.yml

@@ -10,7 +10,7 @@ commands:
     env_spec: rfjl37
 
   list:
-    unix: jupyter serverextension list
+    unix: jupyter serverextension list && jupyter notebook list --json
     env_spec: rfjl37
 
   setup:

atest/acceptance/00_smoke/import.robot renamed to atest/acceptance/00_smoke/00_import.robot

@@ -0,0 +1,41 @@
+*** Settings ***
+Library  JupyterLibrary
+Library  Process
+Test Teardown  Terminate All Processes
+
+*** Test Cases  ***
+Start one server
+  ${nbserver} =  Start New Jupyter Server
+  ${ready} =  Wait for Jupyter Server to be Ready
+  Should be equal as integers  ${ready}  1
+  ...  msg=One server should be ready
+  ${terminated} =  Terminate All Jupyter Servers
+  Should be equal as integers  ${terminated}  1
+  ...  msg=One server should have been terminated
+  ${log} =  Get Process Result   ${nbserver}  stderr=${True}
+  Should Contain    ${log}    The Jupyter Notebook is running
+  ...  msg=Log should contain expected status message
+
+Start three servers
+  ${nb1} =  Start New Jupyter Server
+  ${nb2} =  Start New Jupyter Server
+  ${ready} =  Wait for Jupyter Server to be Ready  ${nb2}  ${nb1}
+  Should be equal as integers  ${ready}  2
+  ...  msg=Three servers should be ready
+  ${nb3} =  Start New Jupyter Server
+  ${terminated} =  Terminate All Jupyter Servers
+  Should be equal as integers  ${terminated}  3
+  ...  msg=Three servers should have been terminated
+  ${log1} =  Get Process Result   ${nb1}  stderr=${True}
+  Should Contain    ${log1}    The Jupyter Notebook is running
+  ...  msg=Log should contain expected status message
+  ${log2} =  Get Process Result   ${nb2}  stderr=${True}
+  Should Contain    ${log2}    The Jupyter Notebook is running
+  ...  msg=Log should contain expected status message
+  ${log3} =  Get Process Result   ${nb3}  stderr=${True}
+  Should Not Contain    ${log3}    The Jupyter Notebook is running
+  ...  msg=Unawaited server log should not contain expected status message
+  ${terminated} =  Terminate All Jupyter Servers
+  Should be equal as integers  ${terminated}  0
+  ...  msg=No servers should have been terminated
+  Run Keyword And Expect Error    Only 0 of 3*  Wait for Jupyter Server to be Ready  ${nb2}  ${nb1}  ${nb3}

atest/acceptance/01_server/00_basic.robot

@@ -8,10 +8,16 @@
 
 
 def run_tests(*robot_args):
-    return subprocess.check_call([
+    proc = subprocess.Popen([
         "python", "-m", "robot", "-d", out, tests
     ], cwd=here)
 
+    try:
+        return proc.wait()
+    except KeyboardInterrupt:
+        proc.kill()
+        return proc.wait()
+
 
 if __name__ == "__main__":
     sys.exit(run_tests(sys.argv[1:]))

atest/run.py

@@ -30,6 +30,7 @@ install_requires =
     robotframework >3
     seleniumlibrary
     pillow
+    six
 package_dir =
     = src
 packages = find:

setup.cfg

@@ -1,8 +1,6 @@
 from SeleniumLibrary import SeleniumLibrary
 
-from .keywords import (
-    server,
-)
+from .keywords import server
 
 
 class JupyterLibrary(SeleniumLibrary):
@@ -28,5 +26,5 @@ def __init__(self, timeout=5.0, implicit_wait=0.0,
             screenshot_root_directory=None
         )
         self.add_library_components([
-            server
+            server.ServerKeywords(self)
         ])

src/JupyterLibrary/core.py

@@ -1,3 +1,90 @@
-class ServerKeywords(object):
-    def start_jupyter_notebook_server():
-        pass
+import subprocess
+import time
+from six.moves.urllib.request import urlopen
+
+from robot.libraries.BuiltIn import BuiltIn
+from tornado.escape import json_decode
+
+from SeleniumLibrary.base import keyword, LibraryComponent
+
+
+class NBServer(object):
+    process = None
+
+
+class ServerKeywords(LibraryComponent):
+    _nbserver_handles = []
+
+    @keyword
+    def start_new_jupyter_server(self, command="jupyter", *arguments, **configuration):
+        """ Start a Jupyter server
+        """
+        plib = BuiltIn().get_library_instance('Process')
+        if not arguments:
+            arguments = self.build_jupyter_server_arguments()
+
+        handle = plib.start_process("jupyter", *arguments, **configuration)
+        self._nbserver_handles += [handle]
+        return handle
+
+    @keyword
+    def build_jupyter_server_arguments(self):
+        return ["notebook", "--no-browser"]
+
+    @keyword
+    def wait_for_jupyter_server_to_be_ready(self, *nbservers, **kwargs):
+        """  Wait for the most-recently started Jupyter server to be ready
+        """
+        interval = float(kwargs.get("interval", 0.25))
+        retries = int(kwargs.get("retries", 20))
+
+        plib = BuiltIn().get_library_instance('Process')
+
+        if not nbservers:
+            if not self._nbserver_handles:
+                return 0
+            nbservers = [self._nbserver_handles[-1]]
+
+        ready = 0
+        last_error = None
+
+        while retries and ready != len(nbservers):
+            retries -= 1
+            ready = 0
+
+            try:
+                nbservers_json = self.get_jupyter_servers()
+                for nbhandle in nbservers:
+                    nbpopen = plib.get_process_object(nbhandle)
+                    nbj = nbservers_json[nbpopen.pid]
+                    urlopen("{url}favicon.ico".format(**nbj))
+                    ready += 1
+            except Exception as err:
+                time.sleep(interval)
+                last_error = err
+
+        assert ready == len(nbservers), (
+            "Only {} of {} servers were ready: {}".format(
+                ready, len(nbservers), last_error
+            ))
+        return ready
+
+    @keyword
+    def terminate_all_jupyter_servers(self, kill=False):
+        """ Close all Jupyter servers started by JupyterLibrary
+        """
+        plib = BuiltIn().get_library_instance('Process')
+        terminated = 0
+        for handle in self._nbserver_handles:
+            plib.terminate_process(handle, kill=kill)
+            terminated += 1
+
+        self._nbserver_handles = []
+
+        return terminated
+
+    def get_jupyter_servers(self):
+        nbservers = list(map(json_decode, subprocess.check_output(
+            ["jupyter", "notebook", "list", "--json"]
+        ).decode("utf-8").strip().split("\n")))
+        return {nbserver["pid"]: nbserver for nbserver in nbservers}