Jest and Supertest

testing.md

Testing Discussion #2

1. What is the role of the describe and it functions in Jest? How do they help in organizing and structuring test cases?
2. Explain how to use Supertest for testing HTTP endpoints in an Express.js application. What are the steps involved in setting up Supertest?
3. Discuss the purpose of mocking in Jest. How can you use jest.mock to simulate dependencies in your tests? Provide an example of mocking a database module in an Express.js application.
4. How can you use Jest’s expect function to perform assertions in your tests? Provide examples of different types of assertions (e.g., toEqual, toBe, toMatchObject) and explain when to use each.
5. What are hooks in Jest, and how can they be used to set up and tear down test environments? Describe the differences between the hooks and provide scenarios where each hook might be appropriately used.

@bonolo @Lethukuthula @ImisebenziEmihle

1** Role of Describe()** :

Grouping Related Tests:
describe acts as a container for all tests related to a specific functionality, module, or class.
This grouping allows you to categorize tests logically, making them easier to understand and navigate.
It enhances the readability of your test suite, especially as it grows in size.

Nesting for Deeper Hierarchy:
You can further organize tests by nesting describe blocks within each other.
This creates a hierarchical structure that reflects the relationships between components or functionalities being tested.

How they help in organizing & structuring test cases :
Descriptive Naming:
When using describe, we provide clear and concise names that accurately describe the tests being grouped.
This name becomes the heading for the section and helps developers quickly identify the focus of the tests.
Improved Readability: A well-structured test suite with clear groupings is easier to comprehend for both beginners and experienced developers.
Maintainability: As your codebase and test suite evolve, adding or modifying tests becomes simpler with clear boundaries established by describe blocks.
Focus on Specific Areas: When debugging or investigating an issue, developers can easily locate relevant tests by filtering according to the describe sections.
Modular Testing: Breaking down the test suite into smaller, well-defined units with describe facilitates parallel test execution (if your testing framework supports it), potentially reducing test run times.
Role of it() :
Defining Individual Tests:
Nestled within describe blocks, it() functions define individual test cases. Each it() specifies a specific behavior or functionality being tested.
Descriptive Names:
As with describe, we provide meaningful names for it() functions that capture the essence of the test being performed.
This clarity allows developers to easily grasp the expected behavior without needing to delve into the implementation details.

2. Supertest is a Node.js library used for testing HTTP endpoints in an Express.js application. To use Supertest, first, install it using npm install supertest. Import Supertest and your Express app in your test file. Use Supertest's request function to make HTTP requests to your endpoints. You can chain methods like .get(), .post(), .put(), or .delete() to specify the HTTP method. Chain .expect() to set the expected HTTP status code and response. Finally, call .end(done) to finish the test. This allows you to automate and validate the behavior of your HTTP endpoints effectively.
   2.1 To set up Supertest, follow these steps:
   Install Supertest: Run npm install supertest.
   Create Test File: Create a test file, e.g., test/app.test.js.
   Import Modules: Import Supertest and your Express app in the test file

3. Mocking in Jest
   The purpose of mocking in Jest is that it enables testing of a unit of code independently of its dependencies to ensure that tests only concentrate on the logic of the code being tested. It gives one control over how dependencies behave, allowing them to test how their code reacts to various situations, including errors or specific return values.

Simulate Dependencies : We can use jest.mock to simulate dependencies on our tests by creating mock functions for modules or components, this will help us when we want to test a function or component in isolation without actually invoking the real dependencies.

Mocking examples in Express

// bookService.test.js
const { fetchBookById } = require('./bookService');
const booksDB = require('./booksDB');

describe('fetchBookById', () => {
it('should return book data for
a valid ID', async () => {
// Arrange: Set up the original implementation
const mockBook = { id: '1', title: '1984', author: 'George Orwell' };
jest.spyOn(booksDB, 'readById').mockResolvedValue(mockBook);

// **Act: Call the function**
const book = await fetchBookById('1');

// Assert: Verify the result
expect(book).toEqual(mockBook);

// Restore the original method
booksDB.readById.mockRestore();
});

it('should handle errors
gracefully', async () => {
// Arrange: Set up the mock to throw an error
const errorMessage = 'Book not found';
jest.spyOn(booksDB, 'readById').mockRejectedValue(new Error(errorMessage));

// **Act & Assert: Verify that the function handles the error**
await expect(fetchBookById('1')).rejects.toThrow(errorMessage);

// **Restore the original method**
booksDB.readById.mockRestore();

});

