// src/validators/userValidator.js
export class UserValidator {
  static validateEmail(email) {
    if (!email || typeof email !== 'string') {
      return { valid: false, error: 'メールアドレスは必須です' };
    }
    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    if (!emailRegex.test(email)) {
      return { valid: false, error: 'メールアドレスの形式が不正です' };
    }
    if (email.length > 254) {
      return { valid: false, error: 'メールアドレスが長すぎます（最大254文字）' };
    }
    return { valid: true, error: null };
  }
 
  static validateAge(age) {
    if (age === undefined || age === null) {
      return { valid: false, error: '年齢は必須です' };
    }
    if (!Number.isInteger(age)) {
      return { valid: false, error: '年齢は整数で指定してください' };
    }
    if (age < 0 || age > 150) {
      return { valid: false, error: '年齢は0〜150の範囲で指定してください' };
    }
    return { valid: true, error: null };
  }
 
  static validateCreateUserInput(input) {
    const errors = [];
    const emailResult = this.validateEmail(input.email);
    if (!emailResult.valid) errors.push({ field: 'email', message: emailResult.error });
 
    const ageResult = this.validateAge(input.age);
    if (!ageResult.valid) errors.push({ field: 'age', message: ageResult.error });
 
    if (!input.name || input.name.trim().length === 0) {
      errors.push({ field: 'name', message: '名前は必須です' });
    } else if (input.name.length > 100) {
      errors.push({ field: 'name', message: '名前は100文字以内で指定してください' });
    }
 
    return { valid: errors.length === 0, errors };
  }
}

// __tests__/unit/userValidator.test.js
import { describe, it, expect } from 'vitest';
import { UserValidator } from '../../src/validators/userValidator';
 
describe('UserValidator', () => {
  // === メールアドレスバリデーション ===
  describe('validateEmail', () => {
    // 正常系
    it('有効なメールアドレスを受け入れる', () => {
      const testCases = [
        'user@example.com',
        'user.name@example.co.jp',
        'user+tag@example.com',
        'user123@sub.domain.example.com',
      ];
      testCases.forEach(email => {
        const result = UserValidator.validateEmail(email);
        expect(result.valid).toBe(true);
        expect(result.error).toBeNull();
      });
    });
 
    // 異常系
    it('不正なメールアドレスを拒否する', () => {
      const testCases = [
        { input: '', expected: 'メールアドレスは必須です' },
        { input: null, expected: 'メールアドレスは必須です' },
        { input: undefined, expected: 'メールアドレスは必須です' },
        { input: 'invalid', expected: 'メールアドレスの形式が不正です' },
        { input: '@example.com', expected: 'メールアドレスの形式が不正です' },
        { input: 'user@', expected: 'メールアドレスの形式が不正です' },
        { input: 'user@.com', expected: 'メールアドレスの形式が不正です' },
      ];
      testCases.forEach(({ input, expected }) => {
        const result = UserValidator.validateEmail(input);
        expect(result.valid).toBe(false);
        expect(result.error).toBe(expected);
      });
    });
 
    // 境界値
    it('254文字を超えるメールアドレスを拒否する', () => {
      const longEmail = 'a'.repeat(243) + '@example.com'; // 255文字
      const result = UserValidator.validateEmail(longEmail);
      expect(result.valid).toBe(false);
      expect(result.error).toBe('メールアドレスが長すぎます（最大254文字）');
    });
 
    it('254文字ちょうどのメールアドレスを受け入れる', () => {
      const email = 'a'.repeat(242) + '@example.com'; // 254文字
      const result = UserValidator.validateEmail(email);
      expect(result.valid).toBe(true);
    });
  });
 
  // === 年齢バリデーション ===
  describe('validateAge', () => {
    it('有効な年齢を受け入れる', () => {
      [0, 1, 25, 100, 150].forEach(age => {
        expect(UserValidator.validateAge(age).valid).toBe(true);
      });
    });
 
    it('境界外の年齢を拒否する', () => {
      expect(UserValidator.validateAge(-1).valid).toBe(false);
      expect(UserValidator.validateAge(151).valid).toBe(false);
    });
 
    it('非整数を拒否する', () => {
      expect(UserValidator.validateAge(25.5).valid).toBe(false);
      expect(UserValidator.validateAge('25').valid).toBe(false);
    });
  });
 
  // === 複合バリデーション ===
  describe('validateCreateUserInput', () => {
    it('全フィールドが有効な場合にtrueを返す', () => {
      const result = UserValidator.validateCreateUserInput({
        name: 'Taro Yamada',
        email: 'taro@example.com',
        age: 30,
      });
      expect(result.valid).toBe(true);
      expect(result.errors).toHaveLength(0);
    });
 
    it('複数フィールドのエラーを同時に返す', () => {
      const result = UserValidator.validateCreateUserInput({
        name: '',
        email: 'invalid',
        age: -5,
      });
      expect(result.valid).toBe(false);
      expect(result.errors).toHaveLength(3);
      expect(result.errors.map(e => e.field)).toEqual(
        expect.arrayContaining(['name', 'email', 'age'])
      );
    });
  });
});

