@engjts/nexus 0.1.7 → 0.1.9

package/documentation/24-testing-utilities.md

@@ -1,1287 +0,0 @@
-# Testing Utilities
-
-Nexus framework menyediakan comprehensive testing toolkit untuk memudahkan testing aplikasi. Toolkit ini mencakup test client, mock utilities, data factory, mock server, dan load testing capabilities.
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [Test Client](#test-client)
-3. [Data Factory](#data-factory)
-4. [Mock Utilities](#mock-utilities)
-5. [Mock Server](#mock-server)
-6. [Load Testing](#load-testing)
-7. [Test Suite Setup](#test-suite-setup)
-8. [Database Seeding](#database-seeding)
-9. [Examples](#examples)
-
----
-
-## Overview
-
-Testing utilities tersedia di `src/advanced/testing/` dan terdiri dari:
-
-- **`harness.ts`** - Test client, suite, dan assertion helpers
-- **`factory.ts`** - Data factory dengan built-in generators
-- **`mock.ts`** - Mock functions, database, fetch, timers
-- **`mock-server.ts`** - Mock HTTP server untuk testing external APIs
-- **`load-test.ts`** - Load testing dan stress testing utilities
-
-### Import
-
-```typescript
-import {
-  TestClient,
-  createTestSuite,
-  TestSeeder,
-  expectDuration,
-  expectSnapshot,
-  waitFor,
-  retry,
-  spyOn,
-  // Factory
-  defineFactory,
-  generators,
-  // Mock
-  createMockFn,
-  MockDatabase,
-  MockFetch,
-  MockTimers,
-  EventSpy,
-  // Mock Server
-  createMockServer,
-  mockResponses,
-  // Load Test
-  createLoadTest,
-  formatLoadTestResults
-} from '../advanced/testing';
-```
-
----
-
-## Test Client
-
-`TestClient` adalah HTTP client untuk testing API endpoints dengan support untuk authentication, headers, dan various HTTP methods.
-
-### Basic Usage
-
-```typescript
-import { TestClient } from '../advanced/testing';
-import { app } from './app';
-
-const client = new TestClient(app);
-
-// GET request
-const response = await client.get('/api/users');
-console.log(response.status); // 200
-console.log(response.json()); // parsed JSON
-
-// POST request
-const createResponse = await client.post('/api/users', {
-  body: { name: 'John', email: 'john@example.com' }
-});
-
-// PUT request
-const updateResponse = await client.put('/api/users/1', {
-  body: { name: 'Jane' }
-});
-
-// DELETE request
-const deleteResponse = await client.delete('/api/users/1');
-
-// PATCH request
-const patchResponse = await client.patch('/api/users/1', {
-  body: { active: true }
-});
-```
-
-### Query Parameters
-
-```typescript
-const response = await client.get('/api/users', {
-  query: {
-    page: 1,
-    limit: 10,
-    search: 'john'
-  }
-});
-```
-
-### Custom Headers
-
-```typescript
-// Set default headers for all requests
-client.setDefaultHeaders({
-  'X-API-Key': 'secret-key',
-  'Accept-Language': 'en-US'
-});
-
-// Or set headers per request
-const response = await client.get('/api/data', {
-  headers: {
-    'X-Request-ID': 'req-123'
-  }
-});
-```
-
-### Authentication
-
-```typescript
-// Authenticate with token
-client.authenticate('eyJhbGc...');
-
-// Authenticate dengan user object
-client.authenticate({
-  token: 'eyJhbGc...',
-  id: 1,
-  email: 'user@example.com'
-});
-
-// Get authenticated user
-const user = client.getAuthUser();
-
-// Clear authentication
-client.clearAuth();
-```
-
-### Response Object
-
-```typescript
-interface TestResponse<T = any> {
-  status: number;
-  headers: Record<string, string | string[]>;
-  body: string;
-  duration: number;
-  json(): T;
-}
-
-const response = await client.get('/api/users/1');
-console.log(response.status);   // 200
-console.log(response.duration); // milliseconds
-console.log(response.json());   // parsed body
-```
-
-### Client Lifecycle
-
-```typescript
-const client = new TestClient(app);
-
-// Start server (automatic, tapi bisa explicit)
-await client.start();
-
-// Use client...
-const response = await client.get('/api/users');
-
-// Stop server
-await client.stop();
-```
-
----
-
-## Data Factory
-
-Data factory untuk generate realistic test data dengan support untuk traits, sequences, dan custom generators.
-
-### Defining a Factory
-
-```typescript
-import { defineFactory, generators } from '../advanced/testing';
-
-const userFactory = defineFactory({
-  id: generators.uuid(),
-  email: generators.email(),
-  firstName: generators.firstName(),
-  lastName: generators.lastName(),
-  username: generators.username(),
-  password: generators.password(),
-  phone: generators.phone(),
-  createdAt: generators.pastDate(365)
-});
-
-// Build a single record (in-memory, tidak disimpan)
-const user = userFactory.build();
-// { 
-//   id: 'uuid-123',
-//   email: 'user_1@example.com',
-//   firstName: 'John',
-//   ...
-// }
-
-// Build banyak records
-const users = userFactory.buildMany(5);
-
-// Build dengan overrides
-const adminUser = userFactory.build({
-  overrides: {
-    email: 'admin@example.com',
-    role: 'admin'
-  }
-});
-```
-
-### Traits
-
-Traits adalah variations dari factory yang bisa di-apply:
-
-```typescript
-const userFactory = defineFactory({
-  id: generators.uuid(),
-  email: generators.email(),
-  role: 'user',
-  active: true
-});
-
-userFactory.trait('admin', {
-  role: 'admin'
-});
-
-userFactory.trait('inactive', {
-  active: false
-});
-
-// Use traits
-const admin = userFactory.build({ traits: ['admin'] });
-const inactiveUser = userFactory.build({ traits: ['inactive'] });
-const inactiveAdmin = userFactory.build({ traits: ['admin', 'inactive'] });
-```
-
-### Persistence
-
-```typescript
-// Set persist function untuk save ke database
-userFactory.setPersist(async (user) => {
-  return db.users.create(user);
-});
-
-// Create dengan persistence
-const savedUser = await userFactory.create();
-
-// Create banyak dengan persistence
-const savedUsers = await userFactory.createMany(10);
-```
-
-### After Create Hooks
-
-```typescript
-userFactory.afterCreate(async (user) => {
-  // Create related data
-  await db.profiles.create({
-    userId: user.id,
-    bio: 'New user'
-  });
-});
-
-const user = await userFactory.create();
-// User dan profile akan dibuat
-```
-
-### Built-in Generators
-
-#### UUID dan ID
-
-```typescript
-generators.uuid()                    // Random UUID
-generators.sequence('USER_')         // USER_1, USER_2, ...
-```
-
-#### Numbers
-
-```typescript
-generators.integer(0, 100)           // Random integer
-generators.float(0, 100, 2)          // Random float with decimals
-generators.boolean(0.7)              // 70% chance true
-```
-
-#### Text
-
-```typescript
-generators.string(10)                // Random string (10 chars)
-generators.lorem(10)                 // 10 random lorem words
-generators.paragraph(3)              // 3 sentences
-generators.slug()                    // url-slug-123-abc
-```
-
-#### Person Data
-
-```typescript
-generators.firstName()               // 'John'
-generators.lastName()                // 'Smith'
-generators.fullName()                // 'John Smith'
-generators.email()                   // 'user_1@example.com'
-generators.username()                // 'user_1_abc'
-generators.phone()                   // '123-456-7890'
-```
-
-#### Company Data
-
-```typescript
-generators.company()                 // 'TechCorp Solutions'
-generators.jobTitle()                // 'Senior Developer'
-```
-
-#### Dates
-
-```typescript
-generators.date(start, end)          // Random date between start and end
-generators.pastDate(365)             // Date up to 365 days ago
-generators.futureDate(365)           // Date up to 365 days in future
-```
-
-#### Web/Network
-
-```typescript
-generators.url()                     // 'https://example.com/abc123'
-generators.ipv4()                    // '192.168.1.1'
-generators.slug()                    // 'slug-1-abc'
-```
-
-#### Commerce
-
-```typescript
-generators.price(1, 1000)            // Random price
-generators.currency()                // 'USD'
-generators.countryCode()             // 'US'
-generators.address()                 // { street, city, state, zip }
-```
-
-#### Media
-
-```typescript
-generators.hexColor()                // '#a1b2c3'
-generators.filePath()                // '/documents/abc.pdf'
-generators.mimeType()                // 'application/json'
-generators.creditCard()              // '1234-5678-9012-3456'
-```
-
-#### Collections
-
-```typescript
-generators.oneOf(['a', 'b', 'c'])    // Pick one random
-generators.someOf(['a', 'b', 'c'], 1, 2)  // Pick 1-2 items
-```
-
----
-
-## Mock Utilities
-
-Utilities untuk mock functions, database, fetch, timers, dan events.
-
-### Mock Functions
-
-```typescript
-import { createMockFn } from '../advanced/testing';
-
-const mockFn = createMockFn();
-
-// Set return value
-mockFn.mockReturnValue('hello');
-mockFn();  // 'hello'
-
-// Set return value for one call
-mockFn.mockReturnValueOnce('first');
-mockFn.mockReturnValue('second');
-mockFn();  // 'first'
-mockFn();  // 'second'
-
-// Async mocking
-mockFn.mockResolvedValue({ id: 1 });
-await mockFn();  // { id: 1 }
-
-// Async reject
-mockFn.mockRejectedValue(new Error('Failed'));
-try {
-  await mockFn();
-} catch (error) {
-  console.log(error.message);  // 'Failed'
-}
-
-// Custom implementation
-mockFn.mockImplementation((x) => x * 2);
-mockFn(5);  // 10
-
-// Assertions
-if (mockFn.toHaveBeenCalled()) {
-  console.log('Function was called');
-}
-
-if (mockFn.toHaveBeenCalledWith(5)) {
-  console.log('Called with 5');
-}
-
-console.log(mockFn.calls);     // Array of all calls
-console.log(mockFn.results);   // Array of all results
-```
-
-### Mock Database
-
-```typescript
-import { MockDatabase } from '../advanced/testing';
-
-const mockDb = new MockDatabase();
-const users = mockDb.table('users');
-
-// Insert
-const user = await users.insert({ name: 'John', email: 'john@example.com' });
-
-// Find
-const found = await users.find(user.id);
-
-// Find many
-const all = await users.findMany();
-const filtered = await users.findMany({ name: 'John' });
-
-// Update
-const updated = await users.update(user.id, { name: 'Jane' });
-
-// Delete
-const deleted = await users.delete(user.id);
-
-// Seed data
-users.seed([
-  { id: 1, name: 'John', email: 'john@example.com' },
-  { id: 2, name: 'Jane', email: 'jane@example.com' }
-]);
-
-// Get all records
-const records = users.getAll();
-
-// Clear data
-users.clear();
-
-// Reset (clear data + reset mocks)
-users.reset();
-
-// Assertions on mock calls
-console.log(users.insert.calls);  // Semua calls ke insert()
-console.log(users.update.calls);  // Semua calls ke update()
-```
-
-### Mock Fetch
-
-```typescript
-import { mockFetch } from '../advanced/testing';
-
-// Register mock routes
-mockFetch
-  .get('/api/users')
-  .reply(200, [{ id: 1, name: 'John' }]);
-
-mockFetch
-  .post('/api/users')
-  .reply(201, { id: 2, name: 'Jane' });
-
-mockFetch
-  .delete('/api/users/:id')
-  .reply(204);
-
-// Install globally
-mockFetch.install();
-
-// Use fetch normally
-const response = await fetch('/api/users');
-const data = await response.json();
-
-// Restore original fetch
-mockFetch.restore();
-
-// Assertions
-if (mockFetch.wasCalled('/api/users', 'GET')) {
-  console.log('GET /api/users was called');
-}
-
-console.log(mockFetch.getCalls());  // All fetch calls
-```
-
-### Mock Fetch dengan Custom Handler
-
-```typescript
-mockFetch
-  .post('/api/users')
-  .replyWith(async (url, options) => {
-    const body = JSON.parse(options?.body || '{}');
-    return {
-      status: 201,
-      body: { id: Math.random(), ...body }
-    };
-  });
-
-// Simulate errors
-mockFetch
-  .get('/api/error')
-  .networkError('Connection refused');
-
-mockFetch
-  .get('/api/timeout')
-  .timeout(5000);
-```
-
-### Mock Timers
-
-```typescript
-import { mockTimers } from '../advanced/testing';
-
-// Install mock timers
-mockTimers.install();
-
-// Set current time
-mockTimers.setTime(Date.now());
-
-// Use setTimeout normally
-let called = false;
-setTimeout(() => { called = true; }, 1000);
-
-// Advance time
-await mockTimers.tick(1000);
-console.log(called);  // true
-
-// Run all pending timers
-await mockTimers.runAll();
-
-// Get current mocked time
-console.log(mockTimers.now());
-
-// Restore
-mockTimers.restore();
-```
-
-### Event Spy
-
-```typescript
-import { EventSpy } from '../advanced/testing';
-import { EventEmitter } from 'events';
-
-const emitter = new EventEmitter();
-const spy = new EventSpy(emitter);
-
-// Spy on events
-spy.on('data').on('error').on('complete');
-
-// Emit events
-emitter.emit('data', { id: 1 });
-emitter.emit('data', { id: 2 });
-emitter.emit('complete');
-
-// Assertions
-if (spy.wasEmitted('data')) {
-  console.log('Data event was emitted');
-}
-
-console.log(spy.count('data'));           // 2
-console.log(spy.getCalls('data'));        // [[{ id: 1 }], [{ id: 2 }]]
-
-// Clear
-spy.clear();
-```
-
----
-
-## Mock Server
-
-Mock HTTP server untuk testing external API calls.
-
-### Basic Setup
-
-```typescript
-import { createMockServer } from '../advanced/testing';
-
-const mockServer = createMockServer();
-
-// Register routes
-mockServer.get('/api/users', (req) => ({
-  status: 200,
-  body: [{ id: 1, name: 'John' }]
-}));
-
-mockServer.post('/api/users', (req) => ({
-  status: 201,
-  body: { id: 2, ...req.body }
-}));
-
-// Start server
-const url = await mockServer.start(3001);
-console.log(url);  // 'http://127.0.0.1:3001'
-
-// Use it...
-const response = await fetch(`${url}/api/users`);
-
-// Stop server
-await mockServer.stop();
-```
-
-### Route Patterns
-
-```typescript
-// Exact path
-mockServer.get('/api/users', handler);
-
-// Path parameters
-mockServer.get('/api/users/:id', (req) => {
-  console.log(req.params.id);  // '123'
-  return { status: 200, body: { id: req.params.id } };
-});
-
-// Regex pattern
-mockServer.get(/^\/api\/v\d+\/users/, handler);
-
-// Any method
-mockServer.any('/webhook', handler);
-```
-
-### Request Object
-
-```typescript
-mockServer.post('/api/data', (req) => {
-  console.log(req.method);     // 'POST'
-  console.log(req.path);       // '/api/data'
-  console.log(req.query);      // { page: '1', limit: '10' }
-  console.log(req.headers);    // { 'content-type': 'application/json' }
-  console.log(req.body);       // Parsed JSON atau raw string
-  console.log(req.params);     // URL parameters dari path pattern
-
-  return { status: 200 };
-});
-```
-
-### Response Helpers
-
-```typescript
-import { mockResponses } from '../advanced/testing';
-
-mockServer.get('/ok', mockResponses.ok());
-mockServer.post('/created', mockResponses.created({ id: 1 }));
-mockServer.get('/no-content', mockResponses.noContent());
-mockServer.get('/error', mockResponses.badRequest('Invalid input'));
-mockServer.get('/unauthorized', mockResponses.unauthorized());
-mockServer.get('/forbidden', mockResponses.forbidden());
-mockServer.get('/not-found', mockResponses.notFound());
-mockServer.get('/error', mockResponses.serverError());
-
-// Echo request back
-mockServer.get('/echo', mockResponses.echo());
-
-// Paginated response
-const items = Array.from({ length: 50 }, (_, i) => ({ id: i + 1 }));
-mockServer.get('/items', mockResponses.paginated(items, 10));
-```
-
-### Route Configuration
-
-```typescript
-mockServer
-  .get('/api/data')
-  .delay(500)           // Delay 500ms before response
-  .times(1)             // Respond only once
-  .reply(200, { data: 'value' });
-
-// Handler for dynamic responses
-mockServer
-  .post('/api/users')
-  .replyWith(async (req) => {
-    if (!req.body.email) {
-      return { status: 400, body: { error: 'Email required' } };
-    }
-    return { status: 201, body: { id: 1, ...req.body } };
-  });
-```
-
-### Assertions
-
-```typescript
-const mockServer = createMockServer();
-
-// ... register routes and use them
-
-// Check if path was called
-if (mockServer.wasCalled('/api/users', 'GET')) {
-  console.log('GET /api/users was called');
-}
-
-// Get call count
-const count = mockServer.callCount('/api/users', 'GET');
-console.log(`Called ${count} times`);
-
-// Get all requests
-const requests = mockServer.getRequests();
-requests.forEach(req => {
-  console.log(`${req.method} ${req.path}`);
-});
-
-// Clear request history
-mockServer.clearRequests();
-
-// Reset everything
-mockServer.reset();
-```
-
----
-
-## Load Testing
-
-Utilities untuk load testing dan stress testing APIs.
-
-### Basic Load Test
-
-```typescript
-import { createLoadTest, formatLoadTestResults } from '../advanced/testing';
-
-const loadTest = createLoadTest({
-  baseUrl: 'http://localhost:3000',
-  vus: 10,                    // 10 virtual users
-  duration: '30s'             // 30 seconds
-});
-
-// Register test function
-loadTest.test('default', async (vu, http) => {
-  const response = await http.get('/api/users');
-  if (response.status !== 200) {
-    throw new Error(`Expected 200, got ${response.status}`);
-  }
-});
-
-// Run test
-const results = await loadTest.run();
-
-// Format and print results
-console.log(formatLoadTestResults(results));
-```
-
-### Scenarios
-
-```typescript
-const loadTest = createLoadTest({
-  baseUrl: 'http://localhost:3000',
-  scenarios: {
-    'ramp-up': {
-      name: 'Ramping up',
-      executor: 'ramping-vus',
-      startVUs: 0,
-      stages: [
-        { duration: '10s', target: 10 },
-        { duration: '20s', target: 50 },
-        { duration: '10s', target: 0 }
-      ],
-      exec: 'load-test'
-    },
-    'spike': {
-      name: 'Spike test',
-      executor: 'constant-vus',
-      vus: 100,
-      duration: '5s',
-      exec: 'load-test'
-    }
-  }
-});
-
-loadTest.test('load-test', async (vu, http) => {
-  await http.get('/api/users');
-});
-
-const results = await loadTest.run();
-```
-
-### Thresholds
-
-```typescript
-const loadTest = createLoadTest({
-  baseUrl: 'http://localhost:3000',
-  vus: 10,
-  duration: '30s',
-  thresholds: {
-    'http_req_duration': [
-      'p(95) < 500',     // 95% requests under 500ms
-      'p(99) < 1000',    // 99% requests under 1000ms
-      'avg < 200'        // average under 200ms
-    ],
-    'http_req_failed': [
-      'rate < 0.01'      // Less than 1% error rate
-    ],
-    'http_reqs': [
-      'rate > 100'       // At least 100 requests per second
-    ]
-  }
-});
-
-loadTest.test('load-test', async (vu, http) => {
-  await http.get('/api/users');
-});
-
-const results = await loadTest.run();
-console.log(results.thresholdsPassed);  // true or false
-```
-
-### HTTP Client
-
-```typescript
-loadTest.test('api-test', async (vu, http) => {
-  // GET request
-  const getResp = await http.get('/api/users', {
-    timeout: 5000
-  });
-
-  // POST request
-  const postResp = await http.post('/api/users', {
-    name: `User ${vu.id}`,
-    email: `user${vu.id}@example.com`
-  });
-
-  // PUT/DELETE requests
-  await http.put('/api/users/1', { name: 'Updated' });
-  await http.delete('/api/users/1');
-
-  // Set headers
-  http.setHeader('Authorization', `Bearer ${vu.data.token}`);
-
-  // Store data per VU
-  vu.data.userId = postResp.json().id;
-});
-```
-
-### Response Object
-
-```typescript
-interface HttpResponse {
-  status: number;
-  headers: Record<string, string | string[]>;
-  body: string;
-  latency: number;  // milliseconds
-}
-
-loadTest.test('api-test', async (vu, http) => {
-  const response = await http.get('/api/data');
-  console.log(response.status);   // HTTP status
-  console.log(response.latency);  // Response time in ms
-  console.log(response.body);     // Response body
-  console.log(response.headers);  // Response headers
-});
-```
-
-### Results
-
-```typescript
-interface LoadTestResult {
-  totalRequests: number;
-  successfulRequests: number;
-  failedRequests: number;
-  duration: number;                    // milliseconds
-  requestsPerSecond: number;
-  latency: {
-    min: number;
-    max: number;
-    avg: number;
-    p50: number;
-    p90: number;
-    p95: number;
-    p99: number;
-  };
-  errorRate: number;                   // 0-1
-  thresholdsPassed: boolean;
-  thresholdResults: Record<string, any>;
-  errors: Array<{ message: string; count: number }>;
-}
-```
-
----
-
-## Test Suite Setup
-
-Helper untuk setup test suite dengan automatic lifecycle management.
-
-### Basic Test Suite
-
-```typescript
-import { createTestSuite } from '../advanced/testing';
-import { app } from './app';
-
-const suite = createTestSuite({
-  app,
-  beforeAll: async () => {
-    // Setup: init database, seed data, etc
-    await db.migrate();
-  },
-  afterAll: async () => {
-    // Teardown: cleanup database, close connections, etc
-    await db.close();
-  },
-  beforeEach: async () => {
-    // Before each test: seed fresh data
-    await seedTestData();
-  },
-  afterEach: async () => {
-    // After each test: cleanup data
-    await db.truncate('users');
-  }
-});
-
-// In your test
-const ctx = await suite.setup();
-const response = await ctx.client.get('/api/users');
-await suite.teardown();
-```
-
----
-
-## Database Seeding
-
-Helper untuk seed database dengan test data.
-
-### Test Seeder
-
-```typescript
-import { TestSeeder } from '../advanced/testing';
-
-const seeder = new TestSeeder();
-
-// Configure database functions
-seeder.configure({
-  insert: async (table, data) => {
-    return db[table].insertMany(data);
-  },
-  truncate: async (table) => {
-    return db[table].truncate();
-  }
-});
-
-// Define seed data
-seeder.define('users', [
-  { id: 1, name: 'John', email: 'john@example.com' },
-  { id: 2, name: 'Jane', email: 'jane@example.com' }
-]);
-
-seeder.define('posts', [
-  { id: 1, userId: 1, title: 'Post 1' },
-  { id: 2, userId: 2, title: 'Post 2' }
-]);
-
-// Seed specific table
-await seeder.seed('users');
-
-// Seed all defined tables
-await seeder.seedAll();
-
-// Seed dengan custom data
-await seeder.seed('users', [
-  { id: 3, name: 'Bob', email: 'bob@example.com' }
-]);
-
-// Truncate tables
-await seeder.truncateAll();
-```
-
----
-
-## Assertion Helpers
-
-### Performance Assertions
-
-```typescript
-import { expectDuration } from '../advanced/testing';
-
-const response = await client.get('/api/data');
-
-expectDuration(response).toBeLessThan(500);      // < 500ms
-expectDuration(response).toBeGreaterThan(10);    // > 10ms
-expectDuration(response).toBeBetween(50, 500);   // 50-500ms
-```
-
-### Snapshot Testing
-
-```typescript
-import { expectSnapshot, updateSnapshots } from '../advanced/testing';
-
-// Capture snapshot (first run)
-const response = await client.get('/api/users');
-expectSnapshot('users-list', response.json()).toMatchSnapshot();
-
-// Update snapshots when needed
-updateSnapshots(true);
-expectSnapshot('users-list', newData).toMatchSnapshot();
-updateSnapshots(false);
-```
-
-### Utility Functions
-
-```typescript
-import { waitFor, retry, spyOn } from '../advanced/testing';
-
-// Wait for condition
-await waitFor(() => someCondition, {
-  timeout: 5000,
-  interval: 100
-});
-
-// Retry operation
-const result = await retry(
-  async () => await unreliableOperation(),
-  {
-    attempts: 3,
-    delay: 100,
-    backoff: true
-  }
-);
-
-// Spy on method
-const obj = { method: () => 'result' };
-const spy = spyOn(obj, 'method');
-obj.method();
-obj.method();
-console.log(spy.calls);  // [[],[]]
-spy.restore();
-```
-
----
-
-## Examples
-
-### Example 1: API Testing
-
-```typescript
-import { TestClient, defineFactory, generators } from '../advanced/testing';
-import { app } from './app';
-
-describe('Users API', () => {
-  let client: TestClient;
-
-  beforeAll(async () => {
-    client = new TestClient(app);
-    await client.start();
-  });
-
-  afterAll(async () => {
-    await client.stop();
-  });
-
-  it('should get all users', async () => {
-    const response = await client.get('/api/users');
-    expect(response.status).toBe(200);
-    expect(Array.isArray(response.json())).toBe(true);
-  });
-
-  it('should create user', async () => {
-    const response = await client.post('/api/users', {
-      body: {
-        name: 'John Doe',
-        email: 'john@example.com'
-      }
-    });
-    expect(response.status).toBe(201);
-    expect(response.json().id).toBeDefined();
-  });
-
-  it('should authenticate user', async () => {
-    const loginResp = await client.post('/api/auth/login', {
-      body: { email: 'john@example.com', password: 'password' }
-    });
-
-    client.authenticate(loginResp.json().token);
-
-    const userResp = await client.get('/api/me');
-    expect(userResp.status).toBe(200);
-
-    client.clearAuth();
-  });
-});
-```
-
-### Example 2: Data Factory
-
-```typescript
-import { defineFactory, generators } from '../advanced/testing';
-
-const userFactory = defineFactory({
-  id: generators.uuid(),
-  email: generators.email(),
-  firstName: generators.firstName(),
-  lastName: generators.lastName(),
-  phone: generators.phone(),
-  country: generators.countryCode(),
-  createdAt: generators.pastDate(365)
-});
-
-userFactory.trait('admin', {
-  role: 'admin',
-  permissions: ['read', 'write', 'delete']
-});
-
-userFactory.trait('inactive', {
-  active: false
-});
-
-// Usage
-const user = userFactory.build();
-const admin = userFactory.build({ traits: ['admin'] });
-const inactiveUsers = userFactory.buildMany(10, { traits: ['inactive'] });
-```
-
-### Example 3: Mock Server
-
-```typescript
-import { createMockServer } from '../advanced/testing';
-import axios from 'axios';
-
-describe('External API Integration', () => {
-  let mockServer;
-  let serverUrl;
-
-  beforeAll(async () => {
-    mockServer = createMockServer();
-    
-    mockServer.get('/api/users', (req) => ({
-      status: 200,
-      body: [{ id: 1, name: 'John' }]
-    }));
-
-    mockServer.post('/api/users', (req) => ({
-      status: 201,
-      body: { id: 2, ...req.body }
-    }));
-
-    serverUrl = await mockServer.start();
-  });
-
-  afterAll(async () => {
-    await mockServer.stop();
-  });
-
-  it('should call external API', async () => {
-    const response = await axios.get(`${serverUrl}/api/users`);
-    expect(response.status).toBe(200);
-    expect(response.data).toHaveLength(1);
-  });
-
-  it('should track API calls', () => {
-    expect(mockServer.wasCalled('/api/users', 'GET')).toBe(true);
-    expect(mockServer.callCount('/api/users', 'GET')).toBe(1);
-  });
-});
-```
-
-### Example 4: Load Testing
-
-```typescript
-import { createLoadTest, formatLoadTestResults } from '../advanced/testing';
-
-describe('Load Testing', () => {
-  it('should handle concurrent requests', async () => {
-    const loadTest = createLoadTest({
-      baseUrl: 'http://localhost:3000',
-      vus: 50,
-      duration: '60s',
-      thresholds: {
-        'http_req_duration': ['p(95) < 500', 'p(99) < 1000'],
-        'http_req_failed': ['rate < 0.01']
-      }
-    });
-
-    loadTest.test('default', async (vu, http) => {
-      const response = await http.get('/api/users');
-      if (response.status !== 200) {
-        throw new Error(`Expected 200, got ${response.status}`);
-      }
-    });
-
-    const results = await loadTest.run();
-    
-    console.log(formatLoadTestResults(results));
-    expect(results.thresholdsPassed).toBe(true);
-  });
-});
-```
-
-### Example 5: Complete Integration Test
-
-```typescript
-import {
-  TestClient,
-  createTestSuite,
-  defineFactory,
-  generators,
-  MockDatabase
-} from '../advanced/testing';
-import { app } from './app';
-
-describe('Complete User Flow', () => {
-  const suite = createTestSuite({
-    app,
-    beforeAll: async () => {
-      await db.connect();
-    },
-    afterAll: async () => {
-      await db.disconnect();
-    },
-    beforeEach: async () => {
-      await db.truncate('users');
-    }
-  });
-
-  const userFactory = defineFactory({
-    id: generators.uuid(),
-    email: generators.email(),
-    password: generators.password(),
-    name: generators.fullName()
-  });
-
-  userFactory.setPersist(async (user) => {
-    return db.users.create(user);
-  });
-
-  it('should complete user lifecycle', async () => {
-    const ctx = await suite.setup();
-
-    // Create user
-    const created = await userFactory.create();
-    expect(created.id).toBeDefined();
-
-    // Get user
-    const response = await ctx.client.get(`/api/users/${created.id}`);
-    expect(response.status).toBe(200);
-    expect(response.json().email).toBe(created.email);
-
-    // Update user
-    const updateResp = await ctx.client.put(`/api/users/${created.id}`, {
-      body: { name: 'Updated Name' }
-    });
-    expect(updateResp.status).toBe(200);
-
-    // Delete user
-    const deleteResp = await ctx.client.delete(`/api/users/${created.id}`);
-    expect(deleteResp.status).toBe(204);
-
-    await suite.teardown();
-  });
-});
-```
-
----
-
-## Best Practices
-
-1. **Use Factories for Complex Data**
-   - Lebih maintainable daripada manual object creation
-   - Traits untuk variations yang berbeda
-
-2. **Isolate Tests**
-   - Gunakan `beforeEach` untuk clean state
-   - Truncate tables sebelum setiap test
-
-3. **Mock External Dependencies**
-   - Gunakan MockServer untuk external APIs
-   - MockFetch untuk fetch calls
-   - MockDatabase untuk database operations
-
-4. **Performance Testing**
-   - Monitor p95 dan p99 latencies
-   - Set realistic thresholds
-   - Test dengan realistic load scenarios
-
-5. **Error Scenarios**
-   - Test error paths dengan mock servers
-   - Test timeouts dan network errors
-   - Test retry logic dengan MockTimers
-
----
-
-## See Also
-
-- [01 - Getting Started](./01-getting-started.md)
-- [05 - Validation](./05-validation.md)
-- [06 - Error Handling](./06-error-handling.md)
-- [10 - Examples](./10-examples.md)