[🇯🇵] 実サービスを使用したテスト：モックを使用しない統合テストの実用的ガイド

// testSetup.ts - Environment bootstrapping import { GenericContainer, StartedTestContainer } from 'testcontainers'; import { Pool } from 'pg'; import Redis from 'ioredis'; export class TestEnvironment { private postgresContainer: StartedTestContainer; private redisContainer: StartedTestContainer; private dbPool: Pool; private redisClient: Redis; async setup(): Promise<void> { // Start PostgreSQL with exact production version this.postgresContainer = await new GenericContainer('postgres:15-alpine') .withEnvironment({ POSTGRES_USER: 'testuser', POSTGRES_PASSWORD: 'testpass', POSTGRES_DB: 'testdb', }) .withExposedPorts(5432) .start(); // Start Redis with production configuration this.redisContainer = await new GenericContainer('redis:7-alpine') .withExposedPorts(6379) .start(); // Initialize real clients const pgPort = this.postgresContainer.getMappedPort(5432); this.dbPool = new Pool({ host: 'localhost', port: pgPort, user: 'testuser', password: 'testpass', database: 'testdb', }); const redisPort = this.redisContainer.getMappedPort(6379); this.redisClient = new Redis({ host: 'localhost', port: redisPort }); // Run migrations on real database await this.runMigrations(); } async cleanup(): Promise<void> { await this.dbPool.end(); await this.redisClient.quit(); await this.postgresContainer.stop(); await this.redisContainer.stop(); } getDbPool(): Pool { return this.dbPool; } getRedisClient(): Redis { return this.redisClient; } private async runMigrations(): Promise<void> { // Run your actual migration scripts // This ensures test DB schema matches production const migrationSQL = await readFile('./migrations/001_initial.sql', 'utf-8'); await this.dbPool.query(migrationSQL); } } 

// config/test.ts export const testConfig = { database: { // Provided by Testcontainers at runtime host: process.env.TEST_DB_HOST || 'localhost', port: parseInt(process.env.TEST_DB_PORT || '5432'), // Safe credentials for testing user: 'testuser', password: 'testpass', }, externalAPIs: { // Use sandbox/test modes of real services stripe: { apiKey: process.env.STRIPE_TEST_KEY, // sk_test_... webhookSecret: process.env.STRIPE_TEST_WEBHOOK_SECRET, }, sendgrid: { apiKey: process.env.SENDGRID_TEST_KEY, // Use SendGrid's sandbox mode sandboxMode: true, }, }, // Feature flags for test scenarios features: { enableRateLimiting: true, // Test rate limits! enableCaching: true, // Test cache invalidation! enableRetries: true, // Test retry logic! }, }; 

// lib/testCredentials.ts import { config } from 'dotenv'; export class TestCredentialManager { private credentials: Map<string, string> = new Map(); constructor() { // Load from .env.test if present (local dev) config({ path: '.env.test' }); // Override with CI environment variables if present this.loadFromEnvironment(); // Validate required credentials this.validate(); } private loadFromEnvironment(): void { const requiredCreds = [ 'STRIPE_TEST_KEY', 'SENDGRID_TEST_KEY', 'AWS_TEST_ACCESS_KEY', 'AWS_TEST_SECRET_KEY', ]; requiredCreds.forEach((key) => { const value = process.env[key]; if (value) { this.credentials.set(key, value); } }); } private validate(): void { const missing: string[] = []; // Check for essential credentials if (!this.credentials.has('STRIPE_TEST_KEY')) { missing.push('STRIPE_TEST_KEY'); } if (missing.length > 0) { console.warn( `⚠️ Missing test credentials: ${missing.join(', ')}\n` + `Some integration tests will be skipped.\n` + `See README.md for credential setup instructions.` ); } } get(key: string): string | undefined { return this.credentials.get(key); } has(key: string): boolean { return this.credentials.has(key); } // Fail gracefully when credentials are missing requireOrSkip(key: string, testFn: () => void): void { if (!this.has(key)) { console.log(`⏭️ Skipping test - missing ${key}`); return; } testFn(); } } // Usage in tests const credManager = new TestCredentialManager(); describe('Stripe Payment Integration', () => { it('should process payment with real Stripe API', async () => { credManager.requireOrSkip('STRIPE_TEST_KEY', async () => { const stripe = new Stripe(credManager.get('STRIPE_TEST_KEY')!); const paymentIntent = await stripe.paymentIntents.create({ amount: 1000, currency: 'usd', payment_method_types: ['card'], }); expect(paymentIntent.status).toBe('requires_payment_method'); }); }); }); 