// src/services/pricingService.js
export class PricingService {
  /**
   * 商品の最終価格を計算する
   * @param {number} basePrice - 基本価格
   * @param {string} membershipTier - 会員ランク ('bronze'|'silver'|'gold'|'platinum')
   * @param {number} quantity - 数量
   * @param {string|null} couponCode - クーポンコード
   * @returns {{ finalPrice: number, discount: number, breakdown: object }}
   */
  static calculatePrice(basePrice, membershipTier, quantity, couponCode = null) {
    if (basePrice < 0) throw new Error('基本価格は0以上である必要があります');
    if (quantity < 1) throw new Error('数量は1以上である必要があります');
 
    // 会員割引率
    const tierDiscounts = {
      bronze: 0,
      silver: 0.05,
      gold: 0.10,
      platinum: 0.15,
    };
 
    // 数量割引率
    let quantityDiscount = 0;
    if (quantity >= 100) quantityDiscount = 0.10;
    else if (quantity >= 50) quantityDiscount = 0.07;
    else if (quantity >= 10) quantityDiscount = 0.05;
 
    // クーポン割引
    const couponDiscounts = {
      'SUMMER2024': 0.20,
      'WELCOME10': 0.10,
      'VIP30': 0.30,
    };
    const couponDiscount = couponCode ? (couponDiscounts[couponCode] || 0) : 0;
 
    // 割引は加算ではなく、最大の割引を適用
    const tierRate = tierDiscounts[membershipTier] || 0;
    const maxDiscount = Math.max(tierRate, quantityDiscount, couponDiscount);
 
    const subtotal = basePrice * quantity;
    const discountAmount = Math.round(subtotal * maxDiscount);
    const finalPrice = subtotal - discountAmount;
 
    return {
      finalPrice,
      discount: discountAmount,
      breakdown: {
        basePrice,
        quantity,
        subtotal,
        tierDiscount: tierRate,
        quantityDiscount,
        couponDiscount,
        appliedDiscount: maxDiscount,
      },
    };
  }
}

// __tests__/unit/pricingService.test.js
import { describe, it, expect } from 'vitest';
import { PricingService } from '../../src/services/pricingService';
 
describe('PricingService.calculatePrice', () => {
  it('基本的な価格計算（割引なし）', () => {
    const result = PricingService.calculatePrice(1000, 'bronze', 1);
    expect(result.finalPrice).toBe(1000);
    expect(result.discount).toBe(0);
  });
 
  it('会員割引の適用', () => {
    const result = PricingService.calculatePrice(1000, 'gold', 1);
    // gold: 10%割引 → 1000 - 100 = 900
    expect(result.finalPrice).toBe(900);
    expect(result.discount).toBe(100);
    expect(result.breakdown.appliedDiscount).toBe(0.10);
  });
 
  it('数量割引の適用（10個以上）', () => {
    const result = PricingService.calculatePrice(100, 'bronze', 10);
    // 100 * 10 = 1000, 5%割引 → 1000 - 50 = 950
    expect(result.finalPrice).toBe(950);
  });
 
  it('クーポン割引が会員割引より大きい場合はクーポンを適用', () => {
    const result = PricingService.calculatePrice(1000, 'silver', 1, 'SUMMER2024');
    // silver: 5%, クーポン: 20% → 最大の20%を適用
    expect(result.finalPrice).toBe(800);
    expect(result.breakdown.appliedDiscount).toBe(0.20);
  });
 
  it('無効なクーポンコードは無視される', () => {
    const result = PricingService.calculatePrice(1000, 'bronze', 1, 'INVALID');
    expect(result.finalPrice).toBe(1000);
    expect(result.breakdown.couponDiscount).toBe(0);
  });
 
  it('負の価格でエラーを投げる', () => {
    expect(() => PricingService.calculatePrice(-100, 'bronze', 1))
      .toThrow('基本価格は0以上である必要があります');
  });
 
  it('数量0でエラーを投げる', () => {
    expect(() => PricingService.calculatePrice(1000, 'bronze', 0))
      .toThrow('数量は1以上である必要があります');
  });
});

// __tests__/setup/testServer.js
import { beforeAll, afterAll, beforeEach } from 'vitest';
import { app } from '../../src/app';
import { db } from '../../src/db';
import { createTestUser, generateToken } from './helpers';
 
// テスト用のサーバーとDB接続を管理
export function setupTestServer() {
  let server;
  let authToken;
  let adminToken;
  let testUser;
  let adminUser;
 
  beforeAll(async () => {
    // テスト用DBのマイグレーション実行
    await db.migrate.latest();
    // テスト用シードデータ投入
    await db.seed.run();
  });
 
  beforeEach(async () => {
    // 各テスト前にテーブルをクリーンアップ
    await db.raw('TRUNCATE TABLE users, orders, products CASCADE');
 
    // テスト用ユーザーとトークンを作成
    testUser = await createTestUser(db, {
      name: 'Test User',
      email: 'test@example.com',
      role: 'user',
    });
    adminUser = await createTestUser(db, {
      name: 'Admin User',
      email: 'admin@example.com',
      role: 'admin',
    });
 
    authToken = generateToken(testUser);
    adminToken = generateToken(adminUser);
  });
 
  afterAll(async () => {
    await db.destroy();
  });
 
  return {
    getApp: () => app,
    getAuthToken: () => authToken,
    getAdminToken: () => adminToken,
    getTestUser: () => testUser,
    getAdminUser: () => adminUser,
    getDb: () => db,
  };
}

