# Traditional Integration Testing Challenges
challenges:
  - End-to-end test complexity
  - Brittle test environments
  - Slow feedback loops
  - Difficult debugging
  - Environment synchronization issues

# Contract Testing Benefits
benefits:
  - Fast test execution
  - Isolated service testing
  - Clear interface definitions
  - Independent team development
  - Reduced integration risks

{
  "consumer": {
    "name": "order-service"
  },
  "provider": {
    "name": "payment-service"
  },
  "interactions": [
    {
      "description": "process payment request",
      "request": {
        "method": "POST",
        "path": "/payments",
        "headers": {
          "Content-Type": "application/json"
        },
        "body": {
          "amount": 100.00,
          "currency": "USD",
          "orderId": "order-123"
        }
      },
      "response": {
        "status": 200,
        "headers": {
          "Content-Type": "application/json"
        },
        "body": {
          "paymentId": "payment-456",
          "status": "completed",
          "transactionId": "txn-789"
        }
      }
    }
  ]
}

npm install --save-dev @pact-foundation/pact
npm install --save-dev @pact-foundation/pact-node

// consumer.spec.js
const { Pact } = require('@pact-foundation/pact');
const { PaymentClient } = require('../src/payment-client');

describe('Payment Service Contract Tests', () => {
  const provider = new Pact({
    consumer: 'order-service',
    provider: 'payment-service',
    port: 1234,
    log: './logs/pact.log',
    dir: './pacts',
    logLevel: 'INFO',
    spec: 2
  });

  beforeAll(() => provider.setup());
  afterEach(() => provider.verify());
  afterAll(() => provider.finalize());

  describe('when processing a payment', () => {
    beforeEach(() => {
      const expectedPayment = {
        paymentId: 'payment-456',
        status: 'completed',
        transactionId: 'txn-789'
      };

      return provider.addInteraction({
        state: 'payment can be processed',
        uponReceiving: 'a valid payment request',
        withRequest: {
          method: 'POST',
          path: '/api/v1/payments',
          headers: {
            'Content-Type': 'application/json',
            'Authorization': 'Bearer token123'
          },
          body: {
            amount: 100.00,
            currency: 'USD',
            orderId: 'order-123'
          }
        },
        willRespondWith: {
          status: 200,
          headers: {
            'Content-Type': 'application/json'
          },
          body: expectedPayment
        }
      });
    });

    it('should process payment successfully', async () => {
      const client = new PaymentClient('http://localhost:1234');
      const response = await client.processPayment({
        amount: 100.00,
        currency: 'USD',
        orderId: 'order-123'
      });

      expect(response.paymentId).toBe('payment-456');
      expect(response.status).toBe('completed');
    });
  });
});

// src/payment-client.js
const axios = require('axios');

class PaymentClient {
  constructor(baseUrl) {
    this.baseUrl = baseUrl;
    this.client = axios.create({
      baseURL: baseUrl,
      timeout: 5000
    });
  }

  async processPayment(paymentRequest) {
    try {
      const response = await this.client.post('/api/v1/payments', paymentRequest, {
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer token123'
        }
      });
      return response.data;
    } catch (error) {
      throw new Error(`Payment processing failed: ${error.message}`);
    }
  }
}

module.exports = { PaymentClient };

<dependency>
    <groupId>au.com.dius.pact.consumer</groupId>
    <artifactId>junit5</artifactId>
    <version>4.6.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>au.com.dius.pact.provider</groupId>
    <artifactId>junit5</artifactId>
    <version>4.6.2</version>
    <scope>test</scope>
</dependency>

// PaymentServiceContractTest.java
@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "payment-service")
class PaymentServiceContractTest {

    @Pact(consumer = "order-service")
    public RequestResponsePact createPact(PactDslWithProvider builder) {
        return builder
            .given("payment can be processed")
            .uponReceiving("a valid payment request")
            .path("/api/v1/payments")
            .method("POST")
            .headers(Map.of(
                "Content-Type", "application/json",
                "Authorization", "Bearer token123"
            ))
            .body(new PactDslJsonBody()
                .numberType("amount", 100.00)
                .stringType("currency", "USD")
                .stringType("orderId", "order-123")
            )
            .willRespondWith()
            .status(200)
            .headers(Map.of("Content-Type", "application/json"))
            .body(new PactDslJsonBody()
                .stringType("paymentId", "payment-456")
                .stringType("status", "completed")
                .stringType("transactionId", "txn-789")
            )
            .toPact();
    }

    @Test
    @PactTestFor(pactMethod = "createPact")
    void testPaymentProcessing(MockServer mockServer) {
        PaymentClient client = new PaymentClient(mockServer.getUrl());
        
        PaymentRequest request = PaymentRequest.builder()
            .amount(100.00)
            .currency("USD")
            .orderId("order-123")
            .build();

        PaymentResponse response = client.processPayment(request);

        assertThat(response.getPaymentId()).isEqualTo("payment-456");
        assertThat(response.getStatus()).isEqualTo("completed");
        assertThat(response.getTransactionId()).isEqualTo("txn-789");
    }
}