# .github/workflows/test.yml name: Integration Tests on: [push, pull_request] jobs: integration-tests: runs-on: ubuntu-latest env: # Inject secrets from GitHub Secrets STRIPE_TEST_KEY: ${{ secrets.STRIPE_TEST_KEY }} SENDGRID_TEST_KEY: ${{ secrets.SENDGRID_TEST_KEY }} AWS_TEST_ACCESS_KEY: ${{ secrets.AWS_TEST_ACCESS_KEY }} AWS_TEST_SECRET_KEY: ${{ secrets.AWS_TEST_SECRET_KEY }} steps: - uses: actions/checkout@v3 - name: Setup Node.js uses: actions/setup-node@v3 with: node-version: '18' - name: Install dependencies run: npm ci - name: Run integration tests run: npm run test:integration - name: Upload coverage reports uses: codecov/codecov-action@v3 with: files: ./coverage/integration-coverage.json 

// tests/integration/userService.test.ts describe('UserService Integration', () => { let testEnv: TestEnvironment; let userService: UserService; beforeAll(async () => { testEnv = new TestEnvironment(); await testEnv.setup(); }); afterAll(async () => { await testEnv.cleanup(); }); beforeEach(async () => { // CLEAN BEFORE, not after // This ensures tests start from known state await cleanDatabase(testEnv.getDbPool()); userService = new UserService(testEnv.getDbPool()); }); it('should create user with unique email', async () => { const user = await userService.createUser({ email: 'test@example.com', name: 'Test User', }); expect(user.id).toBeDefined(); expect(user.email).toBe('test@example.com'); }); it('should reject duplicate email', async () => { await userService.createUser({ email: 'duplicate@example.com', name: 'User One', }); await expect( userService.createUser({ email: 'duplicate@example.com', name: 'User Two', }) ).rejects.toThrow('Email already exists'); }); }); async function cleanDatabase(pool: Pool): Promise<void> { // Truncate tables in correct order (respecting foreign keys) await pool.query('TRUNCATE users, orders, payments CASCADE'); } 

