The Guild

// calculateDiscount.test.ts
import { calculateDiscount } from './calculateDiscount';

describe('calculateDiscount', () => {
  it('gives 20% discount for 5+ year members', () => {
    expect(calculateDiscount(100, 5)).toBe(20);
  });

  it('gives 10% discount for 2-4 year members', () => {
    expect(calculateDiscount(100, 3)).toBe(10);
  });

  it('gives no discount for new members', () => {
    expect(calculateDiscount(100, 1)).toBe(0);
  });
});

// users.integration.test.ts
import { app } from './app';
import { db } from './database';
import request from 'supertest';

beforeEach(async () => {
  await db.migrate.latest();
  await db.seed.run();
});

afterEach(async () => {
  await db('users').truncate();
});

describe('POST /users', () => {
  it('creates a user and persists to database', async () => {
    const res = await request(app)
      .post('/users')
      .send({ name: 'Alice', email: 'alice@example.com' });

    expect(res.status).toBe(201);
    expect(res.body.name).toBe('Alice');

    const row = await db('users')
      .where({ email: 'alice@example.com' }).first();
    expect(row).toBeDefined();
    expect(row.name).toBe('Alice');
  });

  it('rejects duplicate emails', async () => {
    await request(app)
      .post('/users')
      .send({ name: 'Alice', email: 'alice@example.com' });

    const res = await request(app)
      .post('/users')
      .send({ name: 'Bob', email: 'alice@example.com' });

    expect(res.status).toBe(409);
  });
});

// Provider side: user-provider.contract.test.ts
import { Verifier } from '@pact-foundation/pact';

describe('User API provider contract', () => {
  it('satisfies the consumer contract', async () => {
    await new Verifier({
      providerBaseUrl: 'http://localhost:3000',
      pactUrls: ['./pacts/order-service-user-service.json'],
    }).verifyProvider();
  });
});

// Consumer side: user-consumer.contract.test.ts
import { Pact } from '@pact-foundation/pact';

const provider = new Pact({
  consumer: 'OrderService',
  provider: 'UserService',
});

describe('User API consumer contract', () => {
  beforeAll(() => provider.setup());
  afterAll(() => provider.finalize());

  it('expects user response with id, name, email', async () => {
    await provider.addInteraction({
      state: 'a user with id 1 exists',
      uponReceiving: 'a request for user 1',
      withRequest: { method: 'GET', path: '/users/1' },
      willRespondWith: {
        status: 200,
        body: { id: 1, name: 'Alice',
          email: 'alice@example.com' },
      },
    });

    const res = await fetch(
      `${provider.mockService.baseUrl}/users/1`);
    const user = await res.json();

    expect(user.id).toBe(1);
    expect(user.name).toBeDefined();
    expect(user.email).toBeDefined();
  });
});

Feature: Checkout

  Scenario: Registered user completes purchase
    Given I am logged in as "alice@example.com"
    And I have 2 items in my cart
    When I proceed to checkout
    And I confirm my payment method
    Then I should see "Order confirmed"
    And I should receive a confirmation email

// tests/e2e/checkout.spec.ts
import { test, expect } from '@playwright/test';

test('registered user can complete a purchase', async ({ page }) => {
  // Login
  await page.goto('/login');
  await page.fill('[name="email"]', 'alice@example.com');
  await page.fill('[name="password"]', 'testpassword');
  await page.click('button[type="submit"]');

  // Add items
  await page.goto('/products/1');
  await page.click('[data-testid="add-to-cart"]');

  // Checkout
  await page.goto('/cart');
  await page.click('[data-testid="checkout"]');
  await page.click('[data-testid="confirm-payment"]');

  // Verify
  await expect(page.locator('body'))
    .toContainText('Order confirmed');
});