// provider.spec.js
const { Verifier } = require('@pact-foundation/pact');
const app = require('../src/app');

describe('Payment Service Provider Tests', () => {
  it('validates the expectations of order-service', () => {
    const opts = {
      provider: 'payment-service',
      providerBaseUrl: 'http://localhost:3000',
      pactUrls: ['./pacts/order-service-payment-service.json'],
      stateHandlers: {
        'payment can be processed': () => {
          // Setup test data
          return Promise.resolve('Payment processing state ready');
        }
      },
      requestFilter: (req, res, next) => {
        // Add authentication or modify request if needed
        req.headers['authorization'] = 'Bearer token123';
        next();
      }
    };

    return new Verifier(opts).verifyProvider();
  });
});

// PaymentServiceProviderTest.java
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@Provider("payment-service")
@PactFolder("../pacts")
class PaymentServiceProviderTest {

    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void pactVerificationTestTemplate(PactVerificationContext context) {
        context.verifyInteraction();
    }

    @BeforeEach
    void before(PactVerificationContext context) {
        context.setTarget(new HttpTestTarget("localhost", 8080));
    }

    @State("payment can be processed")
    void setupPaymentProcessingState() {
        // Setup test data and mocks
        PaymentTestDataBuilder.createValidPaymentScenario();
    }
}

# docker-compose.yml
version: '3.8'
services:
  pact-broker:
    image: pactfoundation/pact-broker:2.100.0
    ports:
      - "9292:9292"
    environment:
      PACT_BROKER_DATABASE_URL: postgres://pact_broker:password@postgres/pact_broker
      PACT_BROKER_BASIC_AUTH_USERNAME: admin
      PACT_BROKER_BASIC_AUTH_PASSWORD: admin123
    depends_on:
      - postgres

  postgres:
    image: postgres:13
    environment:
      POSTGRES_USER: pact_broker
      POSTGRES_PASSWORD: password
      POSTGRES_DB: pact_broker
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

# Publish consumer contracts
npx pact-broker publish \
  --consumer-app-version $BUILD_NUMBER \
  --broker-base-url http://localhost:9292 \
  --broker-username admin \
  --broker-password admin123 \
  ./pacts

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-contract-verifier</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-contract-wiremock</artifactId>
    <scope>test</scope>
</dependency>

<plugin>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-contract-maven-plugin</artifactId>
    <version>3.1.4</version>
    <extensions>true</extensions>
    <configuration>
        <testFramework>JUNIT5</testFramework>
        <packageWithBaseClasses>com.example.contracts</packageWithBaseClasses>
    </configuration>
</plugin>

// process_payment.groovy
package contracts

import org.springframework.cloud.contract.spec.Contract

Contract.make {
    description("should process payment successfully")
    request {
        method 'POST'
        url '/api/v1/payments'
        body([
            amount: 100.00,
            currency: "USD",
            orderId: "order-123"
        ])
        headers {
            contentType(applicationJson())
            header('Authorization', 'Bearer token123')
        }
    }
    response {
        status OK()
        body([
            paymentId: "payment-456",
            status: "completed",
            transactionId: anyAlphaNumeric()
        ])
        headers {
            contentType(applicationJson())
        }
    }
}

// advanced_payment_contract.groovy
Contract.make {
    description("payment with dynamic values")
    request {
        method 'POST'
        url '/api/v1/payments'
        body([
            amount: anyPositiveDouble(),
            currency: $(consumer(regex('[A-Z]{3}')), producer('USD')),
            orderId: $(consumer(regex('order-[0-9]+')), producer('order-123')),
            timestamp: $(consumer(anyIso8601WithOffset()), 
                      producer('2025-01-01T10:00:00Z'))
        ])
        headers {
            contentType(applicationJson())
        }
    }
    response {
        status OK()
        body([
            paymentId: $(producer(regex('payment-[0-9]+')), 
                        consumer('payment-456')),
            status: $(producer(anyOf('completed', 'pending')), 
                     consumer('completed')),
            amount: fromRequest().body('$.amount'),
            currency: fromRequest().body('$.currency')
        ])
        headers {
            contentType(applicationJson())
        }
    }
}

// payment_event_contract.groovy
Contract.make {
    description("should publish payment completed event")
    label 'payment_completed'
    input {
        messageFrom('payment-service')
        messageBody([
            eventType: 'PaymentCompleted',
            paymentId: 'payment-456',
            orderId: 'order-123',
            amount: 100.00,
            currency: 'USD',
            timestamp: anyIso8601WithOffset()
        ])
        messageHeaders {
            header('Content-Type', applicationJson())
            header('X-Event-Type', 'PaymentCompleted')
        }
    }
}

// PaymentContractBase.java
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
public abstract class PaymentContractBase {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private PaymentService paymentService;

    @BeforeEach
    void setup() {
        PaymentResponse mockResponse = PaymentResponse.builder()
            .paymentId("payment-456")
            .status("completed")
            .transactionId("txn-789")
            .build();

        when(paymentService.processPayment(any(PaymentRequest.class)))
            .thenReturn(mockResponse);

        RestAssuredMockMvc.mockMvc(mockMvc);
    }
}

