@classytic/arc 1.1.0 → 2.1.2

package/dist/testing/index.d.ts

@@ -1,618 +0,0 @@
-import { q as ResourceDefinition, A as AnyRecord, y as CrudRepository } from '../index-B4t03KQ0.js';
-import Fastify, { FastifyInstance } from 'fastify';
-import { C as CreateAppOptions } from '../types-BvckRbs2.js';
-import { Mock } from 'vitest';
-import { Connection } from 'mongoose';
-import '../types-B99TBmFV.js';
-import '@fastify/cors';
-import '@fastify/helmet';
-import '@fastify/rate-limit';
-
-/**
- * Resource Test Harness
- *
- * Generates baseline tests for Arc resources automatically.
- * Tests CRUD operations + preset routes with minimal configuration.
- *
- * @example
- * import { createTestHarness } from '@classytic/arc/testing';
- * import productResource from './product.resource.js';
- *
- * const harness = createTestHarness(productResource, {
- *   fixtures: {
- *     valid: { name: 'Test Product', price: 100 },
- *     update: { name: 'Updated Product' },
- *   },
- * });
- *
- * // Run all baseline tests (50+ auto-generated)
- * harness.runAll();
- *
- * // Or run specific test suites
- * harness.runCrud();
- * harness.runPresets();
- */
-
-/**
- * Test fixtures for a resource
- */
-interface TestFixtures$1<T = any> {
-    /** Valid create payload */
-    valid: Partial<T>;
-    /** Update payload (optional, defaults to valid) */
-    update?: Partial<T>;
-    /** Invalid payload for validation tests (optional) */
-    invalid?: Partial<T>;
-}
-/**
- * Test harness options
- */
-interface TestHarnessOptions<T = any> {
-    /** Test data fixtures */
-    fixtures: TestFixtures$1<T>;
-    /** Custom setup function (runs before all tests) */
-    setupFn?: () => Promise<void> | void;
-    /** Custom teardown function (runs after all tests) */
-    teardownFn?: () => Promise<void> | void;
-    /** MongoDB connection URI (defaults to process.env.MONGO_URI) */
-    mongoUri?: string;
-}
-/**
- * Test harness for Arc resources
- *
- * Provides automatic test generation for:
- * - CRUD operations (create, read, update, delete)
- * - Schema validation
- * - Preset-specific functionality (softDelete, slugLookup, tree, etc.)
- */
-declare class TestHarness<T = unknown> {
-    private resource;
-    private fixtures;
-    private setupFn?;
-    private teardownFn?;
-    private mongoUri;
-    private _createdIds;
-    private Model;
-    constructor(resource: ResourceDefinition<unknown>, options: TestHarnessOptions<T>);
-    /**
-     * Run all baseline tests
-     *
-     * Executes CRUD, validation, and preset tests
-     */
-    runAll(): void;
-    /**
-     * Run CRUD operation tests
-     *
-     * Tests: create, read (list + getById), update, delete
-     */
-    runCrud(): void;
-    /**
-     * Run validation tests
-     *
-     * Tests schema validation, required fields, etc.
-     */
-    runValidation(): void;
-    /**
-     * Run preset-specific tests
-     *
-     * Auto-detects applied presets and tests their functionality:
-     * - softDelete: deletedAt field, soft delete/restore
-     * - slugLookup: slug generation
-     * - tree: parent references, displayOrder
-     * - multiTenant: organizationId requirement
-     * - ownedByUser: userId requirement
-     */
-    runPresets(): void;
-}
-/**
- * Create a test harness for an Arc resource
- *
- * @param resource - The Arc resource definition to test
- * @param options - Test harness configuration
- * @returns Test harness instance
- *
- * @example
- * import { createTestHarness } from '@classytic/arc/testing';
- *
- * const harness = createTestHarness(productResource, {
- *   fixtures: {
- *     valid: { name: 'Product', price: 100 },
- *     update: { name: 'Updated' },
- *   },
- * });
- *
- * harness.runAll(); // Generates 50+ baseline tests
- */
-declare function createTestHarness<T = any>(resource: ResourceDefinition, options: TestHarnessOptions<T>): TestHarness<T>;
-/**
- * Test file generation options
- */
-interface GenerateTestFileOptions {
-    /** Applied presets (e.g., ['softDelete', 'slugLookup']) */
-    presets?: string[];
-    /** Module path for imports (default: '.') */
-    modulePath?: string;
-}
-/**
- * Generate test file content for a resource
- *
- * Useful for scaffolding new resource tests via CLI
- *
- * @param resourceName - Resource name in kebab-case (e.g., 'product')
- * @param options - Generation options
- * @returns Complete test file content as string
- *
- * @example
- * const testContent = generateTestFile('product', {
- *   presets: ['softDelete'],
- *   modulePath: './modules/catalog',
- * });
- * fs.writeFileSync('product.test.js', testContent);
- */
-declare function generateTestFile(resourceName: string, options?: GenerateTestFileOptions): string;
-
-/**
- * Testing Utilities - Test App Factory
- *
- * Create Fastify test instances with Arc configuration
- */
-
-interface CreateTestAppOptions extends Partial<CreateAppOptions> {
-    /**
-     * Use in-memory MongoDB for faster tests (default: true)
-     * Requires: mongodb-memory-server
-     *
-     * Set to false to use a provided mongoUri instead
-     */
-    useInMemoryDb?: boolean;
-    /**
-     * MongoDB connection URI (only used if useInMemoryDb is false)
-     */
-    mongoUri?: string;
-}
-interface TestAppResult {
-    /** Fastify app instance */
-    app: FastifyInstance;
-    /**
-     * Cleanup function to close app and disconnect database
-     * Call this in afterAll() or afterEach()
-     */
-    close: () => Promise<void>;
-    /** MongoDB connection URI (useful for connecting models) */
-    mongoUri?: string;
-}
-/**
- * Create a test application instance with optional in-memory MongoDB
- *
- * **Performance Boost**: Uses in-memory MongoDB by default for 10x faster tests.
- *
- * @example Basic usage with in-memory DB
- * ```typescript
- * import { createTestApp } from '@classytic/arc/testing';
- *
- * describe('API Tests', () => {
- *   let testApp: TestAppResult;
- *
- *   beforeAll(async () => {
- *     testApp = await createTestApp({
- *       auth: { jwt: { secret: 'test-secret' } },
- *     });
- *   });
- *
- *   afterAll(async () => {
- *     await testApp.close(); // Cleans up DB and disconnects
- *   });
- *
- *   test('GET /health', async () => {
- *     const response = await testApp.app.inject({
- *       method: 'GET',
- *       url: '/health',
- *     });
- *     expect(response.statusCode).toBe(200);
- *   });
- * });
- * ```
- *
- * @example Using external MongoDB
- * ```typescript
- * const testApp = await createTestApp({
- *   auth: { jwt: { secret: 'test-secret' } },
- *   useInMemoryDb: false,
- *   mongoUri: 'mongodb://localhost:27017/test-db',
- * });
- * ```
- *
- * @example Accessing MongoDB URI for model connections
- * ```typescript
- * const testApp = await createTestApp({
- *   auth: { jwt: { secret: 'test-secret' } },
- * });
- * await mongoose.connect(testApp.mongoUri); // Connect your models
- * ```
- */
-declare function createTestApp(options?: CreateTestAppOptions): Promise<TestAppResult>;
-/**
- * Create a minimal Fastify instance for unit tests
- *
- * Use when you don't need Arc's full plugin stack
- *
- * @example
- * const app = createMinimalTestApp();
- * app.get('/test', async () => ({ success: true }));
- *
- * const response = await app.inject({ method: 'GET', url: '/test' });
- * expect(response.json()).toEqual({ success: true });
- */
-declare function createMinimalTestApp(options?: Partial<any>): FastifyInstance;
-/**
- * Test request builder for cleaner tests
- *
- * @example
- * const request = new TestRequestBuilder(app)
- *   .get('/products')
- *   .withAuth(mockUser)
- *   .withQuery({ page: 1, limit: 10 });
- *
- * const response = await request.send();
- * expect(response.statusCode).toBe(200);
- */
-declare class TestRequestBuilder {
-    private app;
-    private method;
-    private url;
-    private body?;
-    private query?;
-    private headers;
-    constructor(app: FastifyInstance);
-    get(url: string): this;
-    post(url: string): this;
-    put(url: string): this;
-    patch(url: string): this;
-    delete(url: string): this;
-    withBody(body: any): this;
-    withQuery(query: Record<string, any>): this;
-    withHeader(key: string, value: string): this;
-    withAuth(user: any): this;
-    withContentType(type: string): this;
-    send(): Promise<Fastify.LightMyRequestResponse>;
-}
-/**
- * Helper to create a test request builder
- */
-declare function request(app: FastifyInstance): TestRequestBuilder;
-/**
- * Test helper for authentication
- */
-declare function createTestAuth(app: FastifyInstance): {
-    /**
-     * Generate a JWT token for testing
-     */
-    generateToken(user: any): string;
-    /**
-     * Decode a JWT token
-     */
-    decodeToken(token: string): any;
-    /**
-     * Verify a JWT token
-     */
-    verifyToken(token: string): Promise<any>;
-};
-/**
- * Snapshot testing helper for API responses
- */
-declare function createSnapshotMatcher(): {
-    /**
-     * Match response structure (ignores dynamic values like timestamps)
-     */
-    matchStructure(response: any, expected: any): boolean;
-};
-/**
- * Bulk test data loader
- */
-declare class TestDataLoader {
-    private app;
-    private data;
-    constructor(app: FastifyInstance);
-    /**
-     * Load test data into database
-     */
-    load(collection: string, items: any[]): Promise<any[]>;
-    /**
-     * Clear all loaded test data
-     */
-    cleanup(): Promise<void>;
-}
-
-/**
- * Testing Utilities - Mock Factories
- *
- * Create mock repositories, controllers, and services for testing.
- * Uses Vitest for mocking (compatible with Jest API).
- */
-
-/**
- * Extended repository interface for testing (includes optional preset methods)
- */
-interface MockRepository<T> extends CrudRepository<T> {
-    getBySlug?: Mock;
-    getDeleted?: Mock;
-    restore?: Mock;
-    getTree?: Mock;
-    getChildren?: Mock;
-    [key: string]: unknown;
-}
-/**
- * Create a mock repository for testing
- *
- * @example
- * const mockRepo = createMockRepository<Product>({
- *   getById: vi.fn().mockResolvedValue({ id: '1', name: 'Test' }),
- *   create: vi.fn().mockImplementation(data => Promise.resolve({ id: '1', ...data })),
- * });
- *
- * await mockRepo.getById('1'); // Returns mocked product
- */
-declare function createMockRepository<T extends AnyRecord = AnyRecord>(overrides?: Partial<MockRepository<T>>): MockRepository<T>;
-/**
- * Create a mock user for authentication testing
- */
-declare function createMockUser(overrides?: Partial<AnyRecord>): {
-    _id: string;
-    id: string;
-    email: string;
-    roles: string[];
-    organizationId: null;
-};
-/**
- * Create a mock Fastify request
- */
-declare function createMockRequest(overrides?: Partial<AnyRecord>): unknown;
-/**
- * Create a mock Fastify reply
- */
-declare function createMockReply(): unknown;
-/**
- * Create a mock controller for testing
- */
-declare function createMockController(repository: CrudRepository<AnyRecord>): {
-    repository: CrudRepository<AnyRecord>;
-    list: Mock<(...args: any[]) => any>;
-    get: Mock<(...args: any[]) => any>;
-    create: Mock<(...args: any[]) => any>;
-    update: Mock<(...args: any[]) => any>;
-    delete: Mock<(...args: any[]) => any>;
-};
-/**
- * Create mock data factory
- *
- * @example
- * const productFactory = createDataFactory<Product>({
- *   name: () => faker.commerce.productName(),
- *   price: () => faker.number.int({ min: 10, max: 1000 }),
- *   sku: (i) => `SKU-${i}`,
- * });
- *
- * const product = productFactory.build();
- * const products = productFactory.buildMany(10);
- */
-declare function createDataFactory<T extends AnyRecord>(template: Record<keyof T, (index: number) => unknown>): {
-    build(overrides?: Partial<T>): T;
-    buildMany(count: number, overrides?: Partial<T>): T[];
-    reset(): void;
-};
-/**
- * Create a spy that tracks function calls
- *
- * Useful for testing side effects without full mocking
- */
-declare function createSpy<T extends (...args: unknown[]) => unknown>(_name?: string): Mock<T> & {
-    getCalls(): unknown[][];
-    getLastCall(): unknown[];
-};
-/**
- * Wait for a condition to be true
- *
- * Useful for async testing
- */
-declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
-    timeout?: number;
-    interval?: number;
-}): Promise<void>;
-/**
- * Create a test timer that can be controlled
- */
-declare function createTestTimer(): {
-    now: () => number;
-    advance: (ms: number) => void;
-    set: (timestamp: number) => void;
-    reset: () => void;
-};
-
-/**
- * Testing Utilities - Database Helpers
- *
- * Utilities for managing test databases and fixtures
- */
-
-/**
- * Test database manager
- */
-declare class TestDatabase {
-    private connection?;
-    private dbName;
-    constructor(dbName?: string);
-    /**
-     * Connect to test database
-     */
-    connect(uri?: string): Promise<Connection>;
-    /**
-     * Disconnect and cleanup
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Clear all collections
-     */
-    clear(): Promise<void>;
-    /**
-     * Get connection
-     */
-    getConnection(): Connection;
-}
-/**
- * Higher-order function to wrap tests with database setup/teardown
- *
- * @example
- * describe('Product Tests', () => {
- *   withTestDb(async (db) => {
- *     test('create product', async () => {
- *       const Product = db.getConnection().model('Product', schema);
- *       const product = await Product.create({ name: 'Test' });
- *       expect(product.name).toBe('Test');
- *     });
- *   });
- * });
- */
-declare function withTestDb(tests: (db: TestDatabase) => void | Promise<void>, options?: {
-    uri?: string;
-    dbName?: string;
-}): void;
-/**
- * Create test fixtures
- *
- * @example
- * const fixtures = new TestFixtures(connection);
- *
- * await fixtures.load('products', [
- *   { name: 'Product 1', price: 100 },
- *   { name: 'Product 2', price: 200 },
- * ]);
- *
- * const products = await fixtures.get('products');
- */
-declare class TestFixtures {
-    private connection;
-    private fixtures;
-    constructor(connection: Connection);
-    /**
-     * Load fixtures into a collection
-     */
-    load<T = any>(collectionName: string, data: Partial<T>[]): Promise<T[]>;
-    /**
-     * Get loaded fixtures
-     */
-    get<T = any>(collectionName: string): T[];
-    /**
-     * Get first fixture
-     */
-    getFirst<T = any>(collectionName: string): T | null;
-    /**
-     * Clear all fixtures
-     */
-    clear(): Promise<void>;
-}
-/**
- * In-memory MongoDB for ultra-fast tests
- *
- * Requires: mongodb-memory-server
- *
- * @example
- * import { InMemoryDatabase } from '@classytic/arc/testing';
- *
- * describe('Fast Tests', () => {
- *   const memoryDb = new InMemoryDatabase();
- *
- *   beforeAll(async () => {
- *     await memoryDb.start();
- *   });
- *
- *   afterAll(async () => {
- *     await memoryDb.stop();
- *   });
- *
- *   test('create user', async () => {
- *     const uri = memoryDb.getUri();
- *     // Use uri for connection
- *   });
- * });
- */
-declare class InMemoryDatabase {
-    private mongod?;
-    private uri?;
-    /**
-     * Start in-memory MongoDB
-     */
-    start(): Promise<string>;
-    /**
-     * Stop in-memory MongoDB
-     */
-    stop(): Promise<void>;
-    /**
-     * Get connection URI
-     */
-    getUri(): string;
-}
-/**
- * Database transaction helper for testing
- */
-declare class TestTransaction {
-    private connection;
-    private session?;
-    constructor(connection: Connection);
-    /**
-     * Start transaction
-     */
-    start(): Promise<void>;
-    /**
-     * Commit transaction
-     */
-    commit(): Promise<void>;
-    /**
-     * Rollback transaction
-     */
-    rollback(): Promise<void>;
-    /**
-     * Get session
-     */
-    getSession(): any;
-}
-/**
- * Seed data helper
- */
-declare class TestSeeder {
-    private connection;
-    constructor(connection: Connection);
-    /**
-     * Seed collection with data
-     */
-    seed<T>(collectionName: string, generator: () => T[], count?: number): Promise<T[]>;
-    /**
-     * Clear collection
-     */
-    clear(collectionName: string): Promise<void>;
-    /**
-     * Clear all collections
-     */
-    clearAll(): Promise<void>;
-}
-/**
- * Database snapshot helper for rollback testing
- */
-declare class DatabaseSnapshot {
-    private connection;
-    private snapshots;
-    constructor(connection: Connection);
-    /**
-     * Take snapshot of current database state
-     */
-    take(): Promise<void>;
-    /**
-     * Restore database to snapshot
-     */
-    restore(): Promise<void>;
-    /**
-     * Clear snapshot
-     */
-    clear(): void;
-}
-
-export { type CreateTestAppOptions, DatabaseSnapshot, TestFixtures as DbTestFixtures, type GenerateTestFileOptions, InMemoryDatabase, type TestAppResult, TestDataLoader, TestDatabase, type TestFixtures$1 as TestFixtures, TestHarness, type TestHarnessOptions, TestRequestBuilder, TestSeeder, TestTransaction, createDataFactory, createMinimalTestApp, createMockController, createMockReply, createMockRepository, createMockRequest, createMockUser, createSnapshotMatcher, createSpy, createTestApp, createTestAuth, createTestHarness, createTestTimer, generateTestFile, request, waitFor, withTestDb };