Interview Questions
Mocha supports multiple async patterns: 1) Using done callback, 2) Returning promises, 3) async/await syntax, 4) Using setTimeout/setInterval, 5) Event-based async. Example: it('async test', (done) => { asyncOperation(() => { done(); }); });
done callback: 1) Signals test completion, 2) Must be called exactly once, 3) Can pass error as argument, 4) Has timeout protection, 5) Used for callback-style async code. Test fails if done isn't called or called multiple times.
Promise testing: 1) Return promise from test, 2) Chain .then() and .catch(), 3) Use promise assertions, 4) Handle rejection cases, 5) Test promise states. Example: return Promise.resolve().then(result => assert(result));
async/await usage: 1) Mark test function as async, 2) Use await for async operations, 3) Handle errors with try/catch, 4) Chain multiple await calls, 5) Maintain proper error handling. Example: it('async test', async () => { const result = await asyncOp(); });
Timeout handling: 1) Set test timeout with this.timeout(), 2) Configure global timeouts, 3) Handle slow tests appropriately, 4) Set different timeouts for different environments, 5) Proper error handling for timeouts.
Common pitfalls: 1) Forgetting to return promises, 2) Missing done() calls, 3) Multiple done() calls, 4) Improper error handling, 5) Race conditions. Understanding these helps write reliable async tests.
Event testing: 1) Listen for events with done, 2) Set appropriate timeouts, 3) Verify event data, 4) Handle multiple events, 5) Test error events. Example: emitter.once('event', () => done());
Async hooks: 1) Setup async resources, 2) Clean up async operations, 3) Handle async dependencies, 4) Manage async state, 5) Ensure proper test isolation. Used for async setup/teardown.
Sequential handling: 1) Chain promises properly, 2) Use async/await, 3) Maintain operation order, 4) Handle errors in sequence, 5) Verify sequential results. Ensures correct operation order.
Best practices: 1) Always handle errors, 2) Set appropriate timeouts, 3) Clean up resources, 4) Avoid nested callbacks, 5) Use modern async patterns. Ensures reliable async tests.
Promise chain testing: 1) Return entire chain, 2) Test intermediate results, 3) Handle chain errors, 4) Verify chain order, 5) Test chain completion. Example: return promise.then().then();
Parallel testing: 1) Use Promise.all(), 2) Handle concurrent operations, 3) Manage shared resources, 4) Test race conditions, 5) Verify parallel results. Ensures proper concurrent execution.
Async error testing: 1) Test rejection cases, 2) Verify error types, 3) Check error messages, 4) Test error propagation, 5) Handle error recovery. Important for error handling.
Timeout strategies: 1) Set test timeouts, 2) Test timeout handling, 3) Verify timeout behavior, 4) Handle long operations, 5) Test timeout recovery. Ensures proper timeout handling.
Async state management: 1) Track async state changes, 2) Verify state transitions, 3) Handle state errors, 4) Test state consistency, 5) Manage state cleanup. Important for state-dependent tests.
Stream testing: 1) Test stream events, 2) Verify stream data, 3) Handle stream errors, 4) Test backpressure, 5) Verify stream completion. Important for streaming operations.
Iterator testing: 1) Test async iteration, 2) Verify iterator results, 3) Handle iterator errors, 4) Test completion, 5) Verify iteration order. Important for async collections.
Queue testing: 1) Test queue operations, 2) Verify queue order, 3) Handle queue errors, 4) Test queue capacity, 5) Verify queue completion. Important for queue-based systems.
Hook testing: 1) Test hook execution, 2) Verify hook timing, 3) Handle hook errors, 4) Test hook cleanup, 5) Verify hook order. Important for async lifecycle management.
Complex workflow testing: 1) Break down into steps, 2) Test state transitions, 3) Verify workflow order, 4) Handle errors, 5) Test completion. Important for multi-step processes.
Advanced patterns: 1) Custom async utilities, 2) Complex async flows, 3) Async composition, 4) Error recovery strategies, 5) Performance optimization. Enables sophisticated async testing.
Distributed testing: 1) Test network operations, 2) Handle distributed state, 3) Test consistency, 4) Verify synchronization, 5) Handle partitions. Important for distributed systems.
Performance testing: 1) Measure async operations, 2) Test concurrency limits, 3) Verify timing constraints, 4) Handle resource usage, 5) Test scalability. Important for system performance.
Recovery testing: 1) Test failure scenarios, 2) Verify recovery steps, 3) Handle partial failures, 4) Test retry logic, 5) Verify system stability. Important for system resilience.
Test monitoring: 1) Track async operations, 2) Monitor resource usage, 3) Collect metrics, 4) Analyze performance, 5) Generate reports. Important for test observability.
Security testing: 1) Test authentication flows, 2) Verify authorization, 3) Test secure communication, 4) Handle security timeouts, 5) Verify secure state. Important for system security.
Compliance testing: 1) Verify timing requirements, 2) Test audit trails, 3) Handle data retention, 4) Test logging, 5) Verify compliance rules. Important for regulatory compliance.