Testing Asynchronous Callbacks with Jest

Callbacks are a common pattern in JavaScript and TypeScript, particularly when dealing with asynchronous operations. Ensuring these callbacks function correctly is crucial for application stability. This challenge focuses on writing Jest tests to verify the behavior of a function that utilizes a callback to signal completion or errors.

Problem Description

You are given a function asyncOperation that simulates an asynchronous operation. This function takes a value, performs some operation (simulated by a setTimeout), and then calls a callback function with either the result or an error. Your task is to write Jest tests to verify that:

1. The callback is called with the correct result when the operation is successful.
2. The callback is called with an error when the operation fails (simulated by a random chance).
3. The function handles potential errors gracefully and calls the callback with an appropriate error message.

Key Requirements:

• The asyncOperation function is provided. Do not modify it.
• Write Jest tests using async/await or Promises to properly handle the asynchronous nature of the operation.
• Ensure your tests cover both success and failure scenarios.
• Use meaningful test descriptions.

Expected Behavior:

• When the operation succeeds, the callback should be invoked with the input value.
• When the operation fails (randomly), the callback should be invoked with an error object containing a descriptive message.
• The tests should not hang indefinitely waiting for the asynchronous operation.

Edge Cases to Consider:

• What happens if the input value is null or undefined? (The function should handle this gracefully).
• How can you ensure the test completes even if the asynchronous operation takes longer than expected? (Jest's timeouts are relevant here).

Examples

Example 1: Successful Operation

Input: asyncOperation(5)
Output: Callback called with value 5
Explanation: The asyncOperation completes successfully after a delay, and the callback is invoked with the input value (5).

Example 2: Failed Operation

Input: asyncOperation("hello")
Output: Callback called with an error: "Operation failed!"
Explanation: The asyncOperation simulates a failure, and the callback is invoked with an error object.

Example 3: Null Input

Input: asyncOperation(null)
Output: Callback called with value null
Explanation: The asyncOperation handles null input gracefully and passes it to the callback.

Constraints

• The asyncOperation function is provided and should not be modified.
• Tests should be written using Jest and TypeScript.
• Tests should be readable and well-documented.
• The setTimeout within asyncOperation will simulate a delay of up to 500ms. Your tests should account for this.
• Jest timeout should be set to 1000ms to prevent tests from hanging.

Notes

• Consider using done callback in Jest if you prefer that approach, but async/await is recommended for cleaner code.
• Pay close attention to how you handle Promises and callbacks within your tests.
• Think about how to assert that the callback was indeed called with the expected arguments.
• The random failure in asyncOperation means your tests might occasionally fail even if your code is correct. Run the tests multiple times to ensure they are generally reliable.
• The provided asyncOperation function is:

function asyncOperation(value: any): Promise<void> {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (Math.random() < 0.5) {
        resolve(value);
      } else {
        reject(new Error("Operation failed!"));
      }
    }, Math.random() * 500);
  });
}