it('should return undefined when
readById returns undefined', async () => {
// Arrange: Temporarily replace the implementation
jest.spyOn(booksDB,
'readById').mockImplementation((id) => undefined);

// Act**: Call the function**
const book = await fetchBookById('1');

// Assert: **Verify the result**
expect(book).toBeUndefined();

// **Restore the original method**
booksDB.readById.mockRestore();

});
});

4. Jest Expect function :
   You can use Jest’s expect function to perform assertions in your tests by writing test cases where you call expect with the actual value you want to test and then chain matchers to specify the expected outcome. Jest provides various matchers like toEqual, toBe, toContain, and toThrow to handle different types of assertions. The expect function helps compare the actual result with the expected value, ensuring your code behaves as intended.

Different types of assertions
toEqual:
Example: expect({ name: 'Alice' }).toEqual({ name: 'Alice' });
Use: Check deep equality for objects/arrays.

.toBe:
Example: expect(2 + 2).toBe(4);
Use: Check strict equality for primitives.

.toMatchObject:
Example: expect({ name: 'Alice', age: 25 }).toMatchObject({ name: 'Alice' });
Use: Check partial matches in objects.

.toContain:
Example: expect(['apple', 'banana']).toContain('banana');
Use: Check if an array contains an element.

5. Hooks in Jest
   In Jest, Hooks are functions that let you run certain code at particular stages of the testing process, making it easier to efficiently set up and shut down test environments. There are 4 main hooks: beforeAll, beforeEach, AfterAll, AfterEach. They can be used to set up the required settings before tests begin and for the tidying up when tests are completed.

The difference between these hooks is that beforeAll and afterAll run once per test suite, while beforeEach and afterEach run before and after each individual test within the suite.

describe('User Service', () => {
beforeAll(() => {
// Set up a mock database connection once before all tests
return initializeMockDatabase();
});

beforeEach(() => {
// Reset the database to a known state before each test
return resetDatabase();
});

afterEach(() => {
// Clear any changes made during a test
return clearDatabaseChanges();
});

afterAll(() => {
// Close the mock database connection once after all tests
return closeMockDatabase();
});

test('should create a new user', () => {
// Test for creating a user
});

test('should retrieve a user by ID', () => {
// Test for retrieving a user
});

// More tests...
});

Phamela, Nhlanhla, Mpho

1. They make the test suite easier to read, maintain, and understand by creating a clear hierarchy of test groups and individual test cases.

describe Function
Groups Related Tests: Groups tests that are related to each other, making it clear what part of the code is being tested.
Creates Hierarchy: Allows nesting of describe blocks for more detailed organization.

it Function
Defines Individual Tests: Specifies individual test cases with clear descriptions.
Isolates Tests: Ensures each test is independent and checks a specific behavior.

2. Supertest is a library used for testing HTTP endpoints in an Express.js application..

Step 1: Install Supertest
Add Supertest and a testing library (like Mocha or Jest) to your project to write tests for your HTTP endpoints.
Step 2: Set Up Your Express Application
Have an Express app with endpoints to test. For example, a /hello endpoint that responds with "Hello, world!".
Step 3: Create a Test File
In a new test file:
Import Supertest and your Express app.
Write tests to send HTTP requests
Step 4: Write a Test
In your test file:
Describe the endpoint (e.g., GET /hello).
Write a test case to send a request to the endpoint and check the response is as expected.
Step 5: Run Your Tests
Execute your tests using your chosen testing library. This will check if your endpoints respond correctly.

3. Purpose of Mocking in Jest
   Mocking isolates the code being tested by simulating dependencies, making tests more reliable and faster.
   Using jest.mock
   jest.mock creates a mock version of a module, allowing you to control its behavior in your tests.

Example: Mocking A Database Module.

