API Testing Automation: REST, GraphQL, and Microservices

API Testing Fundamentals

API testing is crucial for modern applications, especially in microservices architectures. This guide covers automated testing of REST APIs, GraphQL endpoints, and microservice interactions.

Types of API Testing

• Functional Testing: Verify API endpoints work correctly
• Performance Testing: Test API response times and throughput
• Security Testing: Validate authentication and authorization
• Contract Testing: Ensure API contracts are maintained
• Integration Testing: Test API interactions with other services

REST API Testing with Postman

// Postman Collection Example
{
    "info": {
        "name": "User API Tests",
        "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
    },
    "item": [
        {
            "name": "Create User",
            "request": {
                "method": "POST",
                "header": [
                    {
                        "key": "Content-Type",
                        "value": "application/json"
                    }
                ],
                "body": {
                    "mode": "raw",
                    "raw": "{
  "name": "John Doe",
  "email": "john@example.com"
}"
                },
                "url": {
                    "raw": "{{baseUrl}}/users",
                    "host": ["{{baseUrl}}"],
                    "path": ["users"]
                }
            },
            "response": [
                {
                    "name": "Success Response",
                    "originalRequest": {
                        "method": "POST",
                        "header": [],
                        "body": {
                            "mode": "raw",
                            "raw": "{
  "name": "John Doe",
  "email": "john@example.com"
}"
                        },
                        "url": {
                            "raw": "{{baseUrl}}/users",
                            "host": ["{{baseUrl}}"],
                            "path": ["users"]
                        }
                    },
                    "status": "Created",
                    "code": 201,
                    "_postman_previewlanguage": "json",
                    "header": [
                        {
                            "key": "Content-Type",
                            "value": "application/json"
                        }
                    ],
                    "cookie": [],
                    "body": "{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com",
  "created_at": "2024-01-01T00:00:00Z"
}"
                }
            ]
        }
    ]
}

GraphQL Testing with JavaScript

// GraphQL Testing Example
const axios = require('axios');

async function testGraphQLQuery() {
    const query = `
        query GetUser($id: ID!) {
            user(id: $id) {
                id
                name
                email
                posts {
                    id
                    title
                }
            }
        }
    `;
    
    const variables = { id: "1" };
    
    try {
        const response = await axios.post('https://api.example.com/graphql', {
            query,
            variables
        });
        
        console.log('Response:', response.data);
        
        // Assertions
        expect(response.status).toBe(200);
        expect(response.data.data.user).toBeDefined();
        expect(response.data.data.user.name).toBe('John Doe');
    } catch (error) {
        console.error('GraphQL test failed:', error);
    }
}

Contract Testing with Pact

// Pact Contract Testing Example
const { Pact } = require('@pact-foundation/pact');
const axios = require('axios');

describe('User API Contract', () => {
    let provider;
    
    beforeAll(async () => {
        provider = new Pact({
            consumer: 'UserService',
            provider: 'UserAPI',
            port: 1234,
            log: './logs/pact.log',
            dir: './pacts'
        });
        
        await provider.setup();
    });
    
    afterAll(async () => {
        await provider.finalize();
    });
    
    it('should create a user', async () => {
        await provider.addInteraction({
            state: 'user does not exist',
            uponReceiving: 'a request to create a user',
            withRequest: {
                method: 'POST',
                path: '/users',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: {
                    name: 'John Doe',
                    email: 'john@example.com'
                }
            },
            willRespondWith: {
                status: 201,
                headers: {
                    'Content-Type': 'application/json'
                },
                body: {
                    id: 1,
                    name: 'John Doe',
                    email: 'john@example.com'
                }
            }
        });
        
        const response = await axios.post('http://localhost:1234/users', {
            name: 'John Doe',
            email: 'john@example.com'
        });
        
        expect(response.status).toBe(201);
        expect(response.data.id).toBe(1);
    });
});

Microservices Testing Strategies

• Unit Testing: Test individual service components
• Integration Testing: Test service interactions
• Contract Testing: Ensure service contracts are maintained
• End-to-End Testing: Test complete user journeys
• Chaos Testing: Test system resilience

API Testing Best Practices

• Test all HTTP methods (GET, POST, PUT, DELETE)
• Validate response status codes and headers
• Test error scenarios and edge cases
• Use environment-specific test data
• Implement API versioning strategies
• Monitor API performance and reliability

Recommended Tools

• Postman: API development and testing platform
• Newman: Command-line collection runner for Postman
• REST Assured: Java library for REST API testing
• Supertest: Node.js library for HTTP testing
• Pact: Contract testing framework

Recommended Books

• "API Testing and Development with Postman" by Dave Westerveld
• "Testing Microservices" by Mark Winteringham
• "GraphQL in Action" by Samer Buna