@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/testing/integration.md

@@ -1,436 +0,0 @@
-# Integration Testing Patterns
-
-Patterns for end-to-end integration tests.
-
-## Database Integration Tests
-
-```typescript
-// __tests__/integration/setup.ts
-import { PrismaClient } from '@prisma/client'
-import { execSync } from 'child_process'
-
-const prisma = new PrismaClient()
-
-export async function setupTestDatabase() {
-  // Reset database before tests
-  await prisma.$executeRawUnsafe(`
-    TRUNCATE TABLE "User", "Post", "Comment" CASCADE;
-  `)
-}
-
-export async function teardownTestDatabase() {
-  await prisma.$disconnect()
-}
-
-// Or use test containers
-import { PostgreSqlContainer } from '@testcontainers/postgresql'
-
-let container: PostgreSqlContainer
-
-export async function startTestContainer() {
-  container = await new PostgreSqlContainer()
-    .withDatabase('testdb')
-    .withUsername('test')
-    .withPassword('test')
-    .start()
-
-  process.env.DATABASE_URL = container.getConnectionUri()
-
-  // Run migrations
-  execSync('npx prisma migrate deploy', {
-    env: { ...process.env, DATABASE_URL: container.getConnectionUri() }
-  })
-}
-
-export async function stopTestContainer() {
-  await container?.stop()
-}
-```
-
-## User Flow Integration Test
-
-```typescript
-// __tests__/integration/user-flow.test.ts
-import { prisma } from '@/lib/db'
-import { POST as createUser } from '@/app/api/users/route'
-import { POST as login } from '@/app/api/auth/login/route'
-import { POST as createPost } from '@/app/api/posts/route'
-import { hash } from 'bcryptjs'
-
-describe('User Flow Integration', () => {
-  beforeEach(async () => {
-    await prisma.post.deleteMany()
-    await prisma.user.deleteMany()
-  })
-
-  afterAll(async () => {
-    await prisma.$disconnect()
-  })
-
-  it('completes full user registration and posting flow', async () => {
-    // Step 1: Register user
-    const registerRequest = new Request('http://localhost/api/users', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        email: 'test@example.com',
-        password: 'password123',
-        name: 'Test User'
-      })
-    })
-
-    const registerResponse = await createUser(registerRequest)
-    expect(registerResponse.status).toBe(201)
-
-    const user = await registerResponse.json()
-    expect(user.email).toBe('test@example.com')
-
-    // Step 2: Login
-    const loginRequest = new Request('http://localhost/api/auth/login', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        email: 'test@example.com',
-        password: 'password123'
-      })
-    })
-
-    const loginResponse = await login(loginRequest)
-    expect(loginResponse.status).toBe(200)
-
-    const { token } = await loginResponse.json()
-    expect(token).toBeDefined()
-
-    // Step 3: Create post
-    const postRequest = new Request('http://localhost/api/posts', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        title: 'My First Post',
-        content: 'Hello world!'
-      })
-    })
-
-    const postResponse = await createPost(postRequest)
-    expect(postResponse.status).toBe(201)
-
-    const post = await postResponse.json()
-    expect(post.title).toBe('My First Post')
-    expect(post.authorId).toBe(user.id)
-
-    // Verify in database
-    const dbPost = await prisma.post.findUnique({
-      where: { id: post.id },
-      include: { author: true }
-    })
-
-    expect(dbPost?.author.email).toBe('test@example.com')
-  })
-})
-```
-
-## API Integration Tests with Supertest
-
-```typescript
-// __tests__/integration/api.test.ts
-import request from 'supertest'
-import { createServer } from 'http'
-import { parse } from 'url'
-import next from 'next'
-
-const dev = process.env.NODE_ENV !== 'production'
-const app = next({ dev })
-const handle = app.getRequestHandler()
-
-let server: ReturnType<typeof createServer>
-
-beforeAll(async () => {
-  await app.prepare()
-  server = createServer((req, res) => {
-    const parsedUrl = parse(req.url!, true)
-    handle(req, res, parsedUrl)
-  })
-  await new Promise<void>(resolve => server.listen(0, resolve))
-})
-
-afterAll(async () => {
-  await new Promise<void>(resolve => server.close(() => resolve()))
-  await app.close()
-})
-
-describe('API Integration Tests', () => {
-  it('GET /api/health returns healthy status', async () => {
-    const res = await request(server)
-      .get('/api/health')
-      .expect(200)
-
-    expect(res.body.status).toBe('healthy')
-  })
-
-  it('POST /api/users creates a new user', async () => {
-    const res = await request(server)
-      .post('/api/users')
-      .send({
-        email: 'new@example.com',
-        name: 'New User',
-        password: 'password123'
-      })
-      .expect(201)
-
-    expect(res.body.email).toBe('new@example.com')
-    expect(res.body.password).toBeUndefined()
-  })
-
-  it('GET /api/users requires authentication', async () => {
-    await request(server)
-      .get('/api/users')
-      .expect(401)
-  })
-})
-```
-
-## Service Integration Tests
-
-```typescript
-// __tests__/integration/services.test.ts
-import { PaymentService } from '@/services/payment'
-import { EmailService } from '@/services/email'
-import { prisma } from '@/lib/db'
-
-// Mock external services
-vi.mock('@/services/email', () => ({
-  EmailService: {
-    sendWelcomeEmail: vi.fn().mockResolvedValue(true),
-    sendReceiptEmail: vi.fn().mockResolvedValue(true)
-  }
-}))
-
-describe('Payment Service Integration', () => {
-  beforeEach(async () => {
-    await prisma.payment.deleteMany()
-    await prisma.subscription.deleteMany()
-    vi.clearAllMocks()
-  })
-
-  it('processes subscription and sends confirmation', async () => {
-    const user = await prisma.user.create({
-      data: {
-        email: 'subscriber@example.com',
-        name: 'Subscriber'
-      }
-    })
-
-    // Process subscription
-    const subscription = await PaymentService.createSubscription({
-      userId: user.id,
-      planId: 'pro',
-      paymentMethodId: 'pm_test_123'
-    })
-
-    expect(subscription.status).toBe('active')
-    expect(subscription.planId).toBe('pro')
-
-    // Verify database state
-    const dbSubscription = await prisma.subscription.findUnique({
-      where: { id: subscription.id }
-    })
-    expect(dbSubscription?.userId).toBe(user.id)
-
-    // Verify email was sent
-    expect(EmailService.sendReceiptEmail).toHaveBeenCalledWith(
-      expect.objectContaining({
-        email: 'subscriber@example.com',
-        subscriptionId: subscription.id
-      })
-    )
-  })
-
-  it('handles failed payment gracefully', async () => {
-    const user = await prisma.user.create({
-      data: {
-        email: 'fail@example.com',
-        name: 'Failed User'
-      }
-    })
-
-    await expect(
-      PaymentService.createSubscription({
-        userId: user.id,
-        planId: 'pro',
-        paymentMethodId: 'pm_card_declined'
-      })
-    ).rejects.toThrow('Payment declined')
-
-    // Verify no subscription was created
-    const subscriptions = await prisma.subscription.findMany({
-      where: { userId: user.id }
-    })
-    expect(subscriptions).toHaveLength(0)
-  })
-})
-```
-
-## Webhook Integration Tests
-
-```typescript
-// __tests__/integration/webhooks.test.ts
-import crypto from 'crypto'
-import { POST } from '@/app/api/webhooks/stripe/route'
-import { prisma } from '@/lib/db'
-
-function createStripeSignature(payload: string, secret: string): string {
-  const timestamp = Math.floor(Date.now() / 1000)
-  const signedPayload = `${timestamp}.${payload}`
-  const signature = crypto
-    .createHmac('sha256', secret)
-    .update(signedPayload)
-    .digest('hex')
-
-  return `t=${timestamp},v1=${signature}`
-}
-
-describe('Stripe Webhook Integration', () => {
-  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!
-
-  beforeEach(async () => {
-    await prisma.payment.deleteMany()
-  })
-
-  it('handles payment_intent.succeeded event', async () => {
-    const user = await prisma.user.create({
-      data: {
-        email: 'payer@example.com',
-        name: 'Payer',
-        stripeCustomerId: 'cus_test_123'
-      }
-    })
-
-    const event = {
-      id: 'evt_test_123',
-      type: 'payment_intent.succeeded',
-      data: {
-        object: {
-          id: 'pi_test_123',
-          amount: 2000,
-          currency: 'usd',
-          customer: 'cus_test_123',
-          metadata: { userId: user.id }
-        }
-      }
-    }
-
-    const payload = JSON.stringify(event)
-    const signature = createStripeSignature(payload, webhookSecret)
-
-    const request = new Request('http://localhost/api/webhooks/stripe', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'stripe-signature': signature
-      },
-      body: payload
-    })
-
-    const response = await POST(request)
-    expect(response.status).toBe(200)
-
-    // Verify payment was recorded
-    const payment = await prisma.payment.findFirst({
-      where: { stripePaymentIntentId: 'pi_test_123' }
-    })
-
-    expect(payment).toBeDefined()
-    expect(payment?.amount).toBe(2000)
-    expect(payment?.status).toBe('succeeded')
-  })
-
-  it('rejects invalid signatures', async () => {
-    const event = {
-      id: 'evt_test_456',
-      type: 'payment_intent.succeeded',
-      data: { object: {} }
-    }
-
-    const request = new Request('http://localhost/api/webhooks/stripe', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'stripe-signature': 'invalid_signature'
-      },
-      body: JSON.stringify(event)
-    })
-
-    const response = await POST(request)
-    expect(response.status).toBe(400)
-  })
-})
-```
-
-## Full Stack Integration Test
-
-```typescript
-// __tests__/integration/full-stack.test.ts
-import { test, expect } from '@playwright/test'
-import { prisma } from '@/lib/db'
-
-test.describe('Full Stack Integration', () => {
-  test.beforeEach(async () => {
-    await prisma.user.deleteMany()
-  })
-
-  test('complete user journey from signup to purchase', async ({ page }) => {
-    // Step 1: Visit homepage
-    await page.goto('/')
-    await expect(page.getByRole('heading', { name: 'Welcome' })).toBeVisible()
-
-    // Step 2: Sign up
-    await page.click('text=Sign Up')
-    await page.fill('input[name="email"]', 'e2e@example.com')
-    await page.fill('input[name="password"]', 'password123')
-    await page.fill('input[name="name"]', 'E2E User')
-    await page.click('button[type="submit"]')
-
-    // Step 3: Verify redirect to dashboard
-    await expect(page).toHaveURL('/dashboard')
-    await expect(page.getByText('Welcome, E2E User')).toBeVisible()
-
-    // Step 4: Navigate to pricing
-    await page.click('text=Upgrade')
-    await expect(page).toHaveURL('/pricing')
-
-    // Step 5: Select a plan
-    await page.click('text=Pro Plan')
-    await expect(page).toHaveURL('/checkout/pro')
-
-    // Step 6: Fill payment details (test mode)
-    const stripeFrame = page.frameLocator('iframe[name*="stripe"]')
-    await stripeFrame.locator('input[name="cardnumber"]').fill('4242424242424242')
-    await stripeFrame.locator('input[name="exp-date"]').fill('12/30')
-    await stripeFrame.locator('input[name="cvc"]').fill('123')
-
-    await page.click('text=Subscribe')
-
-    // Step 7: Verify success
-    await expect(page.getByText('Subscription Active')).toBeVisible()
-
-    // Verify in database
-    const user = await prisma.user.findUnique({
-      where: { email: 'e2e@example.com' },
-      include: { subscription: true }
-    })
-
-    expect(user?.subscription?.planId).toBe('pro')
-    expect(user?.subscription?.status).toBe('active')
-  })
-})
-```
-
-## When to Use
-
-- Critical user flows
-- Payment processing
-- Multi-service interactions
-- Database transactions

