As applications grow in complexity, managing multiple repositories can become cumbersome and inefficient. Monorepos offer a solution by housing all projects and services in a single repository, allowing for shared dependencies, streamlined CI/CD pipelines, and better collaboration between teams. In this module, we will explore Monorepo Architecture using Nx and Turborepo, two powerful tools for managing full-stack applications within a monorepo setup.

By the end of this module, you’ll understand how to:

1. Set up a monorepo using Nx and Turborepo.
2. Organize full-stack applications (frontend and backend) in a monorepo.
3. Use Nx and Turborepo for efficient builds, caching, and testing.

Table of Contents

1. Introduction to Monorepos
2. Why Choose Nx and Turborepo?
3. Setting Up Nx for Monorepo Architecture
4. Setting Up Turborepo for Monorepo Architecture
5. Organizing Fullstack Apps in the Monorepo
6. Managing Dependencies Across Projects
7. Efficient Builds and Caching with Nx and Turborepo
8. Testing and CI/CD for Monorepos
9. Conclusion

Introduction to Monorepos

A monorepo (short for “mono repository”) is a software development strategy where all code for different projects (frontend, backend, libraries, etc.) is stored in a single version-controlled repository. This structure has several advantages, such as:

• Simplified Dependency Management: Shared libraries and packages are easier to manage.
• Better Collaboration: Teams working on different projects can collaborate more effectively by using a unified codebase.
• Improved Consistency: You can ensure consistent versioning and avoid issues like conflicting dependencies across repositories.

In a full-stack application, a monorepo allows you to manage both the frontend (e.g., React, Angular) and the backend (e.g., NestJS, Express) code within the same repository.

Why Choose Nx and Turborepo?

When managing monorepos, it’s crucial to have the right tools to handle things like dependency management, testing, building, and deployment. Both Nx and Turborepo are excellent tools that offer these capabilities with added features.

Nx Features:

• Advanced Dependency Graph: Nx helps you visualize the relationships between your apps and libraries, allowing for intelligent caching, incremental builds, and efficient testing.
• Powerful CLI: Nx provides a powerful CLI to generate, test, and build apps and libraries.
• Extensible Plugins: Nx has plugins for popular frameworks like React, Angular, NestJS, and Next.js, making it easier to integrate with full-stack applications.

Turborepo Features:

• Fast Builds: Turborepo leverages advanced caching to speed up builds and tests by only running the parts of your monorepo that are affected by changes.
• Optimized CI/CD: Turborepo can dramatically reduce the time spent on CI/CD pipelines by caching and parallelizing tasks.
• Simplified Setup: Turborepo’s configuration is minimal, providing an easier setup for smaller or less complex monorepos.

Both Nx and Turborepo enable efficient workflows, but Nx is ideal for larger, more complex applications due to its feature-rich ecosystem, while Turborepo shines for its simplicity and speed.

Setting Up Nx for Monorepo Architecture

Step 1: Install Nx CLI

To get started with Nx, first install the Nx CLI globally by running:

npm install -g nx

Step 2: Create a New Nx Workspace

You can create a new workspace using the following command:

npx create-nx-workspace@latest

Choose the empty workspace option if you want to create a clean slate, or select a preset (e.g., React, NestJS) to get started quickly with a basic project structure.

Step 3: Add Applications and Libraries

In Nx, you can create both applications and libraries. Applications are the main projects (e.g., frontend and backend), while libraries are reusable modules of code (e.g., shared components, services).

To generate a new application, run:

nx generate @nrwl/react:application my-app

To generate a new library, run:

nx generate @nrwl/workspace:lib my-lib

Step 4: Running the Application

You can run your applications using Nx’s CLI:

nx serve my-app

Nx will automatically start the development server for your app.

Setting Up Turborepo for Monorepo Architecture

Step 1: Install Turborepo

To set up Turborepo, start by installing the Turborepo CLI:

npm install turbo --save-dev

Step 2: Initialize a New Turborepo

You can create a new Turborepo project by running:

npx create-turbo@latest

Choose the desired setup (e.g., nextjs, react, or a custom project).

Step 3: Adding Applications and Libraries

In Turborepo, you can organize your code by creating apps and packages:

• Apps: These are your frontend and backend applications.
• Packages: These are shared libraries that you can import across different applications.

For example, you can create a frontend app like this:

