# How to Implement Test-Driven Development with 80% Coverage in ECC

> Learn to implement test-driven development with ECC, enforcing 80% coverage across all test types. Achieve robust code with this automated TDD skill.

- Repository: [Affaan Mustafa/ECC](https://github.com/affaan-m/ECC)
- Tags: how-to-guide
- Published: 2026-05-26

---

**ECC (Everything Claude Code) ships a dedicated TDD skill that codifies the complete test-driven development workflow and enforces a strict 80% minimum coverage threshold across unit, integration, and end-to-end tests.**

The **ECC repository** provides a comprehensive framework for implementing **test-driven development with 80% coverage** through its specialized [`skills/tdd-workflow/SKILL.md`](https://github.com/affaan-m/ECC/blob/main/skills/tdd-workflow/SKILL.md) file. This skill establishes architectural pillars that guide developers through the RED-GREEN-REFACTOR cycle while automating coverage enforcement via Jest configuration and CI pipelines. By following the prescribed workflow, development teams can maintain deterministic test suites that cover branches, functions, lines, and statements to meet the mandatory 80% global threshold.

## The Fail-First Cycle (RED)

The TDD workflow begins with writing a test that expresses desired behavior and intentionally fails. According to [`skills/tdd-workflow/SKILL.md`](https://github.com/affaan-m/ECC/blob/main/skills/tdd-workflow/SKILL.md), this **RED gate** guarantees the test actually exercises missing implementation or edge-case bugs before any production code exists.

Create a failing unit test that targets a specific component behavior:

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

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

  // The following test will fail until the “disabled” prop is implemented
  it('is disabled when disabled prop is true', () => {
    render(<Button disabled>Click me</Button>);
    expect(screen.getByRole('button')).toBeDisabled();
  });
});

```

Run the test suite to confirm the **RED** state:

```bash
npm test

```

## Minimal Implementation (GREEN)

With the failing test establishing the behavioral contract, add only the code required to make the test pass. The ECC skill advises writing the smallest possible implementation to transition from RED to GREEN, avoiding premature abstraction or feature creep.

Implement the minimal code to satisfy the failing assertion:

```typescript
// src/components/Button/Button.tsx
import React from 'react';

export function Button({ children, disabled = false }: { children: React.ReactNode; disabled?: boolean }) {
  return (
    <button disabled={disabled}>
      {children}
    </button>
  );
}

```

Re-run the test suite to confirm the **GREEN** state:

```bash
npm test

```

## Green Validation and Checkpoint Commits

Once the GREEN state is confirmed, the ECC workflow requires creating a **Git checkpoint commit** to lock the transition. This practice maintains a clean Git history that explicitly tracks the TDD cycle.

Create the checkpoint commit after tests pass:

```bash
git add .
git commit -m "fix: implement disabled prop for Button component"

```

## Refactor Safely

With the safety net of passing tests, developers may clean up, rename, or improve production code. The ECC skill mandates a final checkpoint commit after refactoring passes all tests, ensuring the RED-GREEN-REFACTOR loop completes with full traceability.

Example commit after refactoring:

```bash
git commit -m "refactor: simplify Button prop destructuring"

```

## Coverage Enforcement Configuration

ECC expects the command `npm run test:coverage` to generate a coverage report that meets 80% global thresholds defined in the Jest configuration. The thresholds apply to **branches**, **functions**, **lines**, and **statements** simultaneously.

Configure Jest in your [`package.json`](https://github.com/affaan-m/ECC/blob/main/package.json) or [`jest.config.js`](https://github.com/affaan-m/ECC/blob/main/jest.config.js) to enforce the mandate:

```json
{
  "jest": {
    "coverageThresholds": {
      "global": {
        "branches": 80,
        "functions": 80,
        "lines": 80,
        "statements": 80
      }
    }
  }
}

```

Execute coverage verification:

```bash
npm run test:coverage

```

The command fails with a non-zero exit code if any metric falls below 80%, blocking commits and merges.

## Integration Testing Patterns

Beyond unit tests, ECC requires integration tests for API routes and service boundaries. The [`tests/test_templates.py`](https://github.com/affaan-m/ECC/blob/main/tests/test_templates.py) file in the ECC repository provides templates for generating integration test files that maintain the 80% coverage requirement.

Test a Next.js API route using the integration pattern:

```typescript
// src/app/api/markets/route.test.ts
import { NextRequest } from 'next/server';
import { GET } from './route';

describe('GET /api/markets', () => {
  it('returns markets successfully', async () => {
    const request = new NextRequest('http://localhost/api/markets');
    const response = await GET(request);
    const data = await response.json();

    expect(response.status).toBe(200);
    expect(data.success).toBe(true);
    expect(Array.isArray(data.data)).toBe(true);
  });
});

```

## End-to-End Testing with Playwright

ECC incorporates **Playwright** for end-to-end (E2E) testing to ensure critical user flows function correctly in a browser environment. These tests contribute to the overall coverage calculation and verify integration between frontend components and backend services.

Create an E2E test for a critical user flow:

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

test('user can search and filter markets', async ({ page }) => {
  await page.goto('/');
  await page.click('a[href="/markets"]');
  await expect(page.locator('h1')).toContainText('Markets');

  await page.fill('input[placeholder="Search markets"]', 'election');
  await page.waitForTimeout(600);

  const results = page.locator('[data-testid="market-card"]');
  await expect(results).toHaveCount(5);
  await expect(results.first()).toContainText('election', { ignoreCase: true });
});

```

## Automation Hooks and CI/CD Integration

The ECC workflow leverages **pre-commit hooks** and **GitHub Actions** to enforce the 80% coverage threshold automatically. Pre-commit hooks run `npm test && npm run lint` before allowing commits, while CI pipelines execute the same coverage command and upload reports.

Configure pre-commit hooks in [`package.json`](https://github.com/affaan-m/ECC/blob/main/package.json):

```json
{
  "scripts": {
    "test": "jest",
    "test:coverage": "jest --coverage",
    "lint": "eslint src/"
  }
}

```

Implement the CI pipeline in [`.github/workflows/ci.yml`](https://github.com/affaan-m/ECC/blob/main/.github/workflows/ci.yml) to block merges when coverage falls below 80%:

```yaml
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: npm ci
      - run: npm run test:coverage
      - uses: actions/upload-artifact@v3
        with:
          name: coverage-report
          path: coverage/

```

## Mocking External Services

ECC provides ready-to-use mocking patterns for external services (Supabase, Redis, OpenAI) in [`skills/tdd-workflow/SKILL.md`](https://github.com/affaan-m/ECC/blob/main/skills/tdd-workflow/SKILL.md). These patterns ensure unit tests remain deterministic and fast by isolating external dependencies.

Reference the mocking patterns from the skill file to stub external API calls:

```typescript
// Example mocking pattern from skills/tdd-workflow/SKILL.md
jest.mock('@supabase/supabase-js', () => ({
  createClient: jest.fn(() => ({
    from: jest.fn(() => ({
      select: jest.fn().mockResolvedValue({ data: [], error: null })
    }))
  }))
}));

```

## Summary

- **ECC** provides a dedicated TDD skill at [`skills/tdd-workflow/SKILL.md`](https://github.com/affaan-m/ECC/blob/main/skills/tdd-workflow/SKILL.md) that codifies the complete RED-GREEN-REFACTOR workflow.
- The **80% coverage threshold** applies globally to branches, functions, lines, and statements via Jest configuration.
- **Checkpoint commits** (`fix:` and `refactor:`) create a traceable Git history that maps commits to TDD cycle phases.
- **Pre-commit hooks** (`npm test && npm run lint`) and **CI pipelines** block code changes that fail to meet coverage requirements.
- **Integration and E2E tests** using the patterns in [`tests/test_templates.py`](https://github.com/affaan-m/ECC/blob/main/tests/test_templates.py) and Playwright ensure comprehensive coverage beyond unit tests.
- **Mocking patterns** for external services keep tests deterministic and fast while maintaining coverage accuracy.

## Frequently Asked Questions

### How does ECC enforce the 80% coverage threshold?

ECC enforces coverage through Jest configuration thresholds set to 80% for branches, functions, lines, and statements. When running `npm run test:coverage`, Jest calculates coverage metrics and exits with an error code if any metric falls below 80%, preventing commits and merges in CI pipelines.

### What types of tests does the ECC TDD workflow require?

The workflow requires three test layers: **unit tests** for individual components and functions, **integration tests** for API routes and service boundaries using patterns from [`tests/test_templates.py`](https://github.com/affaan-m/ECC/blob/main/tests/test_templates.py), and **end-to-end tests** using Playwright for critical user flows. All three contribute to the global 80% coverage calculation.

### Where does ECC store the TDD workflow documentation?

The complete TDD workflow is documented in [`skills/tdd-workflow/SKILL.md`](https://github.com/affaan-m/ECC/blob/main/skills/tdd-workflow/SKILL.md) within the ECC repository. This file contains step-by-step instructions for the RED-GREEN-REFACTOR cycle, coverage threshold definitions, mocking patterns for external services, and CI/CD integration guidelines.

### Can I use ECC's TDD patterns with other testing frameworks?

While ECC's examples use Jest and Playwright, the architectural principles in [`skills/tdd-workflow/SKILL.md`](https://github.com/affaan-m/ECC/blob/main/skills/tdd-workflow/SKILL.md) are framework-agnostic. You can adapt the RED-GREEN-REFACTOR cycle, checkpoint commit strategy, and 80% threshold requirement to other testing frameworks like Vitest, Mocha, or Cypress by adjusting the coverage configuration and test commands accordingly.