diff --git a/Cask b/Cask index 4dd8ff2..0ff5be3 100644 --- a/Cask +++ b/Cask @@ -1,13 +1,7 @@ (source gnu) (source melpa) -(package-file "webpaste.el") -(files "webpaste.el") - (development - (depends-on "f") - (depends-on "ecukes") (depends-on "request") - (depends-on "el-mock") - (depends-on "ert-runner") + (depends-on "buttercup") (depends-on "undercover")) diff --git a/Makefile b/Makefile index faebe4d..7acf6f1 100644 --- a/Makefile +++ b/Makefile @@ -11,12 +11,10 @@ test: ${MAKE} clean unit: - ${CASK} exec ert-runner + ${CASK} exec buttercup -L . build: ${CASK} build clean: ${CASK} clean-elc - -.PHONY: test diff --git a/test/test-helper.el b/test/test-helper.el deleted file mode 100644 index f56c5d7..0000000 --- a/test/test-helper.el +++ /dev/null @@ -1,18 +0,0 @@ -;;; webpaste --- Test helper for loading webpaste in unit tests -;;; Commentary: -;;; Code: -(require 'f) -(require 'ert) -(require 'undercover) - -(defvar webpaste-test/test-path - (f-parent (f-this-file))) - -(defvar webpaste-test/root-path - (f-parent webpaste-test/test-path)) - -(undercover "webpaste.el") - -(require 'webpaste (f-expand "webpaste" webpaste-test/root-path)) - -;;; test-helper.el ends here diff --git a/test/webpaste-test.el b/test/webpaste-test.el deleted file mode 100644 index 6b713c4..0000000 --- a/test/webpaste-test.el +++ /dev/null @@ -1,238 +0,0 @@ -;;; webpaste --- Tests for webpaste -;;; Commentary: -;;; Code: -(require 'ert) -(require 'cl-lib) -(require 'webpaste) - - - -(ert-deftest webpaste-test/provider () - "Test creation of providers." - - (let ((used-lambda nil) - (provider (webpaste-provider - :uri "http://invalid-domain-name/" - :post-field "data" - :sync t - :success-lambda (cl-function - (lambda (&key data &allow-other-keys) - (setq used-lambda "success"))) - :error-lambda (cl-function - (lambda (&key error-thrown &allow-other-keys) - (setq used-lambda "error")))))) - - (funcall provider "dummy-text") - - (should (equal "error" used-lambda))) - - (let ((used-lambda nil) - (provider (webpaste-provider - :uri "https://httpbin.org/status/200" - :post-field "data" - :sync t - :success-lambda (cl-function - (lambda (&key data &allow-other-keys) - (setq used-lambda "success"))) - :error-lambda (cl-function - (lambda (&key error-thrown &allow-other-keys) - (setq used-lambda "error")))))) - - (funcall provider "dummy-text") - - (should (equal "success" used-lambda)))) - - - -(ert-deftest webpaste-test/paste-region-and-buffer () - "Test pasting of regions and buffers." - - ;; Override pasting function to just return the inserted string - (cl-letf (((symbol-function 'webpaste-paste-text) - (lambda (text) text))) - - ;; Set up a temporary buffer - (with-temp-buffer - ;; With README as content - (insert-file-contents "README.org") - - ;; And make sure that the paste buffer function returns the same as we had - ;; in the buffer. - (should (equal (webpaste-paste-buffer) (buffer-string))) - - ;; Test so webpaste-paste-region selects the same part of the buffer as to - ;; be expected. - (should (equal (webpaste-paste-region 10 100) - (buffer-substring 10 100))) - - ;; Test when wanting a paste confirmation - (let ((webpaste/paste-confirmation t)) - - ;; Override yes-or-no-p to immitate "yes" response - (cl-letf (((symbol-function 'yes-or-no-p) (lambda (text) t))) - - (should (equal (webpaste-paste-buffer) (buffer-string))) - - (should (equal (webpaste-paste-region 10 100) - (buffer-substring 10 100)))) - - ;; Override yes-or-no-p to immitate "no" response - (cl-letf (((symbol-function 'yes-or-no-p) (lambda (text) nil))) - - (should (not (equal (webpaste-paste-buffer) (buffer-string)))) - - (should (not (equal (webpaste-paste-region 10 100) - (buffer-substring 10 100))))))))) - - - -(ert-deftest webpaste-test/return-url () - "Test returning of URL's to the user." - - ;; Override browse-url-generic to set a variable to t if triggered - (cl-letf (((symbol-function 'browse-url-generic) - (lambda (url) (setq webpaste-test/opened-in-browser t)))) - - ;; Test to return a link and check that the message logged is the one we expect - (let ((webpaste/open-in-browser nil)(webpaste-test/opened-in-browser nil)) - (should (equal - (webpaste-return-url "https://example.com/") - "Added \"https://example.com/\" to kill ring.")) - - ;; Check so the kill ring contain the correct contents - (should (equal (car kill-ring) "https://example.com/")) - - ;; Check so the link wasn't opened in a browser - (should (equal webpaste-test/opened-in-browser nil))) - - ;; Test that we call browse-url-generic with the link if option to open in - ;; browser is set - (let ((webpaste/open-in-browser t)(webpaste-test/opened-in-browser nil)) - (webpaste-return-url "https://example.com/") - - (should (equal webpaste-test/opened-in-browser t)))) - - ;; Test appending of language to links when returning - (let ((webpaste/provider-separators - '(("https://example.com/" . "?lang="))) - (webpaste/provider-lang-alists - '(("https://example.com/" . ((fundamental-mode . "text")))))) - - (should (equal (webpaste-return-url "https://example.com/") - "Added \"https://example.com/?lang=text\" to kill ring.")))) - - - -(ert-deftest webpaste-test/get-provider-priority () - "Test how it populates webpaste/get-provider-priority." - - ;; Test autopopulation of list based on providers avaliable - (let ((webpaste-provider-priority nil) - (webpaste-providers-alist '(("provider1" . "lambda") - ("provider2" . "lambda") - ("provider3" . "lambda")))) - ;; Do test - (should (equal (webpaste/get-provider-priority) - '("provider1" "provider2" "provider3")))) - - ;;; Test static population of provider priority - (let ((webpaste-provider-priority '("provider2" "provider1" "provider3")) - (webpaste-providers-alist nil)) - ;; Do test - (should (equal (webpaste/get-provider-priority) - '("provider2" "provider1" "provider3"))))) - - - -(ert-deftest webpaste-test/callback-from-working-provider () - "This test just sends a message to a good provider that just works." - - ;; Temporal storage for result - (let ((returned-result nil) - (webpaste-tested-providers nil) - (webpaste-provider-priority nil)) - - ;; Make a fake provider that just "returns" the paste result by setting a - ;; variable and concatinate it with "Works: " so we can see it showing up - (setq-default webpaste-providers-alist - `(("workingprovider" - ,(lambda (text) - (setq returned-result - (concat "Works: " text)))))) - - ;; Call webpaste - (webpaste-paste-text "test-string") - - ;; Check that we got the expected result - (should (string= returned-result "Works: test-string")))) - - - -(ert-deftest webpaste-test/callback-from-working-provider-as-fallback () - "This test sends a message to a bad provider that returns some error data. - -Then the bad provider pastes again like it should and we check that we got the -result from the good provider only." - - ;; Temporal storage for result - (let ((returned-result nil) - (webpaste-tested-providers nil) - (webpaste-provider-priority nil)) - - ;; Creates a "broken" provider that will call on the next provider due to a - ;; faked failure and checks that the next provider is picked up correctly. - (setq-default webpaste-providers-alist - `(("brokenprovider" - ,(lambda (text) - ;; Set return text - (setq returned-result - (concat "Broken: " text)) - - ;; Call paste again - (webpaste-paste-text text))) - - ("workingprovider" - ,(lambda (text) - (setq returned-result - (concat "Working: " text)))))) - - ;; Call webpaste - (webpaste-paste-text "test-string") - - ;; Check that we got the expected result - (should (string= returned-result "Working: test-string")))) - - - -(ert-deftest webpaste-test/get-lang-alist-with-overrides () - "This test tests all cases that should happen when overriding langs." - - (let ((webpaste/default-lang-alist '((python-mode . "python") - (php-mode . "php")))) - - ;; Test adding mode - (should (equal (webpaste/get-lang-alist-with-overrides - '((emacs-lisp-mode . "lisp"))) - - '((emacs-lisp-mode . "lisp") - (python-mode . "python") - (php-mode . "php")))) - - ;; Test removing mode / clearing it's value - (should (equal (webpaste/get-lang-alist-with-overrides - '((python-mode . nil))) - - '((python-mode) - (python-mode . "python") - (php-mode . "php")))) - - ;; Test overriding mode - (should (equal (webpaste/get-lang-alist-with-overrides - '((python-mode . "python3"))) - - '((python-mode . "python3") - (python-mode . "python") - (php-mode . "php")))))) - - -;;; webpaste-test.el ends here diff --git a/tests/load-undercover.el b/tests/load-undercover.el new file mode 100644 index 0000000..1d08a0b --- /dev/null +++ b/tests/load-undercover.el @@ -0,0 +1,8 @@ +;;; load-undercover --- Helper to load undercoverr +;;; Commentary: +;;; Code: + +(when (require 'undercover nil t) + (undercover "*.el")) + +;;; load-undercover.el ends here diff --git a/tests/test-webpaste-get-provider-priority.el b/tests/test-webpaste-get-provider-priority.el new file mode 100644 index 0000000..af5d62b --- /dev/null +++ b/tests/test-webpaste-get-provider-priority.el @@ -0,0 +1,34 @@ +;;; test-webpaste-get-provider-priority.el --- Tests for webpaste +;;; Commentary: +;;; Code: + +(load "tests/load-undercover.el") +(require 'webpaste) + +(describe + "Get provider priority" + (it + "can autopopulate provider priority if it's not predefined" + + (let ((webpaste-provider-priority nil) + (webpaste-providers-alist '(("provider1" . "lambda") + ("provider2" . "lambda") + ("provider3" . "lambda")))) + + ;; Do test + (expect (webpaste/get-provider-priority) + :to-equal + '("provider1" "provider2" "provider3")))) + + + (it + "can fetch static population of provider priority" + + (let ((webpaste-provider-priority '("provider2" "provider1" "provider3"))) + + ;; Do test + (expect (webpaste/get-provider-priority) + :to-equal + '("provider2" "provider1" "provider3"))))) + +;;; test-webpaste-get-provider-priority.el ends here diff --git a/tests/test-webpaste-paste-region-and-buffer.el b/tests/test-webpaste-paste-region-and-buffer.el new file mode 100644 index 0000000..58c34f5 --- /dev/null +++ b/tests/test-webpaste-paste-region-and-buffer.el @@ -0,0 +1,84 @@ +;;; test-webpaste-paste-region-and-buffer.el --- Tests for webpaste +;;; Commentary: +;;; Code: + +(load "tests/load-undercover.el") +(require 'webpaste) + + +(describe + "Don't to paste region or buffer because of wrong answer to question" + + (before-each + (spy-on 'webpaste-paste-text) + (spy-on 'yes-or-no-p :and-return-value nil) + (setq webpaste/paste-confirmation t)) + + (after-each + (setq webpaste/paste-confirmation nil)) + + (it + "can't paste because of answer to question is no" + + ;; Paste buffer + (webpaste-paste-buffer) + (expect 'webpaste-paste-text :not :to-have-been-called) + + ;; Paste region + (webpaste-paste-region 10 100) + (expect 'webpaste-paste-text :not :to-have-been-called))) + + +(describe + "Paste region or buffer because of correct answer to question" + + (before-each + (spy-on 'webpaste-paste-text) + (spy-on 'yes-or-no-p :and-return-value t) + (setq webpaste/paste-confirmation t)) + + (after-each + (setq webpaste/paste-confirmation nil)) + + (it + "can paste because of answer to question is yes" + + ;; Populate buffer with some content + (with-temp-buffer + (insert-file-contents "README.org") + + ;; Paste buffer + (webpaste-paste-buffer) + (expect 'webpaste-paste-text :to-have-been-called-with (buffer-string)) + + ;; Paste region + (webpaste-paste-region 10 100) + (expect 'webpaste-paste-text + :to-have-been-called-with + (buffer-substring 10 100))))) + + +(describe + "Paste region and buffer without question being asked" + + (before-each + (spy-on 'webpaste-paste-text)) + + (it + "can paste entire buffers or regions" + + (with-temp-buffer + (insert-file-contents "README.org") + + ;; Paste buffer + (webpaste-paste-buffer) + (expect 'webpaste-paste-text :to-have-been-called-with (buffer-string)) + + ;; Paste region + (webpaste-paste-region 10 100) + (expect 'webpaste-paste-text + :to-have-been-called-with + (buffer-substring 10 100))))) + + +;;; test-webpaste-paste-region-and-buffer.el ends here diff --git a/tests/test-webpaste-paste-text.el b/tests/test-webpaste-paste-text.el new file mode 100644 index 0000000..042612c --- /dev/null +++ b/tests/test-webpaste-paste-text.el @@ -0,0 +1,67 @@ +;;; test-webpaste-paste-text.el --- Tests for webpaste +;;; Commentary: +;;; Code: + +(load "tests/load-undercover.el") +(require 'webpaste) + + +(describe + "Paste text to provider" + :var (webpaste/tested-providers) + + (before-each + ;; Override which fake providers exists + (spy-on 'webpaste/get-provider-priority + :and-return-value + '("provider1" "provider2")) + + ;; Don't allow it to try to paste, just fake it + (spy-on 'webpaste-paste-text-to-provider) + + ;; And let tested list be resetted for each test + (setq webpaste/tested-providers nil)) + + + (it + "can paste text to provider and try second provider if called again" + + ;; Let's paste to first provider + (webpaste-paste-text "my test text") + + ;; And check it was to first provider + (expect 'webpaste-paste-text-to-provider + :to-have-been-called-with + "my test text" + "provider1") + + ;; Let's paste to second provider + (webpaste-paste-text "my test text") + + ;; And check it was to second provider + (expect 'webpaste-paste-text-to-provider + :to-have-been-called-with + "my test text" + "provider2") + + ;; Check that the tested list is empty so another run would restart + (expect webpaste/tested-providers :to-equal nil))) + + +(describe + "Run provider lambda to paste text" + + (before-each + (let ((wp-lambda (lambda (text) text))) + (setq webpaste-providers-alist `(("provider1" ,wp-lambda) + ("provider2" ,wp-lambda))))) + + (it + "can get the lambda for the specified provider and run it" + + (expect (webpaste-paste-text-to-provider "my test text" "provider2") + :to-equal + "my test text"))) + + +;;; test-webpaste-paste-text.el ends here diff --git a/tests/test-webpaste-provider-creation.el b/tests/test-webpaste-provider-creation.el new file mode 100644 index 0000000..5b031f4 --- /dev/null +++ b/tests/test-webpaste-provider-creation.el @@ -0,0 +1,77 @@ +;;; test-webpaste-provider-creation.el --- Tests for webpaste +;;; Commentary: +;;; Code: + +(load "tests/load-undercover.el") +(require 'webpaste) + + +(describe + "Creation of providers" + :var (broken-provider working-provider) + + (before-each + (setq broken-provider + (webpaste-provider + :uri "http://invalid-domain-name/" + :post-field "data" + :sync t + :success-lambda (cl-function + (lambda (&key data &allow-other-keys) + (setq used-lambda "success"))) + :error-lambda (cl-function + (lambda (&key error-thrown &allow-other-keys) + (setq used-lambda "error"))))) + + (setq working-provider + (webpaste-provider + :uri "https://httpbin.org/status/200" + :post-field "data" + :sync t + :success-lambda (cl-function + (lambda (&key data &allow-other-keys) + (setq used-lambda "success"))) + :error-lambda (cl-function + (lambda (&key error-thrown &allow-other-keys) + (setq used-lambda "error")))))) + + + (it + "can trigger the error lambda of a provider" + (let ((used-lambda nil)) + (funcall broken-provider "my test text") + + (expect used-lambda :to-equal "error"))) + + + (it + "can trigger the success lambda of a provider" + (let ((used-lambda nil)) + (funcall broken-provider "my test text") + + (expect used-lambda :to-equal "error"))) + + (it + "can failover from a broken provider" + + (spy-on 'message) + (spy-on 'error) + + (let ((used-lambda nil) + (provider (webpaste-provider + :uri "http://invalid-domain-name/" + :post-field "data" + :sync t + :success-lambda (cl-function + (lambda (&key data &allow-other-keys) + (setq used-lambda "success"))) + :error-lambda (cl-function + (lambda (&key error-thrown &allow-other-keys) + (funcall working-provider "failover")))))) + + (funcall provider "text") + + (expect used-lambda :to-equal "success")))) + + +;;; test-webpaste-provider-creation.el ends here diff --git a/tests/test-webpaste-return-url.el b/tests/test-webpaste-return-url.el new file mode 100644 index 0000000..ad55749 --- /dev/null +++ b/tests/test-webpaste-return-url.el @@ -0,0 +1,59 @@ +;;; test-webpaste-return-url.el --- Tests for webpaste +;;; Commentary: +;;; Code: + +(load "tests/load-undercover.el") +(require 'webpaste) + + +(describe + "Returning URLs to the user" + + (before-each + (spy-on 'message) + (spy-on 'kill-new) + (spy-on 'browse-url-generic)) + + (it + "can put in kill-ring and message the user" + + (webpaste-return-url "https://example.com/") + + (expect 'browse-url-generic :not :to-have-been-called) + + (expect 'message + :to-have-been-called-with + "Added %S to kill ring." "https://example.com/") + + (expect 'kill-new + :to-have-been-called-with + "https://example.com/")) + + (it + "can open an external browser with the url" + + (let ((webpaste/open-in-browser t)) + (webpaste-return-url "https://example.com/") + + (expect 'browse-url-generic + :to-have-been-called-with + "https://example.com/"))) + + (it + "can append language on return" + + (let ((webpaste/provider-separators + '(("https://example.com/" . "?lang="))) + (webpaste/provider-lang-alists + '(("https://example.com/" . ((lisp-interaction-mode . "lisp")))))) + + (spy-calls-reset 'kill-new) + + (webpaste-return-url "https://example.com/") + + (expect 'kill-new + :to-have-been-called-with + "https://example.com/?lang=lisp")))) + + +;;; test-webpaste-return-url.el ends here diff --git a/tests/test-webpaste.el b/tests/test-webpaste.el new file mode 100644 index 0000000..8c9af65 --- /dev/null +++ b/tests/test-webpaste.el @@ -0,0 +1,14 @@ +;;; test-webpaste.el --- Tests for webpaste +;;; Commentary: +;;; Code: + +(load "tests/load-undercover.el") +(require 'webpaste) + +(describe "The feature" + (it "can use bug and feature" + (expect t + :to-equal + t))) + +;;; test-webpaste.el ends here