API Mocking

import { setupServer } from 'msw/node'
import { handlers } from './handlers'

// This configures a request mocking server with the given request handlers.
// This server will be used in tests to intercept and mock HTTP requests.
export const server = setupServer(...handlers)

// Establish API mocking before all tests.
// This ensures that the mock server is running and ready to intercept requests.
export function startServer() {
  server.listen({
    onUnhandledRequest: 'warn', // Warn about unhandled requests in tests
  })
}

// Reset any request handlers that we may add during the tests,
// so they don't affect other tests.
export function resetServer() {
  server.resetHandlers()
}

// Clean up after the tests are finished.
export function stopServer() {
  server.close()
}

import { setupWorker } from 'msw/browser'
import { handlers } from './handlers'

// This configures a Service Worker with the given request handlers.
// This worker will be used in the browser during development.
export const worker = setupWorker(...handlers)

// Start the worker
export async function startWorker() {
  if (typeof window === 'undefined') {
    return
  }

  // Only start the worker in development or test mode
  // E2E tests need MSW to intercept API calls and return mocked data
  if (
    process.env.NODE_ENV !== 'development' &&
    process.env.NODE_ENV !== 'test'
  ) {
    return
  }

  // Check if MSW is enabled via environment variable
  if (process.env.NEXT_PUBLIC_MSW_ENABLED !== 'true') {
    console.info('MSW is disabled. Set NEXT_PUBLIC_MSW_ENABLED=true to enable.')
    return
  }

  try {
    await worker.start({
      onUnhandledRequest: 'bypass', // Let unhandled requests pass through
      serviceWorker: {
        url: '/mockServiceWorker.js',
      },
    })
    console.info('🔶 MSW (Mock Service Worker) started successfully')
  } catch (error) {
    console.error('Failed to start MSW:', error)
  }
}

// Stop the worker
export function stopWorker() {
  if (typeof window !== 'undefined' && worker) {
    worker.stop()
  }
}

// Re-export all mock utilities for convenient imports
export { handlers } from './handlers'
export { server, startServer, resetServer, stopServer } from './server'
export { worker, startWorker, stopWorker } from './browser'

// Helper to check if MSW is enabled
export const isMSWEnabled = () => {
  if (typeof window === 'undefined') {
    // Server-side: MSW is always enabled in tests
    return process.env.NODE_ENV === 'test'
  }
  // Client-side: Check environment variable
  return process.env.NEXT_PUBLIC_MSW_ENABLED === 'true'
}

import { http, HttpResponse } from 'msw'
import { isValidRequestBody } from '@/lib/email/types'
import {
  lemonsqueezyHandlers,
  getTierFromSubscription,
} from './lemonsqueezy-handlers'
import { aiHandlers } from './ai-handlers'
import { dashboardHandlers } from './dashboard-handlers'
import { settingsHandlers } from './settings-handlers'
import { billingHandlers } from './billing-handlers'
import { checkoutHandlers } from './checkout-handlers'
import { demoHandlers } from './demo-handlers'
import { creditHistoryHandlers } from './credit-history-handlers'
import { creditPreferencesHandlers } from './credit-preferences-handlers'
import { imageGenHandlers } from './image-gen-handlers'

