Split ZMQ dependent tests into test/jupyter-zmq-test.el

* test/jupyter-test.el: Move all zmq related tests (and code) to
  `test/jupyter-zmq-test.el`, add a `zmq` tag to the tests.

* test/test-helper.el (zmq, jupyter-zmq-channel-ioloop)
(jupyter-zmq-channel-ioloop-comm): Remove requires.
(jupyter-test-ioloop-eval-event, jupyter-test-channel-ioloop)
(initialize-instance) [jupyter-echo-client]: Remove uses of ZMQ by using
a `jupyter-mock-comm-layer` for the `kcomm` slot.
(jupyter-test-zmq-sockets): Move to `test/jupyter-zmq-test.el` along with all
related code.

* test/jupyter-zmq-test.el: Add tests moved from `test/jupyter-test.el` and all
  related code.

Author: nnicandro

test/jupyter-test.el

@@ -26,8 +26,6 @@
 
 ;;; Code:
 
-(require 'zmq)
-(require 'jupyter-zmq-channel-comm)
 (require 'jupyter-env)
 (require 'jupyter-client)
 (require 'jupyter-repl)
@@ -493,58 +491,6 @@
                             msg)
                    (cons "idle" "foo")))))
 
-;;; Channels
-
-(ert-deftest jupyter-zmq-channel ()
-  :tags '(channels zmq)
-  (let* ((port (car (jupyter-available-local-ports 1)))
-         (channel (jupyter-zmq-channel
-                   :type :shell
-                   :endpoint (format "tcp://127.0.0.1:%s" port))))
-    (ert-info ("Starting the channel")
-      (should-not (jupyter-channel-alive-p channel))
-      (jupyter-start-channel channel :identity "foo")
-      (should (jupyter-channel-alive-p channel))
-      (should (equal (zmq-socket-get (oref channel socket)
-                                     zmq-ROUTING-ID)
-                     "foo")))
-    (ert-info ("Stopping the channel")
-      (let ((sock (oref channel socket)))
-        (jupyter-stop-channel channel)
-        (should-not (jupyter-channel-alive-p channel))
-        ;; Ensure the socket was disconnected
-        (should-error (zmq-send sock "foo" zmq-NOBLOCK) :type 'zmq-EAGAIN)))))
-
-(ert-deftest jupyter-hb-channel ()
-  :tags '(channels)
-  (should (eq (oref (jupyter-hb-channel) type) :hb))
-  (let* ((port (car (jupyter-available-local-ports 1)))
-         (channel (jupyter-hb-channel
-                   :endpoint (format "tcp://127.0.0.1:%s" port)
-                   :session (jupyter-session)))
-         (died-cb-called nil)
-         (jupyter-hb-max-failures 1))
-    (oset channel time-to-dead 0.1)
-    (should-not (jupyter-channel-alive-p channel))
-    (should-not (jupyter-hb-beating-p channel))
-    (should (oref channel paused))
-    (oset channel beating t)
-    (jupyter-start-channel channel)
-    (jupyter-hb-on-kernel-dead channel (lambda () (setq died-cb-called t)))
-    (should (jupyter-channel-alive-p channel))
-    ;; `jupyter-hb-unpause' needs to explicitly called
-    (should (oref channel paused))
-    (jupyter-hb-unpause channel)
-    (sleep-for 0.2)
-    ;; It seems the timers are run after returning from the first `sleep-for'
-    ;; call.
-    (sleep-for 0.1)
-    (should (oref channel paused))
-    (should-not (oref channel beating))
-    (should died-cb-called)
-    (should (jupyter-channel-alive-p channel))
-    (should-not (jupyter-hb-beating-p channel))))
-
 ;;; GC
 
 (ert-deftest jupyter-weak-ref ()
@@ -609,45 +555,6 @@
              (lambda (_) nil)))
     (should-error (jupyter-locate-python))))
 
-(ert-deftest jupyter-kernel-lifetime ()
-  :tags '(kernel)
-  (let* ((conn-info (jupyter-local-tcp-conn-info))
-         (kernel (jupyter-spec-kernel
-                  :spec (jupyter-guess-kernelspec "python")
-                  :session (jupyter-session
-                            :key (plist-get conn-info :key)
-                            :conn-info conn-info))))
-    (should-not (jupyter-kernel-alive-p kernel))
-    (jupyter-start-kernel kernel)
-    (should (jupyter-kernel-alive-p kernel))
-    (jupyter-kill-kernel kernel)
-    (should-not (jupyter-kernel-alive-p kernel))
-    (setq conn-info (jupyter-local-tcp-conn-info))
-    (ert-info ("`jupyter-kernel-manager'")
-      ;; TODO: Should the manager create a session if one isn't present?
-      (oset kernel session (jupyter-session
-                            :key (plist-get conn-info :key)
-                            :conn-info conn-info))
-      (let* ((manager (jupyter-kernel-process-manager :kernel kernel))
-             (control-channel (oref manager control-channel))
-             process)
-        (should-not (jupyter-kernel-alive-p manager))
-        (should-not control-channel)
-        (jupyter-start-kernel manager)
-        (setq process (oref kernel process))
-        (setq control-channel (oref manager control-channel))
-        (should (jupyter-zmq-channel-p control-channel))
-        (should (jupyter-kernel-alive-p manager))
-        (should (jupyter-kernel-alive-p kernel))
-        (jupyter-shutdown-kernel manager)
-        (ert-info ("Kernel shutdown is clean")
-          (should-not (process-live-p process))
-          (should (zerop (process-exit-status process)))
-          (should-not (jupyter-kernel-alive-p manager))
-          (should-not (jupyter-kernel-alive-p kernel)))
-        (setq control-channel (oref manager control-channel))
-        (should-not (jupyter-zmq-channel-p control-channel))))))
-
 (ert-deftest jupyter-command-kernel ()
   :tags '(kernel)
   (let ((kernel (jupyter-command-kernel
@@ -703,49 +610,6 @@
 
 ;;; Client
 
-;; TODO: Different values of the session argument
-;; TODO: Update for new `jupyter-channel-ioloop-comm'
-(ert-deftest jupyter-comm-initialize ()
-  :tags '(client init)
-  (skip-unless nil)
-  ;; The default comm is a jupyter-channel-ioloop-comm
-  (let ((conn-info (jupyter-test-conn-info-plist))
-        (client (jupyter-kernel-client)))
-    (oset client kcomm (jupyter-zmq-channel-comm))
-    (jupyter-comm-initialize client conn-info)
-    ;; kcomm by default is a `jupyter-channel-ioloop-comm'
-    (with-slots (session kcomm) client
-      (ert-info ("Client session")
-        (should (string= (jupyter-session-key session)
-                         (plist-get conn-info :key)))
-        (should (equal (jupyter-session-conn-info session)
-                       conn-info)))
-      (ert-info ("Heartbeat channel initialized")
-        (should (eq session (oref (oref kcomm hb) session)))
-        (should (string= (oref (oref kcomm hb) endpoint)
-                         (format "tcp://127.0.0.1:%d"
-                                 (plist-get conn-info :hb_port)))))
-      (ert-info ("Shell, iopub, stdin initialized")
-        (cl-loop
-         for channel in '(:shell :iopub :stdin)
-         for port_sym = (intern (concat (symbol-name channel) "_port"))
-         do
-         (should (plist-member (plist-get channels channel) :alive-p))
-         (should (plist-member (plist-get channels channel) :endpoint))
-         (should
-          (string= (plist-get (plist-get channels channel) :endpoint)
-                   (format "tcp://127.0.0.1:%d"
-                           (plist-get conn-info port_sym))))))
-      (ert-info ("Initialization stops any running channels")
-        (should-not (jupyter-channels-running-p client))
-        (jupyter-start-channels client)
-        (should (jupyter-channels-running-p client))
-        (jupyter-comm-initialize client conn-info)
-        (should-not (jupyter-channels-running-p client)))
-      (ert-info ("Invalid signature scheme")
-        (plist-put conn-info :signature_scheme "hmac-foo")
-        (should-error (jupyter-comm-initialize client conn-info))))))
-
 (ert-deftest jupyter-write-connection-file ()
   :tags '(client)
   (skip-unless (not (memq system-type '(ms-dos windows-nt cygwin))))
@@ -771,28 +635,6 @@
         (delete-file file)))
     (should-not (memq fun kill-emacs-hook))))
 
-(ert-deftest jupyter-client-channels ()
-  :tags '(client channels)
-  (ert-info ("Starting/stopping channels")
-    (let ((conn-info (jupyter-test-conn-info-plist))
-          (client (jupyter-kernel-client)))
-      (oset client kcomm (jupyter-zmq-channel-comm))
-      (jupyter-comm-initialize client conn-info)
-      (cl-loop
-       for channel in '(:hb :shell :iopub :stdin)
-       for alive-p = (jupyter-channel-alive-p client channel)
-       do (should-not alive-p))
-      (jupyter-start-channels client)
-      (cl-loop
-       for channel in '(:hb :shell :iopub :stdin)
-       for alive-p = (jupyter-channel-alive-p client channel)
-       do (should alive-p))
-      (jupyter-stop-channels client)
-      (cl-loop
-       for channel in '(:hb :shell :iopub :stdin)
-       for alive-p = (jupyter-channel-alive-p client channel)
-       do (should-not alive-p)))))
-
 (ert-deftest jupyter-inhibited-handlers ()
   :tags '(client handlers)
   (jupyter-test-with-python-client client
@@ -908,183 +750,6 @@
       (should (memq r1 mapped))
       (should-not (memq r2 mapped)))))
 
-;;; IOloop
-
-(ert-deftest jupyter-ioloop-lifetime ()
-  :tags '(ioloop)
-  (let ((ioloop (jupyter-ioloop))
-        (jupyter-default-timeout 2))
-    (should-not (process-live-p (oref ioloop process)))
-    (jupyter-ioloop-start ioloop :tag1)
-    (should (equal (jupyter-ioloop-last-event ioloop) '(start)))
-    (with-slots (process) ioloop
-      (should (process-live-p process))
-      (jupyter-ioloop-stop ioloop)
-      (should (equal (jupyter-ioloop-last-event ioloop) '(quit)))
-      (sleep-for 0.1)
-      (should-not (process-live-p process)))))
-
-(defvar jupyter-ioloop-test-handler-called nil
-  "Flag variable used for testing the `juyter-ioloop'.")
-
-(cl-defmethod jupyter-ioloop-handler ((_ioloop jupyter-ioloop)
-                                      (_tag (eql :test))
-                                      (event (head test)))
-  (should (equal (cadr event) "message"))
-  (setq jupyter-ioloop-test-handler-called t))
-
-(ert-deftest jupyter-ioloop-wait-until ()
-  :tags '(ioloop)
-  (let ((ioloop (jupyter-ioloop)))
-    (should-not (jupyter-ioloop-last-event ioloop))
-    (jupyter-ioloop-start ioloop :test)
-    (should (equal (jupyter-ioloop-last-event ioloop) '(start)))
-    (jupyter-ioloop-stop ioloop)))
-
-(ert-deftest jupyter-ioloop-callbacks ()
-  :tags '(ioloop)
-  (ert-info ("Callback added before starting the ioloop")
-    (let ((ioloop (jupyter-ioloop)))
-      (setq jupyter-ioloop-test-handler-called nil)
-      (jupyter-ioloop-add-callback ioloop
-        `(lambda () (zmq-prin1 (list 'test "message"))))
-      (jupyter-ioloop-start ioloop :test)
-      (jupyter-ioloop-stop ioloop)
-      (should jupyter-ioloop-test-handler-called)))
-  (ert-info ("Callback added after starting the ioloop")
-    (let ((ioloop (jupyter-ioloop)))
-      (setq jupyter-ioloop-test-handler-called nil)
-      (jupyter-ioloop-start ioloop :test)
-      (should (process-live-p (oref ioloop process)))
-      (jupyter-ioloop-add-callback ioloop
-        `(lambda () (zmq-prin1 (list 'test "message"))))
-      (jupyter-ioloop-wait-until ioloop 'test #'identity)
-      (jupyter-ioloop-stop ioloop)
-      (should jupyter-ioloop-test-handler-called))))
-
-(ert-deftest jupyter-ioloop-setup ()
-  :tags '(ioloop)
-  (let ((ioloop (jupyter-ioloop)))
-    (setq jupyter-ioloop-test-handler-called nil)
-    (jupyter-ioloop-add-setup ioloop
-      (zmq-prin1 (list 'test "message")))
-    (jupyter-ioloop-start ioloop :test)
-    (jupyter-ioloop-stop ioloop)
-    (should jupyter-ioloop-test-handler-called)))
-
-(ert-deftest jupyter-ioloop-teardown ()
-  :tags '(ioloop)
-  (let ((ioloop (jupyter-ioloop)))
-    (setq jupyter-ioloop-test-handler-called nil)
-    (jupyter-ioloop-add-teardown ioloop
-      (zmq-prin1 (list 'test "message")))
-    (jupyter-ioloop-start ioloop :test)
-    (jupyter-ioloop-stop ioloop)
-    (should jupyter-ioloop-test-handler-called)))
-
-(ert-deftest jupyter-ioloop-add-event ()
-  :tags '(ioloop)
-  (let ((ioloop (jupyter-ioloop)))
-    (setq jupyter-ioloop-test-handler-called nil)
-    (jupyter-ioloop-add-event ioloop test (data)
-      "Echo DATA back to the parent process."
-      (list 'test data))
-    (jupyter-ioloop-start ioloop :test)
-    (jupyter-send ioloop 'test "message")
-    (jupyter-ioloop-stop ioloop)
-    (should jupyter-ioloop-test-handler-called)))
-
-(ert-deftest jupyter-channel-ioloop-send-event ()
-  :tags '(ioloop)
-  (jupyter-test-channel-ioloop
-      (ioloop (jupyter-zmq-channel-ioloop))
-    (cl-letf (((symbol-function #'jupyter-send)
-               (lambda (_channel _msg-type _msg msg-id) msg-id)))
-      (setq jupyter-channel-ioloop-session (jupyter-session :key "foo"))
-      (push (jupyter-zmq-channel :type :shell) jupyter-channel-ioloop-channels)
-      (let* ((msg-id (jupyter-new-uuid))
-             (event `(list 'send :shell :execute-request '(msg) ,msg-id)))
-        (jupyter-test-ioloop-eval-event ioloop event)
-        (ert-info ("Return value to parent process")
-          (let ((result (read (buffer-string))))
-            (should (equal result `(sent :shell ,msg-id)))))))))
-
-(ert-deftest jupyter-channel-ioloop-start-channel-event ()
-  :tags '(ioloop)
-  (jupyter-test-channel-ioloop
-      (ioloop (jupyter-zmq-channel-ioloop))
-    (setq jupyter-channel-ioloop-session (jupyter-session :key "foo"))
-    (let ((channel-endpoint "tcp://127.0.0.1:5555"))
-      (ert-info ("start-channel event creates channel")
-        (should (null jupyter-channel-ioloop-channels))
-        (let ((event `(list 'start-channel :shell ,channel-endpoint)))
-          (jupyter-test-ioloop-eval-event ioloop event))
-        (should-not (null jupyter-channel-ioloop-channels))
-        (let ((channel (object-assoc :shell :type jupyter-channel-ioloop-channels)))
-          (should (jupyter-zmq-channel-p channel))))
-      (let ((channel (object-assoc :shell :type jupyter-channel-ioloop-channels)))
-        (with-slots (type socket endpoint) channel
-          (ert-info ("Verify the requested channel was started")
-            (should (eq type :shell))
-            (should (zmq-socket-p socket))
-            (should (equal endpoint channel-endpoint))
-            (should (equal (zmq-socket-get socket zmq-LAST-ENDPOINT) channel-endpoint))
-            (ert-info ("Identity of socket matches session")
-              (should (equal (zmq-socket-get socket zmq-IDENTITY)
-                             (jupyter-session-id jupyter-channel-ioloop-session)))))
-          (ert-info ("Ensure the channel was added to the poller")
-            ;; FIXME: Does it make sense to have this side effect as part of starting
-            ;; a channel? It makes it so that we don't reference any `zmq' functions
-            ;; in `jupyter-channel-ioloop'.
-            (should-error
-             (zmq-poller-add jupyter-ioloop-poller socket (list zmq-POLLIN))
-             :type 'zmq-EINVAL)))
-        (ert-info ("Return value to parent process")
-          (let ((result (read (buffer-string))))
-            (should (equal result `(start-channel :shell)))))))))
-
-(ert-deftest jupyter-channel-ioloop-stop-channel-event ()
-  :tags '(ioloop)
-  (jupyter-test-channel-ioloop
-      (ioloop (jupyter-zmq-channel-ioloop))
-    (setq jupyter-channel-ioloop-session (jupyter-session :key "foo"))
-    (let ((event `(list 'start-channel :shell "tcp://127.0.0.1:5556")))
-      (jupyter-test-ioloop-eval-event ioloop event)
-      (erase-buffer))
-    (let* ((channel (object-assoc :shell :type jupyter-channel-ioloop-channels))
-           (socket (oref channel socket)))
-      (ert-info ("Verify the requested channel stops")
-        (should (jupyter-channel-alive-p channel))
-        (should (progn (zmq-poller-modify
-                        jupyter-ioloop-poller
-                        (oref channel socket) (list zmq-POLLIN zmq-POLLOUT))
-                       t))
-        (jupyter-test-ioloop-eval-event ioloop `(list 'stop-channel :shell))
-        (should-not (jupyter-channel-alive-p channel)))
-      (ert-info ("Ensure the channel was removed from the poller")
-        (should-error
-         (zmq-poller-modify jupyter-ioloop-poller socket (list zmq-POLLIN))
-         :type 'zmq-EINVAL))
-      (ert-info ("Return value to parent process")
-        (let ((result (read (buffer-string))))
-          (should (equal result `(stop-channel :shell))))))))
-
-(ert-deftest jupyter-zmq-channel-ioloop-send-fast ()
-  :tags '(ioloop queue)
-  ;; :expected-result :failed
-  (jupyter-test-with-python-client client
-    (let ((jupyter-current-client client))
-      (jupyter-send-execute-request client :code "1 + 1")
-      (jupyter-send-execute-request client :code "1 + 1")
-      (jupyter-send-execute-request client :code "1 + 1")
-      (let ((req (jupyter-send-execute-request client :code "1 + 1")))
-        (should
-         (equal
-          (jupyter-message-data
-           (jupyter-wait-until-received :execute-result req jupyter-long-timeout)
-           :text/plain)
-          "2"))))))
-
 ;;; Completion
 
 (ert-deftest jupyter-completion-number-p ()