Database Module (db.js
// db.js
const getUserById = (id) => {
return { id, name: "John Doe" };
};
module.exports = { getUserById };

4. Jest's expect function is used to perform assertions in your tests, allowing you to check whether the output of your code matches the expected values. Here are some examples of different types of assertions using Jest's expect function, along with explanations of when to use each:
   -. toBe()
   Use: toBe is used for primitive values like numbers, strings, and booleans. It uses Object.is for strict equality comparison.

• toEqual()
  Use: toEqual is used for deep equality checks, making it suitable for objects and arrays. It recursively checks the properties or elements.
  When to Use: Use toEqual when comparing complex data structures like objects or arrays, where you need to ensure that all nested properties are equal.

• toMatchObject()
  Use: toMatchObject is used for partial matching of objects. It checks that the specified properties exist and have the expected values in the object.
  When to Use: Use toMatchObject when you only care about some properties of an object and want to ensure they have specific values.

• toContain()
  Use: toContain is used for checking if an item exists in an array or if a substring is present in a string.
  When to Use: Use toContain when you want to verify that an array includes a specific element or that a string contains a particular substring.

5. Hooks are special functions that allow you to run code before or after certain events in the testing lifecycle, such as before or after each test or before and after a test suite. Hooks are particularly useful for setting up and tearing down test environments, initializing variables, or cleaning up after tests. They help ensure that your tests are isolated and run in a predictable environment.

Differences Between Hooks
Here's a summary of the differences between these hooks:
beforeAll: Runs once before all tests in a test suite.
afterAll: Runs once after all tests in a test suite.
beforeEach: Runs before each test in a test suite.
afterEach: Runs after each test in a test suite.

Scenario 1: Database Testing
beforeAll: Connect to the database once before running any tests.
afterAll: Disconnect from the database after all tests are complete.
beforeEach: Seed the database with fresh test data before each test.
afterEach: Clear the database entries created during each test.

Scenario 2: API Testing
beforeAll: Start a mock server before running any tests.
afterAll: Stop the mock server after all tests are complete.
beforeEach: Reset request handlers or mocks before each test.
afterEach: Clear any modified states or data after each test.
javascript

Scenario 3: UI Component Testing
beforeEach: Render a component before each test to ensure a fresh state.
afterEach: Unmount or clean up the component after each test.

Lindokuhle Skosana
Sinethemba Zulu
Wesley

1. In Jest, the describe function groups related test cases together within a test file, providing a hierarchical structure that mirrors the organization of the code being tested. Each describe block contains it statements, which define individual test cases with clear descriptions of specific behaviors being tested. This approach enhances readability and maintainability by organizing tests into logical sections based on functionality or modules. describe allows for nested structures, enabling deeper levels of organization for complex test suites. Overall, describe and it functions in Jest facilitate systematic and focused testing, improving developers' ability to manage and debug code efficiently.

2. Supertest provides a high-level abstraction for HTTP assertions, making it easy to write and maintain tests for your API routes.

steps:

a) Install Dependencies- npm install --save-dev supertest jest

b) Set Up Your Express Application
const express = require('express'); const app = express(); app.use(express.json());

c) Write Tests Using Supertest:
Create a test file (e.g., app.test.js) where you will write your test cases using Supertest.
javascript

d) Run Your Tests
Ensure your test script is set up in package.json:

{
"scripts": {
"test": "jest"
}
}

e) Run your tests using the following command:
npm test

3. In Jest, mocking serves to isolate dependencies like databases in tests, ensuring focus on code behavior without external influences. jest.mock replaces modules with mocks, allowing control over return values and behaviors. For an Express.js app, mocking database.js in tests involves defining mock responses using jest.fn() for functions like getUsersFromDB. Tests then verify route handlers like getUsers respond correctly to mocked database behaviors, enhancing reliability and speed of tests while avoiding reliance on actual database connections.

example:
const database = require('./database');

async function getUsers(req, res) {
try {
const users = await database.getUsersFromDB(); // Function to fetch users from database
res.status(200).json(users);
} catch (error) {
console.error('Error fetching users:', error);
res.status(500).send('Error fetching users');
}
}

module.exports = { getUsers };

a) Database Module (database.js):

async function getUsersFromDB() {
// Logic to fetch users from the actual database
return await db.query('SELECT * FROM users');
}