package/skills/patterns/testing/mocking.md

@@ -1,177 +0,0 @@
-# Mocking Patterns
-
-Patterns for mocking dependencies in tests.
-
-## Mock Functions
-
-```typescript
-// Basic mock function
-const mockFn = vi.fn()
-mockFn('arg1', 'arg2')
-
-expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2')
-expect(mockFn).toHaveBeenCalledTimes(1)
-
-// Mock with return value
-const mockGet = vi.fn().mockReturnValue('result')
-const mockAsync = vi.fn().mockResolvedValue({ data: 'test' })
-
-// Mock implementation
-const mockImpl = vi.fn().mockImplementation((x) => x * 2)
-expect(mockImpl(5)).toBe(10)
-```
-
-## Module Mocking
-
-```typescript
-// __tests__/service.test.ts
-import { describe, it, expect, vi } from 'vitest'
-import { sendEmail } from '@/lib/email'
-import { createUser } from '@/services/user'
-
-// Mock entire module
-vi.mock('@/lib/email', () => ({
-  sendEmail: vi.fn().mockResolvedValue({ success: true })
-}))
-
-describe('createUser', () => {
-  it('sends welcome email', async () => {
-    await createUser({ email: 'test@example.com', name: 'Test' })
-
-    expect(sendEmail).toHaveBeenCalledWith(
-      expect.objectContaining({
-        to: 'test@example.com',
-        template: 'welcome'
-      })
-    )
-  })
-})
-```
-
-## Partial Mocking
-
-```typescript
-// Mock specific exports
-vi.mock('@/lib/utils', async () => {
-  const actual = await vi.importActual('@/lib/utils')
-  return {
-    ...actual,
-    generateId: vi.fn().mockReturnValue('test-id')
-  }
-})
-```
-
-## Spy on Methods
-
-```typescript
-// Spy without replacing
-const consoleSpy = vi.spyOn(console, 'log')
-myFunction()
-expect(consoleSpy).toHaveBeenCalledWith('expected message')
-consoleSpy.mockRestore()
-
-// Spy and mock
-const dateSpy = vi.spyOn(Date, 'now').mockReturnValue(1234567890)
-expect(Date.now()).toBe(1234567890)
-dateSpy.mockRestore()
-```
-
-## Mock Timers
-
-```typescript
-describe('debounce', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  it('debounces function calls', () => {
-    const fn = vi.fn()
-    const debounced = debounce(fn, 100)
-
-    debounced()
-    debounced()
-    debounced()
-
-    expect(fn).not.toHaveBeenCalled()
-
-    vi.advanceTimersByTime(100)
-
-    expect(fn).toHaveBeenCalledTimes(1)
-  })
-})
-```
-
-## Mock Fetch/HTTP
-
-```typescript
-// Using msw (Mock Service Worker)
-import { http, HttpResponse } from 'msw'
-import { setupServer } from 'msw/node'
-
-const server = setupServer(
-  http.get('/api/users', () => {
-    return HttpResponse.json([
-      { id: '1', name: 'Test User' }
-    ])
-  }),
-
-  http.post('/api/users', async ({ request }) => {
-    const body = await request.json()
-    return HttpResponse.json({ id: '2', ...body }, { status: 201 })
-  })
-)
-
-beforeAll(() => server.listen())
-afterEach(() => server.resetHandlers())
-afterAll(() => server.close())
-
-// Override for specific test
-it('handles error', async () => {
-  server.use(
-    http.get('/api/users', () => {
-      return HttpResponse.json({ error: 'Not found' }, { status: 404 })
-    })
-  )
-
-  // Test error handling...
-})
-```
-
-## Mock Prisma
-
-```typescript
-// __mocks__/prisma.ts
-import { PrismaClient } from '@prisma/client'
-import { mockDeep, DeepMockProxy } from 'vitest-mock-extended'
-
-export const prismaMock = mockDeep<PrismaClient>()
-
-vi.mock('@/lib/db', () => ({
-  prisma: prismaMock
-}))
-
-// In test
-import { prismaMock } from '../__mocks__/prisma'
-
-it('finds user', async () => {
-  prismaMock.user.findUnique.mockResolvedValue({
-    id: '1',
-    email: 'test@example.com',
-    name: 'Test'
-  })
-
-  const user = await getUserById('1')
-  expect(user.email).toBe('test@example.com')
-})
-```
-
-## When to Use
-
-- External services
-- Database calls
-- Time-dependent code
-- Random values