create-charcole 2.2.2 → 2.3.0

package/template/ts/src/modules/payments/__tests__/payments.controller.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('../payments.service.ts', () => ({
+  createPayment: vi.fn(),
+  refundPayment: vi.fn(),
+  getPaymentStatus: vi.fn(),
+  processWebhook: vi.fn(),
+}))
+
+vi.mock('../../../utils/logger.ts', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}))
+
+import * as controller from '../payments.controller.ts'
+import * as service from '../payments.service.ts'
+
+function buildMocks(overrides: Record<string, unknown> = {}) {
+  const req = {
+    body: {} as unknown,
+    params: {} as Record<string, string>,
+    headers: {} as Record<string, unknown>,
+    ...overrides,
+  }
+
+  const res = {
+    status: vi.fn().mockReturnThis(),
+    json: vi.fn().mockReturnThis(),
+  }
+
+  const next = vi.fn()
+
+  return { req, res, next }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  delete process.env.PAYMENT_PROVIDER
+})
+
+describe('createPayment controller', () => {
+  it('calls service.createPayment with validated body and responds 201', async () => {
+    const result = {
+      id: 'pi_test_123',
+      clientSecret: 'secret_abc',
+      status: 'requires_payment_method',
+      amount: 999,
+      currency: 'usd',
+      metadata: {},
+    }
+    service.createPayment.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({ body: { amount: 999, currency: 'usd' } })
+
+    await controller.createPayment(req as any, res as any, next)
+
+    expect(service.createPayment).toHaveBeenCalledWith({ amount: 999, currency: 'usd', metadata: {} })
+    expect(res.status).toHaveBeenCalledWith(201)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ success: true, data: result }))
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('calls next(err) when schema validation fails', async () => {
+    const { req, res, next } = buildMocks({ body: { amount: 'not-a-number', currency: 'usd' } })
+
+    await controller.createPayment(req as any, res as any, next)
+
+    expect(next).toHaveBeenCalled()
+    expect(res.json).not.toHaveBeenCalled()
+  })
+
+  it('calls next(err) when service.createPayment rejects', async () => {
+    const error = new Error('stripe down')
+    service.createPayment.mockRejectedValue(error)
+
+    const { req, res, next } = buildMocks({ body: { amount: 999, currency: 'usd' } })
+
+    await controller.createPayment(req as any, res as any, next)
+
+    expect(next).toHaveBeenCalledWith(error)
+  })
+
+  it('currency is lowercased by the schema', async () => {
+    const result = {
+      id: 'pi_test_123',
+      clientSecret: 'secret_abc',
+      status: 'requires_payment_method',
+      amount: 100,
+      currency: 'usd',
+      metadata: {},
+    }
+    service.createPayment.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({ body: { amount: 100, currency: 'USD' } })
+
+    await controller.createPayment(req as any, res as any, next)
+
+    expect(service.createPayment).toHaveBeenCalledWith({ amount: 100, currency: 'usd', metadata: {} })
+    expect(res.status).toHaveBeenCalledWith(201)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ success: true, data: result }))
+    expect(next).not.toHaveBeenCalled()
+  })
+})
+
+describe('refundPayment controller', () => {
+  it('calls service.refundPayment with paymentId and optional amount, responds 200', async () => {
+    const result = { id: 're_test_123', status: 'succeeded', amount: 500 }
+    service.refundPayment.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({ body: { paymentId: 'pi_123', amount: 500 } })
+
+    await controller.refundPayment(req as any, res as any, next)
+
+    expect(service.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: 500 })
+    expect(res.status).toHaveBeenCalledWith(200)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ success: true, data: result }))
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('calls service.refundPayment with just paymentId when amount is omitted', async () => {
+    const result = { id: 're_test_456', status: 'succeeded', amount: 0 }
+    service.refundPayment.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({ body: { paymentId: 'pi_123' } })
+
+    await controller.refundPayment(req as any, res as any, next)
+
+    expect(service.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: undefined })
+    expect(res.status).toHaveBeenCalledWith(200)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ success: true, data: result }))
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('calls next(err) when paymentId is missing from body', async () => {
+    const { req, res, next } = buildMocks({ body: { amount: 500 } })
+
+    await controller.refundPayment(req as any, res as any, next)
+
+    expect(next).toHaveBeenCalled()
+    expect(res.json).not.toHaveBeenCalled()
+  })
+
+  it('calls next(err) when service.refundPayment rejects', async () => {
+    const error = new Error('refund failed')
+    service.refundPayment.mockRejectedValue(error)
+
+    const { req, res, next } = buildMocks({ body: { paymentId: 'pi_123', amount: 500 } })
+
+    await controller.refundPayment(req as any, res as any, next)
+
+    expect(next).toHaveBeenCalledWith(error)
+  })
+})
+
+describe('getPaymentStatus controller', () => {
+  it('calls service.getPaymentStatus with req.params.paymentId and responds with result', async () => {
+    const result = { id: 'pi_123', status: 'paid', amount: 999, currency: 'usd', metadata: {} }
+    service.getPaymentStatus.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({ params: { paymentId: 'pi_123' } })
+
+    await controller.getPaymentStatus(req as any, res as any, next)
+
+    expect(service.getPaymentStatus).toHaveBeenCalledWith('pi_123')
+    expect(res.status).toHaveBeenCalledWith(200)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ success: true, data: result }))
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('calls next(err) when service rejects', async () => {
+    const error = new Error('status lookup failed')
+    service.getPaymentStatus.mockRejectedValue(error)
+
+    const { req, res, next } = buildMocks({ params: { paymentId: 'pi_123' } })
+
+    await controller.getPaymentStatus(req as any, res as any, next)
+
+    expect(next).toHaveBeenCalledWith(error)
+  })
+})
+
+describe('handleWebhook controller', () => {
+  it('reads stripe-signature header when PAYMENT_PROVIDER is stripe', async () => {
+    process.env.PAYMENT_PROVIDER = 'stripe'
+    const result = { event: 'payment_intent.succeeded', data: {}, duplicate: false }
+    service.processWebhook.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({
+      headers: { 'stripe-signature': 'test-sig' },
+      body: Buffer.from('{"id":"evt_123"}'),
+    })
+
+    await controller.handleWebhook(req as any, res as any, next)
+
+    expect(service.processWebhook).toHaveBeenCalledWith(req.body, 'test-sig')
+    expect(res.status).toHaveBeenCalledWith(200)
+    expect(res.json).toHaveBeenCalledWith({ received: true })
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('reads x-signature header when PAYMENT_PROVIDER is lemonsqueezy', async () => {
+    process.env.PAYMENT_PROVIDER = 'lemonsqueezy'
+    const result = { event: 'order_created', data: {}, duplicate: false }
+    service.processWebhook.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({
+      headers: { 'x-signature': 'hmac-sig' },
+      body: Buffer.from('{"id":"evt_456"}'),
+    })
+
+    await controller.handleWebhook(req as any, res as any, next)
+
+    expect(service.processWebhook).toHaveBeenCalledWith(req.body, 'hmac-sig')
+    expect(res.status).toHaveBeenCalledWith(200)
+    expect(res.json).toHaveBeenCalledWith({ received: true })
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('responds 200 { received: true, duplicate: true } for duplicate events', async () => {
+    process.env.PAYMENT_PROVIDER = 'stripe'
+    const result = { event: 'payment_intent.succeeded', data: { id: 'evt_789' }, duplicate: true }
+    service.processWebhook.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({
+      headers: { 'stripe-signature': 'test-sig' },
+      body: Buffer.from('{"id":"evt_789"}'),
+    })
+
+    await controller.handleWebhook(req as any, res as any, next)
+
+    expect(res.status).toHaveBeenCalledWith(200)
+    expect(res.json).toHaveBeenCalledWith({ received: true, duplicate: true })
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('responds 400 when signature header is missing', async () => {
+    process.env.PAYMENT_PROVIDER = 'stripe'
+    const { req, res, next } = buildMocks({ body: Buffer.from('{"id":"evt_000"}') })
+
+    await controller.handleWebhook(req as any, res as any, next)
+
+    expect(res.status).toHaveBeenCalledWith(400)
+    expect(res.json).toHaveBeenCalledWith({ error: 'Missing webhook signature header' })
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  it('calls next(err) when processWebhook rejects', async () => {
+    process.env.PAYMENT_PROVIDER = 'stripe'
+    const error = new Error('invalid signature')
+    service.processWebhook.mockRejectedValue(error)
+
+    const { req, res, next } = buildMocks({
+      headers: { 'stripe-signature': 'test-sig' },
+      body: Buffer.from('{"id":"evt_999"}'),
+    })
+
+    await controller.handleWebhook(req as any, res as any, next)
+
+    expect(next).toHaveBeenCalledWith(error)
+  })
+
+  it('passes req.body as raw Buffer to processWebhook', async () => {
+    process.env.PAYMENT_PROVIDER = 'stripe'
+    const result = { event: 'payment_intent.succeeded', data: {}, duplicate: false }
+    service.processWebhook.mockResolvedValue(result)
+
+    const { req, res, next } = buildMocks({
+      headers: { 'stripe-signature': 'test-sig' },
+      body: Buffer.from('{"id":"evt_buffer"}'),
+    })
+
+    await controller.handleWebhook(req as any, res as any, next)
+
+    const rawArg = service.processWebhook.mock.calls[0][0]
+    expect(Buffer.isBuffer(rawArg)).toBe(true)
+    expect(rawArg.toString()).toBe('{"id":"evt_buffer"}')
+    expect(next).not.toHaveBeenCalled()
+  })
+})

package/template/ts/src/modules/payments/__tests__/payments.routes.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import express from 'express'
+import request from 'supertest'
+
+vi.mock('../payments.service.ts', () => ({
+  createPayment: vi.fn(),
+  refundPayment: vi.fn(),
+  getPaymentStatus: vi.fn(),
+  processWebhook: vi.fn(),
+}))
+
+vi.mock('../../../../utils/logger.ts', () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}))
+
+import paymentsRouter from '../payments.routes.ts'
+import * as service from '../payments.service.ts'
+
+function buildTestApp() {
+  const app = express()
+  app.use('/payments/webhook', express.raw({ type: 'application/json' }))
+  app.use(express.json())
+  app.use('/payments', paymentsRouter)
+  app.use((err, _req, res, _next) => {
+    res.status(err.statusCode ?? 500).json({ error: err.message, code: err.code })
+  })
+  return app
+}
+
+let app: express.Express
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  process.env.PAYMENT_PROVIDER = 'stripe'
+  app = buildTestApp()
+})
+
+afterEach(() => {
+  delete process.env.PAYMENT_PROVIDER
+})
+
+describe('payments.routes', () => {
+  describe('POST /payments/create-intent', () => {
+    it('returns 201 with payment data on valid Stripe request', async () => {
+      const result = {
+        id: 'pi_test',
+        clientSecret: 'secret_abc',
+        status: 'requires_payment_method',
+        amount: 999,
+        currency: 'usd',
+      }
+      service.createPayment.mockResolvedValue(result)
+
+      const response = await request(app)
+        .post('/payments/create-intent')
+        .send({ amount: 999, currency: 'usd' })
+
+      expect(response.status).toBe(201)
+      expect(response.body.data.id).toBe('pi_test')
+      expect(response.body.data.clientSecret).toBe('secret_abc')
+      expect(service.createPayment).toHaveBeenCalledWith({ amount: 999, currency: 'usd', metadata: {} })
+    })
+
+    it('returns 201 with checkoutUrl on valid LemonSqueezy request', async () => {
+      const result = {
+        id: 'ls_test',
+        checkoutUrl: 'https://store.lemonsqueezy.com/checkout/buy',
+        status: 'created',
+        amount: 999,
+        currency: 'usd',
+      }
+      service.createPayment.mockResolvedValue(result)
+
+      const response = await request(app)
+        .post('/payments/create-intent')
+        .send({ amount: 999, currency: 'usd', metadata: { variantId: '12345' } })
+
+      expect(response.status).toBe(201)
+      expect(response.body.data.checkoutUrl).toBe('https://store.lemonsqueezy.com/checkout/buy')
+      expect(service.createPayment).toHaveBeenCalledWith({
+        amount: 999,
+        currency: 'usd',
+        metadata: { variantId: '12345' },
+      })
+    })
+
+    it('returns 400 when amount is missing', async () => {
+      const response = await request(app).post('/payments/create-intent').send({ currency: 'usd' })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns 400 when amount is a float', async () => {
+      const response = await request(app).post('/payments/create-intent').send({ amount: 9.99, currency: 'usd' })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns 400 when currency is wrong length', async () => {
+      const response = await request(app).post('/payments/create-intent').send({ amount: 100, currency: 'us' })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns 500 when service throws', async () => {
+      const error = new Error('service failure') as any
+      error.statusCode = 500
+      service.createPayment.mockRejectedValue(error)
+
+      const response = await request(app).post('/payments/create-intent').send({ amount: 999, currency: 'usd' })
+
+      expect(response.status).toBe(500)
+      expect(response.body.error).toBe('service failure')
+    })
+  })
+
+  describe('POST /payments/refund', () => {
+    it('returns 200 with refund data on valid request', async () => {
+      const result = { id: 're_123', status: 'succeeded', amount: 500 }
+      service.refundPayment.mockResolvedValue(result)
+
+      const response = await request(app).post('/payments/refund').send({ paymentId: 'pi_123', amount: 500 })
+
+      expect(response.status).toBe(200)
+      expect(response.body.data).toEqual(result)
+      expect(service.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: 500 })
+    })
+
+    it('returns 200 when amount is omitted (full refund)', async () => {
+      const result = { id: 're_124', status: 'succeeded', amount: 0 }
+      service.refundPayment.mockResolvedValue(result)
+
+      const response = await request(app).post('/payments/refund').send({ paymentId: 'pi_123' })
+
+      expect(response.status).toBe(200)
+      expect(response.body.data).toEqual(result)
+      expect(service.refundPayment).toHaveBeenCalledWith({ paymentId: 'pi_123', amount: undefined })
+    })
+
+    it('returns 400 when paymentId is missing', async () => {
+      const response = await request(app).post('/payments/refund').send({ amount: 500 })
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBeDefined()
+    })
+
+    it('returns error status when service rejects', async () => {
+      const error = new Error('refund failed') as any
+      error.statusCode = 500
+      service.refundPayment.mockRejectedValue(error)
+
+      const response = await request(app).post('/payments/refund').send({ paymentId: 'pi_123', amount: 500 })
+
+      expect(response.status).toBe(500)
+      expect(response.body.error).toBe('refund failed')
+    })
+  })
+
+  describe('GET /payments/status/:paymentId', () => {
+    it('returns 200 with payment status for a valid paymentId', async () => {
+      const result = { id: 'pi_test_123', status: 'paid', amount: 999, currency: 'usd', metadata: {} }
+      service.getPaymentStatus.mockResolvedValue(result)
+
+      const response = await request(app).get('/payments/status/pi_test_123')
+
+      expect(response.status).toBe(200)
+      expect(response.body.data.status).toBe('paid')
+      expect(service.getPaymentStatus).toHaveBeenCalledWith('pi_test_123')
+    })
+
+    it('passes the paymentId from URL params to service', async () => {
+      const result = { id: 'pi_specific_id', status: 'paid', amount: 999, currency: 'usd', metadata: {} }
+      service.getPaymentStatus.mockResolvedValue(result)
+
+      const response = await request(app).get('/payments/status/pi_specific_id')
+
+      expect(response.status).toBe(200)
+      expect(service.getPaymentStatus).toHaveBeenCalledWith('pi_specific_id')
+      expect(response.body.data.id).toBe('pi_specific_id')
+    })
+
+    it('returns error status when service rejects', async () => {
+      const error = new Error('status error') as any
+      error.statusCode = 500
+      service.getPaymentStatus.mockRejectedValue(error)
+
+      const response = await request(app).get('/payments/status/pi_error')
+
+      expect(response.status).toBe(500)
+      expect(response.body.error).toBe('status error')
+    })
+  })
+
+  describe('POST /payments/webhook', () => {
+    it('returns 200 { received: true } for valid Stripe webhook', async () => {
+      service.processWebhook.mockResolvedValue({ event: 'payment_intent.succeeded', data: {}, duplicate: false })
+
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .set('stripe-signature', 'stripe-sig')
+        .send(Buffer.from('{"id":"evt_test_001"}'))
+
+      expect(response.status).toBe(200)
+      expect(response.body.received).toBe(true)
+      expect(service.processWebhook).toHaveBeenCalled()
+      const rawArg = service.processWebhook.mock.calls[0][0]
+      expect(Buffer.isBuffer(rawArg)).toBe(true)
+      expect(rawArg.toString()).toBe('{"id":"evt_test_001"}')
+    })
+
+    it('returns 200 { received: true, duplicate: true } for duplicate event', async () => {
+      service.processWebhook.mockResolvedValue({ event: 'payment_intent.succeeded', data: {}, duplicate: true })
+
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .set('stripe-signature', 'stripe-sig')
+        .send(Buffer.from('{"id":"evt_test_002"}'))
+
+      expect(response.status).toBe(200)
+      expect(response.body.received).toBe(true)
+      expect(response.body.duplicate).toBe(true)
+    })
+
+    it('returns 400 when signature header is missing', async () => {
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .send(Buffer.from('{"id":"evt_test_003"}'))
+
+      expect(response.status).toBe(400)
+      expect(response.body.error).toBe('Missing webhook signature header')
+    })
+
+    it('does NOT require Authorization header', async () => {
+      service.processWebhook.mockResolvedValue({ event: 'payment_intent.succeeded', data: {}, duplicate: false })
+
+      const response = await request(app)
+        .post('/payments/webhook')
+        .set('Content-Type', 'application/json')
+        .set('stripe-signature', 'stripe-sig')
+        .send(Buffer.from('{"id":"evt_test_004"}'))
+
+      expect(response.status).toBe(200)
+      expect(response.body.received).toBe(true)
+    })
+  })
+})

package/template/ts/src/modules/payments/__tests__/payments.schemas.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest'
+import { createPaymentSchema, refundPaymentSchema } from '../payments.schemas.ts'
+
+describe('createPaymentSchema', () => {
+  it('parses valid input correctly', () => {
+    const result = createPaymentSchema.parse({ amount: 999, currency: 'usd' })
+
+    expect(result).toEqual({ amount: 999, currency: 'usd', metadata: {} })
+  })
+
+  it('lowercases currency automatically', () => {
+    const result = createPaymentSchema.parse({ amount: 100, currency: 'USD' })
+
+    expect(result.currency).toBe('usd')
+  })
+
+  it('rejects non-integer amount', () => {
+    expect(() => createPaymentSchema.parse({ amount: 9.99, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects negative amount', () => {
+    expect(() => createPaymentSchema.parse({ amount: -100, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects zero amount', () => {
+    expect(() => createPaymentSchema.parse({ amount: 0, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects amount over maximum', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100000000, currency: 'usd' })).toThrow()
+  })
+
+  it('rejects currency longer than 3 chars', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100, currency: 'usdx' })).toThrow()
+  })
+
+  it('rejects currency shorter than 3 chars', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100, currency: 'us' })).toThrow()
+  })
+
+  it('rejects missing amount', () => {
+    expect(() => createPaymentSchema.parse({ currency: 'usd' })).toThrow(/amount is required/)
+  })
+
+  it('rejects missing currency', () => {
+    expect(() => createPaymentSchema.parse({ amount: 100 })).toThrow(/currency is required/)
+  })
+
+  it('accepts metadata as key-value string pairs', () => {
+    const result = createPaymentSchema.parse({
+      amount: 100,
+      currency: 'usd',
+      metadata: { orderId: '123', userId: '456' },
+    })
+
+    expect(result.metadata).toEqual({ orderId: '123', userId: '456' })
+  })
+
+  it('rejects metadata with non-string values', () => {
+    expect(() =>
+      createPaymentSchema.parse({ amount: 100, currency: 'usd', metadata: { count: 5 } }),
+    ).toThrow()
+  })
+})
+
+describe('refundPaymentSchema', () => {
+  it('parses paymentId correctly', () => {
+    const result = refundPaymentSchema.parse({ paymentId: 'pi_abc123' })
+
+    expect(result).toEqual({ paymentId: 'pi_abc123', amount: undefined })
+  })
+
+  it('accepts optional partial refund amount', () => {
+    const result = refundPaymentSchema.parse({ paymentId: 'pi_abc123', amount: 500 })
+
+    expect(result.amount).toBe(500)
+  })
+
+  it('rejects empty paymentId', () => {
+    expect(() => refundPaymentSchema.parse({ paymentId: '' })).toThrow()
+  })
+
+  it('rejects missing paymentId', () => {
+    expect(() => refundPaymentSchema.parse({})).toThrow(/paymentId is required/)
+  })
+
+  it('rejects non-integer refund amount', () => {
+    expect(() => refundPaymentSchema.parse({ paymentId: 'pi_abc', amount: 9.99 })).toThrow()
+  })
+
+  it('rejects negative refund amount', () => {
+    expect(() => refundPaymentSchema.parse({ paymentId: 'pi_abc', amount: -100 })).toThrow()
+  })
+})