Assertions & Matchers Interview Questions

expect is Jest's assertion function that: 1) Takes a value to test, 2) Returns an expectation object, 3) Chains with matchers (toBe, toEqual, etc.), 4) Supports async assertions, 5) Can be extended with custom matchers. Example: expect(value).toBe(expected);

Key differences: 1) toBe() uses Object.is for strict equality, 2) toEqual() performs deep equality comparison, 3) toBe() is for primitives and object references, 4) toEqual() is for object/array content comparison, 5) toEqual() recursively checks nested structures.

Truthiness matchers include: 1) toBeTruthy() - checks if value is truthy, 2) toBeFalsy() - checks if value is falsy, 3) toBeNull() - checks for null, 4) toBeUndefined() - checks for undefined, 5) toBeDefined() - checks if value is not undefined.

Numeric matchers include: 1) toBeGreaterThan(), 2) toBeLessThan(), 3) toBeGreaterThanOrEqual(), 4) toBeLessThanOrEqual(), 5) toBeCloseTo() for floating point. Example: expect(value).toBeGreaterThan(3);

String matchers include: 1) toMatch() for regex patterns, 2) toContain() for substring checks, 3) toHaveLength() for string length, 4) toEqual() for exact matches, 5) toString() for string conversion checks. Example: expect(string).toMatch(/pattern/);

Array matchers include: 1) toContain() for item presence, 2) toHaveLength() for array length, 3) toEqual() for deep equality, 4) arrayContaining() for partial matches, 5) toContainEqual() for object matching in arrays.

Object matchers include: 1) toEqual() for deep equality, 2) toMatchObject() for partial matching, 3) toHaveProperty() for property checks, 4) objectContaining() for subset matching, 5) toBeInstanceOf() for type checking.

Exception testing uses: 1) toThrow() for any error, 2) toThrowError() with specific error, 3) expect(() => {}).toThrow() syntax, 4) Error message matching, 5) Error type checking. Example: expect(() => fn()).toThrow('error message');

The not modifier: 1) Inverts matcher expectation, 2) Used as .not before matchers, 3) Works with all matchers, 4) Maintains proper error messages, 5) Useful for negative assertions. Example: expect(value).not.toBe(3);

Promise testing uses: 1) resolves matcher for success, 2) rejects matcher for failures, 3) Async/await syntax, 4) Return promises in tests, 5) Chain additional matchers. Example: expect(promise).resolves.toBe(value);

Custom matchers created using: 1) expect.extend(), 2) Matcher function with pass/message, 3) this.isNot for negation, 4) Async matcher support, 5) Custom error messages. Example: expect.extend({ customMatcher(received, expected) { return { pass: condition, message: () => message }; } });

Asymmetric matchers: 1) Allow partial matching, 2) Include expect.any(), expect.arrayContaining(), 3) Used in object/array comparisons, 4) Support custom implementations, 5) Useful for flexible assertions. Example: expect({ prop: 'value' }).toEqual(expect.objectContaining({ prop: expect.any(String) }));

Snapshot testing uses: 1) toMatchSnapshot() matcher, 2) toMatchInlineSnapshot(), 3) Serializer customization, 4) Dynamic snapshot content, 5) Snapshot update flow. Example: expect(component).toMatchSnapshot();

Message best practices: 1) Clear failure descriptions, 2) Context-specific details, 3) Expected vs actual values, 4) Custom matcher messages, 5) Error hint inclusion. Helps with test debugging and maintenance.

DOM assertions use: 1) toBeInTheDocument(), 2) toHaveTextContent(), 3) toHaveAttribute(), 4) toBeVisible(), 5) toBeDisabled(). Often used with @testing-library/jest-dom matchers.

Partial matching uses: 1) objectContaining(), 2) arrayContaining(), 3) stringContaining(), 4) stringMatching(), 5) Custom matchers for specific cases. Example: expect(object).toEqual(expect.objectContaining({ key: value }));

Complex comparisons use: 1) Deep equality checks, 2) Custom matchers, 3) Partial matching, 4) Property path assertions, 5) Nested object validation. Consider performance and maintainability.

Timeout handling includes: 1) Setting timeout duration, 2) Async assertion timing, 3) Custom timeout messages, 4) Retry mechanisms, 5) Polling assertions. Important for async testing scenarios.

Function call testing uses: 1) toHaveBeenCalled(), 2) toHaveBeenCalledWith(), 3) toHaveBeenCalledTimes(), 4) toHaveBeenLastCalledWith(), 5) Call argument inspection. Used with mock functions and spies.

Compound assertions: 1) Chain multiple expectations, 2) Combine matchers logically, 3) Use and/or operators, 4) Group related assertions, 5) Complex condition testing. Example: expect(value).toBeDefined().and.toBeTruthy();

Advanced matchers include: 1) Complex matching logic, 2) Custom error formatting, 3) Assertion composition, 4) Async matcher support, 5) Context-aware matching. Used for specialized testing needs.

Complex async testing: 1) Multiple promise chains, 2) Race condition testing, 3) Timeout handling, 4) Error case coverage, 5) State verification. Requires careful timing management.

State assertions include: 1) Complex state verification, 2) State transition testing, 3) Conditional assertions, 4) State history validation, 5) Side effect checking. Used for stateful component testing.

Advanced snapshots: 1) Dynamic content handling, 2) Serializer customization, 3) Snapshot transformations, 4) Conditional snapshots, 5) Snapshot maintenance strategies. Used for complex component testing.

Performance assertions: 1) Execution time checks, 2) Resource usage validation, 3) Performance threshold testing, 4) Benchmark comparisons, 5) Performance regression detection. Used for performance testing.

Complex data testing: 1) Graph structure validation, 2) Tree traversal assertions, 3) Collection relationship testing, 4) Data integrity checks, 5) Structure transformation verification. Used for complex data scenarios.