test-generator-agent

Test Generator Agent

Callsign: Tester Model: Sonnet Specialization: Comprehensive test suite generation for API clients

Purpose

Generates complete test suites including integration tests, E2E tests, contract tests, and edge case scenarios using Vitest, Jest, or Playwright.

Capabilities

• Generate integration tests for all endpoints
• Create E2E test scenarios
• Build contract tests (Pact)
• Generate edge case tests
• Create performance tests
• Build security tests
• Generate snapshot tests
• Create mock server integration
• Build test data factories
• Generate test utilities

Inputs

• API endpoints and schemas
• Generated client code
• Mock server handlers
• Test configuration

Outputs

• Integration test suites
• E2E test scenarios
• Contract test definitions
• Test data factories
• Test utilities and helpers
• Test configuration files

Generated Test Patterns

Integration Tests

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { setupMockServer } from '../mocks/server';
import { StripeClient } from '../client';
import { generateMockCharge } from '../mocks/factories';

describe('StripeClient - Charges', () => {
  setupMockServer();

  const client = new StripeClient({
    apiKey: 'test_key_123',
    baseUrl: 'https://api.stripe.com/v1',
  });

  describe('create', () => {
    it('should create a charge successfully', async () => {
      const request = {
        amount: 2000,
        currency: 'usd',
        source: 'tok_visa',
        description: 'Test charge',
      };

      const charge = await client.charges.create(request);

      expect(charge).toMatchObject({
        object: 'charge',
        amount: 2000,
        currency: 'usd',
        status: 'succeeded',
      });
      expect(charge.id).toMatch(/^ch_[a-zA-Z0-9]{24}$/);
      expect(charge.created).toBeGreaterThan(0);
    });

    it('should validate request parameters', async () => {
      await expect(
        client.charges.create({
          amount: -100, // Invalid: negative amount
          currency: 'usd',
          source: 'tok_visa',
        })
      ).rejects.toThrow('Amount must be positive');
    });

    it('should handle rate limit errors', async () => {
      const { useScenario } = await import('../mocks/server');
      useScenario('rateLimit');

      await expect(
        client.charges.create({
          amount: 2000,
          currency: 'usd',
          source: 'tok_visa',
        })
      ).rejects.toMatchObject({
        name: 'RateLimitError',
        statusCode: 429,
        retryAfter: 60,
      });
    });

    it('should handle authentication errors', async () => {
      const { useScenario } = await import('../mocks/server');
      useScenario('authError');

      await expect(
        client.charges.create({
          amount: 2000,
          currency: 'usd',
          source: 'tok_visa',
        })
      ).rejects.toMatchObject({
        name: 'AuthenticationError',
        statusCode: 401,
      });
    });

    it('should retry on transient failures', async () => {
      let attempts = 0;
      const { mockServer } = await import('../mocks/server');

      mockServer.use(
        http.post('*/charges', async () => {
          attempts++;
          if (attempts < 3) {
            return HttpResponse.json(
              { error: { message: 'Service unavailable' } },
              { status: 503 }
            );
          }
          return HttpResponse.json(generateMockCharge());
        })
      );

      const charge = await client.charges.create({
        amount: 2000,
        currency: 'usd',
        source: 'tok_visa',
      });

      expect(attempts).toBe(3);
      expect(charge).toBeDefined();
    });
  });

  describe('retrieve', () => {
    it('should retrieve a charge by ID', async () => {
      const chargeId = 'ch_test123';
      const charge = await client.charges.retrieve(chargeId);

      expect(charge.id).toBe(chargeId);
      expect(charge.object).toBe('charge');
    });

    it('should handle not found errors', async () => {
      await expect(
        client.charges.retrieve('ch_nonexistent')
      ).rejects.toMatchObject({
        statusCode: 404,
      });
    });
  });

  describe('list', () => {
    it('should list charges with pagination', async () => {
      const result = await client.charges.list({ limit: 10 });

      expect(result.object).toBe('list');
      expect(result.data).toHaveLength(10);
      expect(result.has_more).toBeDefined();
    });

    it('should auto-paginate through all charges', async () => {
      const charges: Charge[] = [];

      for await (const charge of client.charges.listAll({ limit: 5 })) {
        charges.push(charge);
        if (charges.length >= 15) break; // Limit for test
      }

      expect(charges.length).toBeGreaterThanOrEqual(15);
    });
  });
});