Introduction to Pain Free Mocking with Jest

Course Introduction

Prerequisites

Importance of automated testing

Test classification using the test pyramid

The testing pyramid

What is Jest

Application setup

Everything you need to know to start testing with Jest. You'll set up your environment, learn how to think like a tester with the Testing Pyramid and you'll even write your first test!

Introduction

What is unit test

Entry and exit points

First unit test

Naming and organizing tests

Exercise 1 (Testing for Hash Password Functions)

Exercise 1 solution (Testing for Hash Password Functions)

Set up Jest extension

Introduction to Test Doubles

Mock database

How to test Express controller functions using unit testing principles

Unit test express controller

Exercise 2

Exercise 2 solution

Test coverage

Get started with unit testing and mocking. Write more unit tests, learn how, when, and why to use mocks, stubs, and spies, mock databases and participate in some fun testing exercises.

Getting started with mocking and unit testing

What is integration test

How to use a separate test database instance for testing purposes

Separate database for testing purposes

Test HTTP endpoint

Parallel tests and database connection

Database connection and parallel tests

Exercise 1 (Testing the Login Controller)

Exercise 1 solution (Testing the Login Controller)

Mock API integration using Jest

Mock API integration using Nock

Get started with integration testing. Separate the database from your tests, learn how to test HTTP endpoints, run parallel tests, mock API integrations and participate in even more fun exercises.

Getting started with integration testing

Introduction to test containers

Setup test containers

How to mock the dynamic split join pattern

How to mock slow network

How to mock network failures

Learn advanced mocking and testing techniques. Test complex edge cases like slow or inconsistent networks and learn how to create consistent testing environments with test containers.

Advanced mocking and integration testing

Test costs and maintainability

Version control checks

Create CI/CD pipeline

Note on code coverage

Agile testing quadrant

Become a test strategist by learning about test costs, maintainability and how to have a hollistic testing approach with the Agile Testing Quadrant. Add your tests to the development cycle by setting up Git hooks with Husky and CI pipelines with GitHub actions.

Testing strategy

Conclusion

You did it! By now you'll feel confident testing JavaScript applications with Jest because you have all the knowledge and tools you need to test applications in the real world without headaches.

**Pain Free Mocking with Jest** teaches you how to effectively and painlessly test JavaScript applications with Jest. You'll start by learning how to write unit and integration tests as well as the 'How', 'What', and 'When' of Mocks, Stubs, and Spies. Then we'll move to more advanced technique and strategies you'll be using for the rest of your career, including how to have a hollistic approach to testing and how to automatically add your tests in the development lifecycle.

### The Issue With Unit Testing & Mocks

Writing unit tests has always been equal parts important and confusing. 

While writing your first unit test is simple and easy, the learning curve becomes very steep very quickly once you have to test actual real-life scenarios. 

Because suddenly, you have to know how to **mock a database call** or **spy an HTTP request** or **stub a 3rd party API with a security token**. When you have to test real-life scenarios like that, things become much more complex than they initially seemed.

With every test case being different from the next one, and with Mocks not being used anywhere else in coding except for testing, it's hard to find quality information online. Every answer is different from the next one and is aimed for an ultra-specific scenario that won't necessarily apply to any other case, including yours. 

Instead of making things clear, this confuses things even further. 

### How "Pain Free Mocking with Jest" Helps:

"Pain Free Mocking with Jest" is designed to make testing painless by helping you understand once and for all the 'How', 'What', and 'When' of Mocks, Spies, and Stubs using the Jest testing framework.

You will learn how to write simple and complex test cases, utilize Jest's mocking capabilities, and gain hands-on experience with real-world testing scenarios that involve Databases, HTTP requests, and 3rd Party APIs. 

By the end of the course, you'll feel confident using Mocks, Spies and Stubs in any scenario you may need them. You'll have all the knowledge and tools you need to create complete test suites and confidently test JavaScript applications *with* mocking *without* headaches.

### Course Content Overview

Course Overview:
Total Modules: **6**
Total Lessons: **37**
Total Video Runtime: **2 hours, 28 minutes**

### Summary:
- Build and test a Node.js REST API application with authentication features like 'Sign Up' and 'Sign In'. 
- Learn how to test everything from simple functions all the way to Controllers that interract with 3rd party web services.
- Learn the 'What', 'How', and 'When' of Mocks, Spies, and Stubs.
- Learn to see your application code in testable units. 
- Write integration tests for HTTP endpoints, controllers, middleware functions, and 3rd party integrations.
- Create Git hooks to run unit tests before each commit 
- Build a CI pipeline using Github Actions to automate running integration tests on each git push to Github.

Learn to confidently test JavaScript applications and mock dependencies using Jest, the pain-free way. 

Understand how to painlessly use Mocks, Spies, and Stubs to test any part of your application, without worrying about Databases, APIs and Security Tokens. 

After finishing this course (which only takes a single afternoon), you'll feel confident in your testing skills because you'll have all the knowledge and tools you need to effectively and painlessly test even complex applications in the real world without headaches.

Pain Free Mocking with Jest

How to write unit and integration tests with Jest

How to test functions that interact with Controllers, APIs, and Databases (without relying on their responses)

How to test code in isolation with Mocks, Spies, and Stubs using Mockingoose

How to write integration tests for HTTP endpoints and database connections

Advanced mocking and integration testing techniques like the 3A pattern, network manipulation, and more

How to become a test strategist with the Agile Testing Quadrant, create CI test pipelines, and add tests to the development lifecycle

Setting Up Jest for Automated Testing in Node.js

In this tutorial, we'll guide you through the process of setting up a Node.js project for automated testing using Jest. Automated testing is crucial for ensuring the reliability of your codebase, and Jest provides a robust testing framework for JavaScript applications.

