Skip to content

Instantly share code, notes, and snippets.

@halitbatur

halitbatur/testing.md

Created July 23, 2024 07:14
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save halitbatur/087e799d5f3f7137dc159896e1421c24 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save halitbatur/087e799d5f3f7137dc159896e1421c24 to your computer and use it in GitHub Desktop.
Download ZIP
Jest and Supertest
Raw
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.
@NokulungaM
Copy link

NokulungaM commented Jul 23, 2024 •
edited
Loading

@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.

  1. 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.

  1. 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.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment