Testing Guide

# Run all tests
bun run test

# Run tests in watch mode
bun run test --watch

# Run tests with coverage
bun run test --coverage

# Run specific test file
bun run test tests/credit-system.test.ts

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  roots: ['<rootDir>/tests'],
  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
  transform: {
    '^.+\.ts$': 'ts-jest',
  },
  moduleNameMapper: {
    '^@/convex/_generated/api$': '<rootDir>/tests/mocks/convex-generated-api.ts',
    '^@/convex/_generated/dataModel$': '<rootDir>/tests/mocks/convex-generated-dataModel.ts',
    '^@/convex/(.*)$': '<rootDir>/convex/$1',
    '^@/(.*)$': '<rootDir>/src/$1',
    '^@inngest/agent-kit$': '<rootDir>/tests/mocks/inngest-agent-kit.ts',
    '^@e2b/code-interpreter$': '<rootDir>/tests/mocks/e2b-code-interpreter.ts',
    '^convex/browser$': '<rootDir>/tests/mocks/convex-browser.ts',
  },
  collectCoverageFrom: [
    'src/**/*.ts',
    '!src/**/*.d.ts',
    '!src/generated/**',
  ],
  moduleFileExtensions: ['ts', 'js', 'json'],
  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
};

tests/
├── mocks/                           # Centralized mocks
│   ├── convex-browser.ts
│   ├── convex-generated-api.ts
│   ├── convex-generated-dataModel.ts
│   ├── e2b-code-interpreter.ts
│   └── inngest-agent-kit.ts
├── agent-improvements.test.ts       # AI agent enhancement tests
├── agent-workflow.test.ts           # Agent workflow tests
├── auth-helpers.test.ts             # Authentication tests
├── credit-system.test.ts            # Credit/usage tracking tests
├── file-operations.test.ts          # File handling tests
├── frameworks.test.ts               # Framework selection tests
├── gateway-fallback.test.ts         # API gateway failover tests
├── glm-subagent-system.test.ts      # GLM subagent tests
├── model-selection.test.ts          # Model selection tests
├── sanitizers.test.ts               # Input validation tests
├── security.test.ts                 # Security tests
├── setup.ts                         # Test setup configuration
└── utils.test.ts                    # Utility function tests

import { describe, it, expect, beforeEach } from '@jest/globals';

describe('Feature Name', () => {
  beforeEach(() => {
    // Setup before each test
  });

  describe('Specific Functionality', () => {
    it('should do something specific', () => {
      // Arrange
      const input = 'test';
      
      // Act
      const result = someFunction(input);
      
      // Assert
      expect(result).toBe('expected');
    });
  });
});

// E2B sandbox operations are automatically mocked
import { Sandbox } from '@e2b/code-interpreter';

// Convex queries/mutations are mocked
import { api } from '@/convex/_generated/api';

// Inngest workflows are mocked
import { inngest } from '@inngest/agent-kit';

import { describe, it, expect, beforeEach } from '@jest/globals';

const CREDIT_LIMITS = {
  free: 5,
  pro: 100
};

describe('Credit System', () => {
  let creditSystem: CreditSystem;

  beforeEach(() => {
    creditSystem = new CreditSystem();
  });

  describe('Free Tier Credits', () => {
    it('should give 5 credits to free tier users', async () => {
      await creditSystem.createUsageRecord('user_1', 'free', 0);
      
      const usage = await creditSystem.getUsageForUser('user_1');
      
      expect(usage.creditsRemaining).toBe(5);
      expect(usage.creditsLimit).toBe(5);
      expect(usage.planType).toBe('free');
    });

    it('should throw error when free credits exhausted', async () => {
      await creditSystem.createUsageRecord('user_3', 'free', 5);
      
      await expect(
        creditSystem.checkAndConsumeCreditForUser('user_3')
      ).rejects.toThrow('You have run out of credits');
    });
  });
});

import { sanitizePath } from '@/lib/sanitizers';

describe('sanitizePath', () => {
  it('should remove leading slashes', () => {
    expect(sanitizePath('/path/to/file')).toBe('path/to/file');
  });

  it('should handle relative paths', () => {
    expect(sanitizePath('../../../etc/passwd')).toBe('etc/passwd');
  });
});

import { appRouter } from '@/trpc/routers/_app';

const mockContext = {
  userId: 'user_123',
  session: { /* mock session */ }
};

const caller = appRouter.createCaller(mockContext);

it('should fetch project by id', async () => {
  const project = await caller.projects.getById({ id: 'proj_1' });
  expect(project.id).toBe('proj_1');
});

import { generateCode } from '@/agents/code-agent';

it('should generate Next.js application', async () => {
  const result = await generateCode({
    prompt: 'Create a todo app',
    framework: 'nextjs'
  });
  
  expect(result.files).toContain('app/page.tsx');
  expect(result.success).toBe(true);
});

import { getUserUsage } from '@/convex/usage';

it('should return usage for authenticated user', async () => {
  const usage = await getUserUsage({ userId: 'user_1' });
  
  expect(usage.creditsRemaining).toBeGreaterThanOrEqual(0);
  expect(usage.planType).toMatch(/^(free|pro)$/);
});

# Use Node inspector
node --inspect-brk node_modules/.bin/jest --runInBand

# Add console.log statements
console.log('Debug value:', someValue);

# Use VSCode debugger with breakpoints