gh-xloxn69-agileflow/commands/tests.md

description, allowed-tools

description	allowed-tools
setup-tests	Bash, Read, Edit, Write, Glob, Grep

setup-tests

Automatically set up testing infrastructure for projects without existing tests.

Prompt

ROLE: Test Infrastructure Bootstrapper

OBJECTIVE Detect project type and set up appropriate testing framework with example tests and CI integration.

INPUTS (optional)

• FRAMEWORK=auto|jest|mocha|pytest|rspec|go-test|cargo-test (default: auto-detect)
• COVERAGE=yes|no (default: yes)
• E2E=yes|no (default: no, ask if needed)

PROJECT DETECTION

1. Detect language/runtime:

   • Node.js: package.json
   • Python: requirements.txt, pyproject.toml
   • Ruby: Gemfile
   • Go: go.mod
   • Rust: Cargo.toml
   • Java: pom.xml, build.gradle
   • .NET: *.csproj

2. Detect framework (if applicable):

   • React, Vue, Angular (npm deps)
   • Django, Flask, FastAPI (Python imports)
   • Rails, Sinatra (Gemfile)

3. Check existing test setup:

   • Test directories: test/, tests/, tests/, spec/
   • Test config: jest.config.js, pytest.ini, .rspec
   • CI config: .github/workflows/test

SETUP ACTIONS

For Node.js (Jest)

npm install --save-dev jest @types/jest ts-jest
# If TypeScript: npm install --save-dev @types/jest ts-jest
# If React: npm install --save-dev @testing-library/react @testing-library/jest-dom

Create jest.config.js:

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  coverageDirectory: 'coverage',
  collectCoverageFrom: [
    'src/**/*.{js,ts}',
    '!src/**/*.d.ts',
    '!src/**/*.spec.ts'
  ],
  coverageThreshold: {
    global: {
      branches: 70,
      functions: 70,
      lines: 70,
      statements: 70
    }
  }
};

For Python (pytest)

pip install pytest pytest-cov pytest-mock

Create pytest.ini:

[pytest]
testpaths = tests
python_files = test_*.py *_test.py
python_classes = Test*
python_functions = test_*
addopts = --cov=src --cov-report=html --cov-report=term

For Ruby (RSpec)

# Add to Gemfile
group :test do
  gem 'rspec'
  gem 'rspec-rails' # if Rails
  gem 'factory_bot'
  gem 'simplecov'
end

bundle install
rspec --init

CREATE EXAMPLE TESTS

Unit Test Example (Node.js/Jest)

// tests/unit/example.test.ts
describe('Example Test Suite', () => {
  it('should pass this example test', () => {
    expect(true).toBe(true);
  });

  it('should test basic math', () => {
    expect(2 + 2).toBe(4);
  });
});

Component Test Example (React)

// tests/components/Button.test.tsx
import { render, screen, fireEvent } from '@testing-library/react';
import Button from '@/components/Button';

describe('Button Component', () => {
  it('renders with text', () => {
    render(<Button>Click Me</Button>);
    expect(screen.getByText('Click Me')).toBeInTheDocument();
  });

  it('calls onClick when clicked', () => {
    const handleClick = jest.fn();
    render(<Button onClick={handleClick}>Click</Button>);
    fireEvent.click(screen.getByText('Click'));
    expect(handleClick).toHaveBeenCalledTimes(1);
  });
});

API Test Example (Integration)

// tests/integration/api.test.ts
import request from 'supertest';
import app from '@/app';

describe('API Integration Tests', () => {
  it('GET / should return 200', async () => {
    const response = await request(app).get('/');
    expect(response.status).toBe(200);
  });

  it('POST /api/users should create user', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ name: 'Test User', email: 'test@example.com' });
    expect(response.status).toBe(201);
    expect(response.body).toHaveProperty('id');
  });
});

DIRECTORY STRUCTURE

Create:

tests/
├── unit/           # Unit tests (isolated functions/classes)
├── integration/    # Integration tests (multiple components)
├── e2e/           # End-to-end tests (full user flows) [if E2E=yes]
├── fixtures/      # Test data
└── helpers/       # Test utilities

E2E SETUP (if E2E=yes)

Playwright (recommended)

npm install --save-dev @playwright/test
npx playwright install

Create playwright.config.ts and example E2E test:

// tests/e2e/login.spec.ts
import { test, expect } from '@playwright/test';

test('user can log in', async ({ page }) => {
  await page.goto('http://localhost:3000/login');
  await page.fill('input[name="email"]', 'test@example.com');
  await page.fill('input[name="password"]', 'password123');
  await page.click('button[type="submit"]');
  await expect(page).toHaveURL('http://localhost:3000/dashboard');
});

CI INTEGRATION

Add to .github/workflows/ci.yml (or create):

test:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4

    - name: Setup Node
      uses: actions/setup-node@v4
      with:
        node-version: '20'
        cache: 'npm'

    - name: Install dependencies
      run: npm ci

    - name: Run tests
      run: npm test -- --coverage

    - name: Upload coverage
      uses: codecov/codecov-action@v3
      with:
        files: ./coverage/lcov.info

NPM SCRIPTS

Add to package.json:

{
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage",
    "test:unit": "jest tests/unit",
    "test:integration": "jest tests/integration",
    "test:e2e": "playwright test"
  }
}

DOCUMENTATION

Create docs/02-practices/testing.md:

# Testing Guide

## Running Tests

\`\`\`bash
npm test              # Run all tests
npm run test:watch    # Watch mode
npm run test:coverage # With coverage report
npm run test:unit     # Unit tests only
\`\`\`

## Writing Tests

### Unit Tests
- Test individual functions/classes in isolation
- Mock external dependencies
- Fast (<10ms per test)

### Integration Tests
- Test multiple components together
- Use real dependencies when possible
- Medium speed (<100ms per test)

### E2E Tests
- Test full user flows
- Run against real app
- Slow (seconds per test)

## Coverage Requirements
- Minimum 70% coverage (enforced in CI)
- New code should be 90%+ covered
- Critical paths require 100% coverage

## Best Practices
- Use descriptive test names (Given/When/Then)
- One assertion per test when possible
- Avoid test interdependence
- Use factories/fixtures for test data

WORKFLOW

1. Detect project type and existing setup

2. Show proposed setup plan (diff-first):

   Will install:
   - jest, @types/jest, ts-jest
   - @testing-library/react, @testing-library/jest-dom
   
   Will create:
   - jest.config.js
   - tests/unit/example.test.ts
   - tests/integration/api.test.ts
   - docs/02-practices/testing.md
   
   Will update:
   - package.json (add test scripts)
   - .github/workflows/ci.yml (add test job)
   

3. Ask: "Proceed with test setup? (YES/NO)"

4. If YES:

   • Run installations
   • Create config files
   • Create example tests
   • Update CI
   • Run tests to verify setup

5. Show results:

   ✅ Testing framework installed
   ✅ Example tests created
   ✅ CI integration added
   
   Try running: npm test
   

INTEGRATION

• Create story: "US-XXXX: Set up testing infrastructure"
• Update docs/02-practices/testing.md
• Suggest setting required checks in GitHub

RULES

• Preview all changes (diff-first, YES/NO)
• Run test suite after setup to verify
• Create working examples, not just config
• Document how to run and write tests
• Integrate with CI immediately
• Set reasonable coverage thresholds (not 100%)

OUTPUT

• Setup summary
• Test framework configuration
• Example tests (unit + integration + E2E if requested)
• CI integration
• Testing documentation