mkdir apps/frontend

And a backend app like this:

mkdir apps/backend

For shared libraries, you can create a package folder:

mkdir packages/shared

Step 4: Running the Application

Turborepo uses caching and parallel execution to speed up the development process. To run all your apps, use the following command:

turbo run dev

Organizing Fullstack Apps in the Monorepo

Frontend and Backend in a Monorepo

When structuring a full-stack app in a monorepo, it is a good practice to separate the frontend and backend into distinct folders under the apps directory. For example:

apps/
  frontend/     # React or Next.js frontend
  backend/      # NestJS or Express backend
packages/
  shared/       # Shared logic and components

You can create a shared library for common logic, such as authentication services, utility functions, or API interfaces, and reference it in both the frontend and backend.

Managing Dependencies Across Projects

Both Nx and Turborepo help manage dependencies across different applications and packages in the monorepo. By leveraging workspaces (in Nx or Yarn), you can share dependencies and ensure consistency across your entire project.

Example: Shared Dependency for Both Apps

In your shared library, you can include dependencies that both your frontend and backend require. For example, if both apps need to use lodash:

1. Install lodash in your shared library: npm install lodash
2. Import lodash in both your frontend and backend apps, referencing the shared library.

Nx and Turborepo will ensure that these shared dependencies are properly resolved and available to all parts of your project.

Efficient Builds and Caching with Nx and Turborepo

Both Nx and Turborepo leverage task-based caching to speed up builds, tests, and other operations. Here’s how it works:

• Nx tracks dependencies between apps and libraries. If you make a change to a library, Nx will only rebuild the apps that depend on it.
• Turborepo uses a global cache for builds, meaning that only the tasks that need to be run (based on code changes) are executed. Caching and parallelization make builds incredibly fast.

Testing and CI/CD for Monorepos

Testing with Nx

Nx provides a powerful testing setup using Jest and Cypress. You can write unit tests for libraries, integration tests for applications, and end-to-end tests using Cypress.

To run tests in Nx, simply use the following command:

nx test my-app

CI/CD with Nx and Turborepo

Both Nx and Turborepo integrate seamlessly into CI/CD workflows. You can configure your CI pipeline to use caching, ensuring faster builds and tests. Tools like GitHub Actions or GitLab CI can be set up to automatically run builds and tests on every commit.

Conclusion

In this module, we explored Monorepo Architecture using Nx and Turborepo for building full-stack applications. These tools provide powerful features like dependency management, caching, testing, and efficient CI/CD setups, making it easier to manage large, complex applications.

With Nx, you get a feature-rich platform for managing complex enterprise applications, while Turborepo offers a simpler, faster alternative for smaller projects. Regardless of your choice, adopting a monorepo approach allows for greater collaboration, consistency, and scalability across your full-stack application.

In modern web development, containerization and cloud deployment have become essential practices for ensuring that applications are portable, scalable, and easy to manage. In this module, we will cover how to build and deploy a NestJS application using Docker, Heroku, and Railway, three of the most popular platforms for deploying web applications.

By the end of this module, you will know how to:

1. Set up Docker for local development and deployment.
2. Deploy your application to Heroku for cloud hosting.
3. Use Railway for a simpler, streamlined deployment process.

Table of Contents

1. Introduction to Docker, Heroku, and Railway
2. Setting Up Docker for NestJS
3. Deploying NestJS App to Docker
4. Deploying NestJS App to Heroku
5. Deploying NestJS App to Railway
6. Best Practices for Docker, Heroku, and Railway Deployment
7. Conclusion

Introduction to Docker, Heroku, and Railway

Before we dive into the specifics of building and deploying, let’s understand the tools we will use:

1. Docker: Docker is a platform that allows you to package applications into containers. Containers provide a lightweight, portable, and consistent environment for your application, ensuring it runs the same on all machines (locally, in the cloud, etc.).
2. Heroku: Heroku is a cloud platform that simplifies the deployment of web applications. It provides a platform-as-a-service (PaaS) that handles much of the infrastructure setup, allowing developers to focus on writing code rather than worrying about servers.
3. Railway: Railway is a cloud platform that automates the process of building, deploying, and managing applications. Railway provides a simple setup process with automatic deployments, making it an excellent choice for rapid development and deployment.

Setting Up Docker for NestJS

