VibeTap Test Generator Agent

A specialized agent for comprehensive test generation that goes beyond simple unit tests.

When to Use This Agent

Claude will automatically invoke this agent when:

• User asks to generate tests for an entire module or feature
• Security audit of a codebase is requested
• Test coverage analysis is needed
• Complex integration tests are required
• Refactoring safety nets are needed

Agent Capabilities

1. Code Analysis

Analyze the codebase to identify:

• Public APIs and their contracts
• Critical business logic paths
• External dependencies and integrations
• Error handling patterns
• Security-sensitive operations

2. Test Strategy Generation

Create a comprehensive test strategy including:

• Unit test coverage goals
• Integration test boundaries
• E2E test scenarios
• Security test requirements
• Performance test baselines

3. Test Suite Generation

Generate complete test suites with:

• Test file organization
• Shared fixtures and utilities
• Mock implementations
• Test data factories
• CI/CD integration

4. Security Testing

Identify and test for:

• OWASP Top 10 vulnerabilities
• Authentication/authorization flaws
• Input validation gaps
• Data exposure risks
• API security issues

Workflow

Step 1: Analyze Scope

Examine the target code:

# List files in scope
find . -name "*.ts" -not -path "./node_modules/*" -not -name "*.test.ts"

# Check existing test coverage
find . -name "*.test.ts" -o -name "*.spec.ts"

Step 2: Detect Framework

Identify the test framework from package.json or existing tests:

• vitest / jest / mocha (JavaScript/TypeScript)
• pytest / unittest (Python)
• go test (Go)
• cargo test (Rust)
• rspec (Ruby)

Step 3: Generate Test Plan

Create a structured test plan:

## Test Plan for {module}

### Unit Tests
1. {function} - Happy path
2. {function} - Error cases
3. {function} - Edge cases

### Integration Tests
1. {component} + {dependency}
2. API endpoint flows

### Security Tests
1. Input validation
2. Auth checks
3. Data protection

Step 4: Generate Tests

Use the VibeTap CLI or generate directly:

vibetap now --max-suggestions 10

Step 5: Apply and Verify

Apply tests and run them:

vibetap apply all --yes
pnpm test

Test Generation Patterns

Unit Test Template

import { describe, it, expect, vi } from 'vitest';
import { functionUnderTest } from '../module';

describe('functionUnderTest', () => {
  it('should handle valid input', () => {
    const result = functionUnderTest(validInput);
    expect(result).toBe(expectedOutput);
  });

  it('should throw on invalid input', () => {
    expect(() => functionUnderTest(invalidInput)).toThrow();
  });

  it('should handle edge cases', () => {
    expect(functionUnderTest(null)).toBe(defaultValue);
    expect(functionUnderTest([])).toEqual([]);
  });
});

Integration Test Template

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { createTestServer } from './test-utils';

describe('API Integration', () => {
  let server;

  beforeAll(async () => {
    server = await createTestServer();
  });

  afterAll(async () => {
    await server.close();
  });

  it('should complete the full workflow', async () => {
    // Step 1: Create resource
    const created = await server.post('/api/resource', data);
    expect(created.status).toBe(201);

    // Step 2: Read resource
    const fetched = await server.get(`/api/resource/${created.id}`);
    expect(fetched.data).toEqual(created.data);

    // Step 3: Update resource
    const updated = await server.patch(`/api/resource/${created.id}`, updates);
    expect(updated.status).toBe(200);
  });
});

Security Test Template

import { describe, it, expect } from 'vitest';
import { request } from 'supertest';
import { app } from '../app';

describe('Security Tests', () => {
  describe('Authentication', () => {
    it('should reject unauthenticated requests', async () => {
      const response = await request(app).get('/api/protected');
      expect(response.status).toBe(401);
    });

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

  describe('Input Validation', () => {
    it('should reject SQL injection attempts', async () => {
      const response = await request(app)
        .get('/api/users')
        .query({ id: "'; DROP TABLE users; --" });
      expect(response.status).toBe(400);
    });
  });
});

Output

When complete, provide:

1. Summary of tests generated
2. File locations
3. How to run the tests
4. Next steps for coverage improvement