Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

behavioral-testing

/behavioral-testing

Pisze i przegląda testy zachowania, które sprawdzają doświadczenie użytkownika, zamiast szczegółów implementacji.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
19.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 19.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Pisze i przegląda testy zachowania, które sprawdzają doświadczenie użytkownika, zamiast szczegółów implementacji.

Wyzwalacze z opisu

tests keep breakingtoo many mockstests are verboseis this test any good
Oryginalny opis (EN)

Behavioral testing methodology — test what users experience, not how code is structured. Use when writing tests, reviewing test quality, planning test strategy for new features, or when existing tests are brittle/verbose/coupled to implementation details. Pairs with the `tdd` skill when working test-first. Triggers: writing tests, test review, "tests keep breaking", "too many mocks", "tests are verbose", "is this test any good", test coverage planning.

Jak działa

  1. Core Laws
  2. Writing Tests
  3. Stop Checks
  4. Regression Tests for Bugs
  5. When to Mock
  6. Detailed References
Sekcje z nagłówków SKILL.md, w oryginale · 137 linii, 862 słów
Podgląd SKILL.md
---
name: behavioral-testing
description: >
  Behavioral testing methodology — test what users experience, not how code is structured.
  Use when writing tests, reviewing test quality, planning test strategy for new features,
  or when existing tests are brittle/verbose/coupled to implementation details.
  Pairs with the `tdd` skill when working test-first.
  Triggers: writing tests, test review, "tests keep breaking", "too many mocks",
  "tests are verbose", "is this test any good", test coverage planning.
---

# Behavioral Testing

Test observable behavior. Keep tests terse. Never test implementation details.

## Core Laws

```
1. Test what the user sees, not how the code works
2. If a refactor breaks a test, the test was wrong
3. Mocks isolate — they are never the thing being tested
4. Every assertion must trace to a user-observable outcome
5. Terse tests > thorough ceremony
```

## Writing Tests

### The Pattern

```
Arrange: Set up the minimum preconditions
Act:     Do the thing the user would do
Assert:  Check what the user would see
```

No verbose setup. If test setup is longer than the assertion, something is wrong.

### What to Test

Test **behavior at boundaries**, not every line of code:

| Always test | Skip |
|-------------|------|
| What happens with empty/null/whitespace input | Internal method call order |
| Error messages users see | Which helper function was called |
| State transitions (loading → success → error) | Implementation details of state management |
| API failure recovery | Mock call counts (unless it IS the behavior) |
| Edge cases users will hit | Happy-path-only coverage |

### Test Naming

Name tests after the behavior, not the function:

```
✅ "shows error when email is empty"
✅ "redirects to login after session expires"
✅ "prevents duplicate submission on double-click"

❌ "test validateEmail"
❌ "test handleSubmit calls api"
❌ "test useAuth hook returns null"
```

### Keep Tests Terse

```typescript
// ✅ Terse — tests one behavior, reads in 3 seconds
test('shows error when email is empty', async () => {
  render(<LoginForm />);
  await userEvent.click(screen.getByRole('button', { name: /submit/i }));
  expect(screen.getByText('Email is required')).toBeVisible();
});

// ❌ Verbose — ceremony obscures intent
test('should display an error message when the user submits the form without entering an email address', async () => {
  const mockOnSubmit = vi.fn();
  const mockOnError = vi.fn();
  const { container } = render(
    <LoginForm onSubmit={mockOnSubmit} onError={mockOnError} />
  );
  const form = container.querySelector('form');
  const button = screen.getByRole('button', { name: /submit/i });
  await userEvent.click(button);
  expect(mockOnSubmit).not.toHaveBeenCalled();
  expect(mockOnError).toHaveBeenCalledWith(expect.objectContaining({ field: 'email' }));
  expect(screen.getByText('Email is required')).toBeVisible();
});
```

The terse test catches the same bug. The verbose test also asserts on mock internals — those assertions break when you refactor, even if behavior is unchanged.

