Move unit tests from ert to buttercup

Easier to organize and write. Now I can hopefully strive for better
coverage!
This commit is contained in:
Henrik Lissner 2018-06-15 03:31:54 +02:00
parent 98d2f1de3f
commit eaca8c58fa
No known key found for this signature in database
GPG key ID: 5F6C0EA160557395
41 changed files with 1371 additions and 1101 deletions

View file

@ -1,21 +0,0 @@
;; -*- lexical-binding: t; no-byte-compile: t; -*-
;;; completion/company/test/company.el
;;
(def-test! set-company-backend
:minor-mode company-mode
(let ((company-backends '(default)))
(set! :company-backend 'emacs-lisp-mode '(backend-1))
(set! :company-backend 'lisp-interaction-mode 'backend-1 'backend-2)
(set! :company-backend 'text-mode 'backend-1)
(with-temp-buffer
(emacs-lisp-mode)
(should (equal company-backends '((backend-1) default))))
(with-temp-buffer
(lisp-interaction-mode)
(should (equal company-backends '(backend-1 backend-2 default))))
(with-temp-buffer
(text-mode)
(should (equal company-backends '(backend-1 default))))
;; global backends shouldn't be affected
(should (equal company-backends '(default)))))

View file

@ -0,0 +1,44 @@
;; -*- lexical-binding: t; no-byte-compile: t; -*-
;;; completion/company/test/test-company.el
(load! "../autoload")
;;
(xdescribe "completion/company"
:var (company-backends)
(before-all
(provide 'company))
(after-all
(unload-feature 'company t))
(describe ":company-backend"
:var (text-mode-hook company-backends)
(before-each
(setq company-backends '(default)
text-mode-hook nil))
(it "adds grouped backends"
(set-company-backend! 'text-mode '(backend-1))
(with-temp-buffer
(text-mode)
(expect company-backends :to-equal '((backend-1) default))))
(it "adds multiple backends"
(set-company-backend! 'text-mode 'backend-1 'backend-2)
(with-temp-buffer
(text-mode)
(expect company-backends :to-equal '(backend-1 backend-2 default))))
(it "adds single backend"
(set-company-backend! 'text-mode 'backend-1)
(with-temp-buffer
(text-mode)
(expect company-backends :to-equal '(backend-1 default))))
(it "overwrites past values"
(set-company-backend! 'text-mode 'backend-1)
(set-company-backend! 'text-mode 'backend-2)
(with-temp-buffer
(text-mode)
(expect company-backends :to-equal '(backend-2 default))))))

View file

@ -18,6 +18,36 @@
`(set-evil-initial-state! ,modes ,state))
;;
;; Custom arguments / interactive codes
;;
;;;###autoload
(after! evil
;; These arg types will highlight matches in the current buffer
(evil-ex-define-argument-type buffer-match :runner +evil-ex-buffer-match)
(evil-ex-define-argument-type global-match :runner +evil-ex-global-match)
;; Other commands can make use of this
(evil-define-interactive-code "<//>"
:ex-arg buffer-match (list (if (evil-ex-p) evil-ex-argument)))
(macroexpand '
(evil-define-interactive-code "<//g>"
:ex-arg global-match (list (if (evil-ex-p) evil-ex-argument))))
;; By default :g[lobal] doesn't highlight matches in the current buffer. I've
;; got to write my own argument type and interactive code to get it to do so.
(evil-ex-define-argument-type global-delim-match :runner +evil-ex-global-delim-match)
(dolist (sym '(evil-ex-global evil-ex-global-inverted))
(evil-set-command-property sym :ex-arg 'global-delim-match))
;; Forward declare these so that ex completion works, even if the autoloaded
;; functions aren't loaded yet.
(evil-set-command-properties
'+evil:align :move-point t :ex-arg 'buffer-match :ex-bang t :evil-mc t :keep-visual t :suppress-operator t)
(evil-set-command-properties
'+evil:mc :move-point nil :ex-arg 'global-match :ex-bang t :evil-mc t))
;;
;; Commands
;;

View file

@ -141,28 +141,6 @@ variable for an explanation of the defaults (in comments). See
(advice-add #'evil-window-split :override #'+evil*window-split)
(advice-add #'evil-window-vsplit :override #'+evil*window-vsplit)
;; By default :g[lobal] doesn't highlight matches in the current buffer. I've
;; got to write my own argument type and interactive code to get it to do so.
(evil-ex-define-argument-type global-delim-match :runner +evil-ex-global-delim-match)
(dolist (sym '(evil-ex-global evil-ex-global-inverted))
(evil-set-command-property sym :ex-arg 'global-delim-match))
;; These arg types will highlight matches in the current buffer
(evil-ex-define-argument-type buffer-match :runner +evil-ex-buffer-match)
(evil-ex-define-argument-type global-match :runner +evil-ex-global-match)
;; Other commands can make use of this
(evil-define-interactive-code "<//>"
:ex-arg buffer-match (list (if (evil-ex-p) evil-ex-argument)))
(evil-define-interactive-code "<//g>"
:ex-arg global-match (list (if (evil-ex-p) evil-ex-argument)))
;; Forward declare these so that ex completion works, even if the autoloaded
;; functions aren't loaded yet.
(evil-set-command-properties
'+evil:align :move-point t :ex-arg 'buffer-match :ex-bang t :evil-mc t :keep-visual t :suppress-operator t)
(evil-set-command-properties
'+evil:mc :move-point nil :ex-arg 'global-match :ex-bang t :evil-mc t)
;; Ensure jump points are created
(defun +evil*set-jump (&rest _)
(evil-set-jump))

View file

@ -1,47 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; feature/evil/test/autoload-files.el
(defmacro with-temp-files!! (src dest &rest body)
"Run FORMS in the context of a temporary package setup (as in, it won't
affects your Emacs packages)."
(declare (indent 2) (doc-string 3))
`(let ((it ,src)
(other ,dest))
(with-temp-file it
(insert "Hello world"))
(with-minor-mode! projectile-mode
(unwind-protect
(progn
(should (file-exists-p it))
(find-file-literally it)
(should (equal (buffer-string) "Hello world"))
(should (equal (buffer-file-name) it))
(let ((inhibit-message (not doom-debug-mode)))
,@body))
(ignore-errors (delete-file it))
,(if dest `(ignore-errors (delete-file other)))))))
;;
(def-test! move-this-file
":mv"
(with-temp-files!! "/tmp/doom-buffer" "/tmp/doom-buffer-new"
(should-error (+evil:move-this-file it))
(should (+evil:move-this-file other t))
(should (file-exists-p other))
(should (not (file-exists-p it)))))
(def-test! copy-this-file
":cp"
(with-temp-files!! "/tmp/doom-buffer-2" "/tmp/doom-buffer-2-new"
(should-error (+evil:copy-this-file it))
(should (+evil:copy-this-file other t))
(should (file-exists-p other))
(should (file-exists-p it))))
(def-test! delete-this-file
":rm"
(with-temp-files!! "/tmp/doom-buffer-3" nil
(should-error (+evil:delete-this-file "this-file-does-not-exist"))
(should (+evil:delete-this-file nil t))
(should (not (file-exists-p it)))))

View file

@ -1,59 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; feature/evil/test/evil.el
;;
;; `evil-ex-replace-special-filenames'
(def-test! resolve-vim-path
(cl-flet ((do-it #'evil-ex-replace-special-filenames))
;; file modifiers
(let ((buffer-file-name "~/.emacs.d/test/modules/feature/test-evil.el")
(default-directory "~/.emacs.d/test/modules/"))
(should (equal (do-it "%") "feature/test-evil.el"))
(should (equal (do-it "%:r") "feature/test-evil"))
(should (equal (do-it "%:r.elc") "feature/test-evil.elc"))
(should (equal (do-it "%:e") "el"))
(should (equal (do-it "%:p") (expand-file-name buffer-file-name)))
(should (equal (do-it "%:h") "feature"))
(should (equal (do-it "%:t") "test-evil.el"))
(should (equal (do-it "%:.") "feature/test-evil.el"))
(should (equal (do-it "%:~") "~/.emacs.d/test/modules/feature/test-evil.el"))
(should (equal (file-truename (do-it "%:p"))
(file-truename buffer-file-name))))
;; nested file modifiers
(let ((buffer-file-name "~/vim/src/version.c")
(default-directory "~/vim/"))
(should (equal (do-it "%:p") (expand-file-name "~/vim/src/version.c")))
(should (equal (do-it "%:p:.") "src/version.c"))
(should (equal (do-it "%:p:~") "~/vim/src/version.c"))
(should (equal (do-it "%:h") "src"))
(should (equal (do-it "%:p:h") (expand-file-name "~/vim/src")))
(should (equal (do-it "%:p:h:h") (expand-file-name "~/vim")))
(should (equal (do-it "%:t") "version.c"))
(should (equal (do-it "%:p:t") "version.c"))
(should (equal (do-it "%:r") "src/version"))
(should (equal (do-it "%:p:r") (expand-file-name "~/vim/src/version")))
(should (equal (do-it "%:t:r") "version")))
;; empty file modifiers
(let (buffer-file-name default-directory)
(should (equal (do-it "%") ""))
(should (equal (do-it "%:r") ""))
(should (equal (do-it "%:e") ""))
(should (equal (do-it "%:h") ""))
(should (equal (do-it "%:t") ""))
(should (equal (do-it "%:.") ""))
(should (equal (do-it "%:~") ""))
(should (equal (do-it "%:P") "")))))
(def-test! file-modifiers
(cl-flet ((do-it #'evil-ex-replace-special-filenames))
(let ((buffer-file-name "~/.emacs.d/test/modules/feature/test-evil.el")
(default-directory "~/.emacs.d/test/modules/"))
(should (equal (do-it "%:s?e?x?") "fxature/test-evil.el"))
(should (equal (do-it "%:gs?e?x?") "fxaturx/txst-xvil.xl")))))
(def-test! empty-file-modifiers
(cl-flet ((do-it #'evil-ex-replace-special-filenames))
(let (buffer-file-name default-directory)
(should (equal (do-it "%:s?e?x?") ""))
(should (equal (do-it "%:gs?e?x?") "")))))

View file

@ -0,0 +1,66 @@
;; -*- no-byte-compile: t; -*-
;;; feature/evil/test/test-evil.el
(describe "feature/evil"
:var (resv project-root)
(before-all (require 'evil))
(after-all (unload-feature 'evil t))
(before-each
(fset 'resv #'+evil*resolve-vim-path)
(spy-on 'doom-project-root :and-call-fake (lambda () project-root)))
;; `evil-ex-replace-special-filenames' / `+evil*resolve-vim-path'
(describe "file modifiers"
(it "supports basic vim file modifiers"
(let ((buffer-file-name "~/.emacs.d/test/modules/feature/test-evil.el")
(default-directory "~/.emacs.d/test/modules/")
(project-root "~/.emacs.d/"))
(expect (resv "%") :to-equal "feature/test-evil.el")
(expect (resv "%:r") :to-equal "feature/test-evil")
(expect (resv "%:r.elc") :to-equal "feature/test-evil.elc")
(expect (resv "%:e") :to-equal "el")
(expect (resv "%:p") :to-equal (expand-file-name buffer-file-name))
(expect (resv "%:h") :to-equal "feature")
(expect (resv "%:t") :to-equal "test-evil.el")
(expect (resv "%:.") :to-equal "feature/test-evil.el")
(expect (resv "%:~") :to-equal "~/.emacs.d/test/modules/feature/test-evil.el")
(expect (file-truename (resv "%:p"))
:to-equal (file-truename buffer-file-name))))
(it "supports nested vim file modifiers"
(let ((buffer-file-name "~/vim/src/version.c")
(default-directory "~/vim/")
(project-root "~/vim/"))
(expect (resv "%:p") :to-equal (expand-file-name "~/vim/src/version.c"))
(expect (resv "%:p:.") :to-equal "src/version.c")
(expect (resv "%:p:~") :to-equal "~/vim/src/version.c")
(expect (resv "%:h") :to-equal "src")
(expect (resv "%:p:h") :to-equal (expand-file-name "~/vim/src"))
(expect (resv "%:p:h:h") :to-equal (expand-file-name "~/vim"))
(expect (resv "%:t") :to-equal "version.c")
(expect (resv "%:p:t") :to-equal "version.c")
(expect (resv "%:r") :to-equal "src/version")
(expect (resv "%:p:r") :to-equal (expand-file-name "~/vim/src/version"))
(expect (resv "%:t:r") :to-equal "version")))
(it "cleans up empty file modifiers"
(let (buffer-file-name default-directory)
(expect (resv "%") :to-equal "")
(expect (resv "%:r") :to-equal "")
(expect (resv "%:e") :to-equal "")
(expect (resv "%:h") :to-equal "")
(expect (resv "%:t") :to-equal "")
(expect (resv "%:.") :to-equal "")
(expect (resv "%:~") :to-equal "")
(expect (resv "%:P") :to-equal "")))
(it "supports substitution modifiers"
(let ((buffer-file-name "~/.emacs.d/test/modules/feature/test-evil.el")
(default-directory "~/.emacs.d/test/modules/"))
(expect (resv "%:s?e?x?") :to-equal "fxature/test-evil.el")
(expect (resv "%:gs?e?x?") :to-equal "fxaturx/txst-xvil.xl")))
(it "cleans up empty substitution modifiers"
(let (buffer-file-name default-directory)
(expect (resv "%:s?e?x?") :to-equal "")
(expect (resv "%:gs?e?x?") :to-equal "")))))

View file

@ -1,124 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; feature/workspaces/test/autoload-workspaces.el
(require! :feature workspaces)
(doom|init-custom-hooks)
(defmacro with-workspace!! (buffer-args &rest body)
(declare (indent defun))
(let ((buffers
(cl-loop for bsym in buffer-args
collect `(,bsym (get-buffer-create ,(symbol-name bsym))))))
`(let ((persp-auto-resume-time -1)
(persp-auto-save-opt 0))
(require 'persp-mode)
(let (noninteractive)
(persp-mode +1))
(let (persp-before-switch-functions persp-activated-functions)
(+workspace-switch +workspaces-main t))
(let* (,@buffers)
(cl-loop with persp = (get-current-persp)
for buf in (list ,@(mapcar #'car buffers))
do (persp-add-buffer buf persp)
do (with-current-buffer buf
(setq buffer-file-name (make-temp-file "workspaces-test-"))))
,@body
(let (kill-buffer-query-functions kill-buffer-hook)
(mapc #'kill-buffer (list ,@(mapcar #'car buffers)))))
(let (noninteractive)
(persp-mode -1)))))
;; `+workspaces|init'
(def-test! init
(with-workspace!! ()
(should (equal (+workspace-current-name) +workspaces-main))))
;; `+workspaces*auto-add-buffer'
(def-test! auto-add-buffer-to-persp
(let ((a (generate-new-buffer "a")))
(doom-set-buffer-real a t)
(with-workspace!! ()
(should-not (+workspace-contains-buffer-p a))
(switch-to-buffer a)
(should (+workspace-contains-buffer-p a)))))
;; `+workspace-current'
;; `+workspace-current-name'
(def-test! current
(with-workspace!! ()
(should (equal (+workspace-current-name) +workspaces-main))
(should (+workspace-exists-p +workspaces-main))
(let ((workspace (+workspace-get +workspaces-main))
(current-workspace (+workspace-current)))
(should workspace)
(should (+workspace-p workspace))
(should (+workspace-p current-workspace))
(should (equal workspace current-workspace)))))
;; `+workspace-list'
;; `+workspace-list-names'
(def-test! workspace-list
(with-workspace!! ()
(should (equal (+workspace-list-names)
(list (+workspace-current-name))))
(should (equal (+workspace-list)
(list (+workspace-current))))))
;; `+workspace-new'
;; `+workspace-rename'
;; `+workspace-delete'
(def-test! workspace-crud
"Creating, reading, updating and deleting workspaces."
(with-workspace!! ()
(let ((new-workspace-name "*new-test*")
(renamed-workspace-name "*old-test*"))
(should (+workspace-new new-workspace-name))
(should (seq-contains (+workspace-list-names) new-workspace-name))
(should (equal new-workspace-name
(+workspace-rename new-workspace-name renamed-workspace-name)))
(should-not (seq-contains (+workspace-list-names) new-workspace-name))
(should (seq-contains (+workspace-list-names) renamed-workspace-name))
(should (= (length (+workspace-list-names)) 2))
(+workspace-delete renamed-workspace-name)
(should (= (length (+workspace-list-names)) 1)))))
;; `+workspace-switch'
(def-test! workspace-switch
(with-workspace!! ()
(let ((new-workspace-name "*new-test*"))
(should-error (+workspace-switch new-workspace-name))
(should (+workspace-switch new-workspace-name t))
(should (equal (+workspace-current-name) new-workspace-name)))))
;; `+workspace-buffer-list'
;; `+workspace-contains-buffer-p'
(def-test! buffer-list
(with-workspace!! (a b)
(let ((c (get-buffer-create "c"))
(d (get-buffer-create "d")))
(should (+workspace-contains-buffer-p a))
(should (+workspace-contains-buffer-p b))
(should-not (+workspace-contains-buffer-p c))
;; New (and real) buffers should be added to workspace buffer list.
(doom-set-buffer-real c t)
(switch-to-buffer "c")
(should (+workspace-contains-buffer-p c))
;; unreal buffers shouldn't
(switch-to-buffer "d")
(should-not (+workspace-contains-buffer-p d)))))
;; `+workspace/close-window-or-workspace'
(def-test! close-window-or-workspace
(with-workspace!! (a b)
(let ((ws (+workspace-current-name))
(inhibit-message t))
(+workspace-switch "test" t)
(split-window)
(should (equal (+workspace-current-name) "test"))
(should (= (length (doom-visible-windows)) 2))
;; kill window if more than one
(+workspace/close-window-or-workspace)
(should (= (length (doom-visible-windows)) 1))
;; kill workspace on last window
(+workspace/close-window-or-workspace)
(should (equal (+workspace-current-name) "main")))))

View file

@ -0,0 +1,135 @@
;; -*- no-byte-compile: t; -*-
;;; feature/workspaces/test/test-workspaces.el
(describe "feature/workspaces"
:var (persp-auto-resume-time
persp-auto-save-opt
persp-switch-to-added-buffer
in1 in2 out1 out2
persp1 persp1-name persp2 persp2-name
doom-before-switch-buffer-hook
doom-after-switch-buffer-hook)
(before-all
(require! :feature workspaces)
(require 'persp-mode))
(after-all
(unload-feature 'persp-mode t))
(before-each
(setq persp-auto-resume-time -1
persp-auto-save-opt 0
persp-switch-to-added-buffer nil
in1 (get-buffer-create "a")
in2 (get-buffer-create "b")
out1 (get-buffer-create "c")
out2 (get-buffer-create "d"))
(doom-set-buffer-real in1 t)
(doom-set-buffer-real out1 t)
(let (noninteractive)
(persp-mode +1))
(let (persp-before-switch-functions persp-activated-functions)
(setq persp1-name +workspaces-main
persp1 (persp-add-new persp1-name)
persp2-name "test"
persp2 (persp-add-new persp2-name))
(persp-frame-switch +workspaces-main))
(delete-other-windows)
(switch-to-buffer in1)
(persp-add-buffer (list in1 in2))
(spy-on 'persp-add-buffer :and-call-through)
(doom|init-custom-hooks))
(after-each
(doom|init-custom-hooks 'disable)
(let (kill-buffer-query-functions kill-buffer-hook)
(mapc #'kill-buffer (list in1 in2 out1 out2)))
(let (noninteractive)
(mapc #'persp-kill (cdr (persp-names)))
(persp-mode -1)))
;;
(describe "switch"
(it "throws an error when switching to a non-existent workspace"
(expect (+workspace-switch "non-existent") :to-throw))
(it "switches to a valid workspace"
(+workspace-switch persp2-name)
(expect (+workspace-current-name) :to-equal persp2-name)))
(describe "current"
(it "returns the current workspace persp"
(expect (+workspace-p (+workspace-current)))
(expect (+workspace-current) :to-equal (get-current-persp)))
(it "returns the current workspace's name"
(expect (+workspace-current-name) :to-equal persp1-name)
(persp-switch (persp-name persp2))
(expect (+workspace-current-name) :to-equal persp2-name)))
(describe "exists-p"
(it "returns t for valid workspaces"
(expect (+workspace-exists-p persp1-name)))
(it "returns t for non-current (but valid) workspaces"
(expect (+workspace-exists-p persp2-name)))
(it "returns nil for non-existent workspaces"
(expect (+workspace-exists-p "non-existent") :to-be nil)))
(describe "buffer membership"
(it "returns t for buffers in current workspace"
(expect (+workspace-contains-buffer-p in1)))
(it "returns nil for buffers outside of current workspace"
(expect (+workspace-contains-buffer-p out1) :to-be nil))
(it "automatically adds interactively opened buffers"
(expect (+workspace-contains-buffer-p out1) :to-be nil)
(switch-to-buffer out1)
(expect (+workspace-contains-buffer-p out1)))
(xit "returns a list of orphaned buffers"
(expect (+workspace-orphaned-buffer-list) :to-contain out2)))
(describe "list"
(it "returns a list of names"
(expect (+workspace-list-names)
:to-have-same-items-as (list persp1-name persp2-name)))
(it "returns a list of perspective structs"
(expect (+workspace-list)
:to-have-same-items-as (list persp1 persp2))))
(describe "CRUD"
(it "creates new workspaces"
(+workspace-new "X")
(expect (+workspace-list-names) :to-contain "X"))
(it "renames an existing workspace"
(+workspace-rename persp2-name "X")
(expect (persp-name persp2) :to-equal "X")
(expect (+workspace-list-names)
:to-have-same-items-as (list persp1-name "X")))
(it "deletes a live workspace"
(+workspace-delete persp2-name)
(expect (+workspace-list-names) :not :to-contain persp2-name)))
(describe "command"
(describe "new"
(it "creates a new, blank workspace"
(quiet! (+workspace/new "X"))
(expect (one-window-p))
(expect (current-buffer) :to-be (doom-fallback-buffer)))
(it "clones a workspace"
(quiet! (+workspace/new "X" t))
(expect (current-buffer) :to-be in1)))
(describe "rename"
(it "renames the current workspace"
(quiet! (+workspace/rename "X"))
(expect (+workspace-current-name) :to-equal "X")))
(describe "close-window-or-workspace"
(before-each
(+workspace-switch persp2-name)
(split-window)
(expect (length (doom-visible-windows)) :to-be 2))
(it "kills window if more than one window"
(quiet! (+workspace/close-window-or-workspace))
(expect (length (doom-visible-windows)) :to-be 1))
(it "kills workspace on last window"
(quiet! (+workspace/close-window-or-workspace)
(+workspace/close-window-or-workspace))
(expect (+workspace-current-name) :to-equal persp1-name)))))

View file

@ -40,7 +40,7 @@
"Improve imenu support with better expression regexps and Doom-specific forms."
(setq imenu-generic-expression
'(("Evil Commands" "^\\s-*(evil-define-\\(?:command\\|operator\\|motion\\) +\\(\\_<[^ ()\n]+\\_>\\)" 1)
("Unit tests" "^\\s-*(\\(?:ert-deftest\\|def-test!\\) +\\(\\_<[^ ()\n]+\\_>\\)" 1)
("Unit tests" "^\\s-*(\\(?:ert-deftest\\|describe\\) +\"\\([^\")]+\\)\"" 1)
("Package" "^\\s-*(\\(?:def-\\)?package! +\\(\\_<[^ ()\n]+\\_>\\)" 1)
("Settings" "^\\s-*(def-setting! +\\([^ ()\n]+\\)" 1)
("Major modes" "^\\s-*(define-derived-mode +\\([^ ()\n]+\\)" 1)
@ -113,3 +113,11 @@
(def-project-mode! +emacs-lisp-ert-mode
:modes (emacs-lisp-mode)
:match "/test[/-].+\\.el$")
(associate! buttercup-minor-mode
:modes (emacs-lisp-mode)
:match "/test[/-].+\\.el$")
(after! buttercup
(set! :yas-minor-mode 'buttercup-minor-mode))

View file

@ -1,62 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; lang/org/test/autoload-org.el
(require! :lang org)
(defmacro should-org-buffer!! (source expected &rest body)
`(should-buffer! ,source ,expected
(org-mode)
,@body))
;;
;; `+org/insert-item'
(def-test! insert-item-h1
"Should append/prepend new first-level headers with an extra newline."
(should-org-buffer!! ("* {0}Header") ("* Header\n\n* {|}")
(+org/insert-item 'below))
(should-org-buffer!! ("* {0}Header") ("* {|}\n\n* Header")
(+org/insert-item 'above)))
(def-test! insert-item-h2
"Should append/prepend new second-level (and higher) headers without an extra
newline."
(should-org-buffer!! ("** {0}Header") ("** Header\n** {|}")
(+org/insert-item 'below))
(should-org-buffer!! ("** {0}Header") ("** {|}\n** Header")
(+org/insert-item 'above)))
(def-test! insert-item-plain-list
"Should append/prepend new second-level (and higher) headers without an extra
newline."
(should-org-buffer!! ("+ {0}List item") ("+ List item\n+ {|}")
(+org/insert-item 'below))
(should-org-buffer!! ("+ {0}List item"
" + Sub item")
("+ List item"
" + Sub item"
"+ {|}")
(+org/insert-item 'below))
(should-org-buffer!! ("+ {0}List item"
"+ Next item")
("+ List item"
"+ {|}"
"+ Next item")
(+org/insert-item 'below)))
(def-test! insert-item-numbered-list
"Should append/prepend new second-level (and higher) headers without an extra
newline."
(should-org-buffer!! ("1. {0}List item") ("1. List item\n2. {|}")
(+org/insert-item 'below))
(should-org-buffer!! ("1. {0}List item"
"2. Sub item")
("1. List item"
"2. {|}"
"3. Sub item")
(+org/insert-item 'below))
(should-org-buffer!! ("1. {0}List item"
"2. Next item")
("1. {|}"
"2. List item"
"3. Next item")
(+org/insert-item 'above)))

View file

@ -0,0 +1,145 @@
;; -*- no-byte-compile: t; -*-
;;; lang/org/test/test-autoload-org.el
(describe "lang/org"
;; `+org/insert-item'
(describe "insert-item"
(before-all
(require 'org)
(load! "../autoload/org.el"))
(after-all
(unload-feature 'org t))
(before-each
(set-buffer (get-buffer-create "org"))
(erase-buffer)
(delay-mode-hooks (org-mode)))
(after-each
(kill-buffer (get-buffer "org")))
(describe "headlines"
(it "appends first-level headlines with an extra newline"
(insert! "* {0}Header")
(+org/insert-item 'below)
(expect (eobp))
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal "* Header\n\n* "))
(it "prepends first-level headlines with an extra newline"
(insert! "* {0}Header")
(+org/insert-item 'above)
(expect (eolp))
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal "* \n\n* Header"))
(it "appends second-level headlines with an no extra newline"
(insert! "** {0}Header")
(+org/insert-item 'below)
(expect (eobp))
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal "** Header\n** "))
(it "prepends second-level headlines with an no extra newline"
(insert! "** {0}Header")
(+org/insert-item 'above)
(expect (eolp))
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal "** \n** Header"))
(it "appends headlines, skipping subtrees"
(insert! "** {0}First\n"
"*** sub 1\n"
"*** sub 2\n"
"**** subsub 1\n"
"** Header")
(+org/insert-item 'below)
(expect (eolp))
(expect (line-number-at-pos) :to-be 5)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal
(string-join '("** First"
"*** sub 1"
"*** sub 2"
"**** subsub 1"
"** "
"** Header")
"\n")))
(it "prepends headlines, skipping subtrees"
(insert! "** First\n"
"*** sub 1\n"
"*** sub 2\n"
"**** {0}subsub 1\n"
"** Header")
(+org/insert-item 'above)
(expect (eolp))
(expect (line-number-at-pos) :to-be 4)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal
(string-join '("** First"
"*** sub 1"
"*** sub 2"
"**** "
"**** subsub 1"
"** Header")
"\n"))))
(describe "plain lists"
(it "appends items"
(insert! "+ {0}List item")
(+org/insert-item 'below)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal "+ List item\n+ "))
(it "prepends items"
(insert! "+ {0}List item")
(+org/insert-item 'above)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal "+ \n+ List item"))
(it "appends items, but skips over child items"
(insert! "+ {0}List item\n"
" + Sub item\n"
"+ List item")
(+org/insert-item 'below)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal
(string-join '("+ List item"
" + Sub item"
"+ "
"+ List item")
"\n")))
(it "prepends items, but skips over child items"
(insert! "+ List item\n"
" + Sub item\n"
"+ {0}List item")
(+org/insert-item 'above)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal
(string-join '("+ List item"
" + Sub item"
"+ "
"+ List item")
"\n"))))
(describe "numbered lists"
(it "appends items and updates numbers"
(insert! "1. {0}List item\n"
"2. Sub item\n"
"3. List item")
(+org/insert-item 'below)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal
(string-join '("1. List item"
"2. "
"3. Sub item"
"4. List item")
"\n")))
(it "prepends items and updates numbers"
(insert! "1. List item\n"
"2. Sub item\n"
"3. {0}List item")
(+org/insert-item 'above)
(expect (buffer-substring-no-properties (point-min) (point-max))
:to-equal
(string-join '("1. List item"
"2. Sub item"
"3. "
"4. List item")
"\n"))))))

View file

@ -1,32 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; lang/web/test/autoload-css.el
(def-test! toggle-inline-or-block
(let ((css-indent-offset 2))
(should-buffer!
("body { color: red{0}; font-size: 2em; }")
("body {"
" color: red{|};"
" font-size: 2em;"
"}")
(delay-mode-hooks (css-mode))
(+css/toggle-inline-or-block))))
(def-test! comment-indent-new-line
(should-buffer!
("// test{0}"
"body { color: red; font-size: 2em; }")
("// test"
"// {|}"
"body { color: red; font-size: 2em; }")
(delay-mode-hooks (scss-mode))
(+css/comment-indent-new-line))
(should-buffer!
("// test{0}"
"body { color: red; font-size: 2em; }")
("// test"
"// {|}"
"body { color: red; font-size: 2em; }")
(delay-mode-hooks (scss-mode))
(+css/comment-indent-new-line)))

View file

@ -1,14 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; lang/web/test/autoload-html.el
(def-test! encode-entities
(should (equal (+web-encode-entities "Hello world")
"Hello world"))
(should (equal (+web-encode-entities "H€llø wørld")
"H&euro;ll&oslash; w&oslash;rld")))
(def-test! decode-entities
(should (equal (+web-decode-entities "Hello world")
"Hello world"))
(should (equal (+web-decode-entities "H&euro;ll&oslash; w&oslash;rld")
"H€llø wørld")))

View file

@ -0,0 +1,93 @@
;; -*- no-byte-compile: t; -*-
;;; lang/web/test/test-autoload-web.el
(describe "lang/web"
(describe "+html"
(before-all (load! "../autoload/html.el"))
(describe "encode entities"
(it "encodes strings with html entities"
(expect (+web-encode-entities "H€llø wørld")
:to-equal "H&euro;ll&oslash; w&oslash;rld"))
(it "does nothing when html entities are absent"
(expect (+web-encode-entities "Hello world")
:to-equal "Hello world")))
(describe "decode entities"
(it "decodes strings with html entities"
(expect (+web-decode-entities "H&euro;ll&oslash; w&oslash;rld")
:to-equal "H€llø wørld"))
(it "does nothing when html entities are absent"
(expect (+web-decode-entities "Hello world")
:to-equal "Hello world"))))
(describe "+css"
:var (css-indent-offset)
(before-all
(load! "../autoload/css.el")
(require 'smartparens)
(smartparens-mode +1))
(after-all
(smartparens-mode -1)
(unload-feature 'smartparens t))
(before-each
(setq css-indent-offset 2)
(set-buffer (get-buffer-create "css"))
(delay-mode-hooks (css-mode)))
(after-each
(kill-buffer (get-buffer "css")))
(describe "toggle-inline-or-block"
(after-each
(+css/toggle-inline-or-block)
(expect (string-trim (buffer-string)) :to-equal
(string-join
'("body {"
" color: red;"
" font-size: 2em;"
"}")
"\n")))
(describe "css-mode"
(before-each )
(it "converts inline statements into multiline blocks"
(insert! "body { color: red{0}; font-size: 2em; }"))
(it "works when cursor is on closing brace"
(insert! "body { color: red; font-size: 2em; {0}}"))
(it "works when cursor is on opening brace"
(insert! "body {{0} color: red; font-size: 2em; }"))
(it "works when cursor is on same line"
(insert! "{0}body { color: red; font-size: 2em; }"))))
(describe "comment-indent-new-line"
(before-each
(delay-mode-hooks (scss-mode)))
(it "continues commented lines on newline"
(insert! "// test{0}\n"
"body { color: red; font-size: 2em; }")
(+css/comment-indent-new-line)
(expect (string-trim (buffer-string)) :to-equal
(string-join
'("// test"
"// "
"body { color: red; font-size: 2em; }")
"\n"))
(expect (eolp))
(expect (line-number-at-pos) :to-be 2))
(it "preserves indentation within continued comments"
(insert! "// test{0}\n"
"body { color: red; font-size: 2em; }")
(+css/comment-indent-new-line)
(expect (string-trim (buffer-string)) :to-equal
(string-join
'("// test"
"// "
"body { color: red; font-size: 2em; }")
"\n"))
(expect (eolp))
(expect (line-number-at-pos) :to-be 2)))))
;;

View file

@ -1,42 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; tools/password-store/test/autoload-pass.el
(load! "../autoload")
(defmacro with-passwords!! (buffer-args &rest body)
(declare (indent defun))
`(cl-letf
(((symbol-function '+pass-get-entry)
(lambda (entry)
(when (equal entry "fake/source")
'((secret . "defuse-account-gad")
("login" . "HL2532-GANDI")
("alt-login" . "hlissner")
("email" . "henrik@lissner.net")
("url" . "https://www.gandi.net/login"))))))
,@body))
;;
(def-test! get-field
(with-passwords!!
(should (equal (+pass-get-field "fake/source" "login")
"HL2532-GANDI"))
(should (equal (+pass-get-field "fake/source" "email")
"henrik@lissner.net"))
(should (equal (+pass-get-field "fake/source" '("alt-login" "email"))
"hlissner"))
(should (equal (+pass-get-field "fake/source" '("username" "email"))
"henrik@lissner.net"))))
(def-test! missing-fields-return-nil
(with-passwords!!
(should-not (+pass-get-field "fake/source" '("x" "y" "z")))))
(def-test! missing-entries-throw-error
(with-passwords!!
(should-error (+pass-get-field "nonexistent/source" "login"))))
(def-test! get-login
(with-passwords!!
(should (equal (+pass-get-user "fake/source") "HL2532-GANDI"))
(should (equal (+pass-get-secret "fake/source") "defuse-account-gad"))))

View file

@ -0,0 +1,41 @@
;; -*- no-byte-compile: t; -*-
;;; tools/password-store/test/test-pass.el
(describe "tools/password-store"
(before-all
(load! "../autoload"))
(before-each
(spy-on 'auth-source-pass-parse-entry :and-call-fake
(lambda (entry)
(when (equal entry "fake/source")
'((secret . "defuse-account-gad")
("login" . "HL2532")
("alt-login" . "hlissner")
("email" . "henrik@lissner.net")
("url" . "https://some-place.net/login"))))))
(describe "get field"
(it "returns specific fields"
(expect (+pass-get-field "fake/source" "email")
:to-equal "henrik@lissner.net"))
(it "returns first existing of a list of fields"
(expect (+pass-get-field "fake/source" '("alt-login" "email"))
:to-equal "hlissner")
(expect (+pass-get-field "fake/source" '("username" "email"))
:to-equal "henrik@lissner.net"))
(it "returns nil for missing fields"
(expect (+pass-get-field "fake/source" '("x" "y" "z"))
:to-be nil))
(it "throws error on missing entries"
(expect (+pass-get-field "nonexistent/source" "login")
:to-throw)))
(describe "get user/secret"
(it "returns the user"
(let ((+pass-user-fields '("login" "user" "username" "email")))
(expect (+pass-get-user "fake/source")
:to-equal "HL2532")))
(it "returns the secret"
(expect (+pass-get-secret "fake/source")
:to-equal "defuse-account-gad"))))

View file

@ -1,50 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; ui/doom-dashboard/test/doom-dashboard.el
(require! :ui doom-dashboard)
(defun -dashboard-test-pwd (spec file)
(let ((kill-buffer-query-functions '(+doom-dashboard|reload-on-kill))
(+doom-dashboard-pwd-policy (car spec))
(fallback-buffer (doom-fallback-buffer))
+doom-dashboard--last-cwd
projectile-enable-caching)
(with-temp-buffer
(setq buffer-file-name file
default-directory (file-name-directory file)
doom-real-buffer-p t))
(should +doom-dashboard--last-cwd)
(+doom-dashboard-update-pwd)
(should (equal (buffer-local-value 'default-directory fallback-buffer)
(cdr spec)))))
;;
(def-test! dashboard-p
(let ((fallback-buffer (doom-fallback-buffer)))
(should (equal (buffer-name fallback-buffer) +doom-dashboard-name))
(should (+doom-dashboard-p fallback-buffer))))
(def-test! get-pwd
:minor-mode projectile-mode
(let ((default-directory doom-core-dir)
(+doom-dashboard--last-cwd doom-core-dir)
projectile-enable-caching)
(dolist (spec (list (cons 'last-project doom-emacs-dir)
(cons 'last doom-core-dir)
(cons (lambda (x) "x") "x")
(cons "~" (expand-file-name "~"))
(cons nil default-directory)))
(let ((+doom-dashboard-pwd-policy (car spec)))
(should (equal (+doom-dashboard--get-pwd) (cdr spec)))))))
(def-test! pwd-policy
:minor-mode projectile-mode
(dolist (spec (list (cons 'last-project doom-emacs-dir)
(cons 'last doom-core-dir)
(cons "~" (expand-file-name "~/"))
(cons (lambda (x) "/tmp") "/tmp/")))
(-dashboard-test-pwd spec (expand-file-name "core.el" doom-core-dir))))
;;
(def-test! inhibit-refresh :skip t)
(def-test! inhibit-functions :skip t)

View file

@ -0,0 +1,40 @@
;; -*- no-byte-compile: t; -*-
;;; ui/doom-dashboard/test/test-doom-dashboard.el
(require! :ui doom-dashboard)
(describe "ui/doom-dashboard"
:var (default-directory projectile-enable-caching)
(before-all
(require 'projectile)
(setq projectile-enable-caching nil))
(after-all
(unload-feature 'projectile t))
(before-each (projectile-mode +1))
(after-each (projectile-mode +1))
(describe "get-pwd"
:var (+doom-dashboard--last-cwd)
(before-each
(setq +doom-dashboard--last-cwd doom-core-dir
default-directory doom-core-dir))
(it "returns the current directory when policy is nil"
(let (+doom-dashboard-pwd-policy)
(expect (+doom-dashboard--get-pwd) :to-equal default-directory)))
(it "returns a path if policy is a path"
(let ((+doom-dashboard-pwd-policy "~"))
(expect (+doom-dashboard--get-pwd) :to-equal (expand-file-name "~"))))
(it "returns return value of policy as a function"
(let ((+doom-dashboard-pwd-policy (lambda (x) "x")))
(expect (+doom-dashboard--get-pwd) :to-equal "x")))
(it "returns last cwd if policy is 'last"
(let ((+doom-dashboard-pwd-policy 'last))
(expect (+doom-dashboard--get-pwd) :to-equal doom-core-dir)))
(it "returns last project if policy is 'last-project"
(let ((+doom-dashboard-pwd-policy 'last-project))
(expect (+doom-dashboard--get-pwd) :to-equal doom-emacs-dir))))
(describe "dashboard-p"
(it "changes the fallback buffer to the dashboard buffer"
(expect (+doom-dashboard-p (doom-fallback-buffer))))))