// PaymentMessageContractBase.java
@SpringBootTest
@Import(TestChannelBinderConfiguration.class)
public abstract class PaymentMessageContractBase {

    @Autowired
    private TestChannelBinder testChannelBinder;

    @Autowired
    private PaymentEventPublisher eventPublisher;

    protected void triggerMessage() {
        PaymentCompletedEvent event = PaymentCompletedEvent.builder()
            .eventType("PaymentCompleted")
            .paymentId("payment-456")
            .orderId("order-123")
            .amount(100.00)
            .currency("USD")
            .timestamp(Instant.now())
            .build();

        eventPublisher.publishPaymentCompleted(event);
    }
}

// OrderServiceIntegrationTest.java
@SpringBootTest
@AutoConfigureWireMock(port = 0)
@AutoConfigureStubRunner(
    ids = "com.example:payment-service:+:stubs:${wiremock.server.port}",
    stubsMode = StubRunnerProperties.StubsMode.LOCAL
)
class OrderServiceIntegrationTest {

    @Autowired
    private OrderService orderService;

    @Test
    void shouldProcessOrderWithPayment() {
        Order order = Order.builder()
            .id("order-123")
            .amount(100.00)
            .currency("USD")
            .build();

        OrderResult result = orderService.processOrder(order);

        assertThat(result.getStatus()).isEqualTo("completed");
        assertThat(result.getPaymentId()).isEqualTo("payment-456");
    }
}

// user-service consumer contract
const userServiceContract = {
  consumer: 'user-service',
  provider: 'payment-service',
  interactions: [
    {
      description: 'get user payment methods',
      request: {
        method: 'GET',
        path: '/api/v1/users/user-123/payment-methods'
      },
      response: {
        status: 200,
        body: {
          paymentMethods: [
            {
              id: 'pm-456',
              type: 'credit_card',
              last4: '1234'
            }
          ]
        }
      }
    }
  ]
};

// order-service consumer contract (previously defined)
const orderServiceContract = {
  consumer: 'order-service',
  provider: 'payment-service',
  interactions: [
    // Payment processing interaction
  ]
};

{
  "contractVersion": "2.1.0",
  "compatibilityLevel": "minor",
  "changes": [
    {
      "type": "added",
      "description": "Optional 'metadata' field in response",
      "breaking": false
    }
  ]
}

// CompatibilityValidator.java
@Component
public class ContractCompatibilityValidator {

    public ValidationResult validateBackwardCompatibility(
            Contract newContract, Contract oldContract) {
        
        ValidationResult result = new ValidationResult();
        
        // Validate request compatibility
        validateRequestCompatibility(newContract.getRequest(), 
                                   oldContract.getRequest(), result);
        
        // Validate response compatibility
        validateResponseCompatibility(newContract.getResponse(), 
                                    oldContract.getResponse(), result);
        
        return result;
    }

    private void validateRequestCompatibility(RequestSpec newRequest, 
                                            RequestSpec oldRequest, 
                                            ValidationResult result) {
        // New required fields break compatibility
        Set<String> newRequiredFields = extractRequiredFields(newRequest);
        Set<String> oldRequiredFields = extractRequiredFields(oldRequest);
        
        Set<String> addedRequiredFields = Sets.difference(newRequiredFields, 
                                                          oldRequiredFields);
        
        if (!addedRequiredFields.isEmpty()) {
            result.addBreakingChange(
                "Added required fields: " + addedRequiredFields);
        }
    }

    private void validateResponseCompatibility(ResponseSpec newResponse, 
                                             ResponseSpec oldResponse, 
                                             ValidationResult result) {
        // Removed response fields break compatibility
        Set<String> newResponseFields = extractResponseFields(newResponse);
        Set<String> oldResponseFields = extractResponseFields(oldResponse);
        
        Set<String> removedFields = Sets.difference(oldResponseFields, 
                                                   newResponseFields);
        
        if (!removedFields.isEmpty()) {
            result.addBreakingChange(
                "Removed response fields: " + removedFields);
        }
    }
}

# .github/workflows/contract-testing.yml
name: Contract Testing Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  consumer-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run consumer contract tests
        run: npm run test:contract:consumer

      - name: Publish contracts to Pact Broker
        run: |
          npx pact-broker publish \
            --consumer-app-version $GITHUB_SHA \
            --tag $GITHUB_REF_NAME \
            --broker-base-url ${{ secrets.PACT_BROKER_URL }} \
            --broker-token ${{ secrets.PACT_BROKER_TOKEN }} \
            ./pacts

  provider-tests:
    runs-on: ubuntu-latest
    needs: consumer-tests
    steps:
      - uses: actions/checkout@v3

      - name: Setup Java
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Run provider contract tests
        run: |
          mvn test -Dpact.verifier.publishResults=true \
            -Dpact.provider.version=$GITHUB_SHA \
            -Dpact.provider.tag=$GITHUB_REF_NAME

  can-i-deploy:
    runs-on: ubuntu-latest
    needs: [consumer-tests, provider-tests]
    steps:
      - name: Check deployment readiness
        run: |
          npx pact-broker can-i-deploy \
            --pacticipant order-service \
            --version $GITHUB_SHA \
            --to production \
            --broker-base-url ${{ secrets.PACT_BROKER_URL }} \
            --broker-token ${{ secrets.PACT_BROKER_TOKEN }}

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        PACT_BROKER_URL = credentials('pact-broker-url')
        PACT_BROKER_TOKEN = credentials('pact-broker-token')
    }
    
    stages {
        stage('Consumer Tests') {
            steps {
                script {
                    sh 'npm ci'
                    sh 'npm run test:contract:consumer'
                    
                    // Publish contracts
                    sh """
                        npx pact-broker publish \
                          --consumer-app-version ${BUILD_NUMBER} \
                          --tag ${BRANCH_NAME} \
                          --broker-base-url ${PACT_BROKER_URL} \
                          --broker-token ${PACT_BROKER_TOKEN} \
                          ./pacts
                    """
                }
            }
        }
        
        stage('Provider Tests') {
            steps {
                script {
                    sh """
                        mvn test -Dpact.verifier.publishResults=true \
                          -Dpact.provider.version=${BUILD_NUMBER} \
                          -Dpact.provider.tag=${BRANCH_NAME}
                    """
                }
            }
        }
        
        stage('Can I Deploy?') {
            steps {
                script {
                    def canDeploy = sh(
                        script: """
                            npx pact-broker can-i-deploy \
                              --pacticipant order-service \
                              --version ${BUILD_NUMBER} \
                              --to ${env.DEPLOY_ENVIRONMENT} \
                              --broker-base-url ${PACT_BROKER_URL} \
                              --broker-token ${PACT_BROKER_TOKEN}
                        """,
                        returnStatus: true
                    )
                    
                    if (canDeploy != 0) {
                        error("Deployment blocked by contract verification failures")
                    }
                }
            }
        }
        
        stage('Deploy') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                }
            }
            steps {
                script {
                    sh './deploy.sh'
                    
                    // Record deployment
                    sh """
                        pact-broker record-deployment \
                          --pacticipant order-service \
                          --version ${BUILD_NUMBER} \
                          --environment ${env.DEPLOY_ENVIRONMENT}
                    """
                }
            }
        }
    }
}

# .gitlab-ci.yml
stages:
  - test
  - verify
  - deploy

variables:
  PACT_BROKER_URL: $PACT_BROKER_URL
  PACT_BROKER_TOKEN: $PACT_BROKER_TOKEN

consumer-contract-tests:
  stage: test
  image: node:18
  script:
    - npm ci
    - npm run test:contract:consumer
    - |
      npx pact-broker publish \
        --consumer-app-version $CI_COMMIT_SHA \
        --tag $CI_COMMIT_REF_NAME \
        --broker-base-url $PACT_BROKER_URL \
        --broker-token $PACT_BROKER_TOKEN \
        ./pacts
  artifacts:
    reports:
      junit: test-results.xml
    paths:
      - pacts/

provider-contract-tests:
  stage: verify
  image: maven:3.8-openjdk-17
  script:
    - |
      mvn test -Dpact.verifier.publishResults=true \
        -Dpact.provider.version=$CI_COMMIT_SHA \
        -Dpact.provider.tag=$CI_COMMIT_REF_NAME
  dependencies:
    - consumer-contract-tests

deployment-gate:
  stage: verify
  image: node:18
  script:
    - |
      npx pact-broker can-i-deploy \
        --pacticipant order-service \
        --version $CI_COMMIT_SHA \
        --to production \
        --broker-base-url $PACT_BROKER_URL \
        --broker-token $PACT_BROKER_TOKEN
  only:
    - main

deploy-production:
  stage: deploy
  script:
    - ./deploy.sh production
    - |
      pact-broker record-deployment \
        --pacticipant order-service \
        --version $CI_COMMIT_SHA \
        --environment production
  only:
    - main
  dependencies:
    - deployment-gate

# Multiple consumer versions testing
matrix-consumer-tests:
  strategy:
    matrix:
      consumer-version: ['v1.0', 'v1.1', 'v2.0']
      provider-version: ['latest', 'stable']
  steps:
    - name: Test consumer ${{ matrix.consumer-version }} against provider ${{ matrix.provider-version }}
      run: |
        npx pact-broker can-i-deploy \
          --pacticipant consumer-service \
          --version ${{ matrix.consumer-version }} \
          --pacticipant provider-service \
          --version ${{ matrix.provider-version }}

{
  "webhooks": [
    {
      "description": "Trigger provider build on contract change",
      "events": [
        "contract_content_changed"
      ],
      "request": {
        "method": "POST",
        "url": "https://api.github.com/repos/company/provider-service/dispatches",
        "headers": {
          "Content-Type": "application/json",
          "Authorization": "token ${user.githubToken}"
        },
        "body": {
          "event_type": "pact_changed",
          "client_payload": {
            "pact_url": "${pactbroker.pactUrl}"
          }
        }
      }
    }
  ]
}

// Performance benchmarking for Pact tests
const { performance } = require('perf_hooks');