// __tests__/integration/users.test.js
import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import supertest from 'supertest';
import { app } from '../../src/app';
import { db } from '../../src/db';
 
const request = supertest(app);
 
describe('Users API - 統合テスト', () => {
  let authToken;
 
  beforeAll(async () => {
    await db.migrate.latest();
  });
 
  beforeEach(async () => {
    await db('users').truncate();
    const user = await db('users').insert({
      id: 'user_test',
      name: 'Test Admin',
      email: 'test@example.com',
      role: 'admin',
    }).returning('*');
    authToken = generateToken(user[0]);
  });
 
  afterAll(async () => {
    await db.destroy();
  });
 
  // ============================================
  // GET /api/v1/users - ユーザー一覧取得
  // ============================================
  describe('GET /api/v1/users', () => {
    it('ページネーション付きのユーザー一覧を返す', async () => {
      // データ準備
      await db('users').insert([
        { id: 'u1', name: 'Alice', email: 'alice@example.com', role: 'user' },
        { id: 'u2', name: 'Bob', email: 'bob@example.com', role: 'admin' },
      ]);
 
      const res = await request
        .get('/api/v1/users?limit=10')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);
 
      expect(res.body.data).toHaveLength(3); // test user + 2
      expect(res.body.meta).toHaveProperty('hasNextPage');
      expect(res.body.meta).toHaveProperty('total');
      expect(res.body.meta.total).toBe(3);
    });
 
    it('ロールでフィルタリングできる', async () => {
      await db('users').insert([
        { id: 'u1', name: 'Alice', email: 'alice@example.com', role: 'user' },
        { id: 'u2', name: 'Bob', email: 'bob@example.com', role: 'admin' },
      ]);
 
      const res = await request
        .get('/api/v1/users?filter[role]=admin')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);
 
      expect(res.body.data.every(u => u.role === 'admin')).toBe(true);
    });
 
    it('認証なしで401を返す', async () => {
      await request
        .get('/api/v1/users')
        .expect(401);
    });
 
    it('無効なトークンで401を返す', async () => {
      await request
        .get('/api/v1/users')
        .set('Authorization', 'Bearer invalid-token-here')
        .expect(401);
    });
 
    it('期限切れトークンで401を返す', async () => {
      const expiredToken = generateToken(
        { id: 'user_test', role: 'admin' },
        { expiresIn: '-1h' }
      );
 
      await request
        .get('/api/v1/users')
        .set('Authorization', `Bearer ${expiredToken}`)
        .expect(401);
    });
  });
 
  // ============================================
  // POST /api/v1/users - ユーザー作成
  // ============================================
  describe('POST /api/v1/users', () => {
    it('ユーザーを作成して201を返す', async () => {
      const res = await request
        .post('/api/v1/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send({ name: 'New User', email: 'new@example.com', age: 25 })
        .expect(201);
 
      expect(res.body.data).toMatchObject({
        name: 'New User',
        email: 'new@example.com',
        role: 'user', // デフォルトロール
      });
      expect(res.body.data.id).toBeDefined();
      expect(res.headers.location).toMatch(/\/api\/v1\/users\//);
    });
 
    it('不正なメールアドレスで422を返す', async () => {
      const res = await request
        .post('/api/v1/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send({ name: 'Test', email: 'invalid-email' })
        .expect(422);
 
      expect(res.body.errors).toContainEqual(
        expect.objectContaining({ field: 'email' })
      );
    });
 
    it('重複メールアドレスで409を返す', async () => {
      await request
        .post('/api/v1/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send({ name: 'First', email: 'dup@example.com' })
        .expect(201);
 
      const res = await request
        .post('/api/v1/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send({ name: 'Second', email: 'dup@example.com' })
        .expect(409);
 
      expect(res.body.error.code).toBe('DUPLICATE_RESOURCE');
    });
 
    it('必須フィールド欠落で422を返す', async () => {
      const res = await request
        .post('/api/v1/users')
        .set('Authorization', `Bearer ${authToken}`)
        .send({}) // 空ボディ
        .expect(422);
 
      expect(res.body.errors.length).toBeGreaterThanOrEqual(2);
    });
 
    it('一般ユーザーがadminロールで作成しようとすると403を返す', async () => {
      const userToken = generateToken({ id: 'u_normal', role: 'user' });
 
      await request
        .post('/api/v1/users')
        .set('Authorization', `Bearer ${userToken}`)
        .send({ name: 'Hacker', email: 'hack@example.com', role: 'admin' })
        .expect(403);
    });
  });
 
  // ============================================
  // PUT /api/v1/users/:id - ユーザー更新
  // ============================================
  describe('PUT /api/v1/users/:id', () => {
    it('ユーザー情報を更新する', async () => {
      const res = await request
        .put('/api/v1/users/user_test')
        .set('Authorization', `Bearer ${authToken}`)
        .send({ name: 'Updated Name' })
        .expect(200);
 
      expect(res.body.data.name).toBe('Updated Name');
    });
 
    it('存在しないユーザーIDで404を返す', async () => {
      await request
        .put('/api/v1/users/nonexistent_id')
        .set('Authorization', `Bearer ${authToken}`)
        .send({ name: 'Ghost' })
        .expect(404);
    });
 
    it('楽観的ロックによる競合検出', async () => {
      // バージョン1で取得
      const getRes = await request
        .get('/api/v1/users/user_test')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(200);
 
      const version = getRes.body.data.version;
 
      // 1回目の更新（成功）
      await request
        .put('/api/v1/users/user_test')
        .set('Authorization', `Bearer ${authToken}`)
        .set('If-Match', `"${version}"`)
        .send({ name: 'Update 1' })
        .expect(200);
 
      // 2回目の更新（古いバージョンで競合）
      await request
        .put('/api/v1/users/user_test')
        .set('Authorization', `Bearer ${authToken}`)
        .set('If-Match', `"${version}"`)
        .send({ name: 'Update 2' })
        .expect(409);
    });
  });
 
  // ============================================
  // DELETE /api/v1/users/:id - ユーザー削除
  // ============================================
  describe('DELETE /api/v1/users/:id', () => {
    it('ユーザーを削除して204を返す', async () => {
      const created = await db('users').insert({
        id: 'u_delete', name: 'To Delete', email: 'delete@example.com', role: 'user',
      }).returning('*');
 
      await request
        .delete(`/api/v1/users/${created[0].id}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(204);
 
      // 削除後に取得すると404
      await request
        .get(`/api/v1/users/${created[0].id}`)
        .set('Authorization', `Bearer ${authToken}`)
        .expect(404);
    });
 
    it('冪等性: 同じリソースを2回削除しても安全', async () => {
      await db('users').insert({
        id: 'u_idem', name: 'Idempotent', email: 'idem@example.com', role: 'user',
      });
 
      await request
        .delete('/api/v1/users/u_idem')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(204);
 
      // 2回目の削除は404（既に存在しない）
      await request
        .delete('/api/v1/users/u_idem')
        .set('Authorization', `Bearer ${authToken}`)
        .expect(404);
    });
  });
});

// __tests__/helpers/factories.js
import { faker } from '@faker-js/faker';
import { db } from '../../src/db';
 
export class UserFactory {
  static defaults() {
    return {
      id: faker.string.uuid(),
      name: faker.person.fullName(),
      email: faker.internet.email(),
      role: 'user',
      age: faker.number.int({ min: 18, max: 80 }),
      createdAt: new Date(),
      updatedAt: new Date(),
    };
  }
 
  static async create(overrides = {}) {
    const data = { ...this.defaults(), ...overrides };
    const [user] = await db('users').insert(data).returning('*');
    return user;
  }
 
  static async createMany(count, overrides = {}) {
    const users = Array.from({ length: count }, (_, i) => ({
      ...this.defaults(),
      email: `user${i}@example.com`,
      ...overrides,
    }));
    return db('users').insert(users).returning('*');
  }
}
 
export class OrderFactory {
  static defaults(userId) {
    return {
      id: faker.string.uuid(),
      userId,
      status: 'pending',
      totalAmount: faker.number.int({ min: 100, max: 100000 }),
      items: JSON.stringify([
        { productId: faker.string.uuid(), quantity: 1, price: 1000 },
      ]),
      createdAt: new Date(),
    };
  }
 
  static async create(userId, overrides = {}) {
    const data = { ...this.defaults(userId), ...overrides };
    const [order] = await db('orders').insert(data).returning('*');
    return order;
  }
}

// Postman の Tests タブに記述するスクリプト例
 
// === POST /auth/login のテストスクリプト ===
// ステータスコードの検証
pm.test("ステータスコード200を返す", function () {
    pm.response.to.have.status(200);
});
 
// レスポンスボディの検証
pm.test("アクセストークンを含むレスポンスを返す", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('accessToken');
    pm.expect(jsonData).to.have.property('refreshToken');
    pm.expect(jsonData).to.have.property('expiresIn');
    pm.expect(jsonData.expiresIn).to.be.a('number');
});
 
// トークンを環境変数に保存（後続リクエストで使用）
pm.test("トークンを環境変数に保存する", function () {
    const jsonData = pm.response.json();
    pm.environment.set("accessToken", jsonData.accessToken);
    pm.environment.set("refreshToken", jsonData.refreshToken);
});
 
// レスポンス時間の検証
pm.test("レスポンスが500ms以内に返る", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});
 
// ヘッダーの検証
pm.test("Content-Typeがapplication/jsonである", function () {
    pm.response.to.have.header("Content-Type", "application/json; charset=utf-8");
});
 
// スキーマバリデーション
const schema = {
    type: "object",
    required: ["accessToken", "refreshToken", "expiresIn", "user"],
    properties: {
        accessToken: { type: "string" },
        refreshToken: { type: "string" },
        expiresIn: { type: "number" },
        user: {
            type: "object",
            required: ["id", "name", "email", "role"],
            properties: {
                id: { type: "string" },
                name: { type: "string" },
                email: { type: "string", format: "email" },
                role: { type: "string", enum: ["user", "admin"] },
            }
        }
    }
};
 
pm.test("レスポンスがスキーマに準拠している", function () {
    pm.response.to.have.jsonSchema(schema);
});

# Newman のインストール
npm install -g newman newman-reporter-htmlextra
 
# コレクションの実行
newman run ./postman/collection.json \
  --environment ./postman/env-staging.json \
  --reporters cli,htmlextra \
  --reporter-htmlextra-export ./reports/api-test-report.html \
  --iteration-count 3 \
  --delay-request 100 \
  --timeout-request 10000
 
# GitHub Actions での実行例
# .github/workflows/api-tests.yml
# name: API Tests
# on:
#   push:
#     branches: [main, develop]
#   pull_request:
#     branches: [main]
#
# jobs:
#   api-tests:
#     runs-on: ubuntu-latest
#     steps:
#       - uses: actions/checkout@v4
#       - uses: actions/setup-node@v4
#         with:
#           node-version: '20'
#       - run: npm ci
#       - run: npm run start:test &
#       - run: npx newman run ./postman/collection.json \
#              --environment ./postman/env-test.json \
#              --reporters cli,junit \
#              --reporter-junit-export ./reports/junit.xml
#       - uses: actions/upload-artifact@v4
#         with:
#           name: test-reports
#           path: ./reports/

// __tests__/contract/userApiConsumer.pact.test.js
import { PactV3, MatchersV3 } from '@pact-foundation/pact';
import path from 'path';
import { UserApiClient } from '../../src/clients/userApiClient';
 
const { like, eachLike, regex, string, integer, boolean } = MatchersV3;
 
const provider = new PactV3({
  consumer: 'FrontendApp',
  provider: 'UserAPI',
  dir: path.resolve(process.cwd(), 'pacts'),
  logLevel: 'warn',
});
 
describe('User API Contract - Consumer側', () => {
  // ユーザー一覧取得のコントラクト
  describe('GET /api/v1/users', () => {
    it('ページネーション付きのユーザー一覧を返すこと', async () => {
      provider
        .given('ユーザーが複数存在する')
        .uponReceiving('ユーザー一覧取得リクエスト')
        .withRequest({
          method: 'GET',
          path: '/api/v1/users',
          query: { limit: '10', offset: '0' },
          headers: {
            Authorization: regex(/^Bearer .+$/, 'Bearer valid-token'),
            Accept: 'application/json',
          },
        })
        .willRespondWith({
          status: 200,
          headers: {
            'Content-Type': 'application/json; charset=utf-8',
          },
          body: {
            data: eachLike({
              id: string('user_123'),
              name: string('Taro Yamada'),
              email: string('taro@example.com'),
              role: regex(/^(user|admin)$/, 'user'),
              createdAt: regex(
                /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
                '2024-01-15T09:00:00Z'
              ),
            }),
            meta: {
              total: integer(100),
              limit: integer(10),
              offset: integer(0),
              hasNextPage: boolean(true),
            },
          },
        });
 
      await provider.executeTest(async (mockServer) => {
        const client = new UserApiClient({
          baseUrl: mockServer.url,
          token: 'valid-token',
        });
 
        const result = await client.listUsers({ limit: 10, offset: 0 });
 
        expect(result.data).toBeDefined();
        expect(result.data.length).toBeGreaterThan(0);
        expect(result.meta.total).toBeGreaterThanOrEqual(0);
        expect(result.meta.hasNextPage).toBeDefined();
      });
    });
  });
 
  // ユーザー個別取得のコントラクト
  describe('GET /api/v1/users/:id', () => {
    it('指定IDのユーザーを返すこと', async () => {
      provider
        .given('ID 123 のユーザーが存在する')
        .uponReceiving('ユーザー個別取得リクエスト')
        .withRequest({
          method: 'GET',
          path: '/api/v1/users/123',
          headers: {
            Authorization: regex(/^Bearer .+$/, 'Bearer valid-token'),
          },
        })
        .willRespondWith({
          status: 200,
          headers: { 'Content-Type': 'application/json; charset=utf-8' },
          body: {
            data: {
              id: string('123'),
              name: like('Taro Yamada'),
              email: like('taro@example.com'),
              role: regex(/^(user|admin)$/, 'user'),
              profile: {
                bio: like('ソフトウェアエンジニア'),
                avatarUrl: like('https://example.com/avatar.png'),
              },
            },
          },
        });
 
      await provider.executeTest(async (mockServer) => {
        const client = new UserApiClient({
          baseUrl: mockServer.url,
          token: 'valid-token',
        });
 
        const user = await client.getUser('123');
        expect(user.id).toBe('123');
        expect(user.name).toBeDefined();
        expect(user.email).toBeDefined();
        expect(user.profile).toBeDefined();
      });
    });
 
    it('存在しないIDで404を返すこと', async () => {
      provider
        .given('ID 999 のユーザーは存在しない')
        .uponReceiving('存在しないユーザーの取得リクエスト')
        .withRequest({
          method: 'GET',
          path: '/api/v1/users/999',
          headers: {
            Authorization: regex(/^Bearer .+$/, 'Bearer valid-token'),
          },
        })
        .willRespondWith({
          status: 404,
          headers: { 'Content-Type': 'application/json; charset=utf-8' },
          body: {
            error: {
              code: string('NOT_FOUND'),
              message: like('指定されたユーザーは見つかりませんでした'),
            },
          },
        });
 
      await provider.executeTest(async (mockServer) => {
        const client = new UserApiClient({
          baseUrl: mockServer.url,
          token: 'valid-token',
        });
 
        await expect(client.getUser('999')).rejects.toThrow(/not found/i);
      });
    });
  });
 
  // ユーザー作成のコントラクト
  describe('POST /api/v1/users', () => {
    it('新規ユーザーを作成して201を返すこと', async () => {
      const newUser = {
        name: 'Hanako Suzuki',
        email: 'hanako@example.com',
        age: 28,
      };
 
      provider
        .given('ユーザー登録が可能な状態')
        .uponReceiving('ユーザー作成リクエスト')
        .withRequest({
          method: 'POST',
          path: '/api/v1/users',
          headers: {
            Authorization: regex(/^Bearer .+$/, 'Bearer valid-token'),
            'Content-Type': 'application/json',
          },
          body: newUser,
        })
        .willRespondWith({
          status: 201,
          headers: {
            'Content-Type': 'application/json; charset=utf-8',
            Location: regex(/^\/api\/v1\/users\//, '/api/v1/users/new_id'),
          },
          body: {
            data: {
              id: string('new_id'),
              name: string('Hanako Suzuki'),
              email: string('hanako@example.com'),
              role: string('user'),
              age: integer(28),
            },
          },
        });
 
      await provider.executeTest(async (mockServer) => {
        const client = new UserApiClient({
          baseUrl: mockServer.url,
          token: 'valid-token',
        });
 
        const created = await client.createUser(newUser);
        expect(created.name).toBe('Hanako Suzuki');
        expect(created.email).toBe('hanako@example.com');
        expect(created.id).toBeDefined();
      });
    });
  });
});

// __tests__/contract/userApiProvider.pact.test.js
import { Verifier } from '@pact-foundation/pact';
import { app } from '../../src/app';
import { db } from '../../src/db';
 
describe('User API Contract - Provider検証', () => {
  let server;
  const port = 4567;
 
  beforeAll(async () => {
    await db.migrate.latest();
    server = app.listen(port);
  });
 
  afterAll(async () => {
    server.close();
    await db.destroy();
  });
 
  it('Consumer のコントラクトを満たすこと', async () => {
    const opts = {
      provider: 'UserAPI',
      providerBaseUrl: `http://localhost:${port}`,
 
      // Pact Brokerから取得する場合
      pactBrokerUrl: process.env.PACT_BROKER_URL,
      pactBrokerToken: process.env.PACT_BROKER_TOKEN,
 
      // ローカルファイルから取得する場合
      // pactUrls: ['./pacts/FrontendApp-UserAPI.json'],
 
      publishVerificationResult: process.env.CI === 'true',
      providerVersion: process.env.GIT_COMMIT_SHA,
      providerVersionBranch: process.env.GIT_BRANCH,
 
      // Provider Stateのハンドラー
      stateHandlers: {
        'ユーザーが複数存在する': async () => {
          await db('users').truncate();
          await db('users').insert([
            { id: 'user_1', name: 'Taro', email: 'taro@example.com', role: 'user' },
            { id: 'user_2', name: 'Hanako', email: 'hanako@example.com', role: 'admin' },
          ]);
        },
        'ID 123 のユーザーが存在する': async () => {
          await db('users').truncate();
          await db('users').insert({
            id: '123',
            name: 'Taro Yamada',
            email: 'taro@example.com',
            role: 'user',
            profile: JSON.stringify({
              bio: 'ソフトウェアエンジニア',
              avatarUrl: 'https://example.com/avatar.png',
            }),
          });
        },
        'ID 999 のユーザーは存在しない': async () => {
          await db('users').where({ id: '999' }).delete();
        },
        'ユーザー登録が可能な状態': async () => {
          await db('users').where({ email: 'hanako@example.com' }).delete();
        },
      },
 
      // リクエストフィルター（認証トークンの注入など）
      requestFilter: (req, res, next) => {
        req.headers['authorization'] = 'Bearer test-provider-token';
        next();
      },
    };
 
    await new Verifier(opts).verifyProvider();
  });
});

# Pact Broker での can-i-deploy チェック
# Consumer のデプロイ前に実行
pact-broker can-i-deploy \
  --pacticipant FrontendApp \
  --version $(git rev-parse HEAD) \
  --to-environment production
 
# Provider のデプロイ前に実行
pact-broker can-i-deploy \
  --pacticipant UserAPI \
  --version $(git rev-parse HEAD) \
  --to-environment production
 
# デプロイ成功の記録
pact-broker record-deployment \
  --pacticipant UserAPI \
  --version $(git rev-parse HEAD) \
  --environment production

// load-tests/scenarios/user-api-load.js（k6）
import http from 'k6/http';
import { check, sleep, group } from 'k6';
import { Counter, Rate, Trend } from 'k6/metrics';
 
// カスタムメトリクス定義
const errorRate = new Rate('errors');
const userCreated = new Counter('users_created');
const listDuration = new Trend('list_duration', true);
const createDuration = new Trend('create_duration', true);
 
// テストシナリオ設定
export const options = {
  scenarios: {
    // シナリオ1: 読み取り中心の通常負荷
    read_load: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 30 },    // ウォームアップ
        { duration: '2m',  target: 30 },    // 定常負荷
        { duration: '30s', target: 0 },     // クールダウン
      ],
      gracefulRampDown: '10s',
      exec: 'readScenario',
      tags: { scenario: 'read' },
    },
    // シナリオ2: 書き込み中心の高負荷
    write_load: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 10 },
        { duration: '2m',  target: 10 },
        { duration: '30s', target: 0 },
      ],
      gracefulRampDown: '10s',
      exec: 'writeScenario',
      startTime: '10s',  // 10秒遅れて開始
      tags: { scenario: 'write' },
    },
    // シナリオ3: スパイクテスト
    spike: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '10s', target: 5 },     // ベースライン
        { duration: '5s',  target: 100 },   // 急激なスパイク
        { duration: '30s', target: 100 },   // スパイク維持
        { duration: '5s',  target: 5 },     // 急激な減少
        { duration: '30s', target: 5 },     // 回復確認
        { duration: '10s', target: 0 },     // 終了
      ],
      exec: 'readScenario',
      startTime: '4m',  // 他のシナリオ後に実行
      tags: { scenario: 'spike' },
    },
  },
  thresholds: {
    // グローバル閾値
    http_req_duration: ['p(50)<200', 'p(95)<500', 'p(99)<1000'],
    http_req_failed: ['rate<0.01'],
    errors: ['rate<0.05'],
 
    // シナリオ別の閾値
    'http_req_duration{scenario:read}': ['p(95)<300'],
    'http_req_duration{scenario:write}': ['p(95)<800'],
    'http_req_duration{scenario:spike}': ['p(95)<2000'],
 
    // カスタムメトリクスの閾値
    list_duration: ['p(95)<400'],
    create_duration: ['p(95)<700'],
  },
};
 
