Headless CMS

Definitions & benefits

Tools & Concepts

Open source

Features

Authentication

Custom plugins & Marketplace

Webhooks

Multilingual CMS

APIs

Dynamic Zones

User roles & permissions

Content Modeling

Security & Privacy

Use Cases

Ecommerce

Blog

Forum

About Strapi

Life at Strapi

Releases & Roadmap

Events

Community

News

The Tutorials section covers an introduction to Strapi, some advanced technical content, product updates and releases. From basic workaround to in-depth development guides. 

Tutorials

How tos

Get all the latest updates, news and events.

Subscribe to the newsletter 📣

large_Building a mobile application with React Native and Strapi.png

medium_Building a mobile application with React Native and Strapi.png

small_Building a mobile application with React Native and Strapi.png

thumbnail_Building a mobile application with React Native and Strapi.png

Building a mobile application with React Native and Strapi.png

Building a Complete Food Mobile App with React Native and Strapi

Automated testing is important in software development, both during and after production, to ensure the reliability and robustness of applications. Most applications employ `Jamstack` technology to separate their application backend from the frontend code, facilitating data exchange between both the frontend and backend through API calls.

For smooth interaction between the backend and frontend, it's important to test these APIs automatically. In this tutorial, we'll cover how to set up automated testing for a Strapi API using Jest and [Supertest](https://www.npmjs.com/package/supertest).

## Prerequisites

To follow along and complete this tutorial guide, you will need the following:

- Node and Npm installed.
- [Strapi app](https://docs.strapi.io/dev-docs/installation/cli) installed on your system.
- Understand of how to customize Strapi app.
- A basic understanding of Jest and [Supertest](https://www.npmjs.com/package/supertest).

## Why testing Strapi API?

Testing Strapi API is essential for several important reasons:
- Reliability: Testing helps ensure that your Strapi API functions as intended. It verifies that your endpoints return the expected results and perform correctly under various scenarios.
- Bug Detection: Testing helps identify and catch bugs, errors, or unexpected behaviors early in the development process. This allows you to address issues before they reach production, reducing the risk of critical errors affecting your users.
- Maintainability: Automated tests make it easier to maintain your Strapi API over time. When you make changes or refactor code, tests help ensure that your modifications do not introduce new issues.
- Performance: You can create performance tests to evaluate how well your Strapi API performs under various loads. This helps you optimize your application for better scalability and responsiveness.

## What Is Jest?

[Jest](https://jestjs.io/) is a widely used JavaScript testing framework that plays an important role in the development of robust and reliable software applications. It is specifically designed to simplify and enhance the process of testing JavaScript code, making it a popular choice among developers.
Jest is known for its simplicity, speed, and powerful features, empowering us to write and maintain tests efficiently, thereby contributing to the overall quality and reliability of our software applications.

## What is Supertest?

[Supertest](https://www.npmjs.com/package/supertest) is a JavaScript library commonly used for making HTTP requests and testing APIs in web applications. It is particularly valuable for testing RESTful and HTTP-based APIs in a simple and intuitive manner. 
Supertest is often used in conjunction with testing frameworks like Jest or Mocha to automate the process of sending HTTP requests to an API and making assertions about the responses.

## What is SQLite?

[SQLite](https://www.sqlite.org/index.html) is a lightweight, serverless, and self-contained relational database management system (RDBMS) that is frequently used in various software applications. Unlike traditional database systems, SQLite is known for its simplicity, portability, and compactness, which makes it a popular choice for embedded systems, mobile apps, and small-scale web applications.
We will employ SQLite to establish and manage a separate, temporary database environment specifically designed for Jest tests. This temporary database ensures that the tests do not interfere with the actual data in the main database and provides a clean slate for each test run. This approach helps uphold the integrity and isolation of the tests, ensuring they consistently produce accurate results.

## Installing Jest and Supertest

To install both Jest and Supertest, you need to already have a Strapi application installed. To do this, open your terminal, navigate to the folder where the Strapi app is installed, and then run the command below in the terminal.

`npm install jest supertest sqlite3 --save-dev`

## Setting up Jest and Supertest

After installing the packages, we must include Jest and Supertest in the `package.json` configuration for our Strapi application. To do this, open your code editor, navigate to the root folder of your Strapi app, and open the `package.json` file.

First, in the `package.json` file, add the following Jest configuration to the scripts section.

```
    "scripts": {
        "develop": "strapi develop",
        "start": "strapi start",
        "build": "strapi build",
        "strapi": "strapi",
        "test": "jest --forceExit --detectOpenHandles"
      },
```
Next, at the bottom of the `package.json` file, add the following configurations as well.
```
    "jest": {
        "testPathIgnormnePatterns": [
          "/node_modules/",
          ".tmp",
          ".cache"
        ],
        "testEnvironment": "node"
      }
```
Your `package.json` file should look similar to the one in the image below.

![](https://lh4.googleusercontent.com/qw8yksa_KEVRfmtLp5aBc0lZZG89z6LM-yOYzvRoMoV0t48uEqc9W9qQo6soUXf4o7leOjLaPs_mzx19-4mgzg1qZGo-nyVxl9xt2oK-J4Zd7_UzhBCIJ3iU3B6diMmB4v4KTgN4nVQOtv-UctoIwDQ)

## Configuring Sqlite

To set up SQLite in our Strapi application for testing with Jest, first navigate to the `config` folder. Within this folder, create a new directory named `env/test`. Then, create a file called `database.js` in this directory. Open the `database.js` file and insert the following code:

```
    module.exports = ({ env }) => ({
      connection: {
        client: 'sqlite',
        connection: {
          filename: env('DATABASE_FILENAME', '.tmp/test.db'),
        },
        useNullAsDefault: true,
        debug: false
      },
    });
```

## Set Up Strapi Testing Instance

To enable testing in Strapi, we need to create a specific, controllable instance of Strapi that operates in a virtual testing environment without affecting the main project.

First, let's create a folder to house all the test files. From the project's root directory, create a `'test'` folder; this folder will also contain the Strapi test installation file. Within this folder, create a `strapi.js` file and add the following code.
```
    const Strapi = require("@strapi/strapi");
    const fs = require("fs");
    let instance;
    async function setupStrapi() {
      if (!instance) {
        await Strapi().load();
        instance = strapi;
        
        await instance.server.mount();
      }
      return instance;
    }
    async function cleanupStrapi() {
      const dbSettings = strapi.config.get("database.connection");
      //close server to release the db-file
      await strapi.server.httpServer.close();
      // close the connection to the database before deletion
      await strapi.db.connection.destroy();
      //delete test database after all tests have completed
      if (dbSettings && dbSettings.connection && dbSettings.connection.filename) {
        const tmpDbFile = dbSettings.connection.filename;
        if (fs.existsSync(tmpDbFile)) {
          fs.unlinkSync(tmpDbFile);
        }
      }
    }
    module.exports = { setupStrapi, cleanupStrapi };
```

## Testing Strapi API

### Testing Strapi Instance
Our first test is to verify whether the Strapi server and test instance are set up and running correctly. To accomplish this, create a test file named `app.test.js` in the test folder and add the following code:
```
    const fs = require('fs');
    const { setupStrapi, cleanupStrapi } = require("./strapi");
    beforeAll(async () => {
      await setupStrapi();
    });
    afterAll(async () => {
      await cleanupStrapi();
    });
    it("strapi is defined", () => {
      expect(strapi).toBeDefined();
    });
 ```
![](https://lh3.googleusercontent.com/L897A1_KAvRc9LCkjj1QN_UaKewl9nZO3pAUGpeg3h8dCcQKAfRHrZ2XEB2aD1Ehs_AFVl-v665VvxLAvwgXxBpJMK32GmS-wFMxewt8FP0UAFZN68zeriiZsoRRrlMHyIGQ_hHEZan5RCAHS1fI3Cw)


### Testing Strapi's API Response
In this section, we will test the Strapi application's API to ensure that the GET and POST methods function as expected when making requests.
Let's create a simple collection type called ‘`Book`' to be used for testing. From your Strapi dashboard menu, navigate to `Content-Type Builder` → `Create new collection type`, name the collection type `'Book``,'` and then click on the `Continue` button, as shown in the image below.

![](https://lh4.googleusercontent.com/wzyZRFlTsvYjoS3nXp7vYxPKX1VraVzYcUDYvywhnUeJqAaWXTymhbWGNmSpPSrVDh3BCxPCAq-04ezjTRyep3h-DIFGR7jqo-jnOe6ueC3tfq-3koNdkxoVT_U-27O_ZEUiFMrlk1Knp6zsZpo8OYE)


Next, add a `"``booktitle``"` field to the collection type and then click on the `"``Save``"` button.

![](https://lh3.googleusercontent.com/K0jkQaAtGhURx0qiubHD9aFoS8x9SXaG-fqw_rgStZZZKjpawXHRu_GAxuKScbkrnXpck6AJBBNOn4hEQVof_h75fSq1H84wJQYSSfcQVPOC5GvlQ1Vi_bxrZQczSJxf_HpAHVxZ7biTHvQPthXm1Lw)


Before we continue with our testing, let's make our book API endpoint public. To do that, navigate to `Settings` → `USERS & PERMISSIONS PLUGIN` → `Roles` → `Public` → `book.` Under "`book`," select all and then click on the "`Save`" button, as shown below.

![](https://lh3.googleusercontent.com/0j42eIFsLxM6-4IwMeFr2PuM2dZfLMG2x945cn4HAuSkttd_RNxCYPSbLPpw7NXY5g23hwoZckvP3lyqkA9Y1TJLlLYhJXVitaN8KJVUVv7WSVTROdgMkXM3pv2KMnH-82-rRij0giIIs4lfu5n1ysY)



### Testing GET Strapi Request
Let's test whether our Strapi API GET request method for the Book collection type is running successfully and returning the expected response. 
Inside the `'test'` folder, create a `'get.test.js'` file and add the following code.

    const fs = require('fs');
    const { setupStrapi, cleanupStrapi } = require("./helpers/strapi");
    const request = require('supertest');
    beforeAll(async () => {
      await setupStrapi();
    });
    afterAll(async () => {
      await cleanupStrapi();
    });
    it("should return hello world", async () => {
      const response = await request(strapi.server.httpServer).get("/api/books")
        // .expect(200); // Expect response http code 200
        .then((data) => {
            expect(data.text).toContain('Strapi Tutorial');
          });
    });

In the code above, we define a Jest test case that sends a GET request to the `'/api/books'` endpoint of a Strapi API, expecting a `200` HTTP status code, and then verifies that the response text contains the string `'Strapi Tutorial'`.
Running the test command will show you the following output.

![](https://lh4.googleusercontent.com/erI127mlxno0GuH1wgT3Uhvl8zRTogo60U6jmPLS6jOtH688ZWarcXOIpeHDAFn0otbVQZ3aCgBjQZ21ucRyCyFx23m64zPUxmqyhk9eE3kABAH1WQffQAMsdzZE3r4LgoaR_vwugkCIpt051PoUmVk)


### Testing POST Strapi Request
Let's run a test to check whether a POST request successfully inserts data into the ‘`Article`' collection type.
 In the `'test'` folder, create a `'post.test.js'` file and add the following code.

    const fs = require('fs');
    const { setupStrapi, cleanupStrapi } = require("./helpers/strapi");
    const request = require('supertest');
    beforeAll(async () => {
      await setupStrapi();
    });
    afterAll(async () => {
      await cleanupStrapi();
    });
    const mockData = {
        data:{ fullname: "popoola"}
      };
    it("should return hello world", async () => {
      const response = await request(strapi.server.httpServer).post("/api/books")
      .set("accept", "application/json")
      .set("Content-Type", "application/json")
      .send(mockData)
        .then((data) => {
            expect(data.text).toContain('Getting started with strapi');
          });
    });

In the code above, we define a Jest test case that sends a POST request to the `"/api/books"` endpoint of a Strapi API, with specific headers and data, and then verifies that the response text contains the string `'Getting started with strapi'`.

![](https://lh5.googleusercontent.com/EguX8hRIrT8OqsrG3KV_ZS14L_Smd_uhtpahvgwLyrBinZjj706NT9xfIf1ybgJA3lCLN4Xj52W9maCHO6dc3JnTzY2y7YKVWNfI2Z81465UbR0mMcVKxTeJGEP_sHlf0dyKfQzwByc_w11hJUHpgZY)


### Testing Strapi auth Endpoint
We can also test Strapi user authentication endpoints. First, we'll test the functionality of user login JWT by making a POST request to the `'api/auth/local'` endpoint. Create a new test file named `'auth.test.js'` and add the following.

    const fs = require('fs');
    const { setupStrapi, cleanupStrapi } = require("./strapi");
    const request = require('supertest');
    beforeAll(async () => {
      await setupStrapi();
    });
    afterAll(async () => {
      await cleanupStrapi();
    });
    // user mock data
    const mockUserData = {
      username: "tester",
      email: "tester@strapi.com",
      provider: "local",
      password: "1234abc",
      confirmed: true,
      blocked: null,
    };
    it("should login user and return jwt token", async () => {
      /** Creates a new user and save it to the database */
      await strapi.plugins["users-permissions"].services.user.add({
        ...mockUserData,
      });
      await request(strapi.server.httpServer) 
        .post("/api/auth/local")
        .set("accept", "application/json")
        .set("Content-Type", "application/json")
        .send({
          identifier: mockUserData.email,
          password: mockUserData.password,
        })
        .expect("Content-Type", /json/)
        .expect(200)
        .then((data) => {
          expect(data.body.jwt).toBeDefined();
        });
    });

In the code above,we used a Jest test case to verify the functionality of user login and JWT token generation by creating a new user with mock data and sending a POST request to the `"/api/auth/local"` endpoint using the provided user credentials, expecting to receive a JWT token as a response.

![](https://lh6.googleusercontent.com/cUSSBj_kyFSEkEG9TyQtQufcPbAsNNkwMkyscgXGOd1KbwGogd4K0D65Szau5M1mX7rleUeKFD9NOez97PjcqCezujNgr-1rPp69_2MF9uV3loQww08xyar0_b-Zt3PeJlqHX5lnYVeciqIYsElGfEU)

## Conclusion

This article guided you through setting up automated testing for a Strapi API with Jest and Supertest. By adopting this method of automated testing, we ensure rigorous monitoring and verification of the Strapi API endpoints, guaranteeing they operate as intended.



Automated Testing for Strapi API With Jest and Supertest

large_Automated Testing for Strapi API With Jest and Supertest

medium_Automated Testing for Strapi API With Jest and Supertest

small_Automated Testing for Strapi API With Jest and Supertest

thumbnail_Automated Testing for Strapi API With Jest and Supertest

Efficient API Testing with Jest and Supertest: A Step-by-Step Guide for Strapi Applications

Simply copy and paste the following command line in your terminal to create your first Strapi project.