Dockerizing your NestJS application allows it to be easily deployed across different environments, whether locally or on cloud platforms like Heroku and Railway.

Step 1: Install Docker

First, ensure you have Docker installed on your machine. You can download it from Docker’s official website.

Step 2: Create a Dockerfile

In the root directory of your NestJS project, create a Dockerfile. This file will define the environment needed to run your application inside a container.

Here is a basic Dockerfile for a NestJS application:

# Use official Node.js image as base
FROM node:16-alpine

# Set working directory in container
WORKDIR /usr/src/app

# Install dependencies
COPY package*.json ./
RUN npm install --production

# Copy the rest of the application code
COPY . .

# Build the application
RUN npm run build

# Expose the port the app will run on
EXPOSE 3000

# Start the application
CMD ["npm", "run", "start:prod"]

Step 3: Create a .dockerignore File

To avoid copying unnecessary files into your Docker container, create a .dockerignore file in the root directory. This is similar to a .gitignore file but for Docker.

node_modules
dist
Dockerfile
.dockerignore
.git
.gitignore

Step 4: Build the Docker Image

To build the Docker image for your application, run the following command in your project directory:

docker build -t nestjs-app .

This command will create an image named nestjs-app.

Deploying NestJS App to Docker

Now that your NestJS app is Dockerized, let’s deploy it locally using Docker.

Step 1: Run the Docker Container

Once the image is built, you can run the application in a Docker container with the following command:

docker run -p 3000:3000 nestjs-app

This will map port 3000 on your local machine to port 3000 in the Docker container. You should now be able to access your app by visiting http://localhost:3000.

Deploying NestJS App to Heroku

Heroku is a cloud platform that provides easy deployment options. It supports Docker-based applications, making it a suitable platform for deploying NestJS.

Step 1: Install Heroku CLI

If you don’t already have the Heroku CLI installed, download and install it from Heroku’s website.

Step 2: Create a Heroku App

To create a new app on Heroku, run:

heroku create your-app-name

This will generate a unique URL for your application, such as https://your-app-name.herokuapp.com.

Step 3: Log In to Heroku

Log in to your Heroku account using the CLI:

heroku login

Step 4: Push Docker Image to Heroku

Once logged in, you can deploy your Dockerized NestJS application by pushing it to Heroku using the following commands:

1. Login to Heroku Container Registry: heroku container:login
2. Tag the Docker Image: docker tag nestjs-app registry.heroku.com/your-app-name/web
3. Push the Docker Image to Heroku: docker push registry.heroku.com/your-app-name/web
4. Release the App: heroku container:release web --app your-app-name

Now, your NestJS app should be deployed and accessible on Heroku at the provided URL.

Deploying NestJS App to Railway

Railway simplifies deployments with a streamlined platform for hosting applications, databases, and other services.

Step 1: Install Railway CLI

You can install the Railway CLI by running:

npm install -g railway

Step 2: Create a Railway Project

To create a new project, run:

railway init

Follow the prompts to create a new project, and link it to your existing NestJS repository.

Step 3: Set Up Docker for Railway

Once your project is initialized, Railway automatically detects your Dockerfile and builds your Dockerized app.

Step 4: Deploy the App to Railway

To deploy your app to Railway, simply run:

railway up

Railway will automatically build and deploy your app. You can monitor the deployment status in the Railway dashboard.

Once deployed, your application will be available on a public URL provided by Railway.

Best Practices for Docker, Heroku, and Railway Deployment

1. Use Multi-Stage Builds in Docker: If your application requires different environments for building and running, consider using multi-stage Docker builds to optimize the image size and reduce unnecessary dependencies. Example of multi-stage Dockerfile: # Build Stage FROM node:16-alpine as builder WORKDIR /usr/src/app COPY package*.json ./ RUN npm install COPY . . RUN npm run build # Production Stage FROM node:16-alpine WORKDIR /usr/src/app COPY --from=builder /usr/src/app/dist ./dist COPY --from=builder /usr/src/app/package*.json ./ RUN npm install --production EXPOSE 3000 CMD ["npm", "run", "start:prod"]
2. Use Environment Variables: Both Heroku and Railway allow you to manage environment variables easily. Use environment variables for secrets like database credentials, API keys, etc., rather than hardcoding them in your application code.
3. Automate Deployment: Integrate CI/CD pipelines for automated testing and deployment. Services like GitHub Actions can automate the process of building, testing, and deploying to Docker, Heroku, or Railway.

