Svelte Basics

Styling React Components

Here's how to set up clojure testing environment.



Let's start a new project directory and create a `src` directory:

```
mkdir src
```

Let's create the source file with `src/calc.clj`. There's a simple namespace declaration and function that adds 2 numbers.

```
(ns calc)

(def add [a b]
  (+ a b))
```

Now let's test that `add` function. We need a test runner. There are a couple. The most standard is [test-runner](https://github.com/cognitect-labs/test-runner). Prep for install by adding it to the dependencies list in you project root with `vim deps.edn`:


```
{:aliases
 {:test {:extra-paths ["test"]
         :extra-deps {io.github.cognitect-labs/test-runner
                      {:git/url "https://github.com/cognitect-labs/test-runner.git"
                       :sha "a85b3b02765fb68684ab9ee4a8598eacf7e471d2"}}
         :main-opts ["-m" "cognitect.test-runner"]
         :exec-fn cognitect.test-runner.api/test}}}
```

We are creating an alias that we can call to run tests, called `:test`.


Next, create a `test` directory to store the test file:

```
mkdir test
```

And create that test file with `vim test/calc_test.clj`:

```
(ns calc-test
  (:require [clojure.test :refer [is deftest]]
            [calc])

(deftest test-add
  (is (= 4 (calc/add 3 1))))
```

Note that the significant parts of this setup. For test-runner to find the test:

1. Put the test files in the `test/` directory.
2. Use a `-test`-suffixed namespace.
3. Define tests with `deftest`.

Now we can run the test via our alias by executing:

```
clj -X:test
```

This will give you some output like:

```
Running tests in #{"test"}

Testing calc-test

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

Does it get any simpler? What's your setup?

Simplest Clojure Test

Here's a quick, straightforward way to install Clojure on MacOS.



## Install Java

First, you need the JDK. You can get that in a lot of ways. It's nice to have a utility to help you manager versions of the Java JDK. [Jabba](https://github.com/shyiko/jabba) is such a version manager. Install it with:

```
curl -sL https://github.com/shyiko/jabba/raw/master/install.sh | bash && . ~/.jabba/jabba.sh
```

Now with jabba, you can install the JDK. List what's available with:

```
jabba ls-remote
```

Then choose one to install, such as:

```
jabba install openjdk@1.17.0
```

If you already have a JDK installed with jabba, switch to use it:

```
jabba use openjdk@1.17.0
```

## Install Clojure

If you're on Mac, you probably have [brew](https://brew.sh/) installed. If not, get that. Then use brew to install Clojure:

```
brew install clojure/tools/clojure
```

## Try it out

Now you should be able to start up a Clojure REPL with:

```
$ clojure

Clojure 1.11.1
user=> (+ 1 1)
2
```

Installed. Now go and wrap your life in parens.

Install Clojure

How to run just one test with [pytest](https://docs.pytest.org/en/7.1.x/).



After you make your [first test](/post/simplest-pytest-setup), you'll make hundreds more. But to run them all takes a lot of time. So if you're working in one corner of the code, just run the tests that you care about.

## Run a single file

To run a single test file, such as pie_test.py, run:

```
pytest path/to/pie_test.py
```

## Run related files

If you want to run all the tests related to pie, such as `pie_service_test.py` and `pie_model_test.py` at the same time, run the same command with the substring:

```
pytest path/to/pie*
```

You can put multiple paths on that command, space-delimited.

## Run a single test in the file

What if you have many different tests in the `pie_test.py` file, such as:


```python
def test_one():
    # ...

def test_two():
    # ...

def test_three():
    # ...
```

And you only want to run `test_two`, you can use the `-k` parameter to match on function name substring:

```
pytest path/to/pie_test.py -k two
```

Now you can narrow down and run only the test you want to. Next, [watch the source and re-run the test on change](/post/watch-source-rerun-test-pytest).

Run Single pytest Test

This is how you can watch for changes to your source file and re-run the test on change with [pytest](https://docs.pytest.org/en/7.1.x/).



Pytest needs a plugin to be able to watch for file changes. Install the [simplest pytest setup](/post/simplest-pytest-setup), including installing this plugin, [pytest-watch](https://github.com/joeyespo/pytest-watch). 

Then you can use the `ptw` command in place of `pytest`.

Use this command and pass the path of both the source and the test files. Thus, changes to either will be watched. Imagine a file structure like:

```
├── __init__.py
├── module.py
├── module_test.py
```

Match the test and source pattern at once with a substring:

```
ptw module*
```

Now changes to either file will re-run the test.

Watch the source file and re-run the test on change with pytest

Skill up with a sweet course

Find spicey tips in tech

Simplest Clojure Test

Install Clojure

Run Single pytest Test

Watch Source and Re-run Pytest on Change