Here's a demo of the final project setup:

Begin by creating a new folder for your project. Open your terminal and run the following command:

Run npm init to initialize your project. Accept default options for most prompts, but set "src/app.js" as the entry point and provide your author name.

Create a "src" folder within your project and add an entry point file, e.g., "app.js."

Run the following command to initialize Jest and create the configuration file:

This creates a "Jest.config.js" file with Jest configuration.

In your "app.js" file, export a function, e.g., getRecipes. Implement a basic test in "tests/app.test.js." Import the getRecipes function and use the test function to assert that recipes.length is greater than 0.

// app.js
const recipeList = [
  {
    "title": "Emerald Pea Pasta",
    "ingredients": "1 c Frozen green peas, defrosted|2 tb Chopped fresh mint|1 1/2 c All purpose flour|1 pn Salt|1 pn Pepper",
    "servings": "2 Servings",
    "instructions": "Place peas & mint in a food processor & puree. Add remaining ingredients & pulse until a ball of dough forms. Turn out onto a floured surface & knead until smooth & pliable like a firm bread dough. Place dough in a bowl, cover with plastic wrap & let rest for at least 30 minutes. Shape & cook dough as desired."
  }
]
module.exports.getRecipes = () => {
  return recipeList
};

// tests/app.test.js
const { getRecipes } = require('../src/app');

test('getRecipes returns a non-empty array', () => {
  const recipes = getRecipes();
  expect(recipes.length).toBeGreaterThan(0);
});

The expect function is a fundamental part of Jest's assertion library. It is used to create an assertion or an expectation about a certain value or behavior in your code. The expect function takes a single argument, which is the value or expression you want to make assertions about.

Matchers are functions attached to the expect object in Jest. They are used to perform specific comparisons and determine whether the actual value meets the expected conditions. In this case, toBeGreaterThan is a matcher that checks if the actual value is greater than the expected value.

Execute the test by running the npm test script:

This runs the Jest test suite and provides a test report in the terminal.

Now you have Jest set up in your Node.js project, and you're ready to start writing and running tests. In the next module, we will delve into mocking and unit testing.

---
title: Application setup
description: Basic application with jest setup
privateVideoUrl: https://stream.mux.com/OZ8g5HlN6NuzvAbmw00UlM5LGArT2mqO4sMeyY1bGaxo.m3u8
isPublicLesson: false
useMdx: true
---

# Setting Up Jest for Automated Testing in Node.js

## Introduction

In this tutorial, we'll guide you through the process of setting up a Node.js project for automated testing using Jest. Automated testing is crucial for ensuring the reliability of your codebase, and Jest provides a robust testing framework for JavaScript applications.

Here's a demo of the final project setup:

<ReplitEmbed src="https://replit.com/@newlineauthors/effective-nodejs-and-react-testing-strategies-with-jest-app" />

## Installation and Basic Test Setup

### Create Project Folder

Begin by creating a new folder for your project. Open your terminal and run the following command:

```bash
mkdir myrecipe
```

Navigate into the project folder:

```bash
cd myrecipe
```

### Initialize npm

Run npm init to initialize your project. Accept default options for most prompts, but set "src/app.js" as the entry point and provide your author name.

```bash
npm init
```

### Create Source Folder and Entry Point

Create a "src" folder within your project and add an entry point file, e.g., "app.js."

### Install Jest

Install Jest as a dev dependency:

```bash
npm install --save-dev jest
```

### Initialize Jest Configuration

Run the following command to initialize Jest and create the configuration file:

```bash
npx jest --init
```

Answer the prompts as follows:

-   Use Jest in package.json scripts: Yes
-   Use TypeScript: No
-   Testing environment: node
-   Add test coverage: Yes
-   Test coverage provider: V8
-   Automatically clear mocks: No

This creates a "Jest.config.js" file with Jest configuration.

### Write a Basic Test

In your "app.js" file, export a function, e.g., getRecipes. Implement a basic test in "tests/app.test.js." Import the getRecipes function and use the test function to assert that recipes.length is greater than 0.

```javascript
// app.js
const recipeList = [
  {
    "title": "Emerald Pea Pasta",
    "ingredients": "1 c Frozen green peas, defrosted|2 tb Chopped fresh mint|1 1/2 c All purpose flour|1 pn Salt|1 pn Pepper",
    "servings": "2 Servings",
    "instructions": "Place peas & mint in a food processor & puree. Add remaining ingredients & pulse until a ball of dough forms. Turn out onto a floured surface & knead until smooth & pliable like a firm bread dough. Place dough in a bowl, cover with plastic wrap & let rest for at least 30 minutes. Shape & cook dough as desired."
  }
]
module.exports.getRecipes = () => {
  return recipeList
};
```

```javascript
// tests/app.test.js
const { getRecipes } = require('../src/app');

test('getRecipes returns a non-empty array', () => {
  const recipes = getRecipes();
  expect(recipes.length).toBeGreaterThan(0);
});
```

### Expect function and Jest Matchers

The expect function is a fundamental part of Jest's assertion library. It is used to create an assertion or an expectation about a certain value or behavior in your code. The expect function takes a single argument, which is the value or expression you want to make assertions about.

Matchers are functions attached to the expect object in Jest. They are used to perform specific comparisons and determine whether the actual value meets the expected conditions. In this case, toBeGreaterThan is a matcher that checks if the actual value is greater than the expected value.

### Run the Test

Execute the test by running the npm test script:

```bash
npm test
```

This runs the Jest test suite and provides a test report in the terminal.

Now you have Jest set up in your Node.js project, and you're ready to start writing and running tests. In the next module, we will delve into mocking and unit testing.
