Testing Utilities

// Main testing utilities
import { ... } from '@kit/database/testing';
// PGLite-specific utilities
import { createTestDatabase } from '@kit/database/testing/pglite';

import { createTestDatabase, type TestDatabase } from '@kit/database/testing/pglite';
describe('User Service', () => {
  let testDb: TestDatabase;
  beforeAll(async () => {
    testDb = await createTestDatabase();
  });
  afterEach(async () => {
    await testDb.cleanup(); // Clear all data between tests
  });
  afterAll(async () => {
    await testDb.close(); // Close connection
  });
  it('should create a user', async () => {
    const result = await testDb.db.insert(users).values({
      id: 'user_123',
      email: 'test@example.com',
      name: 'Test User',
    }).returning();
    expect(result[0].email).toBe('test@example.com');
  });
});

interface TestDatabase {
  db: DrizzleInstance;           // Drizzle ORM instance
  client: PGlite;                // Raw PGLite client
  cleanup: () => Promise<void>;  // Truncate all tables
  close: () => Promise<void>;    // Close connection
}

import { setupTestDatabase } from '@kit/database/testing';
let testDb: Awaited<ReturnType<typeof setupTestDatabase>>;
beforeAll(async () => {
  testDb = await setupTestDatabase();
});
afterEach(async () => {
  await testDb.cleanup();
});
afterAll(async () => {
  await testDb.teardown();
});

import { createTestUser } from '@kit/database/testing';
// With defaults
const user = createTestUser();
// { id: 'abc123...', email: 'test-abc1@makerkit.dev', name: 'Test User abc1', ... }
// With overrides
const admin = createTestUser({
  email: 'admin@example.com',
  name: 'Admin User',
});

import { createTestOrganization } from '@kit/database/testing';
const org = createTestOrganization({
  name: 'Acme Corp',
  slug: 'acme-corp',
});

import { createTestUser, createTestOrganization, createTestMember } from '@kit/database/testing';
const user = createTestUser();
const org = createTestOrganization();
const member = createTestMember({
  userId: user.id,        // Required
  organizationId: org.id, // Required
  role: 'owner',
});

import { createTestOrganization, createTestSubscription } from '@kit/database/testing';
const org = createTestOrganization();
const subscription = createTestSubscription({
  referenceId: org.id,
  plan: 'enterprise-annual',
  seats: 10,
});

import { createAuthContext } from '@kit/database';
const ctx = createAuthContext(
  'user_123',    // userId
  null,          // organizationId (optional)
  null           // role (optional)
);
// Use in queries
const posts = await db.select()
  .from(postsTable)
  .where(ctx.user(postsTable)); // eq(postsTable.userId, 'user_123')

import { createOrgAuthContext } from '@kit/database';
const ctx = createOrgAuthContext(
  'user_123',  // userId
  'org_456',   // organizationId (required)
  'admin'      // role (required)
);
// Filter by organization
const projects = await db.select()
  .from(projectsTable)
  .where(ctx.org(projectsTable)); // eq(projectsTable.organizationId, 'org_456')
// Auto-fill organizationId on insert
await db.insert(projectsTable).values(
  ctx.values(projectsTable, {
    name: 'New Project',
    // organizationId is automatically added!
  })
);

import { AuthorizationError } from '@kit/database';
// Throw specific authorization errors
throw AuthorizationError.notAuthenticated();
// Error: "Not authenticated"
throw AuthorizationError.noOrganization();
// Error: "No active organization"
throw AuthorizationError.notAuthorized('project');
// Error: "Not authorized to access project"

import { describe, it, expect, beforeAll, afterEach, afterAll } from 'vitest';
import {
  createTestDatabase,
  createTestUser,
  createTestOrganization,
  createTestMember,
  createTestSubscription,
} from '@kit/database/testing';
import { createOrgAuthContext } from '@kit/database';
import { user, organization, member, subscription } from '@kit/database';
describe('Organization Billing', () => {
  let testDb: Awaited<ReturnType<typeof createTestDatabase>>;
  beforeAll(async () => {
    testDb = await createTestDatabase();
  });
  afterEach(async () => {
    await testDb.cleanup();
  });
  afterAll(async () => {
    await testDb.close();
  });
  it('should create organization with subscription', async () => {
    // Create test data
    const testUser = createTestUser();
    const testOrg = createTestOrganization();
    const testMember = createTestMember({
      userId: testUser.id,
      organizationId: testOrg.id,
      role: 'owner',
    });
    const testSub = createTestSubscription({
      referenceId: testOrg.id,
      plan: 'pro-monthly',
    });
    // Insert into database
    await testDb.db.insert(user).values(testUser);
    await testDb.db.insert(organization).values(testOrg);
    await testDb.db.insert(member).values(testMember);
    await testDb.db.insert(subscription).values(testSub);
    // Create auth context
    const ctx = createOrgAuthContext(testUser.id, testOrg.id, 'owner');
    // Query with auth context
    const [result] = await testDb.db.select()
      .from(subscription)
      .where(ctx.org(subscription));
    expect(result.plan).toBe('pro-monthly');
    expect(result.status).toBe('active');
  });
});

// vitest.setup.ts
import { testDb } from '@kit/database/testing';
// testDb is automatically initialized before all tests
export { testDb };

export default defineConfig({
  test: {
    setupFiles: ['./vitest.setup.ts'],
  },
});