Conclusion

In this module, we covered how to build and deploy a NestJS application using Docker, Heroku, and Railway. These tools provide flexible deployment solutions, allowing you to containerize your application, host it in the cloud, and ensure easy scalability.

By following this module, you should now be able to deploy your NestJS applications with ease, ensuring smooth transitions from development to production environments while maintaining portability and scalability.

In modern development workflows, maintaining clean, readable, and consistent code is essential for collaboration and long-term project sustainability. Linting and code formatting help ensure that your codebase follows consistent styles, reduces errors, and improves the overall quality of the code. Additionally, automating these processes through CI/CD (Continuous Integration/Continuous Deployment) ensures that quality checks are run on every commit, promoting efficient collaboration and reducing the chances of bugs being introduced.

In this module, we will focus on setting up linting, code formatting, and CI/CD integration in a NestJS project to streamline development and maintain code quality.

Table of Contents

1. Introduction to Linting, Formatting, and CI/CD
2. Setting Up Linting with ESLint
3. Setting Up Prettier for Code Formatting
4. Integrating Linting and Formatting into CI/CD
5. Running Linting and Formatting in Pre-Commit Hooks
6. Setting Up Continuous Integration (CI) with GitHub Actions
7. Best Practices for Linting, Formatting, and CI/CD
8. Conclusion

Introduction to Linting, Formatting, and CI/CD

Before diving into the specifics, let’s first understand the importance of linting, code formatting, and CI/CD integration:

1. Linting: The process of checking the code for potential errors, coding style violations, or problematic patterns. Linting helps catch errors early in the development process and ensures that the code adheres to a consistent style.
2. Code Formatting: Consistent formatting across the entire codebase helps make the code more readable and easier to maintain. It automatically enforces rules such as indentation, spacing, and line breaks.
3. CI/CD Integration: Automating the testing, linting, and formatting checks in a CI/CD pipeline ensures that every change is validated before it is merged into the main branch. This helps maintain code quality and accelerates the development process by detecting issues early.

Setting Up Linting with ESLint

To enforce consistent code quality, we use ESLint in NestJS. ESLint is a static analysis tool for identifying problematic patterns in JavaScript and TypeScript code.

Step 1: Install ESLint and Related Plugins

First, you need to install the necessary ESLint packages for your NestJS project:

npm install --save-dev eslint @nestjs/eslint-plugin @typescript-eslint/eslint-plugin @typescript-eslint/parser

Step 2: Initialize ESLint Configuration

Create a .eslintrc.js file in the root of your project:

touch .eslintrc.js

Now, configure the ESLint settings. Below is an example configuration:

module.exports = {
  root: true,
  parser: '@typescript-eslint/parser',
  parserOptions: {
    project: './tsconfig.json',
  },
  plugins: ['@nestjs', '@typescript-eslint'],
  extends: [
    'eslint:recommended',
    'plugin:@typescript-eslint/recommended',
    'plugin:@nestjs/eslint-plugin',
  ],
  rules: {
    '@typescript-eslint/no-unused-vars': 'warn',
    'no-console': 'off',
    '@nestjs/no-missing-dependencies': 'warn',
  },
};

In this configuration:

• We are using the TypeScript parser for TypeScript files.
• We are extending some recommended ESLint rules, as well as NestJS-specific rules.
• Custom rules like no-console and no-unused-vars can be tailored to fit the needs of your project.

Step 3: Add ESLint Script to package.json

In your package.json, add a script to run ESLint:

"scripts": {
  "lint": "eslint 'src/**/*.ts' --fix"
}

You can now run the linting script with:

npm run lint

Setting Up Prettier for Code Formatting

While ESLint helps with code quality, Prettier focuses on formatting. Prettier automatically formats your code to make sure it follows a consistent style.

Step 1: Install Prettier

npm install --save-dev prettier eslint-config-prettier eslint-plugin-prettier

Step 2: Create Prettier Configuration

Create a .prettierrc file to define formatting options. Here’s an example configuration:

{
  "semi": true,
  "singleQuote": true,
  "trailingComma": "all",
  "printWidth": 80
}

Step 3: Integrate Prettier with ESLint

In the .eslintrc.js file, add Prettier as an extension:

module.exports = {
  root: true,
  parser: '@typescript-eslint/parser',
  parserOptions: {
    project: './tsconfig.json',
  },
  plugins: ['@nestjs', '@typescript-eslint', 'prettier'],
  extends: [
    'eslint:recommended',
    'plugin:@typescript-eslint/recommended',
    'plugin:@nestjs/eslint-plugin',
    'plugin:prettier/recommended',
  ],
  rules: {
    '@typescript-eslint/no-unused-vars': 'warn',
    'no-console': 'off',
    '@nestjs/no-missing-dependencies': 'warn',
    'prettier/prettier': 'error',
  },
};

Step 4: Add Prettier Script to package.json

Add the following script to your package.json:

"scripts": {
  "format": "prettier --write 'src/**/*.{ts,js}'"
}

Now, you can format your code with:

npm run format

Integrating Linting and Formatting into CI/CD

Incorporating linting and code formatting checks into your CI/CD pipeline ensures that any code pushed to your repository adheres to the set rules.

Step 1: Setting Up GitHub Actions (CI)

Create a .github/workflows/ci.yml file in the root of your project. This file will define the GitHub Actions workflow for continuous integration.

Here’s an example configuration for linting, formatting, and testing:

name: CI Workflow

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

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'

      - name: Install dependencies
        run: npm install

      - name: Run linting
        run: npm run lint

      - name: Run Prettier formatting check
        run: npm run format -- --check

  test:
    runs-on: ubuntu-latest
    needs: lint
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'

      - name: Install dependencies
        run: npm install

      - name: Run tests
        run: npm run test

This configuration ensures that:

• Linting is run on every push and pull request to the main branch.
• Prettier is used to check formatting.
• Tests are executed after linting passes.

Running Linting and Formatting in Pre-Commit Hooks

To ensure that linting and formatting checks are always run before commits, you can use Husky and lint-staged to run these checks in a pre-commit hook.

Step 1: Install Husky and lint-staged

npm install --save-dev husky lint-staged

Step 2: Set Up Husky

Enable Husky by running:

npx husky install

Then, add the following script to your package.json:

"scripts": {
  "prepare": "husky install"
}

Step 3: Configure lint-staged

Add the following lint-staged configuration to your package.json:

"lint-staged": {
  "*.ts": [
    "eslint --fix",
    "prettier --write"
  ]
}

Now, every time you commit, Husky will run the configured linting and formatting checks.

Best Practices for Linting, Formatting, and CI/CD

• Enforce Linting and Formatting Locally and Remotely: Set up Husky pre-commit hooks and CI/CD pipelines to enforce linting and formatting both locally and on remote branches.
• Automate Testing in CI: Integrate automated tests into your CI pipeline to run with every commit or pull request.
• Use Strict Rules: Use stricter linting and formatting rules to catch issues early and maintain consistency across the codebase.
• Keep the CI Configuration Simple: Focus on the essential tasks like linting, formatting, and testing in your CI pipeline to ensure fast feedback.

Conclusion

In this module, we have explored how to set up linting and code formatting in a NestJS project using ESLint and Prettier. We also integrated these tools into a CI/CD pipeline with GitHub Actions to automate quality checks on every commit or pull request. Finally, we explored how to run linting and formatting checks using Husky and lint-staged in pre-commit hooks to enforce code quality locally.

By automating these processes, you ensure that your project maintains high standards of code quality, improving collaboration and reducing errors in production.

End-to-End (E2E) testing is a critical part of testing in any application. It ensures that the entire system works together as expected, from the frontend all the way to the backend, including all layers of your application. NestJS, with the help of the @nestjs/testing module and Jest, makes it easy to implement effective E2E tests.

In this module, we will dive into End-to-End testing using NestJS, where we’ll learn how to set up an E2E testing environment, test the flow of data across various layers, and ensure that the entire application behaves as expected in a production-like environment.

Table of Contents

1. Introduction to End-to-End Testing
2. Setting Up the Testing Environment
3. Writing E2E Tests in NestJS
4. Using Supertest for HTTP Assertions
5. Testing Full API Workflow
6. Mocking and Handling Dependencies
7. Best Practices for E2E Testing in NestJS
8. Conclusion

Introduction to End-to-End Testing

