initial commit

Author: levand

.gitignore

@@ -0,0 +1,3 @@
+.cpcache
+.rebl
+.rebl.sh

deps.edn

@@ -0,0 +1,8 @@
+{:paths ["src"]
+ :deps {org.clojure/tools.namespace {:mvn/version "0.3.0-alpha4"}
+        org.clojure/tools.cli {:mvn/version "0.3.5"}
+        org.clojure/clojure {:mvn/version "1.9.0"}}
+ :aliases {:dev {:extra-paths ["test" "dev"]
+                 :extra-deps {org.clojure/test.check {:mvn/version "0.9.0"}}}}
+ :mvn/repos {"central" {:url "https://repo1.maven.org/maven2/"}
+             "clojars" {:url "https://clojars.org/repo"}}}

readme.md

@@ -0,0 +1,86 @@
+# test-runner
+
+`test-runner` is a small library for running tests written with
+`clojure.test` and/or `clojure.spec.test` in plain Clojure projects
+(i.e, those that use only Clojure's built-in deps tooling, not
+Leiningen/boot/etc.)
+
+## Rationale
+
+Clojure's 1.9 release includes standalone tools for dependency
+resolution, classpath construction, and launching processes. Clojure
+also ships with a straightforward testing library, `clojure.test`.
+
+Using these tools, however, there is currently no standard way to
+discover and run unit tests. Including a heavyweight project tool such
+as Leiningen or Boot just for the purpose of testing is
+overkill. Projects can build their own ad-hoc test runners, but these
+tend to lack features and tend towards the "quick and dirty," besides
+being nonstandard from project to project.
+
+This library aims to fill in the gap and provide a standardized,
+easy-to-use entry entry point for running unit and property-based
+tests while remaining a lightweight entry in Clojure's suite of
+decomplected project management tools.
+
+## Usage
+
+Include a dependency on this project in your `deps.edn`. You will
+probably wish to put it in a `dev` or `test` alias. For example:
+
+
+```clojure
+:aliases {:dev {:extra-paths ["test"]
+                :extra-deps {net.vanderhart/test-runner {:git/url "[email protected]:levand/test-runner"
+                                                         :sha "..."}}}}
+                                                         ```
+
+Then, invoke Clojure via the command line, passing
+`net.vanderhart.test-runner` as the main namespace to run using the
+`-m` option.
+
+```bash
+clj -Cdev -Rdev -m net.vanderhart.test-runner
+
+You may also supply any of the additional command line options:
+
+```
+  -d, --dir DIRNAME       Name of the directory containing tests. Defaults to "test".
+  -n, --namespace SYMBOL  Symbol indicating a specific namespace to test.
+  -v, --var SYMBOL        Symbol indicating the fully qualified name of a specific test.
+  -i, --include KEYWORD   Run only tests that have this metadata keyword.
+  -e, --exclude KEYWORD   Exclude tests with this metadata keyword.
+  -h, --help              Display this help message
+  ```
+
+All options may be repeated multiple times, for a logical OR effect. For example, the following
+invocation will run all tests in the `foo.bar` and `foo.baz` namespaces:
+
+```
+clj -Cdev -Rdev -m net.vanderhart.test-runner -n foo.bar -n foo.baz
+```
+
+### Using Inclusions and Exclusions
+
+You can use inclusions and exclusions to run only a subset of your tests, identified by metadata on the test var.
+
+For example, you could tag your integration tests like so:
+
+```clojure
+(deftest ^:integration test-live-system
+  (is (= 200 (http/get "http://example.com"))))
+```
+
+Then to run only integration tests, you could do:
+
+```
+clj -Cdev -Rdev -m net.vanderhart.test-runner -i integration
+```
+
+Or to run all tests *except* for integration tests:
+
+```
+clj -Cdev -Rdev -m net.vanderhart.test-runner -e integration
+```
+
+If both inclusions and exclusions are present, exclusions take priority over inclusions.

rebl.sh

@@ -0,0 +1 @@
+/usr/local/bin/clojure -R:dev -C:dev -m cognitect.rebl

repl.sh

@@ -0,0 +1 @@
+/usr/local/bin/clojure -R:dev -C:dev

src/net/vanderhart/test_runner.clj

@@ -0,0 +1,140 @@
+(ns net.vanderhart.test-runner
+  (:require [clojure.tools.namespace.find :as find]
+            [clojure.spec.alpha :as s]
+            [clojure.java.io :as io]
+            [clojure.test :as test]
+            [clojure.tools.cli :refer [parse-opts]]
+            [clojure.string :as str])
+  (:refer-clojure :exclude [test]))
+
+(defn- ns-filter
+  [{:keys [namespace]}]
+  (if namespace
+    #(namespace %)
+    (constantly true)))
+
+(defn- var-filter
+  [{:keys [var include exclude]}]
+  (let [test-specific (if var
+                        (set (map #(or (resolve %)
+                                       (throw (ex-info (str "Could not resolve var: " %)
+                                                       {:symbol %})))))
+                        (constantly true))
+        test-inclusion (if include
+                         #((apply some-fn include) (meta %))
+                        (constantly true))
+        test-exclusion (if exclude
+                         #((complement (apply some-fn exclude)) (meta %))
+                         (constantly true))]
+    #(and (test-specific %)
+          (test-inclusion %)
+          (test-exclusion %))))
+
+(defn- filter-vars!
+  [nses filter-fn]
+  (doseq [ns nses]
+    (doseq [[name var] (ns-publics ns)]
+      (when (:test (meta var))
+        (when (not (filter-fn var))
+          (alter-meta! var #(-> %
+                                (assoc ::test (:test %))
+                                (dissoc :test))))))))
+
+(defn- restore-vars!
+  [nses]
+  (doseq [ns nses]
+    (doseq [[name var] (ns-publics ns)]
+      (when (::test (meta var))
+        (alter-meta! var #(-> %
+                              (assoc :test (::test %))
+                              (dissoc ::test)))))))
+(defn test
+  [options]
+  (let [dirs (or (:dir options)
+                 #{"test"})
+        nses (->> dirs
+                  (map io/file)
+                  (mapcat find/find-namespaces-in-dir))
+        nses (filter (ns-filter options) nses)]
+    (println (format "\nRunning tests in %s" dirs))
+    (dorun (map require nses))
+    (try
+      (filter-vars! nses (var-filter options))
+      (apply test/run-tests nses)
+      (finally
+        (restore-vars! nses)))))
+
+(defn- parse-kw
+  [s]
+  (if (str/starts-with? s ":") (read-string s) (keyword s)))
+
+
+(defn- accumulate [m k v]
+  (update m k (fnil conj #{}) v))
+
+(def cli-options
+  [["-d" "--dir DIRNAME" "Name of the directory containing tests. Defaults to \"test\"."
+    :parse-fn str
+    :assoc-fn accumulate]
+   ["-n" "--namespace SYMBOL" "Symbol indicating a specific namespace to test."
+    :parse-fn symbol
+    :assoc-fn accumulate]
+   ["-v" "--var SYMBOL" "Symbol indicating the fully qualified name of a specific test."
+    :parse-fn symbol
+    :assoc-fn accumulate]
+   ["-i" "--include KEYWORD" "Run only tests that have this metadata keyword."
+    :parse-fn parse-kw
+    :assoc-fn accumulate]
+   ["-e" "--exclude KEYWORD" "Exclude tests with this metadata keyword."
+    :parse-fn parse-kw
+    :assoc-fn accumulate]
+   ["-h" "--help" "Display this help message"]])
+
+(defn- help
+  [args]
+  (println "\nUSAGE:\n")
+  (println "clj -m" (namespace `help) "<test-dir> <options>\n")
+  (println (:summary args))
+  (println "\nAll options may be repeated multiple times for a logical OR effect.")
+  )
+
+(defn -main
+  "Entry point for the test runner"
+  [& args]
+  (let [args (parse-opts args cli-options)]
+    (if (-> args :options :help)
+      (help args)
+      (test (:options args)))))
+
+
+(comment
+
+  (-main "test" "-n" "net.vanderhart.test-runner.samples")
+  (-main "test")
+
+
+  (-main "test" "-v" "net.vanderhart.test-runner.sample-property/first-element-is-min-after-sorting"
+         #_"-v" #_"net.vanderhart.test-runner.samples/foobar")
+
+  (-main "test" "-i" "integration")
+
+  (-main "test" "-e" "integration")
+
+  (-main "test")
+
+  (-main "-h")
+
+  (->> (find/find-namespaces-in-dir (io/file "test"))
+       (map #(do (require %) %))
+       (map ns-publics)
+       (map vals)
+       (apply concat)
+       (test/test-vars)
+       
+       )
+
+  
+
+  
+
+  )

test.sh

@@ -0,0 +1 @@
+/usr/local/bin/clojure -Srepro -R:dev -C:dev -m net.vanderhart.test-runner test

test/net/vanderhart/test_runner/sample_property.clj

@@ -0,0 +1,10 @@
+(ns net.vanderhart.test-runner.sample-property
+  (:require [clojure.test.check :as tc]
+            [clojure.test.check.generators :as gen]
+            [clojure.test.check.properties :as prop]
+            [clojure.test.check.clojure-test :refer [defspec]]))
+
+(defspec first-element-is-min-after-sorting 100
+  (prop/for-all [v (gen/not-empty (gen/vector gen/int))]
+                (= (apply min v)
+                   (first (sort v)))))

test/net/vanderhart/test_runner/samples.clj

@@ -0,0 +1,15 @@
+(ns net.vanderhart.test-runner.samples
+  (:require [clojure.test :as t :refer [deftest is testing]]))
+
+(deftest math-works
+  (testing "basic addition and subtraction"
+    (is (= 42 (+ 40 2)))
+    (is (= 42 (- 44 2))))
+  )
+
+(deftest ^:integration test-i
+  (is (= 1 1)))
+
+
+
+