docs and tasks

2026-01-24 13:44:20 +01:00
commit 3ca9c10678
16 changed files with 6704 additions and 0 deletions
--- a/tasks/06-test-suite.md
+++ b/tasks/06-test-suite.md
@@ -0,0 +1,623 @@
+# Task 06: Comprehensive Test Suite
+
+**Phase**: 1 - Core (MVP)
+**Priority**: High
+**Estimated Time**: 2-3 hours
+**Dependencies**: Tasks 01-05 (All Core Tasks)
+
+## Objective
+
+Create a comprehensive test suite that covers all implemented functionality, including unit tests, integration tests, and org-buffer tests.
+
+## Prerequisites
+
+- All Phase 1 tasks completed
+- Basic functionality working
+
+## Background
+
+A good test suite should:
+1. Test each function in isolation (unit tests)
+2. Test the integration with org-mode (integration tests)
+3. Be runnable in CI/CD (batch mode tests)
+4. Provide good coverage of edge cases
+
+## Steps
+
+### Step 1: Organize test file structure
+
+Create the test directory structure:
+
+```
+test/
+├── test-ob-elixir.el           # Main test file (loads all)
+├── test-ob-elixir-core.el      # Core execution tests
+├── test-ob-elixir-vars.el      # Variable handling tests
+├── test-ob-elixir-results.el   # Result formatting tests
+├── test-ob-elixir-errors.el    # Error handling tests
+└── test-ob-elixir-org.el       # Org integration tests
+```
+
+### Step 2: Create main test file
+
+`test/test-ob-elixir.el`:
+
+```elisp
+;;; test-ob-elixir.el --- Tests for ob-elixir -*- lexical-binding: t; -*-
+
+;;; Commentary:
+
+;; Main test file that loads all test modules.
+;; Run with: make test
+;; Or: emacs -batch -l ert -l test/test-ob-elixir.el -f ert-run-tests-batch-and-exit
+
+;;; Code:
+
+(require 'ert)
+
+;; Add source directory to load path
+(let ((dir (file-name-directory (or load-file-name buffer-file-name))))
+  (add-to-list 'load-path (expand-file-name ".." dir))
+  (add-to-list 'load-path dir))
+
+;; Load the package
+(require 'ob-elixir)
+
+;; Load test modules
+(require 'test-ob-elixir-core)
+(require 'test-ob-elixir-vars)
+(require 'test-ob-elixir-results)
+(require 'test-ob-elixir-errors)
+(require 'test-ob-elixir-org)
+
+;;; Test Helpers
+
+(defvar ob-elixir-test--elixir-available
+  (executable-find ob-elixir-command)
+  "Non-nil if Elixir is available for testing.")
+
+(defmacro ob-elixir-test-with-elixir (&rest body)
+  "Execute BODY only if Elixir is available."
+  `(if ob-elixir-test--elixir-available
+       (progn ,@body)
+     (ert-skip "Elixir not available")))
+
+(defmacro ob-elixir-test-with-temp-org-buffer (&rest body)
+  "Execute BODY in a temporary org-mode buffer."
+  `(with-temp-buffer
+     (org-mode)
+     (ob-elixir--ensure-org-babel-loaded)
+     ,@body))
+
+(defun ob-elixir--ensure-org-babel-loaded ()
+  "Ensure org-babel is loaded with Elixir support."
+  (require 'org)
+  (require 'ob)
+  (org-babel-do-load-languages
+   'org-babel-load-languages
+   '((elixir . t))))
+
+;;; Smoke Test
+
+(ert-deftest ob-elixir-test-smoke ()
+  "Basic smoke test - package loads and Elixir is available."
+  (should (featurep 'ob-elixir))
+  (should (fboundp 'org-babel-execute:elixir))
+  (should (boundp 'org-babel-default-header-args:elixir)))
+
+(provide 'test-ob-elixir)
+;;; test-ob-elixir.el ends here
+```
+
+### Step 3: Create core execution tests
+
+`test/test-ob-elixir-core.el`:
+
+```elisp
+;;; test-ob-elixir-core.el --- Core execution tests -*- lexical-binding: t; -*-
+
+;;; Code:
+
+(require 'ert)
+(require 'ob-elixir)
+
+;;; Command Tests
+
+(ert-deftest ob-elixir-test-command-exists ()
+  "Test that the Elixir command is configured."
+  (should (stringp ob-elixir-command))
+  (should (not (string-empty-p ob-elixir-command))))
+
+(ert-deftest ob-elixir-test-command-executable ()
+  "Test that the Elixir command is executable."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (executable-find ob-elixir-command)))
+
+;;; Basic Execution Tests
+
+(ert-deftest ob-elixir-test-execute-simple-value ()
+  "Test simple value evaluation."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "2" (ob-elixir--execute "1 + 1" 'value))))
+
+(ert-deftest ob-elixir-test-execute-simple-output ()
+  "Test simple output evaluation."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "hello" (ob-elixir--execute "IO.puts(\"hello\")" 'output))))
+
+(ert-deftest ob-elixir-test-execute-multiline ()
+  "Test multiline code execution."
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((code "x = 10\ny = 20\nx + y"))
+    (should (equal "30" (ob-elixir--execute code 'value)))))
+
+(ert-deftest ob-elixir-test-execute-function-def ()
+  "Test function definition and call."
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((code "
+defmodule Test do
+  def double(x), do: x * 2
+end
+Test.double(21)"))
+    (should (equal "42" (ob-elixir--execute code 'value)))))
+
+(ert-deftest ob-elixir-test-execute-enum ()
+  "Test Enum module usage."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "15" 
+                 (ob-elixir--execute "Enum.sum([1, 2, 3, 4, 5])" 'value))))
+
+(ert-deftest ob-elixir-test-execute-pipe ()
+  "Test pipe operator."
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((code "[1, 2, 3] |> Enum.map(&(&1 * 2)) |> Enum.sum()"))
+    (should (equal "12" (ob-elixir--execute code 'value)))))
+
+;;; Data Type Tests
+
+(ert-deftest ob-elixir-test-execute-list ()
+  "Test list result."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "[1, 2, 3]" (ob-elixir--execute "[1, 2, 3]" 'value))))
+
+(ert-deftest ob-elixir-test-execute-tuple ()
+  "Test tuple result."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "{:ok, 42}" (ob-elixir--execute "{:ok, 42}" 'value))))
+
+(ert-deftest ob-elixir-test-execute-map ()
+  "Test map result."
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((result (ob-elixir--execute "%{a: 1, b: 2}" 'value)))
+    (should (string-match-p "%{" result))
+    (should (string-match-p "a:" result))
+    (should (string-match-p "b:" result))))
+
+(ert-deftest ob-elixir-test-execute-string ()
+  "Test string result."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "\"hello world\"" 
+                 (ob-elixir--execute "\"hello world\"" 'value))))
+
+(ert-deftest ob-elixir-test-execute-atom ()
+  "Test atom result."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal ":ok" (ob-elixir--execute ":ok" 'value))))
+
+(ert-deftest ob-elixir-test-execute-boolean ()
+  "Test boolean result."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "true" (ob-elixir--execute "true" 'value)))
+  (should (equal "false" (ob-elixir--execute "false" 'value))))
+
+(ert-deftest ob-elixir-test-execute-nil ()
+  "Test nil result."
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "nil" (ob-elixir--execute "nil" 'value))))
+
+;;; Wrapper Tests
+
+(ert-deftest ob-elixir-test-wrap-for-value ()
+  "Test value wrapper generation."
+  (let ((wrapped (ob-elixir--wrap-for-value "1 + 1")))
+    (should (string-match-p "result = " wrapped))
+    (should (string-match-p "IO\\.puts" wrapped))
+    (should (string-match-p "inspect" wrapped))))
+
+(provide 'test-ob-elixir-core)
+;;; test-ob-elixir-core.el ends here
+```
+
+### Step 4: Create variable tests
+
+`test/test-ob-elixir-vars.el`:
+
+```elisp
+;;; test-ob-elixir-vars.el --- Variable handling tests -*- lexical-binding: t; -*-
+
+;;; Code:
+
+(require 'ert)
+(require 'ob-elixir)
+
+;;; Type Conversion Tests
+
+(ert-deftest ob-elixir-test-convert-nil ()
+  (should (equal "nil" (ob-elixir--elisp-to-elixir nil))))
+
+(ert-deftest ob-elixir-test-convert-true ()
+  (should (equal "true" (ob-elixir--elisp-to-elixir t))))
+
+(ert-deftest ob-elixir-test-convert-integer ()
+  (should (equal "42" (ob-elixir--elisp-to-elixir 42)))
+  (should (equal "-10" (ob-elixir--elisp-to-elixir -10)))
+  (should (equal "0" (ob-elixir--elisp-to-elixir 0))))
+
+(ert-deftest ob-elixir-test-convert-float ()
+  (should (equal "3.14" (ob-elixir--elisp-to-elixir 3.14)))
+  (should (equal "-2.5" (ob-elixir--elisp-to-elixir -2.5))))
+
+(ert-deftest ob-elixir-test-convert-string ()
+  (should (equal "\"hello\"" (ob-elixir--elisp-to-elixir "hello")))
+  (should (equal "\"\"" (ob-elixir--elisp-to-elixir ""))))
+
+(ert-deftest ob-elixir-test-convert-string-escaping ()
+  (should (equal "\"say \\\"hi\\\"\"" 
+                 (ob-elixir--elisp-to-elixir "say \"hi\"")))
+  (should (equal "\"line1\\nline2\"" 
+                 (ob-elixir--elisp-to-elixir "line1\nline2")))
+  (should (equal "\"tab\\there\"" 
+                 (ob-elixir--elisp-to-elixir "tab\there"))))
+
+(ert-deftest ob-elixir-test-convert-symbol ()
+  (should (equal ":foo" (ob-elixir--elisp-to-elixir 'foo)))
+  (should (equal ":ok" (ob-elixir--elisp-to-elixir 'ok)))
+  (should (equal ":error" (ob-elixir--elisp-to-elixir 'error))))
+
+(ert-deftest ob-elixir-test-convert-list ()
+  (should (equal "[1, 2, 3]" (ob-elixir--elisp-to-elixir '(1 2 3))))
+  (should (equal "[]" (ob-elixir--elisp-to-elixir '())))
+  (should (equal "[\"a\", \"b\"]" (ob-elixir--elisp-to-elixir '("a" "b")))))
+
+(ert-deftest ob-elixir-test-convert-nested-list ()
+  (should (equal "[[1, 2], [3, 4]]" 
+                 (ob-elixir--elisp-to-elixir '((1 2) (3 4))))))
+
+(ert-deftest ob-elixir-test-convert-vector ()
+  (should (equal "{1, 2, 3}" (ob-elixir--elisp-to-elixir [1 2 3]))))
+
+(ert-deftest ob-elixir-test-convert-mixed ()
+  (should (equal "[1, \"two\", :three]" 
+                 (ob-elixir--elisp-to-elixir '(1 "two" three)))))
+
+;;; Variable Assignment Tests
+
+(ert-deftest ob-elixir-test-var-assignments-single ()
+  (let ((params '((:var . ("x" . 5)))))
+    (should (equal '("x = 5") 
+                   (org-babel-variable-assignments:elixir params)))))
+
+(ert-deftest ob-elixir-test-var-assignments-multiple ()
+  (let ((params '((:var . ("x" . 5))
+                  (:var . ("y" . 10)))))
+    (let ((assignments (org-babel-variable-assignments:elixir params)))
+      (should (= 2 (length assignments)))
+      (should (member "x = 5" assignments))
+      (should (member "y = 10" assignments)))))
+
+(ert-deftest ob-elixir-test-var-assignments-string ()
+  (let ((params '((:var . ("name" . "Alice")))))
+    (should (equal '("name = \"Alice\"") 
+                   (org-babel-variable-assignments:elixir params)))))
+
+(ert-deftest ob-elixir-test-var-assignments-list ()
+  (let ((params '((:var . ("data" . (1 2 3))))))
+    (should (equal '("data = [1, 2, 3]") 
+                   (org-babel-variable-assignments:elixir params)))))
+
+;;; Execution with Variables
+
+(ert-deftest ob-elixir-test-execute-with-var ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let* ((params '((:var . ("x" . 10))))
+         (var-lines (org-babel-variable-assignments:elixir params))
+         (full-body (concat (mapconcat #'identity var-lines "\n")
+                            "\nx * 2")))
+    (should (equal "20" (ob-elixir--execute full-body 'value)))))
+
+(ert-deftest ob-elixir-test-execute-with-list-var ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let* ((params '((:var . ("nums" . (1 2 3 4 5)))))
+         (var-lines (org-babel-variable-assignments:elixir params))
+         (full-body (concat (mapconcat #'identity var-lines "\n")
+                            "\nEnum.sum(nums)")))
+    (should (equal "15" (ob-elixir--execute full-body 'value)))))
+
+(ert-deftest ob-elixir-test-execute-with-string-var ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let* ((params '((:var . ("name" . "World"))))
+         (var-lines (org-babel-variable-assignments:elixir params))
+         (full-body (concat (mapconcat #'identity var-lines "\n")
+                            "\n\"Hello, #{name}!\"")))
+    (should (equal "\"Hello, World!\"" 
+                   (ob-elixir--execute full-body 'value)))))
+
+(provide 'test-ob-elixir-vars)
+;;; test-ob-elixir-vars.el ends here
+```
+
+### Step 5: Create result formatting tests
+
+`test/test-ob-elixir-results.el`:
+
+```elisp
+;;; test-ob-elixir-results.el --- Result formatting tests -*- lexical-binding: t; -*-
+
+;;; Code:
+
+(require 'ert)
+(require 'ob-elixir)
+
+;;; Parsing Tests
+
+(ert-deftest ob-elixir-test-parse-simple-list ()
+  (should (equal '(1 2 3) (ob-elixir--table-or-string "[1, 2, 3]"))))
+
+(ert-deftest ob-elixir-test-parse-nested-list ()
+  (should (equal '((1 2) (3 4)) 
+                 (ob-elixir--table-or-string "[[1, 2], [3, 4]]"))))
+
+(ert-deftest ob-elixir-test-parse-empty-list ()
+  (should (equal '() (ob-elixir--table-or-string "[]"))))
+
+(ert-deftest ob-elixir-test-parse-tuple ()
+  (should (equal '(1 2 3) (ob-elixir--table-or-string "{1, 2, 3}"))))
+
+(ert-deftest ob-elixir-test-parse-scalar-number ()
+  (should (equal "42" (ob-elixir--table-or-string "42"))))
+
+(ert-deftest ob-elixir-test-parse-scalar-atom ()
+  (should (equal ":ok" (ob-elixir--table-or-string ":ok"))))
+
+(ert-deftest ob-elixir-test-parse-scalar-string ()
+  (should (equal "\"hello\"" (ob-elixir--table-or-string "\"hello\""))))
+
+(ert-deftest ob-elixir-test-parse-empty ()
+  (should (null (ob-elixir--table-or-string "")))
+  (should (null (ob-elixir--table-or-string "  "))))
+
+;;; Table Sanitization Tests
+
+(ert-deftest ob-elixir-test-sanitize-nil-values ()
+  (let ((ob-elixir-nil-to 'hline))
+    (should (equal '((1 hline) (hline 2))
+                   (ob-elixir--sanitize-table '((1 nil) (nil 2)))))))
+
+(ert-deftest ob-elixir-test-sanitize-nested ()
+  (let ((ob-elixir-nil-to 'hline))
+    (should (equal '((1 2) (3 4))
+                   (ob-elixir--sanitize-table '((1 2) (3 4)))))))
+
+(ert-deftest ob-elixir-test-sanitize-simple ()
+  (should (equal '(1 2 3)
+                 (ob-elixir--sanitize-table '(1 2 3)))))
+
+;;; Integration Tests
+
+(ert-deftest ob-elixir-test-full-result-list ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((result (ob-elixir--table-or-string
+                 (ob-elixir--execute "[1, 2, 3]" 'value))))
+    (should (equal '(1 2 3) result))))
+
+(ert-deftest ob-elixir-test-full-result-table ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((result (ob-elixir--table-or-string
+                 (ob-elixir--execute "[[1, 2], [3, 4]]" 'value))))
+    (should (equal '((1 2) (3 4)) result))))
+
+(provide 'test-ob-elixir-results)
+;;; test-ob-elixir-results.el ends here
+```
+
+### Step 6: Create error handling tests
+
+`test/test-ob-elixir-errors.el`:
+
+```elisp
+;;; test-ob-elixir-errors.el --- Error handling tests -*- lexical-binding: t; -*-
+
+;;; Code:
+
+(require 'ert)
+(require 'ob-elixir)
+
+;;; Error Detection Tests
+
+(ert-deftest ob-elixir-test-detect-runtime-error ()
+  (let ((output "** (RuntimeError) something went wrong"))
+    (should (ob-elixir--detect-error output))))
+
+(ert-deftest ob-elixir-test-detect-compile-error ()
+  (let ((output "** (CompileError) test.exs:1: undefined function"))
+    (should (ob-elixir--detect-error output))))
+
+(ert-deftest ob-elixir-test-detect-no-error ()
+  (should-not (ob-elixir--detect-error "42"))
+  (should-not (ob-elixir--detect-error "[1, 2, 3]"))
+  (should-not (ob-elixir--detect-error ":ok")))
+
+(ert-deftest ob-elixir-test-error-type-runtime ()
+  (let* ((output "** (RuntimeError) test error")
+         (info (ob-elixir--detect-error output)))
+    (should (eq 'runtime (plist-get info :type)))))
+
+(ert-deftest ob-elixir-test-error-type-compile ()
+  (let* ((output "** (CompileError) syntax error")
+         (info (ob-elixir--detect-error output)))
+    (should (eq 'compile (plist-get info :type)))))
+
+;;; Error Execution Tests
+
+(ert-deftest ob-elixir-test-runtime-error-no-signal ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((ob-elixir-signal-errors nil))
+    (let ((result (ob-elixir--execute "raise \"test\"" 'value)))
+      (should (string-match-p "RuntimeError" result)))))
+
+(ert-deftest ob-elixir-test-runtime-error-signal ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((ob-elixir-signal-errors t))
+    (should-error (ob-elixir--execute "raise \"test\"" 'value)
+                  :type 'ob-elixir-runtime-error)))
+
+(ert-deftest ob-elixir-test-compile-error ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((ob-elixir-signal-errors nil))
+    (let ((result (ob-elixir--execute "def incomplete(" 'value)))
+      (should (string-match-p "\\(SyntaxError\\|TokenMissingError\\)" result)))))
+
+(provide 'test-ob-elixir-errors)
+;;; test-ob-elixir-errors.el ends here
+```
+
+### Step 7: Create org integration tests
+
+`test/test-ob-elixir-org.el`:
+
+```elisp
+;;; test-ob-elixir-org.el --- Org integration tests -*- lexical-binding: t; -*-
+
+;;; Code:
+
+(require 'ert)
+(require 'org)
+(require 'ob)
+(require 'ob-elixir)
+
+;;; Helper Functions
+
+(defun ob-elixir-test--execute-src-block (code &optional header-args)
+  "Execute CODE as an Elixir src block with HEADER-ARGS."
+  (with-temp-buffer
+    (org-mode)
+    (insert (format "#+BEGIN_SRC elixir%s\n%s\n#+END_SRC"
+                    (if header-args (concat " " header-args) "")
+                    code))
+    (goto-char (point-min))
+    (forward-line 1)
+    (org-babel-execute-src-block)))
+
+;;; Basic Org Tests
+
+(ert-deftest ob-elixir-test-org-simple ()
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "2" (ob-elixir-test--execute-src-block "1 + 1"))))
+
+(ert-deftest ob-elixir-test-org-with-var ()
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "20" (ob-elixir-test--execute-src-block "x * 2" ":var x=10"))))
+
+(ert-deftest ob-elixir-test-org-results-output ()
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal "hello" 
+                 (ob-elixir-test--execute-src-block 
+                  "IO.puts(\"hello\")" 
+                  ":results output"))))
+
+(ert-deftest ob-elixir-test-org-results-value ()
+  (skip-unless (executable-find ob-elixir-command))
+  (should (equal '(1 2 3) 
+                 (ob-elixir-test--execute-src-block 
+                  "[1, 2, 3]" 
+                  ":results value"))))
+
+(ert-deftest ob-elixir-test-org-results-verbatim ()
+  (skip-unless (executable-find ob-elixir-command))
+  (should (stringp (ob-elixir-test--execute-src-block 
+                    "[1, 2, 3]" 
+                    ":results verbatim"))))
+
+;;; Table Tests
+
+(ert-deftest ob-elixir-test-org-table-result ()
+  (skip-unless (executable-find ob-elixir-command))
+  (let ((result (ob-elixir-test--execute-src-block "[[1, 2], [3, 4]]")))
+    (should (equal '((1 2) (3 4)) result))))
+
+(provide 'test-ob-elixir-org)
+;;; test-ob-elixir-org.el ends here
+```
+
+### Step 8: Update Makefile
+
+```makefile
+EMACS ?= emacs
+BATCH = $(EMACS) -Q -batch -L . -L test
+
+.PHONY: all compile test test-unit test-integration lint clean
+
+all: compile test
+
+compile:
+	$(BATCH) -f batch-byte-compile ob-elixir.el
+
+test: test-unit
+
+test-unit:
+	$(BATCH) -l ert \
+		-l test/test-ob-elixir.el \
+		-f ert-run-tests-batch-and-exit
+
+test-integration:
+	$(BATCH) -l ert \
+		-l org -l ob \
+		-l test/test-ob-elixir.el \
+		-f ert-run-tests-batch-and-exit
+
+lint:
+	$(BATCH) --eval "(require 'package)" \
+		--eval "(package-initialize)" \
+		--eval "(unless (package-installed-p 'package-lint) \
+		         (package-refresh-contents) \
+		         (package-install 'package-lint))" \
+		-l package-lint \
+		-f package-lint-batch-and-exit ob-elixir.el
+
+clean:
+	rm -f *.elc test/*.elc
+```
+
+## Acceptance Criteria
+
+- [ ] All test files created and organized
+- [ ] `make test` runs all tests
+- [ ] Tests cover core execution, variables, results, and errors
+- [ ] Org integration tests work
+- [ ] Tests can run in CI (batch mode)
+- [ ] Test coverage is comprehensive (major code paths)
+
+## Test Coverage Goals
+
+| Component | Tests | Coverage |
+|-----------|-------|----------|
+| Type conversion | 12+ tests | All Elisp types |
+| Execution | 10+ tests | Value/output, types |
+| Variables | 8+ tests | All var scenarios |
+| Results | 8+ tests | Parsing, tables |
+| Errors | 6+ tests | Detection, signaling |
+| Org integration | 6+ tests | Full workflow |
+
+## Files Created
+
+- `test/test-ob-elixir.el` - Main test file
+- `test/test-ob-elixir-core.el` - Core tests
+- `test/test-ob-elixir-vars.el` - Variable tests
+- `test/test-ob-elixir-results.el` - Result tests
+- `test/test-ob-elixir-errors.el` - Error tests
+- `test/test-ob-elixir-org.el` - Org integration tests
+
+## References
+
+- [docs/02-testing-emacs-elisp.md](../docs/02-testing-emacs-elisp.md)
+- [ERT Manual](https://www.gnu.org/software/emacs/manual/html_node/ert/)