End-to-End tests simulate real user interactions and verify that the entire system works as expected. E2E testing goes beyond unit and integration tests by verifying that the entire flow—from database interactions to HTTP responses—functions correctly.

For NestJS applications, E2E tests typically focus on testing controllers, services, and other components as a whole, by making HTTP requests, validating responses, and ensuring that the system behaves like it would in production.

Setting Up the Testing Environment

To get started with E2E testing in NestJS, you’ll need to set up a dedicated environment for running tests. NestJS uses Jest and Supertest to make this process seamless.

Install Dependencies

If you haven’t already, install the necessary dependencies:

npm install --save-dev jest @nestjs/testing ts-jest @types/jest supertest

Add or update the jest.config.js file to include E2E settings:

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  globalSetup: './test/setup.ts',
  testTimeout: 30000,  // Ensure the timeout is long enough for E2E tests
};

Writing E2E Tests in NestJS

NestJS integrates Jest with its testing utilities to allow you to write comprehensive E2E tests. The E2E tests can be written using @nestjs/testing, and tests are typically located in the test folder.

Example: Writing a Basic E2E Test

To begin, let’s test an endpoint in the app. Suppose you have a simple UsersController with a GET /users route that fetches user data.

Here’s how you can write a simple E2E test for it:

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';

describe('UsersController (E2E)', () => {
  let app: INestApplication;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('should return a list of users (GET /users)', async () => {
    const response = await request(app.getHttpServer()).get('/users');
    expect(response.status).toBe(200);
    expect(response.body).toEqual(expect.arrayContaining([expect.objectContaining({ id: expect.any(String), name: expect.any(String) })]));
  });

  afterAll(async () => {
    await app.close();
  });
});

Key Steps:

1. Setup: The beforeAll hook initializes the INestApplication instance using the AppModule.
2. Test: The it block makes an HTTP request using Supertest and checks the response’s status and structure.
3. Teardown: The afterAll hook ensures that the NestJS application is closed after the test.

In the example above, we send a GET request to the /users route and verify that the response contains an array of users.

Using Supertest for HTTP Assertions

Supertest is a great utility for performing HTTP assertions in Node.js applications, and it works perfectly for E2E testing in NestJS. It allows you to simulate HTTP requests and check if the application behaves correctly under different conditions.

Example: POST Request with Body Validation

Let’s extend our E2E test by testing a POST /users route that creates a new user.

it('should create a new user (POST /users)', async () => {
  const newUser = { name: 'John Doe', age: 30 };

  const response = await request(app.getHttpServer())
    .post('/users')
    .send(newUser)
    .expect(201);

  expect(response.body.name).toBe(newUser.name);
  expect(response.body.age).toBe(newUser.age);
  expect(response.body).toHaveProperty('id');
});

Here, we simulate a POST request with a newUser payload and verify that the server returns a status of 201 and includes the correct user data in the response.

Testing Full API Workflow

One of the primary use cases for E2E tests is testing the full API workflow, including making sure that controllers, services, and repositories work together as expected.

Example: Full API Workflow Test

In this example, we’ll simulate the flow where the user data is sent to a service, saved in the database, and returned via the controller.

it('should create and return a user (full workflow)', async () => {
  const newUser = { name: 'Jane Doe', age: 25 };

  // Create a new user
  const createResponse = await request(app.getHttpServer())
    .post('/users')
    .send(newUser)
    .expect(201);

  const createdUserId = createResponse.body.id;

  // Fetch the user
  const getResponse = await request(app.getHttpServer())
    .get(`/users/${createdUserId}`)
    .expect(200);

  expect(getResponse.body.name).toBe(newUser.name);
  expect(getResponse.body.age).toBe(newUser.age);
  expect(getResponse.body.id).toBe(createdUserId);
});

Explanation:

1. Create User: We first send a POST request to create a user.
2. Fetch User: Then, we use the GET endpoint to fetch the user by their ID.
3. Assertions: Finally, we assert that the user data returned matches what we created.

This type of test ensures that the entire flow—from creating to fetching the user—works correctly.

Mocking and Handling Dependencies

In some cases, it may be necessary to mock certain dependencies during E2E tests, especially if those dependencies interact with external services like databases, file systems, or third-party APIs.

Example: Mocking a Service

Suppose we have a service that interacts with an external payment API. During E2E testing, you might want to mock the payment gateway to avoid real transactions.