## Stop Checks

Before writing or reviewing any test, run these checks:

```
□ Am I asserting on a mock instead of real output?
  → If yes: delete the assertion or unmock it

□ Would a refactor break this test even though behavior hasn't changed?
  → If yes: the test is coupled to implementation — rewrite it

□ Is mock setup > 50% of the test?
  → If yes: use an integration test with real components instead

□ Does this test name describe a user-visible behavior?
  → If no: rename it or question whether it needs to exist

□ Did I write this test after the implementation?
  → If yes: verify it actually fails when behavior is broken, not just when code changes

□ Would this test still pass if every function it imports returned undefined or a wrong value?
  → If yes: the assertion is too loose. Call the subject with one concrete input and assert
    the literal output or effect. Tells: toBeDefined, toBeTruthy, not.toThrow,
    toHaveBeenCalled alone, an expected value computed by the code under test,
    or a restated constant
```

## Regression Tests for Bugs

When a bug has a clear, cheap test path, make the broken behavior executable before you change production code.

1. Pick the narrowest check the codebase already uses for that path (unit, component, integration).
2. Write the smallest test that would have caught the bug. It encodes the intended behavior, not the current implementation.
3. Run it before the fix and confirm it fails for the intended reason. If it passes, or fails for another reason, fix the test first.
4. Make the smallest fix, rerun, and confirm it passes. Report the failing-before and passing-after output.

Don't force a test when the path needs broad harness setup, brittle mocks, slow end-to-end infrastructure, production-only state, vague repro steps, or large fixture churn. Use the closest executable check instead (a targeted script, a repro command, browser automation, a log assertion) and say why. No new test beats a bad test.

Never change a test to match a wrong implementation, and never weaken an existing assertion unless the intended behavior changed. If the bug is flaky, make the test deterministic and name the signal it locks down.

## When to Mock

**Mock external boundaries only.** Network calls, third-party services, timers — things outside your control.

**Never mock** internal modules, components you own, or "just to be safe."

If you need to mock something you own to test it, the design has a coupling problem. Fix the design, not the test.

## Detailed References

Load these only when needed:

- **[references/anti-patterns.md](references/anti-patterns.md)** — Common testing mistakes with examples: testing mock behavior, test-only production methods, incomplete mocks, over-mocking
- **[references/test-templates.md](references/test-templates.md)** — Copy-paste test patterns for unit, integration, and E2E tests. Factories, helpers, and terse assertion patterns
- **[references/branch-coverage.md](references/branch-coverage.md)** — Branch matrix methodology for systematic coverage: how to map conditions, prioritize, and verify completeness without testing every permutation
Pliki w paczce (4)
  • SKILL.md 6 KB
  • references/anti-patterns.md 6 KB
  • references/branch-coverage.md 5 KB
  • references/test-templates.md 7 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · caidanw/skills100MIT
caidanw/skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 1fd64139023b (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100testing
    Prowadzi behawioralną strategię testowania: co i jak testować, ocena jakości testów oraz naprawa testów sprawdzających mocki zamiast zachowania, z możliwością pisania i uruchamiania testów.
  • 90test-the-site
    Pisze testy, które sprawdzają prawdziwe zachowanie zamiast szczegółów implementacji, wartości konfiguracji i przypadkowych próbek.
  • 90testing
    Podpowiada, jakie testy warto pisać: pewność działania, zachowanie zamiast szczegółów i testy integracyjne, bez kruchych mocków.
  • 90write-tests
    Pisze testy zachowania produktu zamiast szczegółów implementacji i wartości konfiguracji, a także naprawia kruche testy.
  • 100test-strategy
    Decyduje, co testować i na jakim poziomie, i pisze szybkie, deterministyczne testy zachowania zamiast szczegółów implementacji.
  • 100review-testing
    Przegląda kod testów pod kątem jakości, projektu i kompletności po implementacji funkcji lub naprawie błędu, także gdy testy są kruche, niestabilne lub powierzchowne.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.