it('should send email via SendGrid', async () => { const testEmailId = `test-${Date.now()}@example.com`; let emailSent = false; try { // Arrange const sendgrid = new SendGridClient(testConfig.sendgridApiKey); // Act await sendgrid.send({ to: testEmailId, from: 'noreply@example.com', subject: 'Test Email', text: 'This is a test', }); emailSent = true; // Assert const emails = await sendgrid.searchEmails({ to: testEmailId, limit: 1, }); expect(emails).toHaveLength(1); } finally { // Cleanup - even if test fails if (emailSent) { await sendgrid.deleteEmail(testEmailId); } } }); 

// testDataFactory.ts export class TestDataFactory { private static counter = 0; static uniqueEmail(): string { return `test-${process.pid}-${TestDataFactory.counter++}@example.com`; } static uniqueUserId(): string { return `user-${process.pid}-${TestDataFactory.counter++}`; } static async createIsolatedUser(pool: Pool): Promise<User> { const email = TestDataFactory.uniqueEmail(); const result = await pool.query( 'INSERT INTO users (email, name) VALUES ($1, $2) RETURNING *', [email, `Test User ${TestDataFactory.counter}`] ); return result.rows[0]; } } // Usage ensures no collisions between parallel tests it('test A with isolated data', async () => { const user = await TestDataFactory.createIsolatedUser(pool); // Test uses user, no other test can access this user }); it('test B with isolated data', async () => { const user = await TestDataFactory.createIsolatedUser(pool); // Runs in parallel with test A, zero conflicts }); 

import { Toxiproxy } from 'toxiproxy-node-client'; describe('Payment Service - Network Resilience', () => { let toxiproxy: Toxiproxy; let paymentService: PaymentService; beforeAll(async () => { toxiproxy = new Toxiproxy('http://localhost:8474'); // Create proxy for Stripe API await toxiproxy.createProxy({ name: 'stripe_api', listen: '0.0.0.0:6789', upstream: 'api.stripe.com:443', }); }); it('should retry on network timeout', async () => { // Inject 5-second latency await toxiproxy.addToxic({ proxy: 'stripe_api', type: 'latency', attributes: { latency: 5000 }, }); const start = Date.now(); await expect( paymentService.processPayment({ amount: 1000 }) ).rejects.toThrow('Request timeout'); const duration = Date.now() - start; // Verify retry logic kicked in (3 retries = ~15 seconds) expect(duration).toBeGreaterThan(15000); }); it('should handle connection reset', async () => { // Inject connection reset await toxiproxy.addToxic({ proxy: 'stripe_api', type: 'reset_peer', attributes: { timeout: 0 }, }); await expect( paymentService.processPayment({ amount: 1000 }) ).rejects.toThrow('Connection reset'); }); afterEach(async () => { // Remove toxics between tests await toxiproxy.removeToxic({ proxy: 'stripe_api' }); }); }); 

it('should respect rate limits', async () => { const apiClient = new ExternalAPIClient(testConfig.apiKey); const results: Array<'success' | 'throttled'> = []; // Hammer the API with 100 requests const requests = Array.from({ length: 100 }, async () => { try { await apiClient.getData(); results.push('success'); } catch (error) { if (error.statusCode === 429) { results.push('throttled'); } else { throw error; } } }); await Promise.allSettled(requests); // Verify rate limiting kicked in expect(results.filter(r => r === 'throttled').length).toBeGreaterThan(0); // Verify some requests succeeded (we're not completely blocked) expect(results.filter(r => r === 'success').length).toBeGreaterThan(0); }); 

// package.json { "scripts": { "test:unit": "jest --coverage --coverageDirectory=coverage/unit", "test:integration": "jest --config=jest.integration.config.js --coverage --coverageDirectory=coverage/integration", "test:coverage": "node scripts/mergeCoverage.js" } } // scripts/mergeCoverage.js import { mergeCoverageReports } from 'coverage-merge'; const unitCoverage = require('../coverage/unit/coverage-summary.json'); const integrationCoverage = require('../coverage/integration/coverage-summary.json'); const merged = mergeCoverageReports([unitCoverage, integrationCoverage]); console.log('Combined Coverage Report:'); console.log(`Lines: ${merged.total.lines.pct}%`); console.log(`Statements: ${merged.total.statements.pct}%`); console.log(`Functions: ${merged.total.functions.pct}%`); console.log(`Branches: ${merged.total.branches.pct}%`); // Fail if below threshold if (merged.total.lines.pct < 90) { console.error('❌ Coverage below 90% threshold'); process.exit(1); } 

# .github/workflows/full-pipeline.yml name: Full Test Pipeline on: push: branches: [main, develop] pull_request: branches: [main] jobs: unit-tests: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-node@v3 with: node-version: '18' - run: npm ci - run: npm run test:unit - uses: codecov/codecov-action@v3 with: files: ./coverage/unit/coverage-final.json flags: unit integration-tests: runs-on: ubuntu-latest # Only run on main/develop or when PR is marked ready if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' || github.event.pull_request.draft == false services: # GitHub Actions provides service containers postgres: image: postgres:15-alpine env: POSTGRES_USER: testuser POSTGRES_PASSWORD: testpass POSTGRES_DB: testdb options: >- --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5 ports: - 5432:5432 redis: image: redis:7-alpine options: >- --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5 ports: - 6379:6379 env: TEST_DB_HOST: localhost TEST_DB_PORT: 5432 STRIPE_TEST_KEY: ${{ secrets.STRIPE_TEST_KEY }} SENDGRID_TEST_KEY: ${{ secrets.SENDGRID_TEST_KEY }} steps: - uses: actions/checkout@v3 - uses: actions/setup-node@v3 with: node-version: '18' - run: npm ci - run: npm run db:migrate:test - run: npm run test:integration - uses: codecov/codecov-action@v3 with: files: ./coverage/integration/coverage-final.json flags: integration e2e-tests: runs-on: ubuntu-latest needs: [unit-tests, integration-tests] # Only run E2E on main branch or when explicitly requested if: github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'run-e2e') steps: - uses: actions/checkout@v3 - uses: actions/setup-node@v3 with: node-version: '18' - run: npm ci - run: npm run test:e2e 

- name: Cache Docker layers uses: actions/cache@v3 with: path: /tmp/.buildx-cache key: ${{ runner.os }}-buildx-${{ hashFiles('**/Dockerfile') }} restore-keys: | ${{ runner.os }}-buildx- - name: Pull Docker images run: | docker pull postgres:15-alpine docker pull redis:7-alpine 

integration-tests: strategy: matrix: test-suite: [database, api, messaging, cache] steps: - run: npm run test:integration:${{ matrix.test-suite }} 

// tests/integration/checkout.test.ts import { TestEnvironment } from '../testSetup'; import { CheckoutService } from '../../src/services/CheckoutService'; import { StripePaymentProcessor } from '../../src/payments/StripePaymentProcessor'; import { SendGridEmailService } from '../../src/email/SendGridEmailService'; import { TestDataFactory } from '../testDataFactory'; import { TestCredentialManager } from '../testCredentials'; describe('Checkout Integration', () => { let testEnv: TestEnvironment; let checkoutService: CheckoutService; let credManager: TestCredentialManager; beforeAll(async () => { testEnv = new TestEnvironment(); await testEnv.setup(); credManager = new TestCredentialManager(); }); afterAll(async () => { await testEnv.cleanup(); }); beforeEach(async () => { // Clean state before each test await testEnv.getDbPool().query('TRUNCATE orders, payments, users CASCADE'); }); it('should complete full checkout with real payment and email', async () => { credManager.requireOrSkip('STRIPE_TEST_KEY', async () => { credManager.requireOrSkip('SENDGRID_TEST_KEY', async () => { // Arrange: Create test user with isolated data const user = await TestDataFactory.createIsolatedUser(testEnv.getDbPool()); const paymentProcessor = new StripePaymentProcessor( credManager.get('STRIPE_TEST_KEY')! ); const emailService = new SendGridEmailService( credManager.get('SENDGRID_TEST_KEY')! ); checkoutService = new CheckoutService( testEnv.getDbPool(), paymentProcessor, emailService ); const cart = { items: [ { productId: 'prod_123', quantity: 2, price: 1999 }, { productId: 'prod_456', quantity: 1, price: 4999 }, ], }; let orderId: string; try { // Act: Process checkout with REAL Stripe payment const result = await checkoutService.processCheckout({ userId: user.id, cart, paymentMethod: { type: 'card', cardToken: 'tok_visa', // Stripe test token }, }); orderId = result.orderId; // Assert: Verify order created in REAL database const orderResult = await testEnv.getDbPool().query( 'SELECT * FROM orders WHERE id = $1', [orderId] ); expect(orderResult.rows).toHaveLength(1); expect(orderResult.rows[0].status).toBe('completed'); expect(orderResult.rows[0].total_amount).toBe(8997); // Assert: Verify payment recorded const paymentResult = await testEnv.getDbPool().query( 'SELECT * FROM payments WHERE order_id = $1', [orderId] ); expect(paymentResult.rows).toHaveLength(1); expect(paymentResult.rows[0].status).toBe('succeeded'); expect(paymentResult.rows[0].provider).toBe('stripe'); // Assert: Verify email sent via REAL SendGrid const emails = await emailService.searchEmails({ to: user.email, subject: 'Order Confirmation', limit: 1, }); expect(emails).toHaveLength(1); expect(emails[0].body).toContain(orderId); } finally { // Cleanup: Cancel order and refund payment if (orderId) { await checkoutService.cancelOrder(orderId); } } }); }); }); it('should handle payment failure gracefully', async () => { credManager.requireOrSkip('STRIPE_TEST_KEY', async () => { const user = await TestDataFactory.createIsolatedUser(testEnv.getDbPool()); const paymentProcessor = new StripePaymentProcessor( credManager.get('STRIPE_TEST_KEY')! ); checkoutService = new CheckoutService( testEnv.getDbPool(), paymentProcessor, new SendGridEmailService(credManager.get('SENDGRID_TEST_KEY')!) ); const cart = { items: [{ productId: 'prod_789', quantity: 1, price: 9999 }], }; // Act: Use Stripe's test token for declined card await expect( checkoutService.processCheckout({ userId: user.id, cart, paymentMethod: { type: 'card', cardToken: 'tok_chargeDeclined', // Stripe test token for declined }, }) ).rejects.toThrow('Payment declined'); // Assert: Verify order marked as failed const orderResult = await testEnv.getDbPool().query( 'SELECT * FROM orders WHERE user_id = $1', [user.id] ); expect(orderResult.rows).toHaveLength(1); expect(orderResult.rows[0].status).toBe('payment_failed'); // Assert: No successful payment recorded const paymentResult = await testEnv.getDbPool().query( 'SELECT * FROM payments WHERE status = $1', ['succeeded'] ); expect(paymentResult.rows).toHaveLength(0); }); }); }); 

// ❌ 悪い例: 任意のタイムアウト await sleep(1000); expect(order.status).toBe('completed'); // ✅ 良い例: 条件を待つ await waitFor( async () => { const order = await getOrder(orderId); return order.status === 'completed'; }, { timeout: 5000, interval: 100 } ); 

// jest.integration.config.js module.exports = { testTimeout: 10000, // 10 seconds max per test maxWorkers: '50%', // Use half CPU cores for parallel execution setupFilesAfterEnv: ['<rootDir>/tests/testSetup.ts'], }; 

describe.each([ { input: 'valid@email.com', expected: true }, { input: 'invalid', expected: false }, { input: 'no@domain', expected: false }, { input: '', expected: false }, { input: null, expected: false }, ])('Email validation', ({ input, expected }) => { it(`should return ${expected} for "${input}"`, async () => { const result = await validateEmail(input); expect(result).toBe(expected); }); });