const BASE_URL = __ENV.BASE_URL || 'https://api-staging.example.com/v1';
const TOKEN = __ENV.API_TOKEN;
 
const headers = {
  Authorization: `Bearer ${TOKEN}`,
  'Content-Type': 'application/json',
};
 
// 読み取りシナリオ
export function readScenario() {
  group('ユーザー一覧取得', () => {
    const startTime = Date.now();
    const res = http.get(`${BASE_URL}/users?limit=20`, { headers });
    listDuration.add(Date.now() - startTime);
 
    const success = check(res, {
      'ステータスが200': (r) => r.status === 200,
      'レスポンスにdataが存在': (r) => {
        try { return JSON.parse(r.body).data !== undefined; }
        catch { return false; }
      },
      'レスポンスタイム < 500ms': (r) => r.timings.duration < 500,
    });
 
    errorRate.add(!success);
  });
 
  group('ユーザー個別取得', () => {
    const userId = `user_${Math.floor(Math.random() * 100) + 1}`;
    const res = http.get(`${BASE_URL}/users/${userId}`, { headers });
 
    const success = check(res, {
      'ステータスが200または404': (r) => [200, 404].includes(r.status),
      'レスポンスタイム < 300ms': (r) => r.timings.duration < 300,
    });
 
    errorRate.add(!success);
  });
 
  sleep(Math.random() * 2 + 1); // 1〜3秒のランダムなシンクタイム
}
 