describe('Pact Performance Analysis', () => {
  let performanceMetrics = [];

  beforeEach(() => {
    performanceMetrics = [];
  });

  afterEach(() => {
    const avgExecutionTime = performanceMetrics.reduce((a, b) => a + b, 0) / performanceMetrics.length;
    console.log(`Average test execution time: ${avgExecutionTime.toFixed(2)}ms`);
  });

  it('measures contract test performance', async () => {
    const startTime = performance.now();
    
    // Execute contract test
    await provider.addInteraction(largePayloadInteraction);
    const client = new PaymentClient('http://localhost:1234');
    await client.processLargePayment(largePaymentRequest);
    
    const endTime = performance.now();
    performanceMetrics.push(endTime - startTime);
  });
});

// Performance testing configuration
@TestMethodOrder(OrderAnnotation.class)
class ContractPerformanceTest extends PaymentContractBase {

    private static final List<Long> executionTimes = new ArrayList<>();

    @Test
    @Order(1)
    @RepeatedTest(100)
    void measureContractTestPerformance() {
        long startTime = System.nanoTime();
        
        // Contract test execution happens automatically
        // through generated tests
        
        long endTime = System.nanoTime();
        executionTimes.add((endTime - startTime) / 1_000_000); // Convert to ms
    }

    @Test
    @Order(2)
    void analyzePerformanceMetrics() {
        double averageTime = executionTimes.stream()
            .mapToLong(Long::longValue)
            .average()
            .orElse(0.0);

        double p95 = calculatePercentile(executionTimes, 0.95);
        double p99 = calculatePercentile(executionTimes, 0.99);

        System.out.printf("Average execution time: %.2f ms%n", averageTime);
        System.out.printf("95th percentile: %.2f ms%n", p95);
        System.out.printf("99th percentile: %.2f ms%n", p99);

        // Assert performance requirements
        assertThat(averageTime).isLessThan(100.0);
        assertThat(p95).isLessThan(200.0);
    }
}

<!-- Maven Surefire configuration for parallel execution -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <parallel>methods</parallel>
        <threadCount>4</threadCount>
        <forkCount>2</forkCount>
        <reuseForks>true</reuseForks>
    </configuration>
</plugin>

// Efficient test data setup
@TestConfiguration
public class ContractTestConfiguration {

    @Bean
    @Primary
    public PaymentService mockPaymentService() {
        return Mockito.mock(PaymentService.class);
    }

    @Bean
    public TestDataBuilder testDataBuilder() {
        return TestDataBuilder.builder()
            .withCaching(true)
            .withPoolSize(10)
            .build();
    }
}

@Component
public class TestDataBuilder {
    
    private final Map<String, Object> dataCache = new ConcurrentHashMap<>();
    
    public PaymentResponse getOrCreatePaymentResponse(String scenarioId) {
        return (PaymentResponse) dataCache.computeIfAbsent(scenarioId, 
            id -> createPaymentResponse());
    }
    
    private PaymentResponse createPaymentResponse() {
        return PaymentResponse.builder()
            .paymentId("payment-" + UUID.randomUUID())
            .status("completed")
            .transactionId("txn-" + UUID.randomUUID())
            .build();
    }
}

// Resource-efficient Pact testing
class OptimizedPactRunner {
  constructor() {
    this.providerPool = [];
    this.maxProviders = 3;
  }

  async getProvider() {
    if (this.providerPool.length < this.maxProviders) {
      const provider = new Pact({
        consumer: 'order-service',
        provider: 'payment-service',
        port: 1234 + this.providerPool.length,
        log: './logs/pact.log',
        logLevel: 'WARN', // Reduce logging overhead
        spec: 2
      });
      
      await provider.setup();
      this.providerPool.push(provider);
      return provider;
    }
    
    return this.providerPool[Math.floor(Math.random() * this.providerPool.length)];
  }

  async cleanup() {
    await Promise.all(this.providerPool.map(provider => provider.finalize()));
    this.providerPool = [];
  }
}

# JVM optimization for contract tests
export MAVEN_OPTS="-Xmx2g -Xms1g -XX:+UseG1GC -XX:+UseStringDeduplication"

# Contract-specific optimizations
mvn test -Dspring.jpa.hibernate.ddl-auto=none \
         -Dspring.datasource.initialize=false \
         -Dspring.cloud.contract.verifier.skip-wire-mock-server=true

# contract-version.yml
contractMetadata:
  version: "2.1.0"
  compatibility: "backward"
  deprecations:
    - field: "oldPaymentMethod"
      removedIn: "3.0.0"
      migration: "Use 'paymentMethod' instead"
  
changes:
  "2.1.0":
    - type: "addition"
      description: "Added optional 'metadata' field"
      breaking: false
    - type: "deprecation"
      description: "Deprecated 'oldPaymentMethod' field"
      breaking: false
  
  "2.0.0":
    - type: "removal"
      description: "Removed 'legacyId' field"
      breaking: true
    - type: "modification"
      description: "Changed 'amount' from string to number"
      breaking: true

// ContractMigrationService.java
@Service
public class ContractMigrationService {

