Test lifecycle hooks (before, after) in Node.js - Performance & Optimization

Performance: Test lifecycle hooks (before, after)

MEDIUM IMPACT

This concept affects test execution speed and resource usage during automated testing.

Setting up and cleaning resources for multiple tests

Node.js

describe('My tests', () => {
  before(() => {
    // setup once before all tests
    initializeDatabaseConnection();
  });

  after(() => {
    // cleanup once after all tests
    closeDatabaseConnection();
  });

  it('test 1', () => {
    // test code
  });

  it('test 2', () => {
    // test code
  });
});

Setup and teardown run only once, reducing redundant operations and speeding up the test suite.

📈 Performance GainSaves multiple expensive setup/teardown calls, reducing total test runtime significantly.

Setting up and cleaning resources for multiple tests

Node.js

describe('My tests', () => {
  beforeEach(() => {
    // expensive setup repeated before every test
    initializeDatabaseConnection();
  });

  afterEach(() => {
    // cleanup repeated after every test
    closeDatabaseConnection();
  });

  it('test 1', () => {
    // test code
  });

  it('test 2', () => {
    // test code
  });
});

Setup and teardown run before and after every test, causing repeated expensive operations.

📉 Performance CostTriggers multiple redundant resource initializations and teardowns, increasing total test time linearly with test count.

Performance Comparison

Pattern	Setup Calls	Teardown Calls	Total Test Time Impact	Verdict
beforeEach/afterEach for all tests	N (number of tests)	N (number of tests)	High - setup/teardown repeated for each test	[X] Bad
before/after once per suite	1	1	Low - setup/teardown done once	[OK] Good

Rendering Pipeline

Test lifecycle hooks do not affect browser rendering but influence Node.js test execution flow and resource management.

→Test Initialization

→Test Execution

→Test Cleanup

⚠️ BottleneckRepeated setup and teardown before/after each test increases total execution time.

Optimization Tips

1Use before() and after() for shared setup and cleanup to minimize repeated work.

2Avoid expensive operations inside beforeEach() and afterEach() unless necessary.

3Measure test suite duration to identify costly repeated setup/teardown.

Performance Quiz - 3 Questions

Which lifecycle hook reduces redundant setup calls when running multiple tests?

A beforeEach()

B afterEach()

C before()

D after()

DevTools: Performance (Node.js profiling tools or test runner timing output)

How to check: Run tests with timing enabled or profiling; compare total test suite duration with beforeEach/afterEach vs before/after hooks.

What to look for: Look for repeated setup/teardown calls and total test duration; fewer calls and shorter duration indicate better performance.

Practice

1. What is the main purpose of the before hook in Node.js testing frameworks like Mocha?

easy

A. To run setup code once before all tests in a suite

B. To run cleanup code after each test

C. To run code before each individual test

D. To skip a test conditionally

Solution

1. Step 1: Understand the role of before hook

   The before hook runs once before all tests in a test suite to prepare the environment.

2. Step 2: Differentiate from other hooks

   beforeEach runs before each test, and after runs after all tests, so they do not match the question.

3. Final Answer:

   To run setup code once before all tests in a suite -> Option A

4. Quick Check:

   before = setup once before all tests [OK]

Hint: Remember: before = once before all tests [OK]

Common Mistakes:

• Confusing before with beforeEach
• Thinking before runs after tests
• Mixing before with afterEach

2. Which of the following is the correct syntax to define a beforeEach hook in Mocha?

easy

A. before_each(() => { /* setup code */ });

B. beforeEach(() => { /* setup code */ });

C. beforeEach {}

D. beforeEach: function() { /* setup code */ }

Solution

1. Step 1: Recall Mocha hook syntax

   Mocha uses functions like beforeEach(() => { ... }) to define hooks.

2. Step 2: Check each option

   beforeEach(() => { /* setup code */ }); uses correct arrow function syntax. before_each(() => { /* setup code */ }); uses invalid function name. beforeEach {} is incomplete syntax. beforeEach: function() { /* setup code */ } uses incorrect object notation.

3. Final Answer:

   beforeEach(() => { /* setup code */ }); -> Option B

4. Quick Check:

   Correct hook syntax uses function call with callback [OK]

Hint: Use camelCase and parentheses for hooks [OK]

Common Mistakes:

• Using underscores instead of camelCase
• Omitting parentheses
• Using object notation instead of function call

3. Consider this Mocha test code snippet:

let count = 0;
before(() => { count += 1; });
after(() => { count += 10; });
it('test 1', () => { count += 100; });
it('test 2', () => { count += 1000; });

What is the final value of count after all tests run?

medium

A. 1110

B. 1112

C. 111

D. 1111

Solution

1. Step 1: Calculate increments in order

   before runs once: count = 0 + 1 = 1.
   Then test 1: count = 1 + 100 = 101.
   Then test 2: count = 101 + 1000 = 1101.
   Finally after: count = 1101 + 10 = 1111.

2. Step 2: Confirm no other increments

   No beforeEach or afterEach hooks affect count, so final is 1111.

3. Final Answer:

   1111 -> Option D

4. Quick Check:

   Sum increments: 1 + 100 + 1000 + 10 = 1111 [OK]

Hint: Add increments in hook and test order [OK]

Common Mistakes:

• Adding after hook before tests
• Forgetting before hook runs once
• Confusing beforeEach with before

4. Given this Mocha test code:

before(() => { console.log('Setup'); });
after(() => { console.log('Cleanup'); });

it('test 1', () => { console.log('Test 1'); });

it('test 2', () => { console.log('Test 2'); });

What is the correct order of console output?

medium

A. Test 1, Test 2, Setup, Cleanup

B. Test 1, Setup, Test 2, Cleanup

C. Setup, Test 1, Test 2, Cleanup

D. Setup, Test 1, Cleanup, Test 2

Solution

1. Step 1: Understand hook execution order

   before runs once before all tests, so 'Setup' prints first.

2. Step 2: Tests run in order, then after hook

   Tests print 'Test 1' then 'Test 2'. After all tests, after runs printing 'Cleanup'.

3. Final Answer:

   Setup, Test 1, Test 2, Cleanup -> Option C

4. Quick Check:

   before -> tests -> after = Setup, Test 1, Test 2, Cleanup [OK]

Hint: before runs once first; after runs once last [OK]

Common Mistakes:

• Assuming after runs after each test
• Mixing test order
• Thinking before runs before each test

5. You want to open a database connection once before all tests and close it once after all tests. Which hook pair should you use in Mocha?

hard

A. before to open and after to close

B. beforeEach to open and afterEach to close

C. after to open and before to close

D. beforeEach to open and after to close

Solution

1. Step 1: Identify when to open connection

   Opening once before all tests means using before hook.

2. Step 2: Identify when to close connection

   Closing once after all tests means using after hook.

3. Final Answer:

   before to open and after to close -> Option A

4. Quick Check:

   Open once before all, close once after all [OK]

Hint: Use before/after for once-only setup/cleanup [OK]

Common Mistakes:

• Using beforeEach/afterEach causing repeated open/close
• Reversing before and after roles
• Mixing hooks for different purposes