API Test Generation

I'll generate comprehensive API tests for your REST or GraphQL endpoints with proper validation and assertions.

Features:

• Auto-detect API framework (Express, FastAPI, Next.js API routes)
• Generate request/response tests
• Schema validation
• Error handling tests
• Authentication tests

Phase 1: API Framework Detection

# Detect API framework efficiently
detect_api_framework() {
    if [ -f "package.json" ]; then
        if grep -q "\"express\"" package.json; then
            echo "express"
        elif grep -q "\"fastify\"" package.json; then
            echo "fastify"
        elif grep -q "\"next\"" package.json; then
            echo "nextjs"
        elif grep -q "\"@apollo/server\"" package.json; then
            echo "apollo"
        fi
    elif [ -f "requirements.txt" ]; then
        if grep -q "fastapi" requirements.txt; then
            echo "fastapi"
        elif grep -q "flask" requirements.txt; then
            echo "flask"
        elif grep -q "django" requirements.txt; then
            echo "django"
        fi
    elif [ -f "go.mod" ]; then
        if grep -q "gin-gonic" go.mod; then
            echo "gin"
        elif grep -q "fiber" go.mod; then
            echo "fiber"
        fi
    fi
}

FRAMEWORK=$(detect_api_framework)

if [ -z "$FRAMEWORK" ]; then
    echo "❌ No API framework detected"
    echo "Supported frameworks:"
    echo "  Node: Express, Fastify, Next.js API routes, Apollo"
    echo "  Python: FastAPI, Flask, Django"
    echo "  Go: Gin, Fiber"
    exit 1
fi

echo "✓ API Framework: $FRAMEWORK"

Phase 2: Endpoint Discovery

echo ""
echo "Discovering API endpoints..."

# Use Grep to find endpoints efficiently
case $FRAMEWORK in
    express|fastify)
        ENDPOINTS=$(grep -r "\.get\(\\|\.post\(\\|\.put\(\\|\.delete\(\\|\.patch\(" \
                         --include="*.js" --include="*.ts" \
                         --exclude-dir=node_modules \
                         . | head -20)
        ;;
    nextjs)
        # Next.js API routes are file-based
        ENDPOINTS=$(find pages/api app/api -name "*.ts" -o -name "*.js" 2>/dev/null | head -20)
        ;;
    apollo)
        # GraphQL resolvers
        ENDPOINTS=$(grep -r "Query\\|Mutation" --include="*.ts" --include="*.js" \
                         --exclude-dir=node_modules . | head -20)
        ;;
    fastapi)
        ENDPOINTS=$(grep -r "@app\.\(get\|post\|put\|delete\|patch\)" --include="*.py" . | head -20)
        ;;
    flask)
        ENDPOINTS=$(grep -r "@app\.route" --include="*.py" . | head -20)
        ;;
    django)
        ENDPOINTS=$(find . -name "urls.py" -o -name "views.py" | head -20)
        ;;
esac

if [ -z "$ENDPOINTS" ]; then
    echo "⚠️ No API endpoints found"
    exit 1
fi

ENDPOINT_COUNT=$(echo "$ENDPOINTS" | wc -l)
echo "✓ Found $ENDPOINT_COUNT endpoints"
echo ""
echo "Sample endpoints:"
echo "$ENDPOINTS" | head -5 | sed 's/^/  /'

Phase 3: Test Framework Setup

echo ""
echo "Setting up test framework..."

# Detect or install test framework
if [ "$FRAMEWORK" = "express" ] || [ "$FRAMEWORK" = "fastify" ] || [ "$FRAMEWORK" = "nextjs" ]; then
    # Node.js - use supertest + jest
    if ! grep -q "\"supertest\"" package.json; then
        echo "Installing supertest for API testing..."
        npm install --save-dev supertest @types/supertest
    fi

    if ! grep -q "\"jest\"" package.json; then
        echo "Installing Jest..."
        npm install --save-dev jest ts-jest @types/jest
    fi

    echo "✓ Test framework ready: Jest + Supertest"

elif [ "$FRAMEWORK" = "fastapi" ] || [ "$FRAMEWORK" = "flask" ]; then
    # Python - use pytest + requests
    if ! grep -q "pytest" requirements.txt 2>/dev/null; then
        echo "Add to requirements.txt: pytest requests"
    fi

    echo "✓ Test framework: Pytest"
fi

Phase 4: Generate Test Files

echo ""
echo "Generating test files..."

mkdir -p tests/api

# Generate test file based on framework
case $FRAMEWORK in
    express|fastapi)
        cat > tests/api/endpoints.test.ts << 'EOF'
import request from 'supertest';
import app from '../src/app'; // Adjust path to your app

describe('API Endpoints', () => {
  describe('GET /api/health', () => {
    it('should return 200 OK', async () => {
      const response = await request(app)
        .get('/api/health')
        .expect(200);

      expect(response.body).toHaveProperty('status');
      expect(response.body.status).toBe('ok');
    });
  });

  describe('GET /api/users', () => {
    it('should return list of users', async () => {
      const response = await request(app)
        .get('/api/users')
        .expect(200);

      expect(Array.isArray(response.body)).toBe(true);
      if (response.body.length > 0) {
        expect(response.body[0]).toHaveProperty('id');
        expect(response.body[0]).toHaveProperty('name');
        expect(response.body[0]).toHaveProperty('email');
      }
    });

    it('should handle query parameters', async () => {
      const response = await request(app)
        .get('/api/users?limit=10&offset=0')
        .expect(200);

      expect(response.body.length).toBeLessThanOrEqual(10);
    });
  });

  describe('POST /api/users', () => {
    it('should create new user', async () => {
      const newUser = {
        name: 'Test User',
        email: 'test@example.com'
      };

      const response = await request(app)
        .post('/api/users')
        .send(newUser)
        .expect(201);

      expect(response.body).toHaveProperty('id');
      expect(response.body.name).toBe(newUser.name);
      expect(response.body.email).toBe(newUser.email);
    });

    it('should validate required fields', async () => {
      const invalidUser = {
        name: 'Test User'
        // Missing email
      };

      await request(app)
        .post('/api/users')
        .send(invalidUser)
        .expect(400);
    });

    it('should reject invalid email format', async () => {
      const invalidUser = {
        name: 'Test User',
        email: 'invalid-email'
      };

      await request(app)
        .post('/api/users')
        .send(invalidUser)
        .expect(400);
    });
  });

  describe('GET /api/users/:id', () => {
    it('should return user by ID', async () => {
      const response = await request(app)
        .get('/api/users/1')
        .expect(200);

      expect(response.body).toHaveProperty('id');
      expect(response.body.id).toBe(1);
    });

    it('should return 404 for non-existent user', async () => {
      await request(app)
        .get('/api/users/99999')
        .expect(404);
    });
  });

  describe('PUT /api/users/:id', () => {
    it('should update existing user', async () => {
      const updates = {
        name: 'Updated Name'
      };

      const response = await request(app)
        .put('/api/users/1')
        .send(updates)
        .expect(200);

      expect(response.body.name).toBe(updates.name);
    });
  });

  describe('DELETE /api/users/:id', () => {
    it('should delete user', async () => {
      await request(app)
        .delete('/api/users/1')
        .expect(204);
    });

    it('should return 404 for non-existent user', async () => {
      await request(app)
        .delete('/api/users/99999')
        .expect(404);
    });
  });

  describe('Authentication', () => {
    it('should reject requests without auth token', async () => {
      await request(app)
        .get('/api/protected')
        .expect(401);
    });

    it('should accept requests with valid token', async () => {
      const token = 'valid-token'; // Get from login or fixture

      await request(app)
        .get('/api/protected')
        .set('Authorization', `Bearer ${token}`)
        .expect(200);
    });

    it('should reject invalid tokens', async () => {
      await request(app)
        .get('/api/protected')
        .set('Authorization', 'Bearer invalid-token')
        .expect(401);
    });
  });

  describe('Error Handling', () => {
    it('should handle server errors gracefully', async () => {
      // Test endpoint that might throw an error
      const response = await request(app)
        .get('/api/error-test')
        .expect(500);

      expect(response.body).toHaveProperty('error');
    });

    it('should return proper error messages', async () => {
      const response = await request(app)
        .post('/api/users')
        .send({}) // Invalid payload
        .expect(400);

      expect(response.body).toHaveProperty('message');
      expect(typeof response.body.message).toBe('string');
    });
  });
});
EOF

        echo "✓ Created tests/api/endpoints.test.ts"
        ;;

    apollo)
        cat > tests/api/graphql.test.ts << 'EOF'
