aboutsummaryrefslogtreecommitdiff
path: root/test/tests.el
blob: 74ef158106fc499a2e882212a38784c6dfd7f31f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
(defun -stack--nuke ()
  (interactive)
  (mapatoms
   (lambda (symbol)
     (if (string-prefix-p "stack-" (symbol-name symbol))
         (unintern symbol)))))

;;; Tests
(defvar stack-test-data-dir
  (expand-file-name
   "data-samples/"
   (or (file-name-directory load-file-name) "./"))
  "")

(defun stack-test-sample-data (method &optional directory)
  (let ((file (concat (when directory (concat directory "/"))
                      stack-test-data-dir
                      method ".el")))
    (when (file-exists-p file)
      (with-temp-buffer
        (insert-file-contents file)
        (read (buffer-string))))))

(setq
 stack-core-remaining-api-requests-message-threshold 50000
 debug-on-error t
 stack-core-silent-requests nil
 user-emacs-directory "."

 stack-test-data-questions
 (stack-test-sample-data "questions")
 stack-test-data-sites
 (stack-test-sample-data "sites"))

(setq package-user-dir
      (expand-file-name (format "../../.cask/%s/elpa" emacs-version)
                        stack-test-data-dir))
(package-initialize)
(require 'cl-lib)
(require 'stack-core)
(require 'stack-question)
(require 'stack-question-list)

(ert-deftest test-basic-request ()
  "Test basic request functionality"
  (should (stack-core-make-request "sites")))

(ert-deftest test-question-retrieve ()
  "Test the ability to receive a list of questions."
  (should (stack-question-get-questions 'emacs)))

(ert-deftest test-bad-request ()
  "Test a method given a bad set of keywords"
  (should-error
   (stack-core-make-request "questions" '(()))))

(ert-deftest test-tree-filter ()
  "`stack-core-filter-data'"
  ;; flat
  (should
   (equal
    '((1 . t) (2 . [1 2]) (3))
    (stack-core-filter-data '((0 . 3) (1 . t) (a . five) (2 . [1 2])
                              ("5" . bop) (3) (p . 4))
                            '(1 2 3))))
  ;; complex
  (should
   (equal
    '((1 . [a b c])
      (2 . [((a . 1) (c . 3))
            ((a . 4) (c . 6))])
      (3 . peach))
    (stack-core-filter-data '((1 . [a b c])
                              (2 . [((a . 1) (b . 2) (c . 3))
                                    ((a . 4) (b . 5) (c . 6))])
                              (3 . peach)
                              (4 . banana))
                            '(1 (2 a c) 3))))

  ;; vector
  (should
   (equal
    [((1 . 2) (2 . 3) (3 . 4))
     ((1 . a) (2 . b) (3 . c))
     nil ((1 . alpha) (2 . beta))]
    (stack-core-filter-data [((1 . 2) (2 . 3) (3 . 4))
                             ((1 . a) (2 . b) (3 . c) (5 . seven))
                             ((should-not-go))
                             ((1 . alpha) (2 . beta))]
                            '(1 2 3)))))

(ert-deftest test-filters ()
  (let ((stack-cache-directory (make-temp-file "stack-test" t)))
    (should-error (stack-filter-store "names must be symbols"
                                      "this is a filter"))
    ;; basic use
    (should (equal '((test . "filter"))
                   (stack-filter-store 'test "filter")))
    ;; aggregation
    (should (equal '((test2 . "filter2") (test . "filter"))
                   (stack-filter-store 'test2 "filter2")))
    ;; mutation
    (should (equal '((test2 . "filter2") (test . "filter-test"))
                   (stack-filter-store 'test "filter-test")))
    ;; clean up (note: the file should exist)
    (delete-file
     (stack-cache-get-file-name
      stack-filter-cache-file))))

(defmacro line-should-match (regexp)
  ""
  `(let ((line (buffer-substring-no-properties
                (line-beginning-position)
                (line-end-position))))
     (message "Line here is: %S" line)
     (should (string-match ,regexp line))))

(ert-deftest question-list-display ()
  (cl-letf (((symbol-function #'stack-core-make-request)
             (lambda (&rest _) stack-test-data-questions)))
    (list-questions nil)
    (switch-to-buffer "*question-list*")
    (goto-char (point-min))
    (should (equal (buffer-name) "*question-list*"))
    (line-should-match
     "^\\s-+1\\s-+0\\s-+Focus-hook: attenuate colours when losing focus [ 0-9]+[ydhms] ago\\s-+\\[frames\\] \\[hooks\\] \\[focus\\]")
    (stack-question-list-next 5)
    (line-should-match
     "^\\s-+0\\s-+1\\s-+Babel doesn't wrap results in verbatim [ 0-9]+[ydhms] ago\\s-+\\[org-mode\\]")
    ;; ;; Use this when we have a real stack-question buffer.
    ;; (call-interactively 'stack-question-list-display-question)
    ;; (should (equal (buffer-name) "*stack-question*"))
    (switch-to-buffer "*question-list*")
    (stack-question-list-previous 4)
    (line-should-match
     "^\\s-+2\\s-+1\\s-+"Making tag completion table" Freezes/Blocks -- how to disable [ 0-9]+[ydhms] ago\\s-+\\[autocomplete\\]")))