module.exports = { getUsersFromDB };

b).Test File (routes.test.js)
const { getUsers } = require('./routes');
const database = require('./database'); // Mocking the database module
jest.mock('./database', () => ({ getUsersFromDB: jest.fn(), }));
describe('GET /users', () => { let req, res;
beforeEach(() => { req = {};
res = { status: jest.fn().mockReturnThis(), json: jest.fn(), send: jest.fn(), }; });

4. In Jest, the expect function is used to make assertions in your tests, verifying that certain conditions are met during the execution of your code. Here are examples of different types of assertions supported by Jest's expect function, along with explanations of when to use each:
   a).toEqual
   The toEqual matcher checks for deep equality between the actual and expected values. It compares the properties and values of objects or arrays.

example

test('adding 1 + 2 equals 3', () => {
expect(1 + 2).toEqual(3);
});

test('object assignment', () => {
const data = { one: 1 };
data['two'] = 2;
expect(data).toEqual({ one: 1, two: 2 });
});

b) toBe

The toBe matcher checks for strict equality (===) between the actual and expected values. It's used for comparing primitive values like numbers, strings, booleans, or references (for object identity).

example :

test('two plus two is four', () => {
expect(2 + 2).toBe(4);
});

test('checking for the exact equality of a reference', () => {
const value = {};
expect(value).toBe(value); // Same object reference
});

c) toMatchObject
The toMatchObject matcher checks that an object or array contains all the expected properties or elements, ignoring any extra properties.

Example:

test('toMatchObject example', () => {
const obj = {
name: 'John',
age: 30,
city: 'New York'
};
expect(obj).toMatchObject({
name: 'John',
age: 30
});
});

d)toThrow

The toThrow matcher is used to test if a function throws an error when it's called.

Example:

function throwError() {
throw new Error('This is an error');
}

test('throw error example', () => {
expect(throwError).toThrow();
expect(throwError).toThrow(Error);
expect(throwError).toThrow('This is an error');
expect(throwError).toThrow(/error/);
});

e). toHaveBeenCalled / toHaveBeenCalledWith

These matches are used to check if a mock function (or spy) was called during the test.

Example:

const mockFn = jest.fn();

test('mock function example', () => {
mockFn();
expect(mockFn).toHaveBeenCalled();

mockFn('hello', 'world');
expect(mockFn).toHaveBeenCalledWith('hello', 'world');
});

5. Hooks in Jest help you manage the state and configuration needed before and after your tests run, ensuring that each test starts with a clean slate or has the necessary context.

a) beforeAll(fn): This hook runs once before all the tests in a describe block. It is useful for setting up a shared context or state that doesn't need to be reset between individual tests. it is used in setting up a database connection and Initializing a global variable or state.

b) beforeEach(fn): This hook runs before each individual test in a describe block. It is useful for setting up a consistent initial state for each test, ensuring that no test influences the outcome of another. It is used in resetting a database to a known state before each test, reinitializing mock data or state and setting up test-specific conditions.

c) afterAll(fn): This hook runs once after all the tests in a describe block have completed. It is useful for tearing down or cleaning up the context or state that was set up in beforeAll. It is used when closing a database connection, cleaning up global state or resources and performing any final cleanup after all tests have run.

d) afterEach(fn)
This hook runs after each individual test in a describe block. It is useful for cleaning up or resetting any state that should not persist between tests. It is used when clearing caches or temporary data. Releasing resources that are created for each test and ensuring that side effects from one test do not affect subsequent tests.

@NokulungaM
@Tumelo2748
@Pumlanikewana

1. In Jest, the describe and it functions are used to structure and define test cases.
   The describe and it functions in Jest help in creating a well-organized, maintainable, and readable test suite that clearly communicates the functionality being tested and the expected behavior of your code.
   eg:
   a) Logical Grouping: Organizes tests into related groups.
   b) Readable Output: Provides descriptive test output.
   c) Nesting: Allows for a detailed hierarchical structure.
   d) Shared Setup/Teardown: Facilitates common setup and teardown logic.
   e) Isolation: Ensures test suite isolation and reliability.

2. Supertest is a powerful library for testing HTTP endpoints in Node.js applications, particularly with Express.js. It allows you to write tests that make requests to your Express app and assert the responses.