    private final Map<String, ContractMigrator> migrators = Map.of(
        "1.0->2.0", new PaymentV1ToV2Migrator(),
        "2.0->2.1", new PaymentV2ToV2_1Migrator()
    );

    public Contract migrateContract(Contract contract, String targetVersion) {
        String currentVersion = contract.getMetadata().getVersion();
        String migrationKey = currentVersion + "->" + targetVersion;
        
        ContractMigrator migrator = migrators.get(migrationKey);
        if (migrator == null) {
            throw new UnsupportedOperationException(
                "No migration path from " + currentVersion + " to " + targetVersion);
        }
        
        return migrator.migrate(contract);
    }
}

// Specific migrator implementation
public class PaymentV1ToV2Migrator implements ContractMigrator {
    
    @Override
    public Contract migrate(Contract contract) {
        return contract.toBuilder()
            .interactions(contract.getInteractions().stream()
                .map(this::migrateInteraction)
                .collect(Collectors.toList()))
            .metadata(contract.getMetadata().toBuilder()
                .version("2.0")
                .build())
            .build();
    }
    
    private Interaction migrateInteraction(Interaction interaction) {
        // Transform request structure
        JsonNode requestBody = interaction.getRequest().getBody();
        ObjectNode migratedRequest = ((ObjectNode) requestBody)
            .remove("legacyId"); // Remove deprecated field
            
        // Convert amount from string to number
        if (requestBody.has("amount")) {
            String amountStr = requestBody.get("amount").asText();
            migratedRequest.put("amount", Double.parseDouble(amountStr));
        }
        
        return interaction.toBuilder()
            .request(interaction.getRequest().toBuilder()
                .body(migratedRequest)
                .build())
            .build();
    }
}

// compatibility-test.js
describe('Contract Compatibility Tests', () => {
  const versions = ['1.0', '1.1', '2.0', '2.1'];
  
  versions.forEach(version => {
    describe(`Version ${version} compatibility`, () => {
      it('should maintain backward compatibility', async () => {
        const oldContract = await loadContract(`payment-service-${version}.json`);
        const newContract = await loadContract('payment-service-latest.json');
        
        const compatibility = await validateCompatibility(oldContract, newContract);
        
        expect(compatibility.isBackwardCompatible).toBe(true);
        expect(compatibility.breakingChanges).toHaveLength(0);
      });
      
      it('should support graceful degradation', async () => {
        const provider = new Pact({
          consumer: 'order-service',
          provider: 'payment-service',
          port: 1234,
          spec: 2
        });
        
        await provider.setup();
        
        // Test with old contract format
        await provider.addInteraction(createLegacyInteraction(version));
        
        const client = new PaymentClient('http://localhost:1234');
        const response = await client.processPaymentLegacy({
          amount: "100.00", // String format in old versions
          currency: "USD",
          legacyId: "legacy-123" // Deprecated field
        });
        
        expect(response).toBeDefined();
        await provider.verify();
        await provider.finalize();
      });
    });
  });
});

// Feature flag support in contracts
@Contract
public class PaymentContractWithFeatureFlags extends PaymentContractBase {

    @Autowired
    private FeatureFlagService featureFlagService;

    @State("new payment flow enabled")
    void enableNewPaymentFlow() {
        when(featureFlagService.isEnabled("new-payment-flow")).thenReturn(true);
    }

    @State("legacy payment flow active")
    void enableLegacyPaymentFlow() {
        when(featureFlagService.isEnabled("new-payment-flow")).thenReturn(false);
    }
}

# contract-lifecycle.yml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: contract-cleanup
spec:
  schedule: "0 2 * * 0" # Weekly on Sunday at 2 AM
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: contract-cleanup
            image: pact-tools:latest
            command:
            - /bin/sh
            - -c
            - |
              # Remove contracts older than 6 months
              pact-broker delete-versions \
                --broker-base-url $PACT_BROKER_URL \
                --broker-token $PACT_BROKER_TOKEN \
                --older-than "6 months" \
                --keep-min-versions 10
              
              # Clean up unused tags
              pact-broker clean-tags \
                --broker-base-url $PACT_BROKER_URL \
                --broker-token $PACT_BROKER_TOKEN \
                --older-than "3 months"
            env:
            - name: PACT_BROKER_URL
              valueFrom:
                secretKeyRef:
                  name: pact-config
                  key: broker-url
            - name: PACT_BROKER_TOKEN
              valueFrom:
                secretKeyRef:
                  name: pact-config
                  key: broker-token
          restartPolicy: OnFailure

// ContractTestMetrics.java
@Component
public class ContractTestMetrics {

    private final MeterRegistry meterRegistry;
    private final Counter contractTestSuccesses;
    private final Counter contractTestFailures;
    private final Timer contractTestDuration;
    private final Gauge contractCoverage;

    public ContractTestMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.contractTestSuccesses = Counter.builder("contract.test.success")
            .description("Number of successful contract tests")
            .tag("type", "verification")
            .register(meterRegistry);
            