import { ApolloServer } from '@apollo/server';
import { typeDefs, resolvers } from '../src/schema';

describe('GraphQL API', () => {
  let server: ApolloServer;

  beforeAll(() => {
    server = new ApolloServer({
      typeDefs,
      resolvers,
    });
  });

  describe('Queries', () => {
    it('should query users', async () => {
      const response = await server.executeOperation({
        query: `
          query {
            users {
              id
              name
              email
            }
          }
        `,
      });

      expect(response.body.kind).toBe('single');
      if (response.body.kind === 'single') {
        expect(response.body.singleResult.data?.users).toBeDefined();
      }
    });

    it('should query user by ID', async () => {
      const response = await server.executeOperation({
        query: `
          query GetUser($id: ID!) {
            user(id: $id) {
              id
              name
              email
            }
          }
        `,
        variables: { id: '1' },
      });

      expect(response.body.kind).toBe('single');
      if (response.body.kind === 'single') {
        expect(response.body.singleResult.data?.user).toHaveProperty('id');
      }
    });
  });

  describe('Mutations', () => {
    it('should create user', async () => {
      const response = await server.executeOperation({
        query: `
          mutation CreateUser($input: CreateUserInput!) {
            createUser(input: $input) {
              id
              name
              email
            }
          }
        `,
        variables: {
          input: {
            name: 'Test User',
            email: 'test@example.com',
          },
        },
      });

      expect(response.body.kind).toBe('single');
      if (response.body.kind === 'single') {
        expect(response.body.singleResult.data?.createUser).toHaveProperty('id');
      }
    });
  });
});
EOF

        echo "✓ Created tests/api/graphql.test.ts"
        ;;
esac

# Generate test helpers
cat > tests/api/helpers.ts << 'EOF'
// Test helpers and utilities

export const mockUser = {
  id: 1,
  name: 'Test User',
  email: 'test@example.com',
};

export const mockUsers = [mockUser, { ...mockUser, id: 2, name: 'User 2' }];

export const createAuthToken = (userId: number): string => {
  // Generate test auth token
  return `test-token-${userId}`;
};

export const wait = (ms: number): Promise<void> => {
  return new Promise(resolve => setTimeout(resolve, ms));
};
EOF

echo "✓ Created tests/api/helpers.ts"

Phase 5: Configuration

# Add test scripts to package.json
echo ""
echo "Add these scripts to package.json:"
cat << 'EOF'

  "scripts": {
    "test:api": "jest tests/api",
    "test:api:watch": "jest tests/api --watch",
    "test:api:coverage": "jest tests/api --coverage"
  }
EOF

Summary

echo ""
echo "=== API Test Generation Complete! ==="
echo ""
echo "✓ Framework: $FRAMEWORK"
echo "✓ Endpoints discovered: $ENDPOINT_COUNT"
echo "✓ Test files created"
echo ""
echo "📁 Generated files:"
echo "  - tests/api/endpoints.test.ts (or graphql.test.ts)"
echo "  - tests/api/helpers.ts"
echo ""
echo "🚀 Run tests:"
echo "  npm run test:api              # Run API tests"
echo "  npm run test:api:watch        # Watch mode"
echo "  npm run test:api:coverage     # With coverage"
echo ""
echo "📝 Next steps:"
echo "  1. Update test file with actual endpoint paths"
echo "  2. Customize assertions for your data models"
echo "  3. Add authentication setup if needed"
echo "  4. Run tests: npm run test:api"
echo "  5. Add to CI pipeline with /ci-setup"

Best Practices

API Testing Tips:

• Test happy paths and error cases
• Validate request/response schemas
• Test authentication and authorization
• Test rate limiting and pagination
• Mock external dependencies

Integration Points:

• /api-validate - Validate API contracts
• /ci-setup - Add to CI pipeline
• /test - Run alongside unit tests

Credits: API testing patterns based on Supertest documentation, FastAPI testing guide, and industry best practices.

Token Optimization

Expected range: 1,200–2,500 tokens (initial), 300–500 tokens (cache hit)

Caching: Caches API endpoint inventory in .claude/cache/api/endpoints.json for 7 days. Invalidated when route files change.

Early exit: Returns immediately if no API routes found in changed files.

Patterns used: Grep-before-Read, early exit, git diff scope default, template-based generation, caching