// 書き込みシナリオ
export function writeScenario() {
  group('ユーザー作成', () => {
    const startTime = Date.now();
    const uniqueId = `${Date.now()}_${__VU}_${__ITER}`;
    const payload = JSON.stringify({
      name: `LoadTest User ${uniqueId}`,
      email: `loadtest_${uniqueId}@example.com`,
      age: Math.floor(Math.random() * 60) + 18,
    });
 
    const res = http.post(`${BASE_URL}/users`, payload, { headers });
    createDuration.add(Date.now() - startTime);
 
    const success = check(res, {
      'ステータスが201': (r) => r.status === 201,
      '作成されたユーザーIDが返る': (r) => {
        try { return JSON.parse(r.body).data.id !== undefined; }
        catch { return false; }
      },
      'レスポンスタイム < 1000ms': (r) => r.timings.duration < 1000,
    });
 
    if (success) userCreated.add(1);
    errorRate.add(!success);
  });
 
  sleep(Math.random() * 3 + 2); // 2〜5秒のシンクタイム
}
 
// テスト結果のサマリー出力
export function handleSummary(data) {
  return {
    'stdout': textSummary(data, { indent: ' ', enableColors: true }),
    './reports/load-test-summary.json': JSON.stringify(data, null, 2),
  };
}

