Interview Questions
Mocha supports multiple assertion libraries: 1) Node's built-in assert module, 2) Chai for BDD/TDD assertions, 3) Should.js for BDD style assertions, 4) Expect.js for expect() style assertions, 5) Better-assert for C-style assertions. Each offers different syntax and capabilities.
Using Chai involves: 1) Installing: npm install chai, 2) Importing desired interface (expect, should, assert), 3) Writing assertions using chosen style, 4) Using chainable language constructs, 5) Handling async assertions. Example: const { expect } = require('chai'); expect(value).to.equal(expected);
Chai offers three styles: 1) Assert - traditional TDD style (assert.equal()), 2) Expect - BDD style with expect() (expect().to), 3) Should - BDD style with should chaining (value.should). Each style has its own syntax and use cases.
Async assertions handled through: 1) Using done callback, 2) Returning promises, 3) Async/await syntax, 4) Chai-as-promised for promise assertions, 5) Proper error handling. Example: it('async test', async () => { await expect(promise).to.be.fulfilled; });
Common patterns include: 1) Equality checking (equal, strictEqual), 2) Type checking (typeOf, instanceOf), 3) Value comparison (greater, less), 4) Property checking (property, include), 5) Exception testing (throw). Use appropriate assertions for different scenarios.
Exception testing approaches: 1) expect(() => {}).to.throw(), 2) assert.throws(), 3) Testing specific error types, 4) Verifying error messages, 5) Handling async errors. Example: expect(() => fn()).to.throw(ErrorType, 'error message');
Chainable assertions allow: 1) Fluent interface with natural language, 2) Combining multiple checks, 3) Negating assertions with .not, 4) Adding semantic meaning, 5) Improving test readability. Example: expect(value).to.be.an('array').that.is.not.empty;
Object property testing: 1) Check property existence, 2) Verify property values, 3) Test nested properties, 4) Compare object structures, 5) Check property types. Example: expect(obj).to.have.property('key').that.equals('value');
Assertion plugins: 1) Extend assertion capabilities, 2) Add custom assertions, 3) Integrate with testing tools, 4) Provide domain-specific assertions, 5) Enhance assertion functionality. Example: chai-as-promised for promise assertions.
Deep equality testing: 1) Use deep.equal for objects/arrays, 2) Compare nested structures, 3) Handle circular references, 4) Check property order, 5) Consider type coercion. Example: expect(obj1).to.deep.equal(obj2);
Custom assertions: 1) Use Chai's addMethod/addProperty, 2) Define assertion logic, 3) Add chainable methods, 4) Include error messages, 5) Register with assertion library. Creates domain-specific assertions.
Best practices include: 1) Use specific assertions, 2) Write clear error messages, 3) Test one thing per assertion, 4) Handle edge cases, 5) Maintain assertion consistency. Improves test maintainability.
Array testing patterns: 1) Check array contents, 2) Verify array length, 3) Test array ordering, 4) Check array modifications, 5) Test array methods. Example: expect(array).to.include.members([1, 2]);
Promise testing patterns: 1) Test resolution values, 2) Verify rejection reasons, 3) Check promise states, 4) Test promise chains, 5) Handle async operations. Use chai-as-promised for enhanced assertions.
Type checking includes: 1) Verify primitive types, 2) Check object types, 3) Test instance types, 4) Validate type coercion, 5) Handle custom types. Example: expect(value).to.be.a('string');
Event testing patterns: 1) Verify event emission, 2) Check event parameters, 3) Test event ordering, 4) Handle async events, 5) Test error events. Use event tracking and assertions.
Conditional testing: 1) Test all branches, 2) Verify boundary conditions, 3) Check edge cases, 4) Test combinations, 5) Verify default cases. Ensure comprehensive coverage.
Async/await patterns: 1) Handle async operations, 2) Test error conditions, 3) Chain async calls, 4) Verify async results, 5) Test concurrent operations. Use proper async assertions.
Timeout handling: 1) Set assertion timeouts, 2) Handle async timeouts, 3) Configure retry intervals, 4) Manage long-running assertions, 5) Handle timeout errors. Important for async tests.
Error testing patterns: 1) Verify error types, 2) Check error messages, 3) Test error propagation, 4) Handle async errors, 5) Test error recovery. Ensure proper error handling.
Advanced chaining: 1) Combine multiple assertions, 2) Create complex conditions, 3) Handle async chains, 4) Manage state between assertions, 5) Create reusable chains. Enables sophisticated testing.
Complex object testing: 1) Test object hierarchies, 2) Verify object relationships, 3) Test object mutations, 4) Handle circular references, 5) Test object behaviors. Use appropriate assertions.
Assertion reporting: 1) Customize error messages, 2) Format assertion output, 3) Group related assertions, 4) Handle assertion failures, 5) Generate assertion reports. Improves test feedback.
State machine testing: 1) Test state transitions, 2) Verify state invariants, 3) Test invalid states, 4) Check state history, 5) Test concurrent states. Use appropriate assertions.
Property testing: 1) Define property checks, 2) Generate test cases, 3) Verify invariants, 4) Test property combinations, 5) Handle edge cases. Use libraries like jsverify.
Concurrent testing: 1) Test parallel execution, 2) Verify race conditions, 3) Test resource sharing, 4) Handle timeouts, 5) Test synchronization. Use appropriate async assertions.