Run and Test a Clojure App

Running and testing a Clojure application is mostly about controlling the classpath and keeping side effects at the edge. If a Java project asks “which class has main?”, a Clojure project asks “which namespace should be loaded, and which function should be called?”

Runtime Commands

For the first project from the previous page, deps.edn can expose a run command:

1{:paths ["src" "resources"]
2 :deps {org.clojure/clojure {:mvn/version "1.12.4"}}
3 :aliases
4 {:run {:main-opts ["-m" "hello-world.core"]}}}

Run it directly:

1clojure -M -m hello-world.core Ada

Or through the alias:

1clojure -M:run Ada

The matching namespace:

1(ns hello-world.core)
2
3(defn greeting [name]
4  (str "Hello, " name "!"))
5
6(defn -main
7  [& args]
8  (println (greeting (or (first args) "Clojure"))))

Add a Focused Test

Create test/hello_world/core_test.clj:

1(ns hello-world.core-test
2  (:require [clojure.test :refer [deftest is testing]]
3            [hello-world.core :as core]))
4
5(deftest greeting-test
6  (testing "builds a greeting"
7    (is (= "Hello, Ada!" (core/greeting "Ada")))))

This test checks the pure function, not the console. That is the same instinct you would use in Java when you keep business logic separate from System.out or framework code.

Add a Small Test Runner

For a tiny CLI-only project, you can add your own runner instead of introducing a third-party test runner immediately.

Create test/hello_world/test_runner.clj:

1(ns hello-world.test-runner
2  (:require [clojure.test :as test]
3            [hello-world.core-test]))
4
5(defn -main
6  [& _]
7  (let [{:keys [fail error]} (test/run-tests 'hello-world.core-test)]
8    (when (pos? (+ fail error))
9      (System/exit 1))))

Update deps.edn:

1{:paths ["src" "resources"]
2 :deps {org.clojure/clojure {:mvn/version "1.12.4"}}
3 :aliases
4 {:run {:main-opts ["-m" "hello-world.core"]}
5  :test {:extra-paths ["test"]
6         :main-opts ["-m" "hello-world.test-runner"]}}}

Run the tests:

1clojure -M:test

Expected output includes a summary like:

1Ran 1 tests containing 1 assertions.
20 failures, 0 errors.

Leiningen Equivalents

If the project uses Leiningen, use its project tasks:

Do not treat these tools as competing languages. They are different ways to assemble a JVM classpath and invoke Clojure code.

Test the Boundary Separately

Most tests should call pure functions. Boundary behavior can still be tested when needed:

1(deftest main-output-test
2  (testing "prints a greeting"
3    (is (= "Hello, Ada!\n"
4           (with-out-str
5             (core/-main "Ada"))))))

Use boundary tests sparingly. They are helpful for command-line behavior, but they are more brittle than tests over pure return values.

Debugging Failed Runs

Key Takeaways

• Running Clojure code means loading a namespace from the classpath and invoking a function.
• Keep pure logic separate from -main so tests stay small.
• clojure.test is built in and maps naturally to Java unit-testing habits.
• Test paths are explicit in Clojure CLI projects.
• A small runner can make test commands CI-friendly by returning a nonzero exit code.

Quiz: Run and Test