        this.contractTestFailures = Counter.builder("contract.test.failure")
            .description("Number of failed contract tests")
            .tag("type", "verification")
            .register(meterRegistry);
            
        this.contractTestDuration = Timer.builder("contract.test.duration")
            .description("Contract test execution time")
            .register(meterRegistry);
            
        this.contractCoverage = Gauge.builder("contract.coverage.percentage")
            .description("Contract coverage percentage")
            .register(meterRegistry, this, ContractTestMetrics::calculateCoverage);
    }

    public void recordSuccess(String contractName, Duration duration) {
        contractTestSuccesses.increment(Tags.of("contract", contractName));
        contractTestDuration.record(duration);
    }

    public void recordFailure(String contractName, String errorType) {
        contractTestFailures.increment(Tags.of(
            "contract", contractName,
            "error_type", errorType
        ));
    }

    private double calculateCoverage() {
        // Calculate based on covered vs total interactions
        return ContractCoverageCalculator.calculateCoverage();
    }
}

# prometheus-alerts.yml
groups:
- name: contract-testing
  rules:
  - alert: ContractTestFailureRateHigh
    expr: rate(contract_test_failure_total[5m]) > 0.1
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "High contract test failure rate"
      description: "Contract test failure rate is {{ $value }} failures per second"

  - alert: ContractVerificationFailed
    expr: increase(contract_test_failure_total[1h]) > 5
    for: 0m
    labels:
      severity: critical
    annotations:
      summary: "Multiple contract verification failures"
      description: "{{ $value }} contract verifications have failed in the last hour"

  - alert: ContractCoverageLow
    expr: contract_coverage_percentage < 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Contract test coverage below threshold"
      description: "Contract coverage is {{ $value }}%, below the 80% threshold"

#!/bin/bash
# deployment-gate.sh

set -e

SERVICE_NAME=$1
VERSION=$2
ENVIRONMENT=$3

echo "Checking deployment readiness for $SERVICE_NAME:$VERSION to $ENVIRONMENT"

# Check contract verification status
VERIFICATION_STATUS=$(pact-broker can-i-deploy \
  --pacticipant "$SERVICE_NAME" \
  --version "$VERSION" \
  --to "$ENVIRONMENT" \
  --broker-base-url "$PACT_BROKER_URL" \
  --broker-token "$PACT_BROKER_TOKEN" \
  --output json)

if echo "$VERIFICATION_STATUS" | jq -e '.summary.deployable == false' > /dev/null; then
  echo "❌ Deployment blocked by contract verification failures"
  echo "$VERIFICATION_STATUS" | jq '.summary.reason'
  exit 1
fi

# Check contract coverage
COVERAGE=$(curl -s -H "Authorization: Bearer $PACT_BROKER_TOKEN" \
  "$PACT_BROKER_URL/contracts/$SERVICE_NAME/coverage" | jq '.percentage')

if (( $(echo "$COVERAGE < 80" | bc -l) )); then
  echo "⚠️  Warning: Contract coverage is below 80% ($COVERAGE%)"
  if [[ "$ENVIRONMENT" == "production" ]]; then
    echo "❌ Production deployment requires minimum 80% contract coverage"
    exit 1
  fi
fi

# Validate backward compatibility
COMPATIBILITY_CHECK=$(curl -s -H "Authorization: Bearer $PACT_BROKER_TOKEN" \
  "$PACT_BROKER_URL/contracts/$SERVICE_NAME/$VERSION/compatibility")

if echo "$COMPATIBILITY_CHECK" | jq -e '.breaking_changes | length > 0' > /dev/null; then
  echo "❌ Breaking changes detected in contracts"
  echo "$COMPATIBILITY_CHECK" | jq '.breaking_changes'
  exit 1
fi

echo "✅ All contract verification checks passed"
echo "🚀 Deployment approved for $SERVICE_NAME:$VERSION to $ENVIRONMENT"

# contract-maintenance.py
import requests
import json
from datetime import datetime, timedelta

