827 lines
20 KiB
Markdown
827 lines
20 KiB
Markdown
# xstate-audition Testing Patterns
|
|
|
|
Advanced patterns, best practices, and real-world examples for testing XState actors with xstate-audition.
|
|
|
|
## Table of Contents
|
|
|
|
- [Test Organization Patterns](#test-organization-patterns)
|
|
- [Currying Patterns](#currying-patterns)
|
|
- [Hierarchical Actor Testing](#hierarchical-actor-testing)
|
|
- [Event Communication Patterns](#event-communication-patterns)
|
|
- [Timeout and Error Testing](#timeout-and-error-testing)
|
|
- [Integration Testing Patterns](#integration-testing-patterns)
|
|
- [Debugging Failed Tests](#debugging-failed-tests)
|
|
- [Performance Testing](#performance-testing)
|
|
- [Advanced TypeScript Patterns](#advanced-typescript-patterns)
|
|
|
|
---
|
|
|
|
## Test Organization Patterns
|
|
|
|
### Pattern: Describe Block with Shared Setup
|
|
|
|
Organize tests with shared actor creation and curried functions.
|
|
|
|
```typescript
|
|
import { describe, it, beforeEach } from 'node:test';
|
|
import { strict as assert } from 'node:assert';
|
|
import { createActor } from 'xstate';
|
|
import {
|
|
runUntilDone,
|
|
runUntilTransition,
|
|
type CurryTransitionP2,
|
|
} from 'xstate-audition';
|
|
|
|
describe('FetchMachine', () => {
|
|
let actor: Actor<typeof fetchMachine>;
|
|
let runFromIdle: CurryTransitionP2<typeof actor>;
|
|
|
|
beforeEach(() => {
|
|
actor = createActor(fetchMachine);
|
|
runFromIdle = runUntilTransition(actor, 'fetch.idle');
|
|
});
|
|
|
|
describe('successful fetch', () => {
|
|
it('should transition from idle to loading', async () => {
|
|
actor.send({ type: 'FETCH' });
|
|
await runFromIdle('fetch.loading');
|
|
});
|
|
|
|
it('should complete with data', async () => {
|
|
actor.send({ type: 'FETCH' });
|
|
actor.send({ type: 'SUCCESS', data: 'test' });
|
|
|
|
const snapshot = await runUntilSnapshot(actor, (s) =>
|
|
s.matches('success'),
|
|
);
|
|
|
|
assert.equal(snapshot.context.data, 'test');
|
|
});
|
|
});
|
|
|
|
describe('failed fetch', () => {
|
|
it('should transition to error state', async () => {
|
|
actor.send({ type: 'FETCH' });
|
|
actor.send({ type: 'ERROR', error: new Error('Network error') });
|
|
|
|
await runFromIdle('fetch.error');
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Factory Functions for Test Actors
|
|
|
|
Create reusable factory functions for common test scenarios.
|
|
|
|
```typescript
|
|
import { createActorFromLogic } from 'xstate-audition';
|
|
|
|
// Factory with preset configuration
|
|
function createTestActor(input: string) {
|
|
return createActor(myMachine, {
|
|
input,
|
|
logger: process.env.DEBUG ? console.log : undefined,
|
|
});
|
|
}
|
|
|
|
// Factory with currying
|
|
const createActorWithInput = createActorFromLogic(myMachine);
|
|
|
|
describe('myMachine', () => {
|
|
it('should work with input A', async () => {
|
|
const actor = createActorWithInput({ input: 'A' });
|
|
const output = await runUntilDone(actor);
|
|
assert.equal(output, 'processed-A');
|
|
});
|
|
|
|
it('should work with input B', async () => {
|
|
const actor = createActorWithInput({ input: 'B' });
|
|
const output = await runUntilDone(actor);
|
|
assert.equal(output, 'processed-B');
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Parameterized Tests
|
|
|
|
Test multiple scenarios with the same logic.
|
|
|
|
```typescript
|
|
const testCases = [
|
|
{ input: 'hello', expected: 'HELLO' },
|
|
{ input: 'world', expected: 'WORLD' },
|
|
{ input: '', expected: '' },
|
|
];
|
|
|
|
describe('StringTransformMachine', () => {
|
|
testCases.forEach(({ input, expected }) => {
|
|
it(`should transform "${input}" to "${expected}"`, async () => {
|
|
const actor = createActor(transformMachine, { input });
|
|
const output = await runUntilDone(actor);
|
|
assert.equal(output, expected);
|
|
});
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Currying Patterns
|
|
|
|
### Pattern: Multi-Level Currying
|
|
|
|
Create increasingly specific test helpers through currying.
|
|
|
|
```typescript
|
|
describe('TransitionMachine', () => {
|
|
let actor: Actor<typeof machine>;
|
|
let runWithActor: ReturnType<typeof runUntilTransition>;
|
|
let runFromIdle: CurryTransitionP2<typeof actor>;
|
|
|
|
beforeEach(() => {
|
|
actor = createActor(machine);
|
|
|
|
// Level 1: Curry with actor
|
|
runWithActor = runUntilTransition(actor);
|
|
|
|
// Level 2: Curry with actor + fromState
|
|
runFromIdle = runWithActor('machine.idle');
|
|
});
|
|
|
|
it('should transition to loading', async () => {
|
|
actor.send({ type: 'LOAD' });
|
|
// Level 3: Only provide toState
|
|
await runFromIdle('machine.loading');
|
|
});
|
|
|
|
it('should transition to success', async () => {
|
|
actor.send({ type: 'LOAD' });
|
|
actor.send({ type: 'SUCCESS' });
|
|
await runFromIdle('machine.success');
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Shared Options with Currying
|
|
|
|
Create curried functions with preset options.
|
|
|
|
```typescript
|
|
import { runUntilSnapshotWith } from 'xstate-audition';
|
|
|
|
describe('SlowMachine', () => {
|
|
const options = {
|
|
timeout: 5000,
|
|
logger: console.log,
|
|
};
|
|
|
|
it('should eventually reach done state', async () => {
|
|
const actor = createActor(slowMachine);
|
|
|
|
const snapshot = await runUntilSnapshotWith(actor, options, (s) =>
|
|
s.matches('done'),
|
|
);
|
|
|
|
assert.ok(snapshot.matches('done'));
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Hierarchical Actor Testing
|
|
|
|
### Pattern: Parent-Child Communication
|
|
|
|
Test parent-child actor interactions.
|
|
|
|
```typescript
|
|
import { waitForSpawn, waitForSnapshot } from 'xstate-audition';
|
|
|
|
const childLogic = fromPromise<string, string>(async ({ input }) => {
|
|
return `processed: ${input}`;
|
|
});
|
|
|
|
const parentMachine = setup({
|
|
actors: { child: childLogic },
|
|
types: {
|
|
context: {} as { result?: string },
|
|
events: {} as { type: 'START'; value: string },
|
|
},
|
|
}).createMachine({
|
|
initial: 'idle',
|
|
context: { result: undefined },
|
|
states: {
|
|
idle: {
|
|
on: {
|
|
START: 'processing',
|
|
},
|
|
},
|
|
processing: {
|
|
invoke: {
|
|
id: 'worker',
|
|
src: 'child',
|
|
input: ({ event }) => event.value,
|
|
onDone: {
|
|
target: 'done',
|
|
actions: assign({
|
|
result: ({ event }) => event.output,
|
|
}),
|
|
},
|
|
},
|
|
},
|
|
done: {
|
|
type: 'final',
|
|
},
|
|
},
|
|
});
|
|
|
|
describe('Parent-Child Communication', () => {
|
|
it('should spawn child and receive result', async () => {
|
|
const parent = createActor(parentMachine);
|
|
|
|
// Setup spawn detection
|
|
const childPromise = waitForSpawn<typeof childLogic>(parent, 'worker');
|
|
|
|
// Trigger spawning
|
|
parent.send({ type: 'START', value: 'test' });
|
|
|
|
// Wait for child to spawn
|
|
const child = await childPromise;
|
|
assert.equal(child.id, 'worker');
|
|
|
|
// Wait for parent to complete
|
|
const snapshot = await waitForSnapshot(parent, (s) => s.matches('done'));
|
|
assert.equal(snapshot.context.result, 'processed: test');
|
|
|
|
// Cleanup
|
|
parent.stop();
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Testing Actor Hierarchies
|
|
|
|
Test complex multi-level actor systems.
|
|
|
|
```typescript
|
|
describe('Three-Level Hierarchy', () => {
|
|
it('should coordinate grandparent-parent-child', async () => {
|
|
const grandparent = createActor(grandparentMachine);
|
|
|
|
// Wait for parent to spawn
|
|
const parent = await waitForSpawn<typeof parentLogic>(
|
|
grandparent,
|
|
'parentActor',
|
|
);
|
|
|
|
// Wait for child to spawn (spawned by parent)
|
|
const child = await waitForSpawn<typeof childLogic>(
|
|
grandparent, // Detectable from root
|
|
'childActor',
|
|
);
|
|
|
|
// Send event to child
|
|
child.send({ type: 'WORK', value: 42 });
|
|
|
|
// Wait for result to propagate to grandparent
|
|
const snapshot = await waitForSnapshot(
|
|
grandparent,
|
|
(s) => s.context.finalResult !== undefined,
|
|
);
|
|
|
|
assert.equal(snapshot.context.finalResult, 42);
|
|
|
|
grandparent.stop();
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Event Communication Patterns
|
|
|
|
### Pattern: Inter-Actor Event Flow
|
|
|
|
Test event communication between actors.
|
|
|
|
```typescript
|
|
describe('Ping-Pong Actors', () => {
|
|
it('should exchange events', async () => {
|
|
const ping = createActor(pingMachine);
|
|
const pong = createActor(pongMachine);
|
|
|
|
// Start both actors
|
|
ping.start();
|
|
pong.start();
|
|
|
|
try {
|
|
// Setup detection for pong receiving PING
|
|
const pongPromise = waitForEventReceived(pong, ['PING']);
|
|
|
|
// Send PING from ping to pong
|
|
ping.send({ type: 'START_PING', target: pong });
|
|
|
|
// Wait for pong to receive
|
|
const [receivedEvent] = await pongPromise;
|
|
assert.equal(receivedEvent.type, 'PING');
|
|
|
|
// Setup detection for ping receiving PONG
|
|
const pingPromise = waitForEventReceived(ping, ['PONG']);
|
|
|
|
// Pong responds
|
|
pong.send({ type: 'RESPOND', target: ping });
|
|
|
|
// Wait for ping to receive
|
|
const [pongEvent] = await pingPromise;
|
|
assert.equal(pongEvent.type, 'PONG');
|
|
} finally {
|
|
ping.stop();
|
|
pong.stop();
|
|
}
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Event Source Filtering
|
|
|
|
Test events from specific actor sources.
|
|
|
|
```typescript
|
|
describe('Multi-Child Event Filtering', () => {
|
|
it('should filter events by source actor', async () => {
|
|
const parent = createActor(parentMachine);
|
|
|
|
// Parent spawns multiple children: child-1, child-2, child-3
|
|
parent.send({ type: 'SPAWN_CHILDREN', count: 3 });
|
|
|
|
// Wait for events only from child-2
|
|
const events = await runUntilEventReceivedWith(
|
|
parent,
|
|
{ otherActorId: 'child-2', timeout: 2000 },
|
|
['READY', 'COMPLETE'],
|
|
);
|
|
|
|
// Should only have events from child-2
|
|
assert.equal(events.length, 2);
|
|
assert.equal(events[0].type, 'READY');
|
|
assert.equal(events[1].type, 'COMPLETE');
|
|
});
|
|
|
|
it('should filter events by pattern', async () => {
|
|
const parent = createActor(parentMachine);
|
|
|
|
// Filter events from any child matching pattern
|
|
const events = await runUntilEventReceivedWith(
|
|
parent,
|
|
{ otherActorId: /^child-\d+$/ },
|
|
['STATUS'],
|
|
);
|
|
|
|
assert.equal(events[0].type, 'STATUS');
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Timeout and Error Testing
|
|
|
|
### Pattern: Testing Timeout Scenarios
|
|
|
|
Verify actors handle timeouts correctly.
|
|
|
|
```typescript
|
|
describe('Timeout Handling', () => {
|
|
it('should timeout if actor takes too long', async () => {
|
|
const actor = createActor(slowMachine);
|
|
|
|
await assert.rejects(
|
|
runUntilDoneWith(actor, { timeout: 100 }),
|
|
(err: Error) => {
|
|
assert.match(err.message, /did not complete in 100ms/);
|
|
return true;
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should complete within timeout', async () => {
|
|
const actor = createActor(fastMachine);
|
|
|
|
// Should not timeout
|
|
const output = await runUntilDoneWith(actor, { timeout: 1000 });
|
|
assert.ok(output);
|
|
});
|
|
|
|
it('should work with infinite timeout', async () => {
|
|
const actor = createActor(unpredictableMachine);
|
|
|
|
// No timeout
|
|
const output = await runUntilDoneWith(actor, { timeout: Infinity });
|
|
assert.ok(output);
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Error State Testing
|
|
|
|
Test error handling and recovery.
|
|
|
|
```typescript
|
|
describe('Error Handling', () => {
|
|
it('should transition to error state on failure', async () => {
|
|
const actor = createActor(fetchMachine);
|
|
|
|
actor.send({ type: 'FETCH' });
|
|
actor.send({ type: 'ERROR', error: new Error('Network failed') });
|
|
|
|
const snapshot = await runUntilSnapshot(actor, (s) => s.matches('error'));
|
|
|
|
assert.ok(snapshot.context.error);
|
|
assert.match(snapshot.context.error.message, /Network failed/);
|
|
});
|
|
|
|
it('should retry after error', async () => {
|
|
const actor = createActor(retryMachine);
|
|
|
|
actor.send({ type: 'FETCH' });
|
|
actor.send({ type: 'ERROR' });
|
|
|
|
// Should transition to error
|
|
await waitForSnapshot(actor, (s) => s.matches('error'));
|
|
|
|
// Send retry
|
|
actor.send({ type: 'RETRY' });
|
|
|
|
// Should transition back to loading
|
|
const snapshot = await waitForSnapshot(actor, (s) => s.matches('loading'));
|
|
|
|
assert.ok(snapshot.matches('loading'));
|
|
actor.stop();
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Integration Testing Patterns
|
|
|
|
### Pattern: End-to-End Flow Testing
|
|
|
|
Test complete user flows through state machines.
|
|
|
|
```typescript
|
|
describe('User Registration Flow', () => {
|
|
it('should complete full registration', async () => {
|
|
const actor = createActor(registrationMachine);
|
|
|
|
// Start registration
|
|
const idleToForm = waitForTransition(
|
|
actor,
|
|
'registration.idle',
|
|
'registration.form',
|
|
);
|
|
actor.send({ type: 'START_REGISTRATION' });
|
|
await idleToForm;
|
|
|
|
// Fill form
|
|
actor.send({
|
|
type: 'SUBMIT_FORM',
|
|
data: { email: 'user@example.com', password: 'secure123' },
|
|
});
|
|
|
|
// Wait for validation
|
|
await waitForSnapshot(actor, (s) => s.matches('validating'));
|
|
|
|
// Simulate validation success
|
|
actor.send({ type: 'VALIDATION_SUCCESS' });
|
|
|
|
// Wait for API call
|
|
await waitForSnapshot(actor, (s) => s.matches('submitting'));
|
|
|
|
// Simulate API success
|
|
actor.send({
|
|
type: 'API_SUCCESS',
|
|
userId: '123',
|
|
});
|
|
|
|
// Should reach success state
|
|
const snapshot = await waitForSnapshot(actor, (s) => s.matches('success'));
|
|
|
|
assert.equal(snapshot.context.userId, '123');
|
|
actor.stop();
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Testing with External Services
|
|
|
|
Test actors that interact with external services.
|
|
|
|
```typescript
|
|
import { vi } from 'vitest';
|
|
|
|
describe('API Integration', () => {
|
|
it('should call API and handle response', async () => {
|
|
// Mock API
|
|
const mockFetch = vi.fn().mockResolvedValue({
|
|
json: async () => ({ id: '123', name: 'Test' }),
|
|
});
|
|
|
|
const machine = setup({
|
|
actors: {
|
|
fetchUser: fromPromise(async ({ input }) => {
|
|
const response = await mockFetch(`/api/users/${input.id}`);
|
|
return response.json();
|
|
}),
|
|
},
|
|
}).createMachine({...});
|
|
|
|
const actor = createActor(machine);
|
|
|
|
actor.send({ type: 'FETCH_USER', id: '123' });
|
|
|
|
const snapshot = await runUntilSnapshot(
|
|
actor,
|
|
(s) => s.context.userData !== null
|
|
);
|
|
|
|
assert.ok(mockFetch.calledOnce);
|
|
assert.equal(snapshot.context.userData.id, '123');
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Debugging Failed Tests
|
|
|
|
### Pattern: Adding Debug Logging
|
|
|
|
Use logger and inspector for debugging.
|
|
|
|
```typescript
|
|
describe('Debugging Failed Test', () => {
|
|
it('should debug with logger', async () => {
|
|
const actor = createActor(problemMachine);
|
|
|
|
const snapshot = await runUntilSnapshotWith(
|
|
actor,
|
|
{
|
|
logger: (...args) => console.log('[DEBUG]', ...args),
|
|
timeout: 5000,
|
|
},
|
|
(s) => s.matches('targetState'),
|
|
);
|
|
|
|
// Logs will show all state transitions and actions
|
|
});
|
|
|
|
it('should debug with inspector', async () => {
|
|
const actor = createActor(problemMachine);
|
|
const events: any[] = [];
|
|
|
|
const snapshot = await runUntilSnapshotWith(
|
|
actor,
|
|
{
|
|
inspector: (event) => {
|
|
events.push(event);
|
|
console.log('Inspection:', event.type);
|
|
},
|
|
timeout: 5000,
|
|
},
|
|
(s) => s.matches('targetState'),
|
|
);
|
|
|
|
// Inspect collected events
|
|
console.log('All events:', events);
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Incremental Testing
|
|
|
|
Break complex tests into smaller steps.
|
|
|
|
```typescript
|
|
describe('Complex Flow - Incremental', () => {
|
|
it('Step 1: should start correctly', async () => {
|
|
const actor = createActor(complexMachine);
|
|
actor.send({ type: 'START' });
|
|
|
|
await waitForSnapshot(actor, (s) => s.matches('started'));
|
|
actor.stop();
|
|
});
|
|
|
|
it('Step 2: should process data', async () => {
|
|
const actor = createActor(complexMachine);
|
|
actor.send({ type: 'START' });
|
|
await waitForSnapshot(actor, (s) => s.matches('started'));
|
|
|
|
actor.send({ type: 'PROCESS', data: 'test' });
|
|
await waitForSnapshot(actor, (s) => s.matches('processing'));
|
|
|
|
actor.stop();
|
|
});
|
|
|
|
it('Step 3: should complete', async () => {
|
|
const actor = createActor(complexMachine);
|
|
actor.send({ type: 'START' });
|
|
await waitForSnapshot(actor, (s) => s.matches('started'));
|
|
|
|
actor.send({ type: 'PROCESS', data: 'test' });
|
|
await waitForSnapshot(actor, (s) => s.matches('processing'));
|
|
|
|
actor.send({ type: 'COMPLETE' });
|
|
const snapshot = await runUntilSnapshot(actor, (s) => s.matches('done'));
|
|
|
|
assert.ok(snapshot.matches('done'));
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Performance Testing
|
|
|
|
### Pattern: Testing Timing Constraints
|
|
|
|
Verify actors meet performance requirements.
|
|
|
|
```typescript
|
|
describe('Performance', () => {
|
|
it('should complete within 100ms', async () => {
|
|
const start = Date.now();
|
|
const actor = createActor(fastMachine);
|
|
|
|
await runUntilDoneWith(actor, { timeout: 100 });
|
|
|
|
const elapsed = Date.now() - start;
|
|
assert.ok(elapsed < 100, `Took ${elapsed}ms, expected < 100ms`);
|
|
});
|
|
|
|
it('should handle burst of events', async () => {
|
|
const actor = createActor(eventHandlerMachine);
|
|
|
|
// Send many events rapidly
|
|
const promise = waitForSnapshot(
|
|
actor,
|
|
(s) => s.context.processedCount === 1000,
|
|
);
|
|
|
|
for (let i = 0; i < 1000; i++) {
|
|
actor.send({ type: 'PROCESS', id: i });
|
|
}
|
|
|
|
const snapshot = await promise;
|
|
assert.equal(snapshot.context.processedCount, 1000);
|
|
|
|
actor.stop();
|
|
});
|
|
});
|
|
```
|
|
|
|
### Pattern: Memory Leak Detection
|
|
|
|
Test for memory leaks in long-running actors.
|
|
|
|
```typescript
|
|
describe('Memory Leaks', () => {
|
|
it('should not leak memory with many iterations', async () => {
|
|
const iterations = 1000;
|
|
|
|
for (let i = 0; i < iterations; i++) {
|
|
const actor = createActor(myMachine);
|
|
await runUntilDone(actor);
|
|
// Actor is stopped by runUntilDone
|
|
}
|
|
|
|
// If test completes, no obvious leaks
|
|
// Use memory profiling tools for deeper analysis
|
|
});
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Advanced TypeScript Patterns
|
|
|
|
### Pattern: Generic Test Helpers
|
|
|
|
Create reusable, type-safe test utilities.
|
|
|
|
```typescript
|
|
async function testMachineOutput<TLogic extends AnyActorLogic>(
|
|
logic: TLogic,
|
|
input: InputFrom<TLogic>,
|
|
expectedOutput: OutputFrom<TLogic>,
|
|
) {
|
|
const actor = createActor(logic, { input });
|
|
const output = await runUntilDone(actor);
|
|
|
|
assert.deepEqual(output, expectedOutput);
|
|
}
|
|
|
|
// Usage
|
|
await testMachineOutput(promiseMachine, 'input', 'expected-output');
|
|
```
|
|
|
|
### Pattern: Type-Safe Event Testing
|
|
|
|
Create helpers with full type inference.
|
|
|
|
```typescript
|
|
function createEmittedTester<TMachine extends AnyStateMachineActor>(
|
|
machine: TMachine,
|
|
) {
|
|
return async (
|
|
emittedTypes: Array<EmittedFrom<TMachine>['type']>,
|
|
assertions: (events: Array<EmittedFrom<TMachine>>) => void,
|
|
) => {
|
|
const actor = createActor(machine);
|
|
const events = await runUntilEmitted(actor, emittedTypes);
|
|
assertions(events);
|
|
};
|
|
}
|
|
|
|
// Usage with full type safety
|
|
const testEmitted = createEmittedTester(myMachine);
|
|
|
|
await testEmitted(['EVENT1', 'EVENT2'], (events) => {
|
|
// events is fully typed as Array<EmittedFrom<typeof myMachine>>
|
|
assert.equal(events[0].type, 'EVENT1');
|
|
assert.equal(events[1].type, 'EVENT2');
|
|
});
|
|
```
|
|
|
|
### Pattern: Conditional Type Guards
|
|
|
|
Use type guards for snapshot testing.
|
|
|
|
```typescript
|
|
function isErrorState(
|
|
snapshot: SnapshotFrom<typeof machine>,
|
|
): snapshot is SnapshotFrom<typeof machine> & { context: { error: Error } } {
|
|
return snapshot.matches('error') && snapshot.context.error !== null;
|
|
}
|
|
|
|
it('should reach error state with error', async () => {
|
|
const actor = createActor(machine);
|
|
|
|
actor.send({ type: 'TRIGGER_ERROR' });
|
|
|
|
const snapshot = await runUntilSnapshot(actor, isErrorState);
|
|
|
|
// TypeScript knows snapshot.context.error is Error
|
|
assert.equal(snapshot.context.error.message, 'Expected error');
|
|
});
|
|
```
|
|
|
|
---
|
|
|
|
## Best Practice Checklist
|
|
|
|
### Test Organization
|
|
|
|
- ✅ Use `describe` blocks for logical grouping
|
|
- ✅ Extract shared setup to `beforeEach`
|
|
- ✅ Clean up actors in `afterEach` if using `waitFor*`
|
|
- ✅ Use factory functions for actor creation
|
|
- ✅ Keep tests focused on single behavior
|
|
|
|
### Currying
|
|
|
|
- ✅ Curry repeated patterns in `beforeEach`
|
|
- ✅ Type curried functions explicitly
|
|
- ✅ Use multi-level currying for complex scenarios
|
|
- ✅ Create reusable helpers with preset options
|
|
|
|
### Assertions
|
|
|
|
- ✅ Assert on specific values, not just truthiness
|
|
- ✅ Use snapshot matchers for complex state
|
|
- ✅ Test both success and error paths
|
|
- ✅ Verify context changes, not just state values
|
|
|
|
### Performance
|
|
|
|
- ✅ Set explicit timeouts for slow operations
|
|
- ✅ Keep timeouts < test framework timeout
|
|
- ✅ Test timing constraints when critical
|
|
- ✅ Profile for memory leaks in long-running tests
|
|
|
|
### Debugging
|
|
|
|
- ✅ Add logger for failing tests
|
|
- ✅ Use inspector to see all events
|
|
- ✅ Break complex tests into steps
|
|
- ✅ Increase timeout to isolate timing issues
|
|
|
|
---
|
|
|
|
## See Also
|
|
|
|
- [Core Functions Reference](./core-functions.md) - Detailed API documentation
|
|
- [Options & Types](./options-types.md) - AuditionOptions and TypeScript types
|