---
title: "Implementing tests in CI | Clarive"
description: "Continuous integration (CI) is now becoming a standard in all software projects. With this, a pipeline is executed for each new feature or change in code that is made, and this allows you to carry out a series of steps to ensure that nothing has been..."
url: "https://clarive.com/blog/implementing-tests-in-your-ci"
published: "2018-03-02"
author: "Manuel Touriño"
---

# Implementing tests in CI

It was never so easy

**Continuous integration** (CI) is now becoming a standard in all software projects. With this, a pipeline is executed for each new feature or change in code that is made, and this allows you to carry out a series of steps to ensure that nothing has been "broken".

One of the main steps that needs to be undertaken in the CI is the implementation of tests, both unit tests and regression tests. The latter can be done in the _nightly build_ that Clarive is responsible for launching on a daily basis, at the time that we pre-define within our Releases.

Unit tests must be run whenever there has been any change in the code. This brings us to our first step. **The unit tests must be run with each change in source code** using a transfer (Continuous Integration) and the tests will be launched in the nightly builds of each new Release. This will ensure that the new version of our product will go onto the market without any bugs or problems in the features that worked well in the current versions.

At the end of this post the reader should know how to:

- **Integrate** tests into a Clarive rulebook.
- **Publish** files in an artifact repository.
- Send **notifications** to users.

## Ready to start

To start this step-by-step guide you need a copy of **Clarive** installed on your server (you can request a \*\* 30-day trial\*\*).

## Overview

For this post, we will use the following workflow:

1- User commit tests. 2- Clarive runs rulebook. 3- Mocha run tests. 4- Clarive post a message in Slack with the report.

For the first part of the development, we will assume that the developer has already written his tests. In this example we will use a simple "Hello world" and some example tests that you can find here and which will use the library _expect.js_, which will be installed during the running of the rulebook.

**Workspace files:**

In this example within our git repository we have the following file **structure**:

```text
`├── .clarive.yml
├── package.json
├── src
│   ├── add.js
│   ├── cli.js
│   ├── divide.js
│   ├── helloWorld.js
│   ├── multiply.js
│   ├── sort.js
│   └── subtract.js
└── test
├── helloWorld.tests.js
├── test-cli.tests.js
└── test.tests.js
`
```

`.clarive.yml`: The **rulebook** file that Clarive runs `package.json`: NPM configuration file. Within this file we have defined a command to run the tests that are found in the test folder:

```text
`"scripts": {
"test": "mocha --reporter mochawesome --reporter-options reportDir=/clarive/,reportFilename=report,reportPageTitle=Results,inline=true"
},
`
```

`src`: Folder where we find the source code. `tests`: Folder where the test files are located.

## Writing a rulebook

The **rulebook** will be **responsible** for running the tests and generating a report to notify the user of the results of the tests.

#### First phase: Running the tests

As we can see in the file skeleton `clarive.yml`, there is a step named **TEST** that we will use to run the tests:

```text
`test:
do:
- log:
level: info
msg: The app will be tested here
`
```

But first, let's define some global **variables**:

```text
`vars:
- workspace: "${project}/${repository}"
- server:  https://<my-clarive>.clarive.io
- art_path: ${server}/artifacts/repo/test-reports
`
```

We can see from the code that we are going to use node.js with mocha, chai and expectjs as libraries to run the tests. And thanks to **Docker** images, we can use a container with mocha and chai already installed, and this means that you only need to install expectjs using the rulebook.

We can now specify the Docker image we're going to use during this TEST phase and then install the expectjs library from our working directory and, finally, update our _package.json_:

```text
`test:
image: mocha-chai-report
do:
- shell:
cmd: |
cd ${workspace}
npm install expect.js
npm install
`
```

Next, we just need to run the tests. As we have already defined the command to run the tests in our _json_ package, we only need to run `npm test`:

```text
`test:
image: mocha-chai-report
do:
- shell:
cmd: |
cd ${workspace}
npm install expect.js
npm install
npm test
`
```

#### Second phase: Publish report

When you finish running the tests, an HTML report will be generated with all the results, thanks to the mochawesome library installed in the Docker image. We will now **publish** this report in our **artifact** repository:

```text
`- publish_report = publish:
repository: Test reports
from: 'report.html'
to: "test-reports/{{ ctx.job('name') }}/"
- log:
level: info
msg: "Report generated successfully!"
`
```

Now, we are now going to complete the POST step. During this step we will inform the users that we want to complete the deployment.

#### Third phase: Notifications

We need to post the message in **Slack**, with a link to the report. To do this, we will have to have our **WebHook** configured in Slack and in Clarive:

Now all that remains is to add the sending of the message to the POST step: From the Slack API any user can configure their own messages. In this case we have configured a message in which the user, on receiving the message, will be able to access the report from the same channel:

```text
`- slack_post:
webhook: SlackIncomingWebhook-1
text: ":loudspeaker: Job *{{ ctx.job('name') }}* finished."
payload: {
"attachments": [
{
"text": "Choose an action to do",
"color": "#3AA3E3",
"attachment_type": "default",
"actions": [
{
"name": "report",
"text": "View test report :bar_chart:",
"type": "button",
"style": "primary",
"value": "report",
"url": "${art_path}/test-reports/{{ ctx.job('name') }}/report.html"
},
{
"name": "open",
"text": "Open Monitor in Clarive",
"type": "button",
"value": "open",
"url": "${server}/r/job/monitor"
}]
}
]
}
`
```

## Lets make continuous integration!

Using Clarive, we can create a Story where we will attach all the code. If we haven't already created a **Project**, we can create one using the Admin panel:

Then we create a **repository** of artifacts (a public one in this case):

Once we have carried out the previous steps we will create the Story in Clarive:

We'll now change the state to "In Progress" and Clarive will **automatically** create a branch in the repository:

From the console we'll clone the repository and change to the branch we've just created:

We'll now place all our files in this branch and **push** them to the repository:

Clarive will automatically generate the deployment:

After finished, we will received the **notification** on the Slack channel that we've selected:

Finally, we can **check** test report in the artifact repository.

## Next Steps:

**In Clarive** \- After making this first contact with Clarive, our Story can be assigned to a **Release** (one that was previously created from the release menu) and, after changing the state to "Ready", the developed feature will be automatically merged into the branch of therelease.

**In Rulebook** \- Well, this is a simple **example**. The rulebook can be as **complex** as the user wants it to be, for example, by adding _if statements_, adding elements in the different deployments. For example, if something has gone wrong, create a new Issue in Clarive automatically, only run tests if the "tests/" folder has been modified in the commit...the po**ssibilities a**re li**mitless!.**

Visit \*\* our documentation\*\* to learn more about the features of Clarive.