class ContractMaintenanceService:
    def __init__(self, broker_url, broker_token):
        self.broker_url = broker_url
        self.broker_token = broker_token
        self.headers = {
            'Authorization': f'Bearer {broker_token}',
            'Content-Type': 'application/json'
        }

    def audit_contract_health(self):
        """Audit contract health across all services"""
        services = self._get_all_services()
        health_report = {}
        
        for service in services:
            health_report[service] = {
                'contract_count': self._get_contract_count(service),
                'verification_status': self._get_verification_status(service),
                'last_updated': self._get_last_update_time(service),
                'coverage': self._calculate_coverage(service)
            }
        
        return health_report

    def identify_stale_contracts(self, days_threshold=30):
        """Identify contracts that haven't been updated recently"""
        cutoff_date = datetime.now() - timedelta(days=days_threshold)
        stale_contracts = []
        
        contracts = self._get_all_contracts()
        for contract in contracts:
            last_updated = datetime.fromisoformat(contract['lastUpdated'])
            if last_updated < cutoff_date:
                stale_contracts.append({
                    'consumer': contract['consumer'],
                    'provider': contract['provider'],
                    'last_updated': contract['lastUpdated'],
                    'age_days': (datetime.now() - last_updated).days
                })
        
        return stale_contracts

    def suggest_contract_optimizations(self):
        """Suggest optimizations for contract test suite"""
        optimizations = []
        
        # Identify duplicate interactions
        duplicates = self._find_duplicate_interactions()
        if duplicates:
            optimizations.append({
                'type': 'duplicate_removal',
                'impact': 'medium',
                'description': f'Found {len(duplicates)} duplicate interactions',
                'details': duplicates
            })
        
        # Identify overly complex contracts
        complex_contracts = self._find_complex_contracts()
        if complex_contracts:
            optimizations.append({
                'type': 'complexity_reduction',
                'impact': 'high',
                'description': 'Complex contracts found that could be simplified',
                'details': complex_contracts
            })
        
        return optimizations

    def _get_all_services(self):
        response = requests.get(f'{self.broker_url}/pacticipants', headers=self.headers)
        return [p['name'] for p in response.json()['pacticipants']]

    def _get_contract_count(self, service):
        response = requests.get(f'{self.broker_url}/pacts/provider/{service}', headers=self.headers)
        return len(response.json().get('pacts', []))

    def _get_verification_status(self, service):
        response = requests.get(f'{self.broker_url}/verification-results/provider/{service}/latest', headers=self.headers)
        return response.json().get('success', False)

// contract-docs-generator.js
const fs = require('fs').promises;
const path = require('path');

class ContractDocumentationGenerator {
  constructor(pactBrokerUrl, brokerToken) {
    this.brokerUrl = pactBrokerUrl;
    this.brokerToken = brokerToken;
  }

  async generateDocumentation() {
    const contracts = await this.fetchAllContracts();
    const documentation = {
      generatedAt: new Date().toISOString(),
      services: {}
    };

    for (const contract of contracts) {
      const serviceName = contract.provider.name;
      
      if (!documentation.services[serviceName]) {
        documentation.services[serviceName] = {
          name: serviceName,
          consumers: [],
          endpoints: []
        };
      }

      documentation.services[serviceName].consumers.push({
        name: contract.consumer.name,
        version: contract.consumer.version,
        interactions: contract.interactions.length
      });

      for (const interaction of contract.interactions) {
        const endpoint = {
          method: interaction.request.method,
          path: interaction.request.path,
          description: interaction.description,
          request: this.formatRequestDoc(interaction.request),
          response: this.formatResponseDoc(interaction.response)
        };

        documentation.services[serviceName].endpoints.push(endpoint);
      }
    }

    await this.writeDocumentation(documentation);
    return documentation;
  }

  formatRequestDoc(request) {
    return {
      headers: request.headers || {},
      body: this.formatBodyDoc(request.body),
      queryParams: request.query || {}
    };
  }

  formatResponseDoc(response) {
    return {
      status: response.status,
      headers: response.headers || {},
      body: this.formatBodyDoc(response.body)
    };
  }

  formatBodyDoc(body) {
    if (!body) return null;
    
    // Extract schema from body
    const schema = this.extractSchema(body);
    return {
      schema: schema,
      example: body
    };
  }

  extractSchema(obj, depth = 0) {
    if (depth > 3) return 'object'; // Prevent infinite recursion
    
    if (Array.isArray(obj)) {
      return obj.length > 0 ? [this.extractSchema(obj[0], depth + 1)] : [];
    }
    
    if (typeof obj === 'object' && obj !== null) {
      const schema = {};
      for (const [key, value] of Object.entries(obj)) {
        schema[key] = this.extractSchema(value, depth + 1);
      }
      return schema;
    }
    
    return typeof obj;
  }

  async writeDocumentation(documentation) {
    const markdownDoc = this.generateMarkdown(documentation);
    await fs.writeFile('contract-documentation.md', markdownDoc);
    
    const jsonDoc = JSON.stringify(documentation, null, 2);
    await fs.writeFile('contract-documentation.json', jsonDoc);
  }

  generateMarkdown(documentation) {
    let markdown = '# Contract Documentation\n\n';
    markdown += `Generated on: ${documentation.generatedAt}\n\n`;
    
    for (const [serviceName, service] of Object.entries(documentation.services)) {
      markdown += `## ${serviceName}\n\n`;
      
      markdown += '### Consumers\n\n';
      service.consumers.forEach(consumer => {
        markdown += `- **${consumer.name}** (v${consumer.version}) - ${consumer.interactions} interactions\n`;
      });
      
      markdown += '\n### Endpoints\n\n';
      service.endpoints.forEach(endpoint => {
        markdown += `#### ${endpoint.method} ${endpoint.path}\n\n`;
        markdown += `${endpoint.description}\n\n`;
        
        if (endpoint.request.body) {
          markdown += '**Request Body:**\n```json\n';
          markdown += JSON.stringify(endpoint.request.body.example, null, 2);
          markdown += '\n```\n\n';
        }
        
        markdown += '**Response:**\n```json\n';
        markdown += JSON.stringify(endpoint.response.body.example, null, 2);
        markdown += '\n```\n\n';
      });
    }
    
    return markdown;
  }
}