[nongnu] elpa/webpaste e87a37c 158/298: Switched from ert to buttercup for testing

[ELPA Syncer]

branch: elpa/webpaste
commit e87a37cdcfc6e0b40216cc16c8d2793acd5e10d2
Author: Elis Axelsson <elis.axelsson@gmail.com>
Commit: Elis Axelsson <elis.axelsson@gmail.com>

    Switched from ert to buttercup for testing
    
    Squashed commit of the following:
    
    commit a30392580e74d209025b17477387de3be2eab5ad
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Sat May 20 15:13:43 2017 +0200
    
        Added test for appending of language on return
    
    commit bc79bb4df16a16864810fdf67c4ee8b447b47722
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Sat May 20 14:24:02 2017 +0200
    
        Added test for failover testing
    
    commit ba7210503165d1a6bda30f6d1cdb3a437d8c8801
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Sat May 20 13:57:05 2017 +0200
    
        Added test for triggering success lambda
    
    commit 85acab8052a73b7c723f86b4d3ab40072c1c232e
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Sat May 20 13:50:12 2017 +0200
    
        Added test to trigger error lambda for a provider
    
    commit da272a6d3831651a9d0efc24449353541b209146
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Sat May 20 12:13:41 2017 +0200
    
        Check if it can open a browser
    
    commit 46da19799de01ae6838e17d54c114b4b33b9552f
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Sat May 20 11:55:11 2017 +0200
    
        Fix test for webaste-paste-text-to-provider
    
    commit 984caed0a69043aa66e5fa5f20fa28d40891e38a
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Thu May 18 21:43:52 2017 +0200
    
        Added first test for returning of links to the user
    
    commit 32bd218f49586a536c9f80d9fa674ec09cb9add7
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Thu May 18 17:19:50 2017 +0200
    
        Disable test because it fails all the time on travis
    
    commit 4fb1521f847810e614d66bb69a95551b23fcb1ca
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Wed May 17 18:55:42 2017 +0200
    
        Added buttercup test for calling of the provider lambda
    
    commit c850899b27c4eade94e7afa44cd9b28c49c6b558
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Wed May 17 18:22:55 2017 +0200
    
        Added buttercup test for pasting of regions and buffers
    
    commit b09c6c8f1944b956df6d3e7ca9f92bbc04937b28
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Tue May 16 23:50:12 2017 +0200
    
        Added test to test failover of pasting text to any provider
    
    commit 1bfe835a15170840f5044ab84f108d0a2e0ac928
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Tue May 16 22:25:22 2017 +0200
    
        Added buttercup tests for webpaste/get-provider-priority
    
    commit 0703e8a0ea4787e5fdc143bf1ce59464d93837e0
    Author: Elis Axelsson <elis.axelsson@gmail.com>
    Date:   Tue May 16 21:09:23 2017 +0200
    
        Setup of buttercup, cask and undercover and placeholder file for tests
---
 Cask                                           |   8 +-
 Makefile                                       |   4 +-
 test/test-helper.el                            |  18 --
 test/webpaste-test.el                          | 238 -------------------------
 tests/load-undercover.el                       |   8 +
 tests/test-webpaste-get-provider-priority.el   |  34 ++++
 tests/test-webpaste-paste-region-and-buffer.el |  84 +++++++++
 tests/test-webpaste-paste-text.el              |  67 +++++++
 tests/test-webpaste-provider-creation.el       |  77 ++++++++
 tests/test-webpaste-return-url.el              |  59 ++++++
 tests/test-webpaste.el                         |  14 ++
 11 files changed, 345 insertions(+), 266 deletions(-)

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