Add file-local config for etest

Macros like `etest-deftest-r` are not compatible with `etest-update`.
Instead we use a file-local variable to provide mode configuration.

Author: lionel-

test/ess-test-inf.el

@@ -72,7 +72,7 @@
 
 ;;*;; Evaluation
 
-(etest-deftest-r ess-command-test ()
+(etest-deftest ess-command-test ()
   "`ess-command' saves output in specified buffer."
   :eval (let ((output-buffer (get-buffer-create " *ess-test-command-output*")))
           (ess-command "identity(TRUE)\n" output-buffer)
@@ -115,7 +115,7 @@
     (should (string-match "^\\[1\\] \"foo\"\nSourced file"
                           (output nil (ess-load-file (expand-file-name "file.R" ess-test-fixtures-directory)))))))
 
-(etest-deftest-r ess-command-incomplete-test ()
+(etest-deftest ess-command-incomplete-test ()
   "`ess-command' fails with incomplete input."
   :eval (should-error (ess-command "list(" nil nil nil nil nil nil 0.01))
 
@@ -128,7 +128,7 @@
          (should-error (ess-command "list(" nil nil nil nil nil nil 0.01)))
   :inf-result "")
 
-(etest-deftest-r ess-command-hanging-test ()
+(etest-deftest ess-command-hanging-test ()
   "`ess-command' fails with hanging command."
   :eval (should-error (ess-command "Sys.sleep(2)\n" nil nil nil nil nil nil 0.01))
   :inf-result ""
@@ -143,7 +143,7 @@
   (ess-wait-for-process)
   (etest-clear-inferior-buffer))
 
-(etest-deftest-r ess--command-browser-timeout-test ()
+(etest-deftest ess--command-browser-timeout-test ()
   "`ess-command' fails with hanging command within browser (#1081)."
   :cleanup (ess-test--browser-cleanup)
   :eval (ess-test--browser)
@@ -164,7 +164,7 @@ Browse[1]> "
   :inf-result "NULL
 Browse[1]> ")
 
-(etest-deftest-r ess-command-browser-curly-braces ()
+(etest-deftest ess-command-browser-curly-braces ()
   "`{` expressions when debugger is active do not interrupt command."
   :cleanup (ess-test--browser-cleanup)
   :eval (ess-test--browser)
@@ -177,7 +177,7 @@ Browse[1]> "
   :inf-result ""
   :eval (should (inferior-ess-available-p)))
 
-(etest-deftest-r ess-command-environment ()
+(etest-deftest ess-command-environment ()
   "Can access current env with `.ess.environment()`"
   :cleanup (ess-test--browser-cleanup)
   :eval (progn
@@ -187,7 +187,7 @@ Browse[1]> "
   :eval (should (string= (ess-string-command "ls(envir = .ess.environment())\n")
                          "[1] \"foo\"")))
 
-(etest-deftest-r ess-command-quit-test ()
+(etest-deftest ess-command-quit-test ()
   "`ess-command' does not leak output on quit (#794, #842).
 This is especially important within `while-no-input' used by
 packages like eldoc and company-quickhelp. `throw-on-input' sets
@@ -201,7 +201,7 @@ packages like eldoc and company-quickhelp. `throw-on-input' sets
   :inf-result ""
   :eval (should (inferior-ess-available-p)))
 
-(etest-deftest-r ess-command-quit-async-interrupt-test ()
+(etest-deftest ess-command-quit-async-interrupt-test ()
   "`ess-command' interrupts asynchronously on quits (#1091, #1102).
 Needed with slow-responding processes."
   :eval
@@ -229,14 +229,14 @@ Needed with slow-responding processes."
   ;; There should be no output after the early exit or async restoration
   :inf-result "")
 
-(etest-deftest-r ess-command-newlines-test ()
+(etest-deftest ess-command-newlines-test ()
   "`ess-command' doesn't garble new lines (#1110)."
   :eval ((should (string= (ess--strip-final-newlines "1\n2")
                           "1\n2"))
          (should (equal (ess-get-words-from-vector "{ 'foo'\n'bar'\n }\n")
                         (list "bar")))))
 
-(etest-deftest-r ess-command-multiline-test ()
+(etest-deftest ess-command-multiline-test ()
   "`ess-command' output doesn't include continuation prompts (#1116)."
   :eval ((let ((buf (generate-new-buffer "ess-command-multiline-test")))
            (ess-command "{ 1\n 2 }\n" buf)
@@ -301,7 +301,7 @@ new output")
     (should (equal (ess--command-delimited-output-info (current-buffer) "my-sentinel")
                    (list 20 27 49)))))
 
-(etest-deftest-r command-without-trailing-newline-test ()
+(etest-deftest command-without-trailing-newline-test ()
   "It is a bug when a command doesn't output a trailing newline.
 With delimiters it might be possible to figure out the output.
 However if they are not available then the output is
@@ -313,7 +313,7 @@ indistinguishable from the prompt."
   :inf-result "
 > ")
 
-(etest-deftest-r ess-command-intervening-input-test ()
+(etest-deftest ess-command-intervening-input-test ()
   "Test that user can send input while command is interrupting (#1119)."
   :eval
   (progn
@@ -527,7 +527,7 @@ some. text
 
 ;;*;; Help
 
-(etest-deftest-r ess-help-aliases-test ()
+(etest-deftest ess-help-aliases-test ()
   :eval (let ((aliases (ess-get-help-aliases-list)))
           (should (member "list" aliases)))
   :inf-result ""
@@ -624,6 +624,11 @@ some. text
     (ess-switch-to-inferior-or-script-buffer nil)
     (should (derived-mode-p 'inferior-ess-mode))))
 
+
 (provide 'ess-test-inf)
 
+;; Local Variables:
+;; etest-local-config: etest-r-config
+;; End:
+
 ;;; ess-test-inf.el ends here

test/ess-test-r-eval.el

@@ -254,11 +254,16 @@ TODO: Install company-mode dependency in CI."
          "C-c C-r")
   :inf-result "+ + + + + + > ")
 
-(etest-deftest-r ess-string-command-test ()
+(etest-deftest ess-string-command-test ()
   "`ess-string-command` handles multiline outputs (#922)"
   :eval ((should (string= (ess-string-command "quote({ 1 })\n")
                           "{\n    1\n}"))
          (should (string= (ess-string-command "list(1)\n")
                           "[[1]]\n[1] 1\n"))))
 
+
+;; Local Variables:
+;; etest-local-config: etest-r-config
+;; End:
+
 ;;; ess-test-r-eval.el ends here

test/ess-test-r-mode.el

@@ -16,11 +16,16 @@
 ;;; Commentary:
 ;;
 
-(etest-deftest-r test-ess-inferior-r-backticked ()
+(etest-deftest test-ess-inferior-r-backticked ()
   "Backticked symbols are not fontified as strings."
   :case "¶`f¶oo¶`"
   :eval (progn
           (setq-local font-lock-syntactic-face-function
                       'inferior-ess-r-font-lock-syntactic-face-function)
           (font-lock-ensure)
           (should (not (face-at-point)))))
+
+
+;; Local Variables:
+;; etest-local-config: etest-r-config
+;; End:

test/ess-test-r-syntax.el

@@ -21,32 +21,32 @@
 (require 'ess-r-mode)
 (require 'ess-test-r-utils)
 
-(etest-deftest-r ess-r-syntax-backslash-test ()
+(etest-deftest ess-r-syntax-backslash-test ()
   :case "sapply(x, ¶\\(y) y"
   :eval (should (equal (syntax-after (point))
                        (string-to-syntax ".")))
   :case "c(\"¶\\\"\")"
   :eval (should (equal (syntax-after (point))
                        (string-to-syntax "\\"))))
 
-(etest-deftest-r ess-r-font-lock-boolean-operator-test ()
+(etest-deftest ess-r-font-lock-boolean-operator-test ()
   :case "foo ¶| foo ¶|¶| foo ¶& foo ¶&¶& foo"
   :eval (ess-with-enabled-font-lock-keyword 'ess-fl-keyword:operators
           (font-lock-ensure)
           (should (eq (face-at-point) 'ess-operator-face))))
 
-(etest-deftest-r ess-r-font-lock-pipe-operator-test ()
+(etest-deftest ess-r-font-lock-pipe-operator-test ()
   :case "a ¶|¶> b"
   :eval (ess-with-enabled-font-lock-keyword 'ess-fl-keyword:operators
           (font-lock-ensure)
           (should (eq (face-at-point) 'ess-operator-face))))
 
-(etest-deftest-r ess-r-tokens-pipe-operator-test ()
+(etest-deftest ess-r-tokens-pipe-operator-test ()
   :case "a ¶|> b"
   :eval (should (token= "|>"))
   :result "a |>¶ b")
 
-(etest-deftest-r ess-r-raw-strings-test ()
+(etest-deftest ess-r-raw-strings-test ()
   :case "
 r¶\"(foo\"bar))¶\"
 r¶\"(foo}\"bar))¶\"
@@ -90,3 +90,8 @@ r\"(foor¶'()¶'bar))\"
 "
   :eval (should (not (equal (syntax-after (point))
                             (string-to-syntax "|")))))
+
+
+;; Local Variables:
+;; etest-local-config: etest-r-config
+;; End:

test/ess-test-r-utils.el

@@ -23,6 +23,10 @@
 (require 'tramp)
 (require 'seq)
 
+(defvar etest-r-config
+  '(:init ((mode . r)
+           (eval . (ess-test-r-set-local-process)))))
+
 (defvar ess-test-fixtures-directory
   (expand-file-name "fixtures"
                     (file-name-directory (or load-file-name
@@ -300,17 +304,6 @@ representative to the common interactive use with tracebug on."
     (setq ess-local-process-name (process-name (get-buffer-process proc-buf)))
     (setq etest-local-inferior-buffer proc-buf)))
 
-(cl-defmacro etest-deftest-r (name args &body body)
-  (declare (doc-string 3)
-           (indent 2))
-  (let ((etest--docstring (when (stringp (car body))
-                            (list (pop body)))))
-    `(etest-deftest ,name ,args
-       ,@etest--docstring
-       :init ((mode . r)
-              (eval . (ess-test-r-set-local-process)))
-       ,@body)))
-
 ;; Utilities for testing remote functionality
 
 ;; Define a mock TRAMP method to use for testing. This code is taken from
@@ -423,4 +416,9 @@ token."
 
 (provide 'ess-test-r-utils)
 
+
+;; Local Variables:
+;; etest-local-config: etest-r-config
+;; End:
+
 ;;; ess-test-r-utils.el ends here

test/ess-test-r.el

@@ -807,7 +807,7 @@ https://github.com/emacs-ess/ESS/issues/725#issuecomment-431781558"
   (should (commandp 'R))
   (should (commandp 'R-newest)))
 
-(etest-deftest-r ess-command-last-value-test ()
+(etest-deftest ess-command-last-value-test ()
   "`ess-command` preserves `.Last.value (#1058)"
   :case "100¶"
   :eval "C-c C-c"
@@ -826,15 +826,15 @@ https://github.com/emacs-ess/ESS/issues/725#issuecomment-431781558"
 [1] 100
 > ")
 
-(etest-deftest-r ess-r-pager-test ()
+(etest-deftest ess-r-pager-test ()
   :eval ((should (string= (car (ess-get-words-from-vector "getOption('pager')\n"))
                           "cat"))))
 
 ;; rdired
 
 (require 'ess-rdired)
 
-(etest-deftest-r ess-rdired-test ()
+(etest-deftest ess-rdired-test ()
   :inf-cleanup
   (progn
     (kill-buffer ess-rdired-buffer)
@@ -895,4 +895,9 @@ https://github.com/emacs-ess/ESS/issues/725#issuecomment-431781558"
 
 (provide 'ess-test-r)
 
+
+;; Local Variables:
+;; etest-local-config: etest-r-config
+;; End:
+
 ;;; ess-test-r.el ends here

test/etest/etest.el

@@ -29,11 +29,18 @@
 Use the `:inf-result' to flush this buffer and test its
 contents.")
 
+(defvar-local etest-local-config nil
+  "Local configuration for `etest-deftest'.
+List of etest keywords and commands, e.g. an `:init' spec to set
+up a particular mode.")
+
 (cl-defmacro etest-deftest (name args &body body)
   (declare (doc-string 3)
            (indent 2))
   (let ((etest--docstring (when (stringp (car body))
                             (list (pop body)))))
+    ;; Record this at compile time because ert doesn't run tests locally
+    (etest--push-local-config body)
     `(ert-deftest ,name ,args
        ,@etest--docstring
        (etest--run-test (quote ,body)
@@ -47,6 +54,17 @@ contents.")
        (setq local (append local (pop ,place))))
      local))
 
+;; Evaluate symbols to make it easier to set local variables
+(defmacro etest--push-local-config (place)
+  `(let ((etest--config (cond ((not etest-local-config)
+                               nil)
+                              ((symbolp etest-local-config)
+                               (eval etest-local-config))
+                              (t
+                               etest-local-config))))
+     (when etest--config
+       (setq ,place (append etest--config ,place)))))
+
 (defmacro etest--with-test-buffer (init &rest body)
   (declare (indent 1)
            (debug (&rest form)))
@@ -189,6 +207,7 @@ keywords."
           (pop body))
         (when (stringp (car body))
           (pop body))
+        (etest--push-local-config body)
         (let ((results (etest--read-results body)))
           (goto-char beg)
           (forward-char 1)

test/etest/test-etest.el

@@ -1,3 +1,4 @@
+;; -*- lexical-binding: t -*-
 
 (require 'ert)
 (require 'etest)
@@ -234,3 +235,18 @@ bar"
   :result "f¶oo×"
   :eval "<right>"
   :result "fo¶o×")
+
+;; `let' doesn't seem to work here, perhaps an interaction between
+;; scoping in macros and file-local variables
+(setq etest-local-config '(:init ((mode . text))))
+
+(etest-deftest etest-local-config-test ()
+  "Local configuration is picked up"
+  :eval (should (eq major-mode 'text-mode)))
+
+(setq etest-local-config nil)
+
+(etest-deftest etest-default-mode ()
+  "Default mode is fundamental.
+Also tests local config test is cleaned up properly."
+  :eval (should (eq major-mode 'fundamental-mode)))