Problem statement

match? is a multi-method dispatch symbol, not a function. So it misses highlighting and a proper refer.

This has a couple of caveats:

• lack of traceability. The assert-expr is registered when nedap.utils.test.matcher-combinators is loaded, which might be in a different ns
• formatters might remove [nedap.utils.test.matcher-combinators] as a dependency, if it is only loaded for registering the match?-matcher.

Proposal

add a declaration for the multimethod. Similar to matcher-combinators:
https://github.com/nubank/matcher-combinators/blob/b3da18923f0aa6a5ef924e9303f690a3efa1d978/src/cljc/matcher_combinators/test.cljc#L10-L11

Context

The expect helper is locked to use meta= internally. This has a couple of disadvantages;

• lack of flexibility.
• cloverage uses metadata to measure coverage; breaks expect-tests.

Task

1. add matcher-combinators namespace (see #28)
2. add expect-match? which uses matcher-combinators.core/match for the :form-assertion, and matcher-combinators.test/match? for the :to assertion.

Additional resources

https://github.com/nubank/matcher-combinators

Rightfully, (= ^:a [] ^:b []) is true, but one may want metadata to be part of the equality criteria.

Problem statement

nedap.utils.test.api/simple= has a couple of disadvantages (as mentioned in the docstring) and is not composible.

The usage has been dropped in several projects in favor of https://github.com/nubank/matcher-combinators.

Proposal

remove mention from README.md, mark api-function as deprecated.

Alternatives and comparison

keep the function advertised in README.md.

Context

"Fail-fast" is a commonly wanted feature. Some alternative test runners provide a form of it, although they may be a bit framework-ish. I like that utils.test is literally a collection of utils for clojure.test, assuming nothing.

It seems great to have a reusable defn that can be invoked from any project (especially from a repl) regardless of its setup.

Proposal

Bundle a helper such as:

(defn run-tests [& namespaces]
  (let [summary (-> (->> namespaces
                         (reduce (bound-fn [r n]
                                   (let [{:keys [fail error]
                                          :as v} (clojure.test/test-ns n)
                                         failed? (some pos? [fail error])
                                         ret (merge-with + r v)]
                                     (cond-> ret
                                       failed? reduced)))
                                 clojure.test/*initial-report-counters*))
                    (assoc :type :summary))]
    (clojure.test/do-report summary)
    summary))

(defn run-all-tests
  "Like `clojure.test/run-all-tests` but fails-fast."
  []
  (->> (all-ns)
       (filter (fn [n]
                 (->> n
                      ns-publics
                      vals
                      (some (fn [var-ref]
                              {:pre [(var? var-ref)]}
                              (-> var-ref meta :test))))))
       (sort-by pr-str)
       (reverse) ;; unit.* first
       (apply run-tests)))

Then one can do (clojure.tools.namespace.repl/refresh :after 'my/run-all-tests).

This could be further integrated with formatting-stack's test runner, with the project template, etc

...the snippet has worked well for me over the last month, also I had a similar but more intrincate incarnation of it based off CircleCI's test runner over 2020.

Thoughts?

cc/ @thumbnail

Context

macroexpand= is great; but unifies any symbol it recognizes as a gensym. providing a matcher-combinators matcher for gensyms allows for more specific matches

Task

1. add a GensymMatcher + wrapper fns
2. add readme examples

Additional resources

Blocked by #28, at least for the opt-in requirement of m-c.

In an internal project we use:

(defrecord GensymMatcher [expected]
 matcher-combinators.core/Matcher
 (match [_this actual]
   (let [value (symbol (string/replace actual #"(.?+)(\d)*" "$1"))]
     (if (= expected value)
       {:matcher-combinators.result/type   :match
        :matcher-combinators.result/value  value
        :matcher-combinators.result/weight 0}
       {:matcher-combinators.result/type   :mismatch
        :matcher-combinators.result/value  (model/->Mismatch expected value)
        :matcher-combinators.result/weight 1}))))