const mockPaymentService = {
  processPayment: jest.fn().mockResolvedValue({ status: 'success' }),
};

const moduleFixture: TestingModule = await Test.createTestingModule({
  imports: [AppModule],
  providers: [
    {
      provide: PaymentService,
      useValue: mockPaymentService,
    },
  ],
}).compile();

In this case, we use Jest’s jest.fn() to mock the processPayment method of the PaymentService during testing.

Best Practices for E2E Testing in NestJS

• Isolate Tests: Always ensure that your tests are isolated from production data. Use in-memory databases or mock services where possible.
• Test Realistic Use Cases: Ensure that the E2E tests simulate real user interactions and cover the full workflow of your application.
• Clean Up After Tests: Make sure to clean up any test data created during the tests, especially when using real databases.
• Use CI/CD Pipelines: Automate your E2E tests by running them in a Continuous Integration pipeline to catch errors early in the development cycle.

Conclusion

In this module, we explored how to perform End-to-End (E2E) testing in NestJS using Jest and Supertest. We covered how to set up a testing environment, write tests for controllers and services, and simulate real HTTP requests to verify the full API workflow. By writing comprehensive E2E tests, you can ensure that your entire application works correctly, providing a seamless experience for end users.

E2E testing is crucial for identifying issues that might not be visible in unit or integration tests, ensuring that all components of your system work together as intended.

Testing is an essential part of software development, ensuring that your application behaves as expected and preventing bugs. NestJS provides excellent tools and support for both unit and integration testing, allowing you to write tests that ensure the reliability and correctness of your codebase.

In this module, we will dive deep into unit testing and integration testing in NestJS, covering how to test services, controllers, and how to set up a testing environment. We will also look at the best practices for writing effective tests.

Table of Contents

1. Introduction to Testing in NestJS
2. Setting Up the Testing Environment
3. Unit Testing in NestJS
   • Writing Tests for Services
   • Mocking Dependencies
4. Integration Testing in NestJS
   • Setting Up Integration Tests
   • Testing Controllers and Routes
5. Using @nestjs/testing Module
6. Best Practices for Testing in NestJS
7. Conclusion

Introduction to Testing in NestJS

NestJS uses Jest as its default testing framework, which provides an easy-to-use, powerful testing environment. Jest supports unit tests, integration tests, mocking, and much more. Unit tests are designed to test individual parts of your application in isolation, while integration tests are used to test how components interact with each other.

In this module, we’ll explore both types of testing and demonstrate how to implement them effectively in a NestJS project.

Setting Up the Testing Environment

To get started with testing in NestJS, you must first set up the testing environment. NestJS uses the @nestjs/testing package to facilitate the setup of unit and integration tests.

Install Dependencies

NestJS comes with Jest pre-configured. However, if you’re starting from scratch, ensure you have the necessary dependencies:

npm install --save-dev jest @nestjs/testing ts-jest @types/jest

You also need to configure your jest.config.js file for NestJS if it’s not already set up:

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
};

Unit Testing in NestJS

Unit tests are used to verify the behavior of individual units or components, such as services or methods, in isolation from other parts of the system. When writing unit tests, it’s essential to mock external dependencies to isolate the unit being tested.

Writing Tests for Services

Services in NestJS are typically where business logic resides, and they are an excellent candidate for unit testing. For example, if we have a UsersService that contains a method for fetching user data, we can write unit tests for it.

Example: Unit Test for a Service

Consider a UsersService with a findOne() method:

@Injectable()
export class UsersService {
  constructor(@InjectRepository(User) private userRepository: Repository<User>) {}

  async findOne(id: string): Promise<User> {
    return await this.userRepository.findOne(id);
  }
}

To write a unit test for findOne, we’ll mock the userRepository dependency:

import { Test, TestingModule } from '@nestjs/testing';
import { UsersService } from './users.service';
import { getRepositoryToken } from '@nestjs/typeorm';
import { User } from './user.entity';

