Grove Testing Skill

When to Activate

Activate this skill when:

• Deciding what to test (not just how)

• Writing tests for new Grove features

• Reviewing existing tests for effectiveness

• Asked to "add tests" without specific guidance

• Evaluating whether tests are providing real value

• Refactoring causes many tests to break (symptom of bad tests)

For technical implementation (Vitest syntax, mocking patterns, assertions), use the javascript-testing skill alongside this one.

The Testing Philosophy

"Write tests. Not too many. Mostly integration." — Guillermo Rauch

This captures everything Grove believes about testing:

Write tests — Automated tests are worthwhile. They enable confident refactoring, serve as documentation, and catch regressions before users do.

Not too many — Tests have diminishing returns. The goal isn't coverage numbers. It's confidence. When you feel confident shipping, you have enough tests.

Mostly integration — Integration tests catch real problems without being brittle. They test behavior users actually experience, not internal implementation.

The Guiding Principle

"The more your tests resemble the way your software is used, the more confidence they can give you." — Kent C. Dodds (Testing Library)

Ask yourself: Does this test fail when the feature breaks? If yes, it's valuable. If it only fails during refactors, it's testing implementation details.

What Makes a Test Valuable

A good test has these properties (Kent Beck's Test Desiderata):

Property What It Means

Behavior-sensitive Fails when actual functionality breaks

Structure-immune Doesn't break when you refactor safely

Deterministic Same result every time, no flakiness

Fast Gives feedback in seconds, not minutes

Clear diagnosis When it fails, you know exactly what broke

Cheap to write Effort proportional to code complexity

The Confidence Test

Before writing a test, ask:

• Would I notice if this broke in production? If yes, test it.

• Would this test fail if the feature broke? If no, don't write it.

• Does this test resemble how users interact with the feature? If no, reconsider.

What NOT to Test

Not everything needs tests. Some things actively harm your codebase when tested.

Skip Testing

What Why

Trivial code Getters, setters, data models with no logic

Framework behavior Trust that SvelteKit routing works

Implementation details Internal state, private methods, CSS classes

One-off scripts Maintenance cost exceeds value

Volatile prototypes Requirements unclear, code will change

Test Lightly

What Approach

Configuration Smoke test that it loads, not every option

Third-party integrations Mock at boundaries, test your code's response

Visual design Snapshot tests or visual regression, not unit tests

Test Thoroughly

What Why

Business logic Core value of the application

User-facing flows What users actually experience

Edge cases Error states, empty states, boundaries

Bug fixes Every bug becomes a test to prevent regression

The Testing Trophy

Modern JavaScript testing follows the Testing Trophy, not the old Testing Pyramid:

                ╭─────────╮
                │   E2E   │  ← Few: critical user journeys
                ╰────┬────╯
           ╭─────────┴─────────╮
           │   Integration     │  ← Many: this is where confidence lives
           ╰─────────┬─────────╯
              ╭──────┴──────╮
              │    Unit     │  ← Some: pure functions, algorithms
              ╰──────┬──────╯
          ╭──────────┴──────────╮
          │   Static Analysis   │  ← TypeScript, ESLint (always on)
          ╰─────────────────────╯

What Each Layer Does

Static Analysis (TypeScript, ESLint)

• Catches typos, type errors, obvious mistakes

• Zero runtime cost, always running

• This is your first line of defense

Unit Tests

• Pure functions, algorithms, utilities

• Fast, isolated, easy to debug

• Don't mock everything—test real behavior where practical

Integration Tests (THE SWEET SPOT)

• Multiple units working together

• Tests behavior users actually experience

• Less brittle than unit tests, faster than E2E

• This is where most of your tests should live

E2E Tests (Playwright)

• Critical user journeys only: login, checkout, core flows

• Expensive to write and maintain

• Reserve for flows where failure = business impact

Writing Effective Tests

Structure: Arrange-Act-Assert

Every test should follow this pattern:

it("should reject invalid email during registration", async () => { // Arrange: Set up the scenario const invalidEmail = "not-an-email";

// Act: Do the thing
const result = await registerUser({ email: invalidEmail, password: "valid123" });

// Assert: Check the outcome
expect(result.success).toBe(false);
expect(result.error).toContain("email");

});

The Act section should be one line. If it's not, the test is probably doing too much.

Naming: Say What Breaks

Test names should describe the behavior, not the implementation:

Good names:

• should reject registration with invalid email

• should show error message when API fails

• should preserve draft when navigating away

Bad names:

• test email validation (what about it?)

• handleSubmit works (what does "works" mean?)

• test case 1 (no)

Test One Thing

Each test should have one reason to fail. If a test fails, you should immediately know what broke.

// Bad: Testing multiple things it('should handle registration', async () => { // Tests validation, API call, redirect, AND email sending });

// Good: Focused tests it('should reject invalid email format', ...); it('should call API with valid data', ...); it('should redirect after successful registration', ...); it('should send welcome email after registration', ...);

Testing Trust Boundaries (Rootwork)

Every trust boundary should have tests for both valid and invalid data:

Form actions: Submit with missing fields, wrong types, edge-case values → verify parseFormData() returns structured errors (not crashes)

KV reads: Mock KV returning corrupted/stale JSON → verify safeJsonParse() falls back to default

Cache reads: Mock cache service returning unexpected shapes → verify createTypedCacheReader() uses fallback

Catch blocks: Trigger redirects and HTTP errors → verify isRedirect() /isHttpError() route them correctly

Reference: Rootwork (@autumnsgrove/lattice/server ) provides parseFormData , safeJsonParse , createTypedCacheReader , isRedirect , and isHttpError .

Integration Tests in Practice

Integration tests are the heart of Grove's testing strategy. Here's how to write them well.

Test User Behavior, Not Implementation

// Bad: Testing implementation it("should set isLoading state to true", async () => { const { component } = render(LoginForm); await fireEvent.click(getByRole("button")); expect(component.isLoading).toBe(true); // Testing internal state! });

// Good: Testing user experience it("should show loading indicator while logging in", async () => { render(LoginForm); await fireEvent.click(getByRole("button", { name: /sign in/i })); expect(getByRole("progressbar")).toBeInTheDocument(); });

Use Accessible Queries

Query elements the way users find them:

// Priority order (best to worst): getByRole("button", { name: /submit/i }); // How screen readers see it getByLabelText("Email"); // Form fields getByText("Welcome back"); // Visible text getByTestId("login-form"); // Last resort

Don't Over-Mock

Mocks remove confidence in the integration. Use them sparingly:

// Over-mocked: False confidence vi.mock("./api"); vi.mock("./validation"); vi.mock("./utils"); // You're testing... nothing real

// Better: Mock at boundaries vi.mock("./external-api"); // Mock the network, not your code // Let validation, utils, etc. run for real

Rule of thumb: If you're mocking something you wrote, reconsider.

When Tests Break

Tests that break are telling you something. Listen.

Good Breaks (Expected)

• Feature changed — Test caught that behavior shifted. Update the test.

• Bug fixed — Old test was wrong. Fix it.

• Requirement changed — Test reflects old requirement. Update it.

Bad Breaks (Symptoms of Poor Tests)

• Refactored internal code — Test was coupled to implementation. Rewrite it.

• Changed CSS class — Test was querying implementation details. Use accessible queries.

• Reordered code — Test depended on execution order. Make it order-independent.

If refactoring frequently breaks tests, your tests are testing the wrong things.

The Bug → Test Pipeline

Every production bug should become a test:

• Bug reported — User can't check out with certain items

• Reproduce locally — Find the exact conditions

• Write failing test — Captures the bug's conditions

• Fix the bug — Test now passes

• Test prevents regression — Bug can never return

This is one of the highest-value testing practices. It turns pain into protection.

Anti-Patterns to Avoid

The Ice Cream Cone

    ╭───────────────────────────╮
    │      Many E2E tests       │  ← Slow, brittle, expensive
    ╰───────────┬───────────────╯
          ╭─────┴─────╮
          │ Few int.  │
          ╰─────┬─────╯
            ╭───┴───╮
            │ Few   │
            │ unit  │
            ╰───────╯

This is backwards. E2E tests are expensive. Integration tests give the best ROI.

Testing Implementation Details

// Testing implementation (bad) expect(component.state.items).toHaveLength(3); expect(handleClick).toHaveBeenCalledWith({ id: 1 });

// Testing behavior (good) expect(getByRole("list").children).toHaveLength(3); expect(getByText("Item added!")).toBeInTheDocument();

Coverage Theater

Chasing 100% coverage leads to bad tests:

// Written only to hit coverage, provides zero value it("should have properties", () => { const user = new User(); expect(user.email).toBeDefined(); expect(user.name).toBeDefined(); });

Coverage is a signal, not a goal. High coverage with bad tests is worse than moderate coverage with good tests.

Snapshot Abuse

Snapshots are useful for:

• Complex serialized output

• Error message formatting

• API response shapes

Snapshots are harmful for:

• UI components (break on every style change)

• Anything with timestamps or random IDs

• Large objects (nobody reviews 500-line snapshot diffs)

The Grove Testing Workflow

When asked to add tests, follow this workflow:

1. Understand the Feature

What does this feature do for users? Not how it's implemented—what value does it provide?

2. Identify Critical Paths

What would break if this feature failed? Those are your test cases.

3. Write Integration Tests First

Start with tests that exercise real user behavior. Add unit tests only for complex logic.

4. Keep Tests Close to Code

src/ └── lib/ └── features/ └── auth/ ├── login.ts ├── login.test.ts ← Right next to the code └── register.ts

5. Run Tests Continuously

npx vitest # Watch mode during development npx vitest run # CI verification

Quick Decision Guide

Situation Action

New feature Write integration tests for user-facing behavior

Bug fix Write test that reproduces bug first, then fix

Refactoring Run existing tests; if they break on safe changes, they're bad tests

"Need more coverage" Add tests for uncovered behavior, not uncovered lines

Pure function/algorithm Unit test it

API endpoint Integration test with mocked external services

UI component Component test with Testing Library

Critical user flow E2E test with Playwright

Integration with Other Skills

javascript-testing

Use javascript-testing for:

• Vitest configuration syntax

• Mocking patterns and APIs

• Assertion reference

• SvelteKit-specific test patterns

grove-documentation

When writing test descriptions, follow Grove voice:

• Clear, direct names

• No jargon

• Say what the user experiences

code-quality

Run linting and type checking before/after writing tests. Static analysis catches different bugs than tests do.

Self-Review Checklist

Before considering tests "done":

• Tests describe user behavior, not implementation

• Each test has one clear reason to fail

• Tests use accessible queries (getByRole, getByLabelText)

• Mocks are limited to external boundaries

• Test names explain what breaks when they fail

• No snapshot tests for volatile content

• Bug fixes include regression tests

• Tests run fast (seconds, not minutes)

Good tests let you ship with confidence. That's the whole point.