# k6 実行コマンド
k6 run load-tests/scenarios/user-api-load.js \
  --env BASE_URL=https://api-staging.example.com/v1 \
  --env API_TOKEN=sk_test_xxx \
  --out json=./reports/k6-results.json
 
# Grafana + InfluxDB への出力
k6 run load-tests/scenarios/user-api-load.js \
  --out influxdb=http://localhost:8086/k6

# load-tests/artillery/user-api.yml
config:
  target: "https://api-staging.example.com"
  phases:
    - name: "ウォームアップ"
      duration: 30
      arrivalRate: 5
    - name: "通常負荷"
      duration: 120
      arrivalRate: 20
    - name: "ピーク負荷"
      duration: 60
      arrivalRate: 50
    - name: "クールダウン"
      duration: 30
      arrivalRate: 5
  defaults:
    headers:
      Authorization: "Bearer {{ $processEnvironment.API_TOKEN }}"
      Content-Type: "application/json"
  plugins:
    expect: {}
  ensure:
    p95: 500
    p99: 1000
    maxErrorRate: 1
 
scenarios:
  - name: "ユーザー一覧取得"
    weight: 60
    flow:
      - get:
          url: "/api/v1/users?limit=20"
          expect:
            - statusCode: 200
            - hasProperty: "data"
            - contentType: "application/json"
 
  - name: "ユーザー作成→取得→更新"
    weight: 30
    flow:
      - post:
          url: "/api/v1/users"
          json:
            name: "Artillery User {{ $randomString() }}"
            email: "artillery_{{ $timestamp() }}@example.com"
            age: "{{ $randomNumber(18, 80) }}"
          capture:
            - json: "$.data.id"
              as: "userId"
          expect:
            - statusCode: 201
      - think: 1
      - get:
          url: "/api/v1/users/{{ userId }}"
          expect:
            - statusCode: 200
      - think: 1
      - put:
          url: "/api/v1/users/{{ userId }}"
          json:
            name: "Updated User {{ $randomString() }}"
          expect:
            - statusCode: 200
 
  - name: "検索シナリオ"
    weight: 10
    flow:
      - get:
          url: "/api/v1/users?filter[role]=admin&sort=-createdAt&limit=5"
          expect:
            - statusCode: 200

