@classytic/arc 1.1.0 → 2.1.2

package/dist/testing/index.d.mts

@@ -0,0 +1,908 @@
+import "../elevation-B_2dRLVP.mjs";
+import { D as CrudRepository, T as ResourceDefinition } from "../interface-Ch8HU9uM.mjs";
+import "../types-aYB4V7uN.mjs";
+import { AnyRecord } from "../types/index.mjs";
+import "../queryCachePlugin-7THaI5mt.mjs";
+import "../eventPlugin-CTrLH3mt.mjs";
+import "../errorHandler-BbcgBmIH.mjs";
+import { r as CreateAppOptions } from "../types-CIgB7UUl.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
+//#region src/testing/authHelpers.d.ts
+interface BetterAuthTestHelpersOptions {
+  /** Base path for auth routes (default: '/api/auth') */
+  basePath?: string;
+}
+interface AuthResponse {
+  statusCode: number;
+  token: string;
+  user: any;
+  body: any;
+}
+interface OrgResponse {
+  statusCode: number;
+  orgId: string;
+  body: any;
+}
+interface BetterAuthTestHelpers {
+  signUp(app: FastifyInstance, data: {
+    email: string;
+    password: string;
+    name: string;
+  }): Promise<AuthResponse>;
+  signIn(app: FastifyInstance, data: {
+    email: string;
+    password: string;
+  }): Promise<AuthResponse>;
+  createOrg(app: FastifyInstance, token: string, data: {
+    name: string;
+    slug: string;
+  }): Promise<OrgResponse>;
+  setActiveOrg(app: FastifyInstance, token: string, orgId: string): Promise<{
+    statusCode: number;
+    body: any;
+  }>;
+  authHeaders(token: string, orgId?: string): Record<string, string>;
+}
+interface TestUserContext {
+  token: string;
+  userId: string;
+  email: string;
+}
+interface TestOrgContext<T = Record<string, TestUserContext>> {
+  app: FastifyInstance;
+  orgId: string;
+  users: T;
+  teardown: () => Promise<void>;
+}
+interface SetupUserConfig {
+  /** Key used to reference this user in the context (e.g. 'admin', 'member') */
+  key: string;
+  email: string;
+  password: string;
+  name: string;
+  /** Organization role assigned after joining */
+  role: string;
+  /** If true, this user creates the org (becomes org owner). Exactly one user should have this. */
+  isCreator?: boolean;
+}
+interface SetupBetterAuthOrgOptions {
+  /** Factory function to create the Fastify app instance */
+  createApp: () => Promise<FastifyInstance>;
+  /** Organization to create */
+  org: {
+    name: string;
+    slug: string;
+  };
+  /** Users to create and add to the organization */
+  users: SetupUserConfig[];
+  /**
+   * Callback to add a member to the org.
+   * Apps wire Better Auth differently — some use auth.api.addMember, others use HTTP.
+   */
+  addMember: (data: {
+    organizationId: string;
+    userId: string;
+    role: string;
+  }) => Promise<{
+    statusCode: number;
+  }>;
+  /**
+   * Optional hook for app-specific initialization after all users are set up.
+   * Use this for things like recruiter→account manager hierarchy.
+   */
+  afterSetup?: (ctx: TestOrgContext) => Promise<void>;
+  /** Override auth helper options (e.g. custom basePath) */
+  authHelpers?: BetterAuthTestHelpersOptions;
+}
+/**
+ * Safely parse a JSON response body.
+ * Returns null if parsing fails.
+ */
+declare function safeParseBody(body: string): any;
+/**
+ * Create stateless Better Auth test helpers.
+ *
+ * All methods take the app instance as a parameter, making them
+ * safe to use across multiple test suites.
+ */
+declare function createBetterAuthTestHelpers(options?: BetterAuthTestHelpersOptions): BetterAuthTestHelpers;
+/**
+ * Set up a complete test organization with users.
+ *
+ * Creates the app, signs up users, creates an org, adds members,
+ * and returns a context object with tokens and a teardown function.
+ *
+ * @example
+ * ```typescript
+ * const ctx = await setupBetterAuthOrg({
+ *   createApp: () => createAppInstance(),
+ *   org: { name: 'Test Corp', slug: 'test-corp' },
+ *   users: [
+ *     { key: 'admin', email: 'admin@test.com', password: 'pass', name: 'Admin', role: 'admin', isCreator: true },
+ *     { key: 'member', email: 'user@test.com', password: 'pass', name: 'User', role: 'member' },
+ *   ],
+ *   addMember: async (data) => {
+ *     await auth.api.addMember({ body: data });
+ *     return { statusCode: 200 };
+ *   },
+ * });
+ *
+ * // Use in tests:
+ * const res = await ctx.app.inject({
+ *   method: 'GET',
+ *   url: '/api/products',
+ *   headers: auth.authHeaders(ctx.users.admin.token, ctx.orgId),
+ * });
+ *
+ * // Cleanup:
+ * await ctx.teardown();
+ * ```
+ */
+declare function setupBetterAuthOrg(options: SetupBetterAuthOrgOptions): Promise<TestOrgContext>;
+//#endregion
+//#region src/testing/HttpTestHarness.d.ts
+/**
+ * Abstraction for generating auth headers in tests.
+ * Supports JWT, Better Auth, or any custom auth mechanism.
+ */
+interface AuthProvider {
+  /** Get HTTP headers for a given role key */
+  getHeaders(role: string): Record<string, string>;
+  /** Available role keys (e.g. ['admin', 'member', 'viewer']) */
+  availableRoles: string[];
+  /** Role key that has full CRUD access */
+  adminRole: string;
+}
+/**
+ * Create an auth provider for JWT-based apps.
+ *
+ * Generates JWT tokens on the fly using the app's JWT plugin.
+ *
+ * @example
+ * ```typescript
+ * const auth = createJwtAuthProvider({
+ *   app,
+ *   users: {
+ *     admin: { payload: { id: '1', roles: ['admin'] }, organizationId: 'org1' },
+ *     viewer: { payload: { id: '2', roles: ['viewer'] } },
+ *   },
+ *   adminRole: 'admin',
+ * });
+ * ```
+ */
+declare function createJwtAuthProvider(options: {
+  app: FastifyInstance;
+  users: Record<string, {
+    payload: Record<string, unknown>;
+    organizationId?: string;
+  }>;
+  adminRole: string;
+}): AuthProvider;
+/**
+ * Create an auth provider for Better Auth apps.
+ *
+ * Uses pre-existing tokens (from signUp/signIn) rather than generating them.
+ *
+ * @example
+ * ```typescript
+ * const auth = createBetterAuthProvider({
+ *   tokens: {
+ *     admin: ctx.users.admin.token,
+ *     member: ctx.users.member.token,
+ *   },
+ *   orgId: ctx.orgId,
+ *   adminRole: 'admin',
+ * });
+ * ```
+ */
+declare function createBetterAuthProvider(options: {
+  tokens: Record<string, string>;
+  orgId: string;
+  adminRole: string;
+}): AuthProvider;
+interface HttpTestHarnessOptions<T = unknown> {
+  /** Fastify app instance (must be ready) */
+  app: FastifyInstance;
+  /** Test data fixtures */
+  fixtures: {
+    /** Valid payload for creating a resource */valid: Partial<T>; /** Payload for updating a resource (defaults to valid) */
+    update?: Partial<T>; /** Invalid payload that should fail validation */
+    invalid?: Partial<T>;
+  };
+  /** Auth provider for generating request headers */
+  auth: AuthProvider;
+  /** API path prefix (default: '/api') */
+  apiPrefix?: string;
+}
+/** Options can be passed directly or as a getter for deferred resolution */
+type OptionsOrGetter<T> = HttpTestHarnessOptions<T> | (() => HttpTestHarnessOptions<T>);
+/**
+ * HTTP-level test harness for Arc resources.
+ *
+ * Generates tests that exercise the full HTTP lifecycle:
+ * routes, auth, permissions, pipeline, and response envelope.
+ *
+ * Supports deferred options via a getter function, which is essential
+ * when the app instance comes from async `beforeAll()` setup.
+ */
+declare class HttpTestHarness<T = unknown> {
+  private resource;
+  private optionsOrGetter;
+  private baseUrl;
+  private enabledRoutes;
+  private updateMethod;
+  constructor(resource: ResourceDefinition<unknown>, optionsOrGetter: OptionsOrGetter<T>);
+  /** Resolve options (supports both direct and deferred) */
+  private getOptions;
+  /**
+   * Run all test suites: CRUD + permissions + validation
+   */
+  runAll(): void;
+  /**
+   * Run HTTP-level CRUD tests.
+   *
+   * Tests each enabled CRUD operation through app.inject():
+   * - POST (create) → 200/201 with { success: true, data }
+   * - GET (list) → 200 with array or paginated response
+   * - GET /:id → 200 with { success: true, data }
+   * - PATCH/PUT /:id → 200 with { success: true, data }
+   * - DELETE /:id → 200
+   * - GET /:id with non-existent ID → 404
+   */
+  runCrud(): void;
+  /**
+   * Run permission tests.
+   *
+   * Tests that:
+   * - Unauthenticated requests return 401
+   * - Admin role gets 2xx for all operations
+   */
+  runPermissions(): void;
+  /**
+   * Run validation tests.
+   *
+   * Tests that invalid payloads return 400.
+   */
+  runValidation(): void;
+}
+/**
+ * Create an HTTP test harness for an Arc resource.
+ *
+ * Accepts options directly or as a getter function for deferred resolution.
+ *
+ * @example Deferred (recommended for async setup)
+ * ```typescript
+ * let ctx: TestContext;
+ * beforeAll(async () => { ctx = await setupTestOrg(); });
+ *
+ * createHttpTestHarness(jobResource, () => ({
+ *   app: ctx.app,
+ *   fixtures: { valid: { title: 'Test' } },
+ *   auth: createBetterAuthProvider({ ... }),
+ * })).runAll();
+ * ```
+ */
+declare function createHttpTestHarness<T = unknown>(resource: ResourceDefinition<unknown>, optionsOrGetter: HttpTestHarnessOptions<T> | (() => HttpTestHarnessOptions<T>)): HttpTestHarness<T>;
+//#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
+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 };
+//# sourceMappingURL=index.d.mts.map