TDD Companion

Enforce test-driven development during implementation sessions.

Required Reference

Before proceeding, read: references/tdd-workflow.md

This reference contains:

• •Red-Green-Refactor cycle details
• •Drupal test type selection guide
• •Phase 3 enforcement checkpoints
• •Common TDD violations

Activation

Activate automatically during Phase 3 coding when:

• •About to write implementation code
• •After task-context-loader loads a task
• •User asks to implement a feature
• •Code changes are being discussed

Core Rule

STOP before writing any implementation code.

Ask: "Have you written the failing test first?"

If no test exists, do NOT write implementation. Instead:

1. •Help write the test
2. •Run test to confirm it FAILS (RED)
3. •Only then write MINIMUM implementation (GREEN)
4. •After passing, consider refactoring (REFACTOR)

Red-Green-Refactor Enforcement

RED Phase

Before any implementation:

CHECKPOINT: Is there a failing test for this?

If NO:
  → Write test first
  → Run test to confirm failure
  → Show error message

If YES:
  → Proceed to implementation

GREEN Phase

When writing implementation:

CHECKPOINT: Write MINIMUM code to pass.

Rules:
- Only code needed to pass the test
- No additional features
- No premature optimization
- No "while I'm here" additions

REFACTOR Phase

After test passes:

CHECKPOINT: Can this be improved?

Only if:
- Tests are green
- Refactoring doesn't change behavior
- Tests stay green after changes

Drupal Test Types Quick Reference

Test Template

When helping write tests, use this structure:

<?php

namespace Drupal\Tests\{module}\{Type};

use Drupal\Tests\{TestBase};

class {ClassName}Test extends {TestBase} {

  public function test{Behavior}(): void {
    // Arrange
    $input = ...;

    // Act
    $result = $this->subject->method($input);

    // Assert
    $this->assertEquals($expected, $result);
  }
}

Intervention Points

Intervene when you detect:

• •"Let me just add this feature..." → "Stop. Is there a test?"
• •"I'll add tests later..." → "Tests first. What behavior are we testing?"
• •"This is too simple for tests..." → "Simple now, complex later. Test it."
• •Implementing multiple features at once → "One test, one feature at a time."

Integration with superpowers:test-driven-development

For complex testing scenarios, defer:

This needs detailed TDD guidance.
Invoking superpowers:test-driven-development for full methodology.

Use superpowers skill for:

• •Complex mocking scenarios
• •Integration test strategies
• •Test refactoring approaches

Stop Points

STOP and enforce:

• •Before ANY implementation code is written
• •If implementation goes beyond test requirements
• •If user tries to skip testing
• •Before moving to next feature (are tests green?)

Blocking Violations (from references/tdd-workflow.md)

These BLOCK implementation:

• •Writing implementation before test exists
• •Test passes on first run (test might be wrong)
• •Adding untested features
• •Skipping RED phase confirmation

Integration with Quality Gates

This skill enforces Gate 2 from references/quality-gates.md:

• •All tests must pass before /complete
• •New code must have test coverage
• •No skipped tests without documented reason