@classytic/arc 2.3.0 → 2.4.2

package/dist/testing/index.d.mts

@@ -1,450 +1,9 @@
-import "../elevation-DGo5shaX.mjs";
-import { D as CrudRepository, T as ResourceDefinition } from "../interface-BtdYtQUA.mjs";
-import "../types-RLkFVgaw.mjs";
-import { AnyRecord } from "../types/index.mjs";
-import "../queryCachePlugin-Q6SYuHZ6.mjs";
-import "../eventPlugin-H6wDDjGO.mjs";
-import "../errorHandler-CW3OOeYq.mjs";
-import { r as CreateAppOptions } from "../types-tKwaViYB.mjs";
-import Fastify, { FastifyInstance } from "fastify";
-import { Mock } from "vitest";
-import { Connection } from "mongoose";
-
-//#region src/testing/TestHarness.d.ts
-/**
- * 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 (model-level)
-   *
-   * Tests: create, read (list + getById), update, delete
-   *
-   * @deprecated Use `HttpTestHarness.runCrud()` for HTTP-level CRUD tests.
-   * This method tests Mongoose models directly and does not exercise
-   * HTTP routes, authentication, permissions, or the Arc pipeline.
-   */
-  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;
-  /**
-   * Run field-level permission tests
-   *
-   * Auto-generates tests for each field permission:
-   * - hidden: field is stripped from responses
-   * - visibleTo: field only shown to specified roles
-   * - writableBy: field stripped from writes by non-privileged users
-   * - redactFor: field shows redacted value for specified roles
-   */
-  runFieldPermissions(): void;
-  /**
-   * Run pipeline configuration tests
-   *
-   * Validates that pipeline steps are properly configured:
-   * - All steps have names
-   * - All steps have valid _type discriminants
-   * - Operation filters (if set) use valid CRUD operation names
-   */
-  runPipeline(): void;
-  /**
-   * Run event definition tests
-   *
-   * Validates that events are properly defined:
-   * - All events have handler functions
-   * - Event names follow resource:action convention
-   * - Schema definitions (if present) are valid objects
-   */
-  runEvents(): 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;
-/**
- * Run config-level tests for a resource (no DB required)
- *
- * Tests field permissions, pipeline configuration, and event definitions.
- * Works with any adapter — no Mongoose dependency.
- *
- * @param resource - The Arc resource definition to test
- *
- * @example
- * ```typescript
- * import { createConfigTestSuite } from '@classytic/arc/testing';
- * import productResource from './product.resource.js';
- *
- * // Generates field permission, pipeline, and event tests
- * createConfigTestSuite(productResource);
- * ```
- */
-declare function createConfigTestSuite(resource: ResourceDefinition<unknown>): void;
-//#endregion
-//#region src/testing/testFactory.d.ts
-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: { type: 'jwt', 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: { type: 'jwt', 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: { type: 'jwt', 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 method;
-  private url;
-  private body?;
-  private query?;
-  private headers;
-  private app;
-  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(userOrHeaders: Record<string, unknown>): 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 data;
-  private app;
-  constructor(app: FastifyInstance);
-  /**
-   * Load test data into database
-   */
-  load(collection: string, items: any[]): Promise<any[]>;
-  /**
-   * Clear all loaded test data
-   */
-  cleanup(): Promise<void>;
-}
-//#endregion
-//#region src/testing/mocks.d.ts
-/**
- * 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;
-};
-//#endregion
+import { Lt as ResourceDefinition, l as AnyRecord, zt as CrudRepository } from "../interface-DGmPxakH.mjs";
+import { r as CreateAppOptions } from "../types-Dt0-AI6E.mjs";
+import Fastify, { FastifyInstance, FastifyServerOptions } from "fastify";
+import { Connection } from "mongoose";
+import { Mock } from "vitest";
+
 //#region src/testing/authHelpers.d.ts
 interface BetterAuthTestHelpersOptions {
   /** Base path for auth routes (default: '/api/auth') */
@@ -576,7 +135,189 @@ declare function createBetterAuthTestHelpers(options?: BetterAuthTestHelpersOpti
  * await ctx.teardown();
  * ```
  */
-declare function setupBetterAuthOrg(options: SetupBetterAuthOrgOptions): Promise<TestOrgContext>;
+declare function setupBetterAuthOrg(options: SetupBetterAuthOrgOptions): Promise<TestOrgContext>;
+//#endregion
+//#region src/testing/dbHelpers.d.ts
+/**
+ * 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 fixtures;
+  private connection;
+  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 session?;
+  private connection;
+  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 snapshots;
+  private connection;
+  constructor(connection: Connection);
+  /**
+   * Take snapshot of current database state
+   */
+  take(): Promise<void>;
+  /**
+   * Restore database to snapshot
+   */
+  restore(): Promise<void>;
+  /**
+   * Clear snapshot
+   */
+  clear(): void;
+}
 //#endregion
 //#region src/testing/HttpTestHarness.d.ts
 /**
@@ -732,186 +473,429 @@ declare class HttpTestHarness<T = unknown> {
  */
 declare function createHttpTestHarness<T = unknown>(resource: ResourceDefinition<unknown>, optionsOrGetter: HttpTestHarnessOptions<T> | (() => HttpTestHarnessOptions<T>)): HttpTestHarness<T>;
 //#endregion
-//#region src/testing/dbHelpers.d.ts
+//#region src/testing/mocks.d.ts
 /**
- * Test database manager
+ * Extended repository interface for testing (includes optional preset methods)
  */
-declare class TestDatabase {
-  private connection?;
-  private dbName;
-  constructor(dbName?: string);
+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;
+};
+//#endregion
+//#region src/testing/TestHarness.d.ts
+/**
+ * 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;
+}
+declare class TestHarness<T = unknown> {
+  private resource;
+  private Model;
+  private fixtures;
+  private setupFn?;
+  private teardownFn?;
+  private mongoUri;
+  private _createdIds;
+  constructor(resource: ResourceDefinition<unknown>, options: TestHarnessOptions<T>);
   /**
-   * Connect to test database
+   * Run all baseline tests
+   *
+   * Executes CRUD, validation, and preset tests
    */
-  connect(uri?: string): Promise<Connection>;
+  runAll(): void;
   /**
-   * Disconnect and cleanup
+   * Run CRUD operation tests (model-level)
+   *
+   * Tests: create, read (list + getById), update, delete
+   *
+   * @deprecated Use `HttpTestHarness.runCrud()` for HTTP-level CRUD tests.
+   * This method tests Mongoose models directly and does not exercise
+   * HTTP routes, authentication, permissions, or the Arc pipeline.
    */
-  disconnect(): Promise<void>;
+  runCrud(): void;
   /**
-   * Clear all collections
+   * Run validation tests
+   *
+   * Tests schema validation, required fields, etc.
    */
-  clear(): Promise<void>;
+  runValidation(): void;
   /**
-   * Get connection
+   * 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
    */
-  getConnection(): Connection;
+  runPresets(): void;
+  /**
+   * Run field-level permission tests
+   *
+   * Auto-generates tests for each field permission:
+   * - hidden: field is stripped from responses
+   * - visibleTo: field only shown to specified roles
+   * - writableBy: field stripped from writes by non-privileged users
+   * - redactFor: field shows redacted value for specified roles
+   */
+  runFieldPermissions(): void;
+  /**
+   * Run pipeline configuration tests
+   *
+   * Validates that pipeline steps are properly configured:
+   * - All steps have names
+   * - All steps have valid _type discriminants
+   * - Operation filters (if set) use valid CRUD operation names
+   */
+  runPipeline(): void;
+  /**
+   * Run event definition tests
+   *
+   * Validates that events are properly defined:
+   * - All events have handler functions
+   * - Event names follow resource:action convention
+   * - Schema definitions (if present) are valid objects
+   */
+  runEvents(): 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;
 }
 /**
- * Higher-order function to wrap tests with database setup/teardown
+ * 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
- * 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');
- *     });
- *   });
+ * const testContent = generateTestFile('product', {
+ *   presets: ['softDelete'],
+ *   modulePath: './modules/catalog',
  * });
+ * fs.writeFileSync('product.test.js', testContent);
  */
-declare function withTestDb(tests: (db: TestDatabase) => void | Promise<void>, options?: {
-  uri?: string;
-  dbName?: string;
-}): void;
+declare function generateTestFile(resourceName: string, options?: GenerateTestFileOptions): string;
 /**
- * Create test fixtures
+ * Run config-level tests for a resource (no DB required)
  *
- * @example
- * const fixtures = new TestFixtures(connection);
+ * Tests field permissions, pipeline configuration, and event definitions.
+ * Works with any adapter — no Mongoose dependency.
  *
- * await fixtures.load('products', [
- *   { name: 'Product 1', price: 100 },
- *   { name: 'Product 2', price: 200 },
- * ]);
+ * @param resource - The Arc resource definition to test
  *
- * const products = await fixtures.get('products');
+ * @example
+ * ```typescript
+ * import { createConfigTestSuite } from '@classytic/arc/testing';
+ * import productResource from './product.resource.js';
+ *
+ * // Generates field permission, pipeline, and event tests
+ * createConfigTestSuite(productResource);
+ * ```
  */
-declare class TestFixtures {
-  private fixtures;
-  private connection;
-  constructor(connection: Connection);
-  /**
-   * Load fixtures into a collection
-   */
-  load<T = any>(collectionName: string, data: Partial<T>[]): Promise<T[]>;
+declare function createConfigTestSuite(resource: ResourceDefinition<unknown>): void;
+//#endregion
+//#region src/testing/testFactory.d.ts
+interface CreateTestAppOptions extends Partial<CreateAppOptions> {
   /**
-   * Get loaded fixtures
+   * Use in-memory MongoDB for faster tests (default: true)
+   * Requires: mongodb-memory-server
+   *
+   * Set to false to use a provided mongoUri instead
    */
-  get<T = any>(collectionName: string): T[];
+  useInMemoryDb?: boolean;
   /**
-   * Get first fixture
+   * MongoDB connection URI (only used if useInMemoryDb is false)
    */
-  getFirst<T = any>(collectionName: string): T | null;
+  mongoUri?: string;
+}
+interface TestAppResult {
+  /** Fastify app instance */
+  app: FastifyInstance;
   /**
-   * Clear all fixtures
+   * Cleanup function to close app and disconnect database
+   * Call this in afterAll() or afterEach()
    */
-  clear(): Promise<void>;
+  close: () => Promise<void>;
+  /** MongoDB connection URI (useful for connecting models) */
+  mongoUri?: string;
 }
 /**
- * In-memory MongoDB for ultra-fast tests
+ * Create a test application instance with optional in-memory MongoDB
  *
- * Requires: mongodb-memory-server
+ * **Performance Boost**: Uses in-memory MongoDB by default for 10x faster tests.
  *
- * @example
- * import { InMemoryDatabase } from '@classytic/arc/testing';
+ * @example Basic usage with in-memory DB
+ * ```typescript
+ * import { createTestApp } from '@classytic/arc/testing';
  *
- * describe('Fast Tests', () => {
- *   const memoryDb = new InMemoryDatabase();
+ * describe('API Tests', () => {
+ *   let testApp: TestAppResult;
  *
  *   beforeAll(async () => {
- *     await memoryDb.start();
+ *     testApp = await createTestApp({
+ *       auth: { type: 'jwt', jwt: { secret: 'test-secret' } },
+ *     });
  *   });
  *
  *   afterAll(async () => {
- *     await memoryDb.stop();
+ *     await testApp.close(); // Cleans up DB and disconnects
  *   });
  *
- *   test('create user', async () => {
- *     const uri = memoryDb.getUri();
- *     // Use uri for connection
+ *   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: { type: 'jwt', 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: { type: 'jwt', jwt: { secret: 'test-secret' } },
+ * });
+ * await mongoose.connect(testApp.mongoUri); // Connect your models
+ * ```
  */
-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;
-}
+declare function createTestApp(options?: CreateTestAppOptions): Promise<TestAppResult>;
 /**
- * Database transaction helper for testing
+ * 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 class TestTransaction {
-  private session?;
-  private connection;
-  constructor(connection: Connection);
-  /**
-   * Start transaction
-   */
-  start(): Promise<void>;
-  /**
-   * Commit transaction
-   */
-  commit(): Promise<void>;
-  /**
-   * Rollback transaction
-   */
-  rollback(): Promise<void>;
-  /**
-   * Get session
-   */
-  getSession(): any;
+declare function createMinimalTestApp(options?: FastifyServerOptions): 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 method;
+  private url;
+  private body?;
+  private query?;
+  private headers;
+  private app;
+  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: Record<string, unknown>): this;
+  withQuery(query: Record<string, string | string[]>): this;
+  withHeader(key: string, value: string): this;
+  withAuth(userOrHeaders: Record<string, unknown>): this;
+  withContentType(type: string): this;
+  send(): Promise<Fastify.LightMyRequestResponse>;
 }
 /**
- * Seed data helper
+ * Helper to create a test request builder
  */
-declare class TestSeeder {
-  private connection;
-  constructor(connection: Connection);
+declare function request(app: FastifyInstance): TestRequestBuilder;
+/**
+ * Test helper for authentication
+ */
+declare function createTestAuth(app: FastifyInstance): {
   /**
-   * Seed collection with data
+   * Generate a JWT token for testing
    */
-  seed<T>(collectionName: string, generator: () => T[], count?: number): Promise<T[]>;
+  generateToken(user: Record<string, unknown>): string;
   /**
-   * Clear collection
+   * Decode a JWT token
    */
-  clear(collectionName: string): Promise<void>;
+  decodeToken(token: string): Record<string, unknown> | null;
   /**
-   * Clear all collections
+   * Verify a JWT token
    */
-  clearAll(): Promise<void>;
-}
+  verifyToken(token: string): Promise<Record<string, unknown>>;
+};
 /**
- * Database snapshot helper for rollback testing
+ * Snapshot testing helper for API responses
  */
-declare class DatabaseSnapshot {
-  private snapshots;
-  private connection;
-  constructor(connection: Connection);
+declare function createSnapshotMatcher(): {
   /**
-   * Take snapshot of current database state
+   * Match response structure (ignores dynamic values like timestamps)
    */
-  take(): Promise<void>;
+  matchStructure(response: unknown, expected: unknown): boolean;
+};
+/**
+ * Bulk test data loader
+ */
+declare class TestDataLoader {
+  private data;
   /**
-   * Restore database to snapshot
+   * Load test data into database
    */
-  restore(): Promise<void>;
+  load(collection: string, items: Record<string, unknown>[]): Promise<Record<string, unknown>[]>;
   /**
-   * Clear snapshot
+   * Clear all loaded test data
    */
-  clear(): void;
+  cleanup(): Promise<void>;
 }
 //#endregion
 export { type AuthProvider, type AuthResponse, type BetterAuthTestHelpers, type BetterAuthTestHelpersOptions, type CreateTestAppOptions, DatabaseSnapshot, TestFixtures as DbTestFixtures, type GenerateTestFileOptions, HttpTestHarness, type HttpTestHarnessOptions, InMemoryDatabase, type OrgResponse, type SetupBetterAuthOrgOptions, type SetupUserConfig, type TestAppResult, TestDataLoader, TestDatabase, type TestFixtures$1 as TestFixtures, TestHarness, type TestHarnessOptions, type TestOrgContext, TestRequestBuilder, TestSeeder, TestTransaction, type TestUserContext, createBetterAuthProvider, createBetterAuthTestHelpers, createConfigTestSuite, createDataFactory, createHttpTestHarness, createJwtAuthProvider, createMinimalTestApp, createMockController, createMockReply, createMockRepository, createMockRequest, createMockUser, createSnapshotMatcher, createSpy, createTestApp, createTestAuth, createTestHarness, createTestTimer, generateTestFile, request, safeParseBody, setupBetterAuthOrg, waitFor, withTestDb };