branch: elpa/with-simulated-input
commit 1a610d65876db558930b8bb130743769792febef
Author: Ryan C. Thompson <[email protected]>
Commit: Ryan C. Thompson <[email protected]>
Reorganize test suite
Note that the tests here still reflect the behavior of the 2.x branch.
---
tests/test-with-simulated-input.el | 248 ++++++++++++++++++++++++-------------
1 file changed, 160 insertions(+), 88 deletions(-)
diff --git a/tests/test-with-simulated-input.el
b/tests/test-with-simulated-input.el
index 7aa6f7e6aa..2a85a62db0 100644
--- a/tests/test-with-simulated-input.el
+++ b/tests/test-with-simulated-input.el
@@ -26,30 +26,173 @@
(describe "`with-simulated-input'"
- (it "should work for basic string input"
- (expect
- (with-simulated-input "hello RET"
- (read-string "Enter a string: "))
- :to-equal "hello"))
+ (describe "should work when KEYS"
+
+ (it "is a literal string"
+ (expect
+ (with-simulated-input "hello RET"
+ (read-string "Enter a string: "))
+ :to-equal "hello"))
+
+ (it "is a quoted list of literal strings"
+ (expect
+ (with-simulated-input '("hello" "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello"))
+
+ (it "is a quoted list of lisp forms"
+ (expect
+ (with-simulated-input '((insert "hello") (exit-minibuffer))
+ (read-string "Enter a string: "))
+ :to-equal "hello"))
+
+ (it "is a quoted list of strings and lisp forms"
+ (expect
+ (with-simulated-input '((insert "hello") "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello")
+ (expect
+ (with-simulated-input '("hello" (exit-minibuffer))
+ (read-string "Enter a string: "))
+ :to-equal "hello")
+ (expect
+ (with-simulated-input '("hello SPC" (insert "world") "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello world"))
+
+ (it "is a variable containing any of the above"
+ (cl-loop
+ for input in
+ '("hello RET"
+ ("hello" "RET")
+ ((insert "hello") (exit-minibuffer))
+ ((insert "hello") "RET")
+ ("hello" (exit-minibuffer)))
+ do (expect
+ (with-simulated-input input
+ (read-string "Enter a string: "))
+ :to-equal "hello")))
+
+ (it "is an arbitrary expression evaluating to any of the above"
+ (expect
+ (with-simulated-input (list "hello" "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello")
+ (expect
+ (let ((my-input "hello"))
+ (with-simulated-input (list '(insert my-input) "RET")
+ (read-string "Enter a string: ")))
+ :to-equal "hello")
+ (expect
+ (with-simulated-input (concat "hello" " " "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello")
+ (let ((my-key-sequence "hello")
+ (my-lisp-form '(insert " world")))
+ (expect
+ (with-simulated-input (list
+ my-key-sequence
+ my-lisp-form
+ "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello world")))
+ (it "is evaluated at run time in a lexical environment"
+ (let ((my-input "hello"))
+ (expect
+ (with-simulated-input `((insert ,my-input) "RET")
+ (read-string "Enter a string: "))
+ :to-equal "hello"))
+ (let ((greeting "hello")
+ (target "world"))
+ (expect
+ (with-simulated-input
+ (list greeting "SPC"
+ (list 'insert target)
+ "RET")
+ (read-string "Say hello: "))
+ :to-equal "hello world"))
+ (let ((my-lexical-var nil))
+ (with-simulated-input '("hello"
+ (setq my-lexical-var t)
+ "RET")
+ (read-string "Enter a string: "))
+ (expect my-lexical-var
+ :to-be-truthy)))
+
+ (it "is evaluated at run time in a non-lexical environment"
+ (let ((my-non-lexical-var nil))
+ (eval
+ '(with-simulated-input '("hello"
+ (setq my-non-lexical-var t)
+ "RET")
+ (read-string "Enter a string: "))
+ nil)
+ (expect my-non-lexical-var
+ :to-be-truthy))))
+
+ (describe "should correctly propagate errors"
+
+ (it "thrown directly from expressions in KEYS"
+ (expect
+ (with-simulated-input '("hello" (error "Throwing an error from KEYS")
"RET")
+ (read-string "Enter a string: "))
+ :to-throw))
+
+ (it "caused indirectly by the inputs in KEYS"
+ (expect
+ (with-simulated-input
+ "(error SPC \"Manually SPC throwing SPC an SPC error\") RET"
+ (command-execute 'eval-expression))
+ :to-throw))
+
+ (it "thrown by BODY"
+ (expect
+ (with-simulated-input
+ "hello RET"
+ (read-string "Enter a string: ")
+ (error "Throwing an error after reading input"))
+ :to-throw)
+ (expect
+ (with-simulated-input
+ "hello RET"
+ (error "Throwing an error before reading input")
+ (read-string "Enter a string: "))
+ :to-throw))
+
+ (it "from aborting via C-g in KEYS"
+ (expect
+ (condition-case nil
+ (with-simulated-input "C-g"
+ (read-string "Enter a string: "))
+ (quit 'caught-quit))
+ :to-be 'caught-quit)))
+
+ ;; TODO: Warn on no-op elements like this: any variable or
+ ;; non-string literal, or any expression known to involve only pure
+ ;; functions.
+ (it "should ignore the return value of expressions in KEYS"
+ (let ((desired-input "hello")
+ (undesired-input "goodbye"))
+ (expect
+ (with-simulated-input '((insert desired-input) undesired-input "RET")
+ (read-string "Enter a string: "))
+ :to-equal desired-input)))
(it "should throw an error if the input is incomplete"
(expect
- (with-simulated-input "hello"
+ (with-simulated-input "hello" ; No RET
(read-string "Enter a string: "))
:to-throw))
- (it "should allow the input to trigger errors"
+ (it "should discard any extra input after BODY has completed"
(expect
-
(with-simulated-input
- "(error SPC \"Manually SPC throwing SPC an SPC error\") RET"
- (command-execute 'eval-expression))
- :to-throw))
-
- (it "should ignore extra input after BODY has completed"
+ "hello RET M-x eval-expression (error SPC \"Manually SPC throwing SPC
an SPC error\") RET"
+ (read-string "Enter a string: "))
+ :to-equal "hello")
(expect
(with-simulated-input
- "hello RET M-x eval-expression (error SPC \"Manually SPC throwing SPC
an SPC error\") RET"
+ '("hello RET" (error "Throwing an error after BODY has completeld."))
(read-string "Enter a string: "))
:to-equal "hello"))
@@ -60,16 +203,8 @@
(read-string "Second word: ")))
:to-equal '("hello" "world")))
- (it "should allow aborting via C-g in KEYS"
- (expect
- (condition-case nil
- (with-simulated-input "C-g"
- (read-string "Enter a string: "))
- (quit 'caught-quit))
- :to-be 'caught-quit))
-
;; https://github.com/DarwinAwardWinner/with-simulated-input/issues/4
- (it "should work inside code that switches buffer (issue #4)"
+ (it "should work inside code that switches buffers (issue #4)"
(let ((orig-current-buffer (current-buffer)))
(with-temp-buffer
(let ((temp-buffer (current-buffer)))
@@ -77,7 +212,7 @@
(expect (current-buffer) :to-equal temp-buffer)
(expect (current-buffer) :not :to-equal orig-current-buffer)))))
- (it "should work in byte-compiled code (issue #6)"
+ (xit "should work in byte-compiled code (issue #6)"
(expect (call-wsi-from-bytecomp-fun)
:not :to-throw))
@@ -110,70 +245,7 @@
(with-simulated-input "bl TAB C-j"
(completing-read "Choose: " my-collection nil t))
- :to-throw)))
-
- (describe "using lisp forms in KEYS argument of `with-simulated-input'"
-
- (it "should allow evaluating arbitrary lisp forms"
- (expect
- (with-simulated-input '("hello SPC" (insert "world") "RET")
- (read-string "Enter a string: "))
- :to-equal "hello world"))
-
- (it "should allow KEYS to be evaluated at run time"
- (let ((greeting "hello")
- (target "world"))
- (expect
- (with-simulated-input
- (list greeting "SPC"
- (list 'insert target)
- "RET")
- (read-string "Say hello: "))
- :to-equal "hello world")))
-
- (it "should allow lisp forms to throw errors"
- (expect
- (with-simulated-input '("hello SPC" (error "Throwing an error") "RET")
- (read-string "Enter a string: "))
- :to-throw))
-
- (it "should not interpret lisp forms once BODY has finished"
- (expect
- (with-simulated-input '("hello SPC world RET RET"
- (error "Should not reach this error"))
- (read-string "Enter a string: "))
- :to-equal "hello world"))
-
- (it "should evaluate lisp forms in the proper lexical environment"
- (let ((my-lexical-var nil))
- (with-simulated-input '("hello"
- (setq my-lexical-var t)
- "RET")
- (read-string "Enter a string: "))
- (expect my-lexical-var
- :to-be-truthy)))
-
- (it "should work in a non-lexical environment"
- (let ((my-non-lexical-var nil))
- (eval
- '(with-simulated-input '("hello"
- (setq my-non-lexical-var t)
- "RET")
- (read-string "Enter a string: "))
- nil)
- (expect my-non-lexical-var
- :to-be-truthy)))
-
- (it "should allow interpolation of variables into KEYS"
- (let ((my-key-sequence "hello")
- (my-lisp-form '(insert " world")))
- (expect
- (with-simulated-input (list
- my-key-sequence
- my-lisp-form
- "RET")
- (read-string "Enter a string: "))
- :to-equal "hello world")))))
+ :to-throw))))
(defun time-equal-p (t1 t2)
"Return non-nil if T1 and T2 represent the same time.
