Jest's hasAssertions(): Ensuring Test Completeness

Testing is crucial for software reliability, and ensuring your tests actually perform assertions is a vital part of robust testing practices. Jest's expect.hasAssertions() is a powerful tool that helps you verify that your test functions have at least one assertion. This challenge will guide you through understanding and implementing this concept.

Problem Description

Your task is to create a Jest test that demonstrates the use of expect.hasAssertions() to ensure that a test function makes at least one assertion. You need to write a test that passes when assertions are present and fails when they are absent, simulating the behavior of expect.hasAssertions() itself.

Key Requirements:

• Create a Jest test file (.spec.ts or .test.ts).
• The test should use expect.hasAssertions() to enforce the presence of at least one assertion.
• Demonstrate a scenario where the test passes because an assertion is made.
• Demonstrate a scenario (in a separate test, or by commenting out the assertion) where the test would fail if expect.hasAssertions() were strictly enforced and no assertion was made.
• The solution should be written in TypeScript.

Expected Behavior:

A test that calls expect.hasAssertions() and then proceeds to make at least one expect call should pass. A test that calls expect.hasAssertions() but makes no expect calls should fail with an error message indicating that no assertions were made.

Edge Cases:

• What happens if expect.hasAssertions() is called multiple times within the same test? (Jest handles this gracefully, but it's good to be aware).
• Consider tests that have asynchronous operations. expect.hasAssertions() should still work correctly.

Examples

Example 1: Test with Assertion (Should Pass)

// my-module.spec.ts

import { describe, it, expect } from '@jest/globals';

describe('hasAssertions Example', () => {
  it('should pass when an assertion is made', () => {
    expect.hasAssertions(); // Enforces at least one assertion
    const sum = 2 + 2;
    expect(sum).toBe(4); // This is the assertion
  });
});

Explanation: This test calls expect.hasAssertions() and then makes a valid assertion expect(sum).toBe(4). Because an assertion is present, the test passes.

Example 2: Test Without Assertion (Illustrative - would fail if run standalone without an assertion)

// my-module.spec.ts (continued)

describe('hasAssertions Example', () => {
  // ... (previous test)

  it('should fail if no assertion is made (if run as is)', () => {
    expect.hasAssertions(); // Enforces at least one assertion
    // No expect calls here!
    console.log('This test has no assertions.');
  });
});

Explanation: If this test were run by Jest with expect.hasAssertions() active and no other expect calls were present, it would fail, likely with an error similar to: "Test has 0 assertions, but expect.hasAssertions() was called." For the purpose of this challenge, you should aim to create a passing test that demonstrates the principle, implying the failure case conceptually.

Constraints

• The solution must use Jest.
• The solution must be written in TypeScript.
• The test file should be named hasAssertions.spec.ts (or similar).
• No complex external libraries are required, only Jest itself.

Notes

• expect.hasAssertions() is typically used at the beginning of a test to ensure that the test logic actually verifies something.
• It's a good practice to include expect.hasAssertions() in tests that involve asynchronous operations (like promises or callbacks) to prevent silent test failures where the assertions might never be reached.
• You can manually simulate the failing case by commenting out the assertion in your passing test.
• The goal is to show how to use expect.hasAssertions() and understand its purpose, not to reimplement Jest's core functionality.