Continuous Integration for API

Introduction

Continuous Integration (CI) is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. This guide covers how to implement CI for APIs, ensuring that your API development process is streamlined, reliable, and efficient.

Why Use Continuous Integration?

Implementing CI offers several benefits:

Automated testing: Ensures that new changes do not break existing functionality.
Faster feedback: Provides immediate feedback on code quality and functionality.
Improved collaboration: Facilitates collaboration between team members by integrating code frequently.
Consistent builds: Ensures that builds are consistent and reproducible.
Reduced integration issues: Minimizes integration problems by detecting issues early.

Setting Up Continuous Integration

Let's set up CI for a Node.js API using GitHub Actions.

1. Create a Node.js API

# Initialize a new Node.js project
mkdir ci-example-api
cd ci-example-api
npm init -y

# Install dependencies
npm install express jest supertest

# Create a simple API
// app.js
const express = require('express');
const app = express();

app.get('/api/users', (req, res) => {
    res.json([{ id: 1, name: 'John Doe' }]);
});

module.exports = app;

// server.js
const app = require('./app');
app.listen(3000, () => {
    console.log('API is running on port 3000');
});

// Create a test
// __tests__/app.test.js
const request = require('supertest');
const app = require('../app');

describe('GET /api/users', () => {
    it('should return a list of users', async () => {
        const response = await request(app).get('/api/users');
        expect(response.status).toBe(200);
        expect(response.body).toEqual([{ id: 1, name: 'John Doe' }]);
    });
});

2. Set Up GitHub Actions

GitHub Actions is a CI/CD service that allows you to automate your workflows. Let's create a GitHub Actions workflow for our Node.js API.

Step 1: Create a Workflow File

# Create a .github/workflows directory
mkdir -p .github/workflows

# Create a workflow file
// .github/workflows/ci.yml
name: CI

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [14.x, 16.x]

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: \${{ matrix.node-version }}

    - name: Install dependencies
      run: npm install

    - name: Run tests
      run: npm test

Step 2: Commit and Push the Code

# Initialize a new Git repository
git init
git add .
git commit -m "Initial commit"

# Create a new repository on GitHub and push the code
git remote add origin https://github.com/yourusername/ci-example-api.git
git branch -M main
git push -u origin main

3. Configure npm Scripts

Update the package.json file to include scripts for running the tests.

// package.json
{
  "name": "ci-example-api",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": {
    "test": "jest"
  },
  "dependencies": {
    "express": "^4.17.1"
  },
  "devDependencies": {
    "jest": "^26.6.3",
    "supertest": "^6.0.1"
  }
}

Monitoring and Reporting

Monitoring and reporting are crucial aspects of CI. GitHub Actions provides built-in features for monitoring workflows and reporting test results.

Monitoring Workflows

After pushing your code, you can monitor the workflow execution in the Actions tab of your GitHub repository.

# GitHub Actions Tab
Navigate to your repository on GitHub.
Click on the "Actions" tab.
View the details of the CI workflow runs.

Generating Test Reports

Generating test reports helps in understanding the test results and identifying issues. Jest can generate test reports in various formats.

# Install jest-junit for generating JUnit reports
npm install jest-junit --save-dev

# Update jest configuration to use jest-junit
// jest.config.js
module.exports = {
  testEnvironment: 'node',
  reporters: [
    'default',
    ['jest-junit', {
      outputDirectory: './reports',
      outputName: 'junit.xml',
    }]
  ]
};

Conclusion

Implementing Continuous Integration (CI) for your APIs ensures that your development process is efficient, reliable, and collaborative. By setting up automated builds and tests with tools like GitHub Actions, you can quickly identify and address issues, leading to more stable and robust APIs. This guide provided a step-by-step process for setting up CI for a Node.js API, but the principles can be applied to any tech stack.