export const handlers = [
  // Include all Lemon Squeezy handlers
  ...lemonsqueezyHandlers,
  // Include all AI handlers
  ...aiHandlers,
  // Include all Dashboard handlers (NEW)
  ...dashboardHandlers,
  // Include all Settings handlers (NEW)
  ...settingsHandlers,
  // Include all Billing handlers (NEW)
  ...billingHandlers,
  // Include all Checkout handlers (PRP: Direct Checkout)
  ...checkoutHandlers,
  // Include all Demo handlers (Demo Mode: tier-aware mocks)
  ...demoHandlers,
  // Include all Credit History handlers (NESAI-037)
  ...creditHistoryHandlers,
  // Include all Credit Preferences handlers (NESAI-054)
  ...creditPreferencesHandlers,
  // Include all Image Generation handlers (NESAI-062)
  ...imageGenHandlers,

import { http, HttpResponse } from 'msw'

export const myHandlers = [
  // GET — return static data
  http.get('/api/posts', () => {
    return HttpResponse.json({
      posts: [{ id: '1', title: 'Hello World' }],
      total: 1,
    })
  }),

  // POST — inspect request body and respond
  http.post('/api/posts', async ({ request }) => {
    const body = await request.json()
    return HttpResponse.json(
      { id: 'new-post', ...body },
      { status: 201 }
    )
  }),
]

http.get('/api/posts/:slug', ({ params, request }) => {
  const { slug } = params
  const url = new URL(request.url)
  const page = url.searchParams.get('page') || '1'
  const authHeader = request.headers.get('authorization')

  // Use extracted values to customize response
  return HttpResponse.json({ slug, page })
})

// Permanent error endpoint for testing
http.get('/api/error/500', () => {
  return new HttpResponse(null, {
    status: 500,
    statusText: 'Internal Server Error',
  })
})

// Conditional error based on request content
http.post('/api/contact', async ({ request }) => {
  const body = await request.json()

  if (!body?.email) {
    return HttpResponse.json(
      { error: 'Email is required' },
      { status: 400 }
    )
  }

  return HttpResponse.json({ success: true })
})

http.post('/api/ai/chat', () => {
  const encoder = new TextEncoder()
  const stream = new ReadableStream({
    start(controller) {
      // Send chunks in OpenAI-compatible format
      const chunks = ['Hello', ' from', ' AI', '!']
      chunks.forEach((chunk, i) => {
        const data = JSON.stringify({
          choices: [{ delta: { content: chunk } }],
        })
        controller.enqueue(
          encoder.encode(`data: ${data}\n\n`)
        )
      })
      controller.enqueue(encoder.encode('data: [DONE]\n\n'))
      controller.close()
    },
  })

  return new HttpResponse(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      Connection: 'keep-alive',
    },
  })
})

http.get('/api/posts', ({ request }) => {
  const url = new URL(request.url)
  const page = parseInt(url.searchParams.get('page') || '1')
  const limit = parseInt(url.searchParams.get('limit') || '10')

  const startIndex = (page - 1) * limit
  const paginatedPosts = allPosts.slice(startIndex, startIndex + limit)

  return HttpResponse.json({
    posts: paginatedPosts,
    total: allPosts.length,
    page,
    totalPages: Math.ceil(allPosts.length / limit),
  })
})

http.get('/api/payments/subscription', () => {
  const subscription = {
    status: 'active',
    variantId: 'var_pro_monthly',
    currentPeriodEnd: new Date(
      Date.now() + 30 * 24 * 60 * 60 * 1000
    ).toISOString(),
  }

  // Dynamic tier calculation — handles active, trial,
  // cancelled, paused, expired, past_due states
  const tier = getTierFromSubscription(subscription)

  return HttpResponse.json({
    subscription,
    tier,
    hasActiveSubscription: subscription.status === 'active',
  })
})

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

describe('Dashboard', () => {
  it('shows empty state when no data', async () => {
    // Override the dashboard handler for this test only
    server.use(
      http.get('/api/dashboard', () => {
        return HttpResponse.json({
          stats: { totalPosts: 0, totalViews: 0 },
          recentActivity: [],
        })
      })
    )

    // Test now receives empty data from the overridden handler
    render(<Dashboard />)
    await expect(screen.getByText(/no data yet/i)).toBeInTheDocument()
  })

  it('shows error state on API failure', async () => {
    server.use(
      http.get('/api/dashboard', () => {
        return HttpResponse.json(
          { error: 'Server error' },
          { status: 500 }
        )
      })
    )

    render(<Dashboard />)
    await expect(screen.getByText(/something went wrong/i)).toBeInTheDocument()
  })
})

import { test, expect } from '@playwright/test'

test('shows error when subscription API fails', async ({ page }) => {
  await page.route('/api/payments/subscription', (route) => {
    route.fulfill({
      status: 500,
      contentType: 'application/json',
      body: JSON.stringify({ error: 'Service unavailable' }),
    })
  })

  await page.goto('/dashboard/billing')
  await expect(page.getByText(/unable to load subscription/i)).toBeVisible()
})

// In ai-handlers.ts (simplified)
http.post('/api/ai/chat', async ({ request }) => {
  const { credits } = demoCreditStore.getState()

  if (credits <= 0) {
    return HttpResponse.json(
      { error: 'No credits remaining' },
      { status: 402 }
    )
  }

  // Deduct credits based on estimated token usage
  demoCreditStore.getState().deductCredits(10)

  // Return streaming response...
})

// Before all tests — start the server
beforeAll(() => {
  server.listen({ onUnhandledRequest: 'warn' })
})

// After each test — reset overrides
afterEach(() => {
  cleanup()
  server.resetHandlers()
})

// After all tests — stop the server
afterAll(() => {
  server.close()
})

export const handlers = [
  http.get('/api/user/:id', specificHandler),  // Checked first
  http.get('/api/user', listHandler),          // Checked second
  // Don't put catch-all handlers before specific ones
]