Unit Tests

import { defineConfig } from 'vitest/config'
import react from '@vitejs/plugin-react'
import { resolve } from 'path'

export default defineConfig({
  plugins: [react()],
  test: {
    environment: 'happy-dom',
    globals: true,
    setupFiles: ['./src/test/setup.ts'],
    env: {
      // CRITICAL: Disable Repository mocks in unit tests
      // Unit tests mock Prisma directly and need full control over data flow
      // This flag tells Repository.isTestMode() to return false, allowing Prisma mocks to work
      DISABLE_REPOSITORY_MOCKS: 'true',

      // CRITICAL: Enable credit system in unit tests
      // Allows testing credit deduction, initialization, tier adjustment, etc.
      // E2E tests do NOT set this flag (credit system disabled, no database)
      ENABLE_CREDIT_SYSTEM_IN_TESTS: 'true',
    },
    exclude: ['node_modules/**', '.next/**', 'e2e/**'],
    coverage: {
      provider: 'v8',
      reporter: ['text', 'json', 'html'],
      exclude: [
        'node_modules/',
        'src/test/',
        '*.config.ts',
        '**/*.d.ts',
        '.next/',
        'src/components/ui/**', // shadcn/ui components ausschließen
      ],
    },
  },
  resolve: {
    alias: {
      '@': resolve(__dirname, './src'),
    },
  },
})

import '@testing-library/jest-dom'
import { expect, afterEach, vi, beforeAll, afterAll } from 'vitest'
import { cleanup } from '@testing-library/react'
import * as matchers from '@testing-library/jest-dom/matchers'
import { server } from '@/mocks/server'

// Extend Vitest matchers
expect.extend(matchers)

// Start MSW server before all tests
beforeAll(() => {
  server.listen({
    onUnhandledRequest: 'warn',
  })
})

// Reset handlers after each test
afterEach(() => {
  cleanup()
  server.resetHandlers()
})

// Clean up after all tests
afterAll(() => {
  server.close()
})

// Mock Next.js Router
vi.mock('next/navigation', () => ({
  useRouter() {
    return {
      push: vi.fn(),
      replace: vi.fn(),
      prefetch: vi.fn(),
      back: vi.fn(),
      pathname: '/',
      query: {},
      asPath: '/',
    }
  },
  usePathname() {
    return '/'
  },
  useSearchParams() {
    return new URLSearchParams()
  },
}))

// Mock Clerk v6 - Updated for async auth()
vi.mock('@clerk/nextjs', () => ({
  auth: () =>
    Promise.resolve({
      userId: 'test-user-id',
      protect: () => Promise.resolve(),
    }),
  currentUser: () =>
    Promise.resolve({
      id: 'test-user-id',
      firstName: 'Test',
      lastName: 'User',
      emailAddresses: [{ emailAddress: 'test@example.com' }],
    }),
  useAuth: () => ({
    userId: 'test-user-id',
    sessionId: 'test-session-123',
    isLoaded: true,
    isSignedIn: true,
    getToken: async () => 'test-token-123',
    signOut: async () => {},
  }),
  useUser: () => ({
    user: {
      id: 'test-user-id',
      firstName: 'Test',
      lastName: 'User',
    },
    isLoaded: true,
    isSignedIn: true,
  }),
  ClerkProvider: ({ children }: { children: React.ReactNode }) => children,
  SignIn: () => null,
  SignUp: () => null,
  UserButton: () => null,
}))

// Mock Sonner Toast
vi.mock('sonner', () => ({
  toast: {
    success: vi.fn(),
    error: vi.fn(),
    info: vi.fn(),
    warning: vi.fn(),
  },
  Toaster: () => null,
}))

apps/boilerplate/src/
  lib/
    payments/
      __tests__/
        config.test.ts
        lemonsqueezy-client.test.ts
        subscriptions.test.ts
      config.ts
      lemonsqueezy-client.ts
      subscriptions.ts
  components/
    credits/
      __tests__/
        low-credit-banner.test.tsx
        usage-counter.test.tsx
      low-credit-banner.tsx
      usage-counter.tsx

import { render, screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { LowCreditBanner } from '../low-credit-banner'

describe('LowCreditBanner', () => {
  it('shows warning when credits are low', () => {
    render(<LowCreditBanner credits={5} threshold={10} />)

    expect(screen.getByRole('alert')).toBeInTheDocument()
    expect(screen.getByText(/5 credits remaining/i)).toBeInTheDocument()
  })

  it('hides when dismissed', async () => {
    const user = userEvent.setup()
    render(<LowCreditBanner credits={5} threshold={10} />)

    await user.click(screen.getByRole('button', { name: /dismiss/i }))

    expect(screen.queryByRole('alert')).not.toBeInTheDocument()
  })
})

import { renderHook, waitFor } from '@testing-library/react'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { useCreditDeduction } from '../use-credit-deduction'

function createWrapper() {
  const queryClient = new QueryClient({
    defaultOptions: { queries: { retry: false } },
  })
  return ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={queryClient}>
      {children}
    </QueryClientProvider>
  )
}

describe('useCreditDeduction', () => {
  it('deducts credits on mutation', async () => {
    const { result } = renderHook(() => useCreditDeduction(), {
      wrapper: createWrapper(),
    })

    result.current.mutate({ amount: 10, reason: 'ai-chat' })

    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true)
    })
  })
})

import { server } from '@/mocks/server'
import { http, HttpResponse } from 'msw'

describe('POST /api/contact', () => {
  it('returns success for valid input', async () => {
    const response = await fetch('/api/contact', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        name: 'Jane Doe',
        email: 'jane@example.com',
        subject: 'Hello',
        message: 'This is a test message for the contact form.',
      }),
    })

    const data = await response.json()
    expect(data.success).toBe(true)
  })

  it('returns 400 for invalid body', async () => {
    // Override default handler for this test only
    server.use(
      http.post('/api/contact', () => {
        return HttpResponse.json(
          { error: 'Validation failed' },
          { status: 400 }
        )
      })
    )

    const response = await fetch('/api/contact', {
      method: 'POST',
      body: JSON.stringify({}),
    })

    expect(response.status).toBe(400)
  })
})

import { vi } from 'vitest'

describe('AI Feature Flags', () => {
  afterEach(() => {
    vi.resetModules()
    vi.restoreAllMocks()
  })

  it('disables RAG when flag is off', async () => {
    vi.stubEnv('NEXT_PUBLIC_AI_RAG_CHAT_ENABLED', 'false')

    // Dynamic import to pick up new env value
    const { isRAGEnabled } = await import('@/lib/ai/feature-flags')

    expect(isRAGEnabled()).toBe(false)
  })
})

describe('Config', () => {
  const originalEnv = process.env

  beforeEach(() => {
    vi.resetModules()
    process.env = { ...originalEnv }
  })

  afterEach(() => {
    process.env = originalEnv
  })

  it('uses credit_based pricing when configured', async () => {
    process.env.NEXT_PUBLIC_PRICING_MODEL = 'credit_based'
    const { pricingModel } = await import('@/lib/config')
    expect(pricingModel).toBe('credit_based')
  })
})

import {
  createMockProUser,
  createMockActiveSubscription,
} from '@/test/factories'

const user = createMockProUser()
const subscription = createMockActiveSubscription()

import { QueryClient, QueryClientProvider } from '@tanstack/react-query'

export function createQueryWrapper() {
  const queryClient = new QueryClient({
    defaultOptions: {
      queries: { retry: false, gcTime: 0 },
      mutations: { retry: false },
    },
  })

  return ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={queryClient}>
      {children}
    </QueryClientProvider>
  )
}

pnpm test:coverage