How to use Supertest for testing HTTP endpoints in an Express.js application:
a)Install Supertest and Jest: npm install supertest jest
b)Create Express App : Define your endpoints in an Express app.
c) Create a test file : Write tests using Supertest to send requests to your Express app.
d)Write Tests : Use Supertest to write tests for your endpoints.
e)Configure Jes t: Ensure your package.json is set up to use Jest.
f)Run Tests : Execute the tests with npm test.

Steps to setup Supertest:
a)Install Dependencies: Install Supertest and Jest using npm install supertest jest
b)Create or Identify Your Express App: Ensure you have an Express app set up.
c)Create a Test File: Write tests using Supertest to send requests to your Express app.
d)Configure Jest: Make sure Jest is set up in your package.json.

3. Jest is a widely used JavaScript testing framework developed by Facebook. It’s designed to make writing and running tests more efficient and user-friendly. While originally intended for testing React applications, Jest is versatile enough to test any JavaScript codebase. Its intuitive design and robust features have contributed to its popularity among developers.

Simulating Dependencies with Jest.mock

Jest's jest.mock function enables you to replace external dependencies with controlled mock implementations during testing. This isolation enhances test reliability and speed by preventing unexpected behaviors from external systems.

Mocking in Jest is a technique to replace real functions or modules with simulated ones during testing.
Purpose:
Isolation: Focuses testing on a specific code unit without external dependencies.
Control: Manipulates input and output to test different scenarios.
Speed: Improves test execution time by avoiding slow operations.
Reliability: Reduces test flakiness by eliminating external factors.

Here's an example :

Create fake weather data: Make up weather information for your tests.
Test the code with the fake data: Check if the code handles different weather conditions correctly.
Only when everything works, test with real weather data: This is for final checks.

Example:

const fetchWeatherData = async (location) => {
  // Fetch weather data from a real API
};

// weatherService.test.js
const weatherService = require('./weatherService');

jest.mock('./weatherService');

test('fetchWeatherData', async () => {
  const dummyWeatherData = {
    city: 'New York',
    temperature: 75,
    condition: 'sunny',
    humidity: 50,
  };

  weatherService.fetchWeatherData.mockResolvedValue(dummyWeatherData);

  const data = await weatherService.fetchWeatherData('New York');

  expect(data).toEqual(dummyWeatherData);
});

4.Jest's expect function is the cornerstone of writing assertions in your tests. It takes a value and allows you to chain various matchers to check specific conditions.

toBe:Checks if values are exactly the same.

expect(2+2).toBe(4);

toEqual: Checks if values are equal, even for objects.
expect({name: 'John'}).toEqual({name: 'John'});

toMatch: Checks if a string matches a pattern.
expect('hello world').toMatch(/world/);

When to Use Which:
a) toBe: For primitive values (numbers, strings, booleans) and when strict equality is required.
b) toEqual: For objects and arrays when you care about the values, not the references.
c) toMatch: For string comparisons using regular expressions.
d) toBeTruthy/toBeFalsy: For checking if a value is truthy or falsy.
e) toContain: For checking if an item exists within an array or iterable.
f) toThrow: For testing if a function throws an expected error.

5. Hooks in Jest are functions that allow you to run code at specific points in the testing lifecycle. They help in setting up and tearing down the environment before and after tests run.
   Hooks in Jest can be effectively used to set up and tear down test environments by organizing the code that initializes and cleans up resources needed for the tests.

The difference between hooks and the scenario's you can you use them in:
a) beforeAll (fn, timeout): This hook can be used to set up resources that are shared across all tests and only need to be initialized once. For example, you might start a database connection, initialize a server, or set up some shared state.

b) afterAll (fn, timeout): This hook is used to tear down the resources set up by beforeAll. For example, you might close the database connection, stop the server, or clean up shared state.

c) beforeEach (fn, timeout): This hook is used to set up the environment before each test runs. For example, you might reset a database to a known state, initialize mock data, or create new instances of objects needed for the tests.

d) afterEach (fn, timeout): This hook is used to clean up after each test runs. For example, you might clear mock data, reset configurations, or release resources that were allocated in beforeEach.