describe('UsersService', () => {
  let service: UsersService;
  let mockUserRepository: Partial<Repository<User>>;

  beforeEach(async () => {
    mockUserRepository = {
      findOne: jest.fn().mockResolvedValue({ id: '1', name: 'John' }),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        {
          provide: getRepositoryToken(User),
          useValue: mockUserRepository,
        },
      ],
    }).compile();

    service = module.get<UsersService>(UsersService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('should return a user by ID', async () => {
    const result = await service.findOne('1');
    expect(result).toEqual({ id: '1', name: 'John' });
    expect(mockUserRepository.findOne).toHaveBeenCalledWith('1');
  });
});

In this test, we mock the userRepository and test that the findOne() method of the service correctly returns a user object.

Mocking Dependencies

Mocking dependencies allows us to isolate the service or component being tested. In the example above, we used Jest’s jest.fn() method to mock the findOne method of the repository.

This ensures that the actual database interaction is not triggered during testing, providing more control over the test environment.

Integration Testing in NestJS

Integration tests focus on testing the interaction between multiple components or systems. These tests are typically broader in scope and ensure that the parts of your application work together as expected.

Setting Up Integration Tests

To write integration tests in NestJS, we create an instance of the NestJS application using Test.createTestingModule(), similar to how we set up unit tests. However, in integration tests, we aim to run the application in a test environment, where real or mocked modules are used to test how components interact.

import { Test, TestingModule } from '@nestjs/testing';
import { AppModule } from '../src/app.module';
import { INestApplication } from '@nestjs/common';

describe('AppController (e2e)', () => {
  let app: INestApplication;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('/GET users', async () => {
    const response = await request(app.getHttpServer()).get('/users');
    expect(response.status).toBe(200);
    expect(response.body).toEqual(expect.arrayContaining([expect.objectContaining({ id: expect.any(String), name: expect.any(String) })]));
  });

  afterAll(async () => {
    await app.close();
  });
});

In the above example, we use supertest (integrated with Jest) to make HTTP requests to the app and validate the responses. The test checks whether the /GET users endpoint returns the correct status and structure.

Testing Controllers and Routes

In integration tests, controllers are tested by sending HTTP requests to routes. This ensures that the controller correctly interacts with the services and provides the expected responses.

Example: Testing a Controller

import { Test, TestingModule } from '@nestjs/testing';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { getRepositoryToken } from '@nestjs/typeorm';
import { User } from './user.entity';

describe('UsersController', () => {
  let controller: UsersController;
  let service: UsersService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [UsersController],
      providers: [
        UsersService,
        {
          provide: getRepositoryToken(User),
          useValue: {},
        },
      ],
    }).compile();

    controller = module.get<UsersController>(UsersController);
    service = module.get<UsersService>(UsersService);
  });

  it('should return a user', async () => {
    const user = { id: '1', name: 'John' };
    jest.spyOn(service, 'findOne').mockResolvedValue(user);

    expect(await controller.getUser('1')).toEqual(user);
  });
});

This test checks that the UsersController correctly delegates the logic to the UsersService and returns the expected user object.

Using @nestjs/testing Module

The @nestjs/testing module is a powerful tool for testing in NestJS. It provides utilities like:

• createTestingModule(): This method allows you to create a testing module with the same setup as your main application.
• get(): It helps retrieve the provider (service, controller, etc.) to be tested.
• compile(): Compiles the testing module, which initializes and prepares it for use.

This module ensures that unit and integration tests are straightforward and allow NestJS applications to be tested in an isolated and controlled environment.

Best Practices for Testing in NestJS

• Keep Tests Isolated: For unit tests, make sure that each test case is isolated from the others. Use mocking to ensure that you’re not testing external dependencies.
• Test Public APIs: When performing integration tests, focus on testing the public interfaces of the application, such as HTTP endpoints, rather than private implementation details.
• Use In-Memory Databases: For integration tests that require database interaction, use an in-memory database like SQLite or MongoDB in memory to keep tests fast and isolated from the production environment.
• Test Edge Cases: Always test edge cases, error handling, and failure scenarios to ensure robustness in your application.
• Run Tests on CI/CD: Make sure to integrate your tests into your Continuous Integration and Continuous Deployment pipeline to catch bugs early.

Conclusion

In this module, we explored unit testing and integration testing in NestJS, covering the setup, writing tests, and mocking dependencies. We also discussed how to test services, controllers, and routes using Jest and @nestjs/testing.

By following best practices and leveraging the tools provided by NestJS, you can ensure that your application is robust, maintainable, and free of bugs. Testing is essential for delivering high-quality software, and NestJS offers a streamlined approach to writing tests with minimal setup.