Writing Test Cases and Assertions in Clojure

11.2.1 Writing Test Cases and Assertions in Clojure

Testing is a fundamental aspect of software development, ensuring that code behaves as expected and reducing the risk of bugs. In Clojure, the primary library for testing is clojure.test, which provides a robust framework for writing and running tests. This section will guide you through setting up clojure.test, defining tests, and writing assertions, with practical examples to illustrate these concepts.

Setting Up clojure.test

To begin writing tests in Clojure, you need to include the clojure.test library in your project. This is typically done by requiring it in your test namespace. Here’s how you can set up clojure.test:

Including clojure.test in Your Project

If you’re using Leiningen, ensure that your project.clj file is set up to include test paths. By default, Leiningen includes test as a source path, so you can place your test files there. You don’t need to explicitly add clojure.test as a dependency since it’s part of the Clojure core library.

Using the ns Macro with :require

In your test file, you’ll use the ns macro to declare the namespace and require clojure.test. Here’s an example:

(ns myapp.core-test
  (:require [clojure.test :refer :all]
            [myapp.core :refer :all]))

In this example, myapp.core-test is the namespace for your tests, and clojure.test is required with all its public functions. The myapp.core namespace is also required, as it contains the functions you want to test.

Defining Tests

Once clojure.test is set up, you can start defining your tests. The primary macro for defining test functions is deftest.

Using deftest to Define Test Functions

The deftest macro is used to define a test function. Each test function can contain multiple assertions. Here’s a simple example:

(deftest addition-test
  (is (= 4 (+ 2 2)))
  (is (= 5 (+ 2 3))))

In this example, addition-test is a test function that contains two assertions, checking the results of addition operations.

Example of Simple Test Cases

Let’s consider a simple function and write a test for it:

(defn add [a b]
  (+ a b))

(deftest test-add
  (is (= 5 (add 2 3)))
  (is (= 0 (add -1 1)))
  (is (= -3 (add -1 -2))))

Here, the add function is tested with different inputs to ensure it behaves correctly.

Assertions

Assertions are the heart of any test. They check whether the actual output of a function matches the expected output. clojure.test provides several assertion functions, with is being the most commonly used.

Introducing Assertion Functions

• is: The basic assertion function. It checks if a given expression evaluates to true.
• are: Allows for more concise tests by checking multiple conditions in a single expression.
• testing: Provides a way to group related assertions and give them a descriptive label.

Using is with Different Conditions

The is function can be used to test various conditions, such as equality, exception handling, and more.

Testing Equality

(deftest equality-test
  (is (= 4 (+ 2 2)))
  (is (not= 5 (+ 2 2))))

Testing Exception Handling

You can use is to test if a function throws an expected exception:

(deftest exception-test
  (is (thrown? ArithmeticException (/ 1 0))))

In this example, thrown? checks if dividing by zero throws an ArithmeticException.

Using are for Concise Tests

The are macro is useful for testing multiple conditions with similar structure:

(deftest arithmetic-tests
  (are [x y result] (= result (+ x y))
    1 2 3
    -1 1 0
    0 0 0))

Here, are iterates over the provided data and checks if the sum of x and y equals result for each case.

Grouping Assertions with testing

The testing macro helps organize tests by grouping related assertions under a descriptive label:

(deftest grouped-tests
  (testing "Addition"
    (is (= 4 (+ 2 2)))
    (is (= 5 (+ 2 3))))
  (testing "Subtraction"
    (is (= 0 (- 2 2)))
    (is (= -1 (- 2 3)))))

Example: Writing Assertions for Expected Outcomes

Let’s walk through a more comprehensive example, including a sample function and corresponding unit tests.

Sample Function

Consider a function that calculates the factorial of a number:

(defn factorial [n]
  (if (<= n 1)
    1
    (* n (factorial (dec n)))))

Writing Unit Tests

Now, let’s write tests for the factorial function:

(deftest test-factorial
  (testing "Factorial of positive numbers"
    (is (= 1 (factorial 0)))
    (is (= 1 (factorial 1)))
    (is (= 2 (factorial 2)))
    (is (= 6 (factorial 3)))
    (is (= 24 (factorial 4))))
  (testing "Factorial of negative numbers"
    (is (thrown? IllegalArgumentException (factorial -1)))))

In this example, the test-factorial function contains two groups of assertions: one for positive numbers and one for negative numbers. The thrown? assertion checks if an exception is thrown for negative input.

Best Practices for Writing Tests

• Keep Tests Independent: Each test should be independent and not rely on the outcome of other tests.
• Use Descriptive Names: Name your test functions and assertions descriptively to convey their purpose.
• Test Edge Cases: Ensure you test edge cases and not just typical scenarios.
• Run Tests Frequently: Integrate tests into your development workflow and run them frequently to catch issues early.

Common Pitfalls and Optimization Tips

• Avoid Complex Logic in Tests: Tests should be straightforward and focus on verifying behavior, not implementing complex logic.
• Minimize External Dependencies: Tests should run quickly and reliably, so minimize dependencies on external systems.
• Use Mocks and Stubs: When testing functions that interact with external systems, use mocks and stubs to simulate those interactions.

Conclusion

Writing effective test cases and assertions in Clojure is crucial for building reliable software. By leveraging clojure.test, you can define comprehensive tests that ensure your code behaves as expected. Remember to follow best practices, test edge cases, and keep your tests independent and descriptive.

Quiz Time!