Kiểm thử hợp đồng Microservices với Pact & Node.js

// Example: Pact V4 consumer contract test in Node.js using @pact-foundation/pact
import { PactV4, MatchersV3 } from '@pact-foundation/pact';
import path from 'path';
import { fetchUserProfile } from '../src/api-client';

const { like, string, integer } = MatchersV3;

const provider = new PactV4({
  consumer: 'OrderWebClient',
  provider: 'UserService',
  dir: path.resolve(process.cwd(), 'pacts'),
});

describe('User Service Contract Tests', () => {
  it('returns user profile details for a valid user ID', async () => {
    await provider.addInteraction({
      states: [{ description: 'user with ID 101 exists' }],
      uponReceiving: 'a request for user profile 101',
      withRequest: {
        method: 'GET',
        path: '/api/v1/users/101',
        headers: { Accept: 'application/json' },
      },
      willRespondWith: {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          id: integer(101),
          name: string('Jane Doe'),
          email: like('jane.doe@example.com'),
          role: string('admin'),
        },
      },
    });

    await provider.executeTest(async (mockServer) => {
      const user = await fetchUserProfile(mockServer.url, 101);
      expect(user.name).toEqual('Jane Doe');
      expect(user.role).toEqual('admin');
    });
  });
});

// Client implementation verified by the Pact consumer test
import axios from 'axios';

export interface UserProfile {
  id: number;
  name: string;
  email: string;
  role: string;
}

export async function fetchUserProfile(baseUrl: string, userId: number): Promise<UserProfile> {
  const response = await axios.get(`${baseUrl}/api/v1/users/${userId}`, {
    headers: { Accept: 'application/json' },
  });
  return response.data;
}

// Asynchronous message contract testing example with Pact
import { MessageConsumerPact, Matchers } from '@pact-foundation/pact';

const messageProvider = new MessageConsumerPact({
  consumer: 'NotificationService',
  provider: 'OrderEventProducer',
  dir: path.resolve(process.cwd(), 'pacts'),
});

describe('Order Created Event Contract', () => {
  it('handles order created domain events correctly', async () => {
    await messageProvider
      .given('order 4004 was created')
      .expectsToReceive('an order created event payload')
      .withContent({
        orderId: Matchers.like('ORD-4004'),
        amount: Matchers.decimal(149.99),
        customerEmail: Matchers.like('customer@example.com'),
      })
      .verify(async (message) => {
        // Verify message handler processes event object cleanly
        const parsed = JSON.parse(message.contents.toString());
        expect(parsed.orderId).toBeDefined();
      });
  });
});

// Advanced Pact V4 consumer test with array and regex matchers
import { PactV4, MatchersV3 } from '@pact-foundation/pact';
import path from 'path';
import { fetchOrderHistory } from '../src/order-client';

const { eachLike, string, decimal, regex } = MatchersV3;

const provider = new PactV4({
  consumer: 'DashboardApp',
  provider: 'OrderService',
  dir: path.resolve(process.cwd(), 'pacts'),
});

describe('Order Service List Contract', () => {
  it('returns a list of recent customer orders', async () => {
    await provider.addInteraction({
      states: [{ description: 'customer 502 has existing orders' }],
      uponReceiving: 'a request for customer order history',
      withRequest: {
        method: 'GET',
        path: '/api/v1/customers/502/orders',
        query: { limit: '5' },
      },
      willRespondWith: {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          customerId: 502,
          orders: eachLike({
            orderId: regex(/^ORD-\d{6}$/, 'ORD-123456'),
            totalAmount: decimal(99.95),
            status: regex(/^(PENDING|COMPLETED|SHIPPED)$/, 'COMPLETED'),
          }),
        },
      },
    });

    await provider.executeTest(async (mockServer) => {
      const history = await fetchOrderHistory(mockServer.url, 502, 5);
      expect(history.orders.length).toBeGreaterThan(0);
    });
  });
});