# Artillery 実行コマンド
artillery run load-tests/artillery/user-api.yml \
  --output ./reports/artillery-report.json
 
# HTMLレポート生成
artillery report ./reports/artillery-report.json \
  --output ./reports/artillery-report.html

// __tests__/e2e/purchaseFlow.test.js
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import supertest from 'supertest';
import { app } from '../../src/app';
import { db } from '../../src/db';
import { seedProducts } from '../helpers/seedData';
 
const request = supertest(app);
 
describe('E2E: 商品購入フロー', () => {
  let accessToken;
  let userId;
  let productId;
  let cartId;
  let orderId;
 
  beforeAll(async () => {
    await db.migrate.latest();
    await db.raw('TRUNCATE TABLE users, products, carts, orders, payments CASCADE');
    // テスト用商品データを投入
    const products = await seedProducts(db);
    productId = products[0].id;
  });
 
  afterAll(async () => {
    await db.destroy();
  });
 
  it('ステップ1: 会員登録', async () => {
    const res = await request
      .post('/auth/register')
      .send({
        name: 'E2E Test User',
        email: 'e2e@example.com',
        password: 'SecurePass123!',
      })
      .expect(201);
 
    expect(res.body.data.id).toBeDefined();
    userId = res.body.data.id;
  });
 
  it('ステップ2: ログイン', async () => {
    const res = await request
      .post('/auth/login')
      .send({
        email: 'e2e@example.com',
        password: 'SecurePass123!',
      })
      .expect(200);
 
    expect(res.body.accessToken).toBeDefined();
    expect(res.body.refreshToken).toBeDefined();
    accessToken = res.body.accessToken;
  });
 
  it('ステップ3: 商品一覧取得', async () => {
    const res = await request
      .get('/api/v1/products?limit=10')
      .set('Authorization', `Bearer ${accessToken}`)
      .expect(200);
 
    expect(res.body.data.length).toBeGreaterThan(0);
    expect(res.body.data[0]).toHaveProperty('id');
    expect(res.body.data[0]).toHaveProperty('price');
  });
 
  it('ステップ4: 商品をカートに追加', async () => {
    const res = await request
      .post('/api/v1/cart/items')
      .set('Authorization', `Bearer ${accessToken}`)
      .send({
        productId,
        quantity: 2,
      })
      .expect(201);
 
    expect(res.body.data.items).toHaveLength(1);
    expect(res.body.data.items[0].productId).toBe(productId);
    cartId = res.body.data.id;
  });
 
  it('ステップ5: カート確認', async () => {
    const res = await request
      .get('/api/v1/cart')
      .set('Authorization', `Bearer ${accessToken}`)
      .expect(200);
 
    expect(res.body.data.items).toHaveLength(1);
    expect(res.body.data.totalAmount).toBeGreaterThan(0);
  });
 
  it('ステップ6: 注文作成', async () => {
    const res = await request
      .post('/api/v1/orders')
      .set('Authorization', `Bearer ${accessToken}`)
      .send({
        cartId,
        shippingAddress: {
          postalCode: '100-0001',
          prefecture: '東京都',
          city: '千代田区',
          line1: '千代田1-1',
        },
      })
      .expect(201);
 
    expect(res.body.data.status).toBe('pending');
    expect(res.body.data.totalAmount).toBeGreaterThan(0);
    orderId = res.body.data.id;
  });
 
  it('ステップ7: 決済実行', async () => {
    const res = await request
      .post('/api/v1/payments')
      .set('Authorization', `Bearer ${accessToken}`)
      .send({
        orderId,
        method: 'credit_card',
        cardToken: 'tok_test_visa',
      })
      .expect(200);
 
    expect(res.body.data.status).toBe('succeeded');
    expect(res.body.data.orderId).toBe(orderId);
  });
 
  it('ステップ8: 注文ステータス確認', async () => {
    const res = await request
      .get(`/api/v1/orders/${orderId}`)
      .set('Authorization', `Bearer ${accessToken}`)
      .expect(200);
 
    expect(res.body.data.status).toBe('paid');
    expect(res.body.data.payment).toBeDefined();
    expect(res.body.data.payment.status).toBe('succeeded');
  });
});