API Test Automation Project: Build a Complete Testing Suite

// postman/collections/dodatech-smoke.json (simplified)
{
    "info": {
        "name": "DodaTech Smoke Tests",
        "description": "Critical path smoke tests for every deployment"
    },
    "item": [
        {
            "name": "Health Check",
            "event": [
                {
                    "listen": "test",
                    "script": {
                        "exec": [
                            "pm.test('Health endpoint returns 200', function () {",
                            "    pm.response.to.have.status(200);",
                            "});",
                            "pm.test('Response time < 500ms', function () {",
                            "    pm.expect(pm.response.responseTime).to.be.below(500);",
                            "});"
                        ]
                    }
                }
            ],
            "request": {
                "method": "GET",
                "url": "{{base_url}}/health"
            }
        }
    ]
}

# postman/ci/run-smoke.sh
#!/bin/bash
newman run collections/dodatech-smoke.json \
  -e environments/staging.json \
  --reporters cli,junit \
  --reporter-junit-export results/smoke.xml \
  --timeout-request 10000
echo "Smoke tests complete. Exit code: $?"

# pytest-tests/tests/test_payments.py
import allure
import pytest
from core.base_test import BaseAPITest

@allure.epic("Payment Processing")
@allure.feature("Stripe Integration")
class TestPaymentAPI(BaseAPITest):

    @allure.story("Create Payment")
    @allure.severity(allure.severity_level.BLOCKER)
    def test_create_payment_success(self):
        with allure.step("Prepare payment data"):
            payment_data = {
                "order_id": "ORD-TEST-123",
                "amount": 2999,
                "currency": "usd",
                "card_token": "tok_visa"
            }

        with allure.step("Send payment request"):
            response = self.client.post("/payments", json=payment_data)

        with allure.step("Verify payment created"):
            self.assert_status(response, 201)
            data = response.json()
            assert data["status"] == "succeeded"
            assert data["amount"] == 2999

    @allure.story("Payment Validation")
    @pytest.mark.parametrize("payload,expected_status", [
        ({"amount": -1}, 400),
        ({"amount": 0}, 400),
        ({"currency": "invalid"}, 400),
        ({}, 400),
    ])
    def test_payment_validation(self, payload, expected_status):
        response = self.client.post("/payments", json=payload)
        self.assert_status(response, expected_status)

    @allure.story("Payment Error Handling")
    def test_payment_card_declined(self):
        response = self.client.post("/payments", json={
            "order_id": "ORD-DECLINED",
            "amount": 5000,
            "card_token": "tok_chargeDeclined"
        })
        self.assert_status(response, 402)
        assert "declined" in response.json()["error"].lower()

// load-tests/scripts/checkout-flow.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const checkoutDuration = new Trend('checkout_duration');
const errorRate = new Rate('checkout_errors');

export const options = {
    stages: [
        { duration: '1m', target: 50 },
        { duration: '3m', target: 50 },
        { duration: '1m', target: 100 },
        { duration: '3m', target: 100 },
        { duration: '1m', target: 0 },
    ],
    thresholds: {
        http_req_duration: ['p(95)<1000', 'p(99)<2000'],
        checkout_duration: ['p(95)<1500'],
        checkout_errors: ['rate<0.02'],
    },
};

const BASE_URL = __ENV.BASE_URL || 'https://api.staging.dodatech.com';

export default function () {
    // Simulate checkout flow
    const productResp = http.get(`${BASE_URL}/v1/products?limit=1`);
    check(productResp, { 'products fetched': (r) => r.status === 200 });

    if (productResp.json().length > 0) {
        const product = productResp.json()[0];
        sleep(1);

        const cartResp = http.post(`${BASE_URL}/v1/cart`, JSON.stringify({
            product_id: product.id,
            quantity: 1,
        }), { headers: { 'Content-Type': 'application/json' } });
        check(cartResp, { 'item added to cart': (r) => r.status === 200 });

        sleep(2);

        const start = Date.now();
        const checkoutResp = http.post(`${BASE_URL}/v1/checkout`, '{}');
        checkoutDuration.add(Date.now() - start);
        check(checkoutResp, { 'checkout completed': (r) => r.status === 200 });

        if (checkoutResp.status !== 200) {
            errorRate.add(1);
        }
    }

    sleep(3);
}

# .github/workflows/api-test-pipeline.yml
name: API Test Pipeline
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  smoke:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Smoke Tests
        run: |
          npm install -g newman
          bash postman/ci/run-smoke.sh
      - uses: actions/upload-artifact@v4
        with:
          name: smoke-results
          path: postman/ci/results/

  integration:
    needs: smoke
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: test
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - run: |
          pip install -r pytest-tests/requirements.txt
          pytest pytest-tests/tests/ \
            --alluredir=allure-results \
            -n auto -v
      - uses: actions/upload-artifact@v4
        with:
          name: allure-results
          path: allure-results/

  contract:
    needs: integration
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: |
          pip install pact-python
          python contract-tests/provider/verify_contracts.py

  load:
    needs: contract
    runs-on: ubuntu-latest
    steps:
      - uses: actions/setup-python@v5
      - name: Load Tests
        run: |
          sudo apt-get install -y k6
          k6 run load-tests/scripts/checkout-flow.js \
            --out json=load-results.json
      - uses: actions/upload-artifact@v4
        with:
          name: load-results
          path: load-results.json

  deploy:
    needs: [smoke, integration, contract, load]
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - run: echo "Deploying to production"