// Custom header matchers preventing rigid authorization token failures
export const authenticatedHeadersContract = {
  Authorization: regex(/^Bearer [A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*$/, 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9'),
  'Content-Type': 'application/json',
};

// Example: Provider verification test script using @pact-foundation/pact Verifier
import { Verifier } from '@pact-foundation/pact';
import { createServer } from '../src/app';
import { Server } from 'http';
import { seedTestDatabase } from '../test/db-helpers';

describe('Pact Provider Verification', () => {
  let server: Server;
  const PORT = 8088;

  beforeAll((done) => {
    const app = createServer();
    server = app.listen(PORT, () => done());
  });

  afterAll((done) => {
    server.close(() => done());
  });

  it('validates contract specs against local provider server', async () => {
    const verifier = new Verifier({
      provider: 'UserService',
      providerBaseUrl: `http://localhost:${PORT}`,
      pactBrokerUrl: process.env.PACT_BROKER_URL || 'https://broker.example.com',
      pactBrokerToken: process.env.PACT_BROKER_TOKEN,
      publishVerificationResult: process.env.CI === 'true',
      providerVersion: process.env.GIT_COMMIT || '1.0.0',
      providerVersionBranch: process.env.GIT_BRANCH || 'main',
      stateHandlers: {
        'user with ID 101 exists': async () => {
          await seedTestDatabase([{ id: 101, name: 'Jane Doe', email: 'jane.doe@example.com', role: 'admin' }]);
          return { description: 'State seeded: user 101 created' };
        },
      },
    });

    const output = await verifier.verifyProvider();
    console.log('Pact verification complete:', output);
  });
});

// Express app setup snippet supporting test state hooks
import express from 'express';

export function createServer() {
  const app = express();
  app.use(express.json());

  app.get('/api/v1/users/:id', async (req, res) => {
    const userId = parseInt(req.params.id, 10);
    // Fetch from database seeded by state handler
    const user = await findUserInDatabase(userId);
    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }
    return res.json(user);
  });

  return app;
}

async function findUserInDatabase(id: number) {
  // Mock DB query implementation
  return { id, name: 'Jane Doe', email: 'jane.doe@example.com', role: 'admin' };
}

// Transactional database rollback wrapper for provider state handlers
export async function withTestTransaction(callback: () => Promise<void>) {
  const connection = await db.getConnection();
  await connection.beginTransaction();
  try {
    await callback();
  } finally {
    await connection.rollback();
    connection.release();
  }
}

#!/usr/bin/env bash
# CI Script: Executing Pact Broker can-i-deploy check before staging release

set -euo pipefail

SERVICE_NAME="UserService"
VERSION=$(git rev-parse --short HEAD)
ENVIRONMENT="production"

echo "Checking if ${SERVICE_NAME} version ${VERSION} is safe to deploy to ${ENVIRONMENT}..."

npx @pact-foundation/pact-cli broker can-i-deploy \
  --pact-broker-base-url="${PACT_BROKER_URL}" \
  --broker-token="${PACT_BROKER_TOKEN}" \
  --to-environment="${ENVIRONMENT}" \
  --pacticipant="${SERVICE_NAME}" \
  --version="${VERSION}"

echo "Deployment check passed! Service is safe to release."

// Versioned migration contract pattern supporting dual schema fields
export function mapUserResponse(data: any) {
  return {
    id: data.id,
    // Accept new field 'fullName' or fall back to legacy 'name'
    displayName: data.fullName || data.name,
    email: data.email,
  };
}

# GitHub Actions workflow for publishing contracts and checking deploy safety
name: Pact Contract Pipeline
on: [push]

jobs:
  contract-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - name: Run Consumer Contract Tests
        run: npm test -- --grep "Contract"
      - name: Publish Contracts to Pact Broker
        run: |
          npx @pact-foundation/pact-cli broker publish pacts \
            --pact-broker-base-url="${{ secrets.PACT_BROKER_URL }}" \
            --broker-token="${{ secrets.PACT_BROKER_TOKEN }}" \
            --consumer-app-version="${{ github.sha }}" \
            --branch="${{ github.ref_name }}"
      - name: Can I Deploy Check
        run: |
          npx @pact-foundation/pact-cli broker can-i-deploy \
            --pact-broker-base-url="${{ secrets.PACT_BROKER_URL }}" \
            --broker-token="${{ secrets.PACT_BROKER_TOKEN }}" \
            --pacticipant="OrderWebClient" \
            --version="${{ github.sha }}" \
            --to-environment="production"

// Clean state handler isolation module pattern
export const stateHandlers = {
  'user 101 exists': async () => {
    await db.user.upsert({
      where: { id: 101 },
      update: { name: 'Jane Doe' },
      create: { id: 101, name: 'Jane Doe', email: 'jane@example.com' },
    });
  },
  'user 101 has zero balance': async () => {
    await db.account.update({
      where: { userId: 101 },
      data: { balance: 0.00 },
    });
  },
};