Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

hypothesis-testing

/hypothesis-testing

Pisze testy oparte na właściwościach w Pythonie z Hypothesis: strategie, filtrowanie, ustawienia i testy odwracalności parse(format(x)).

Repozytorium
qa-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
12.11.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
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.11.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 testy oparte na właściwościach w Pythonie z Hypothesis: strategie, filtrowanie, ustawienia i testy odwracalności parse(format(x)).

Oryginalny opis (EN)

Use for any question or task about property-based or generated-input tests in Python, including quick how-to questions, round-trip checks like parse(format(x)), and inputs that break code in production: Hypothesis @given strategies, composite strategies, assume and filtering, settings, reproducibility and CI. Has round-trip and metamorphic property templates.

Jak działa

  1. Overview
  2. When to use
  3. Step 1 - Install
  4. Step 2 - Basic property test
  5. Step 3 - Strategies
  6. Step 4 - Composite strategies (dependent fields)
  7. Step 5 - Filtering and assumptions
  8. Step 6 - Settings and reproducibility
  9. Step 7 - Round-trip and metamorphic properties
  10. Step 8 - pytest integration
Sekcje z nagłówków SKILL.md, w oryginale · 241 linii, 919 słów
Podgląd SKILL.md
---
name: hypothesis-testing
description: "Use for any question or task about property-based or generated-input tests in Python, including quick how-to questions, round-trip checks like parse(format(x)), and inputs that break code in production: Hypothesis @given strategies, composite strategies, assume and filtering, settings, reproducibility and CI. Has round-trip and metamorphic property templates."
---

# hypothesis-testing

## Overview

Hypothesis is the canonical Python property-based testing library
([hyp-quickstart][hq]). It generates inputs from `strategies` and
automatically shrinks any failure to the simplest reproducer.

[hq]: https://hypothesis.readthedocs.io/en/latest/quickstart.html
[py-expr]: https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations

## When to use

- A Python function has a non-trivial input domain (numeric ranges,
  string formats, list shapes) and example-based tests miss edge
  cases.
- A bug fix needs a property test to prevent regression of a class
  of inputs (not just the one that caused the bug).
- Refactoring code where the new implementation should be
  observably equivalent to the old (use Hypothesis to verify
  property: `new(x) == old(x) for all x`).
- Testing parsers / serializers / encoders where round-trip
  properties hold (`decode(encode(x)) == x`).

If only one or two specific examples need verification, parametrize
or fixtures suffice - Hypothesis is overkill.

## Step 1 - Install

```bash
pip install hypothesis
```

Pin a version in `requirements-dev.txt` / `pyproject.toml`.
Hypothesis is well-maintained but adds 1-2 seconds to test runtime
per generated case; default 100 examples per `@given`.

## Step 2 - Basic property test

Per [hyp-quickstart][hq]:

```python
from hypothesis import given, strategies as st

@given(st.integers(0, 100))
def test_example(n):
    assert n < 50
```

The decorator runs the test 100 times with random `n` in `[0, 100]`.
On failure, Hypothesis reports the **falsifying example** (the
smallest `n` that violates the assertion) - typically `50` here.

## Step 3 - Strategies

Per [hyp-quickstart][hq], a strategy names the shape of the input. The
common ones:

```python
st.integers(0, 100)                   # bounded ints
st.floats(allow_nan=False)            # floats, optionally excluding NaN/Inf
st.text(min_size=1)                   # strings
st.lists(st.integers(), max_size=10)  # collections
st.from_regex(r"[a-z]+@[a-z]+\.com", fullmatch=True)  # format-validated
st.sampled_from(Status)               # enum-like
```

Full catalog (`binary`, `dictionaries`, `tuples`, `builds`, `composite`):
[references/hypothesis-reference.md](references/hypothesis-reference.md).

## Step 4 - Composite strategies (dependent fields)

Per [hyp-quickstart][hq], `@st.composite` lets later values depend
on earlier ones via `draw()`:

```python
from hypothesis import strategies as st

@st.composite
def valid_dates(draw):
    year = draw(st.integers(1900, 2100))
    month = draw(st.integers(1, 12))
    if month in (1, 3, 5, 7, 8, 10, 12):
        day = draw(st.integers(1, 31))
    elif month in (4, 6, 9, 11):
        day = draw(st.integers(1, 30))
    else:
        # Feb: account for leap years
        max_day = 29 if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else 28
        day = draw(st.integers(1, max_day))
    return date(year, month, day)

@given(valid_dates())
def test_date_round_trip(d):
    assert date.fromisoformat(d.isoformat()) == d
```

The `draw()` call requests a value from a strategy; the composite
returns the constructed value.

## Step 5 - Filtering and assumptions

Two ways to constrain inputs:

```python
# Filter at strategy level (preferred - Hypothesis can sample efficiently)
@given(st.integers(0, 100).filter(lambda x: x % 2 == 0))
def test_even_squares(n):
    assert (n * n) % 2 == 0

# Filter at test level (fallback when filtering depends on multi-input)
from hypothesis import assume

@given(st.integers(), st.integers())
def test_division(a, b):
    assume(b != 0)   # discard cases where b == 0
    # Python's floor-division identity: x == (x//y)*y + (x%y)
    assert (a // b) * b + a % b == a
```

The assertion is Python's documented floor-division identity
([py-expr][py-expr]): a property of `//` and `%`, not an expression
that is true for any `result`.

Per [hyp-quickstart][hq], use `.filter()` at the strategy level
when possible (Hypothesis can sample efficiently). Use `assume()`
inside the test when the precondition involves multiple inputs.

**Heavy filtering is a smell** - if 90% of generated cases are
discarded, redesign the strategy.

## Step 6 - Settings and reproducibility

```python
from hypothesis import given, settings, strategies as st

@settings(max_examples=500, deadline=2000)   # 500 cases, 2s deadline per case
@given(st.integers())
def test_expensive(n):
    expensive_function(n)
```

For CI, set `derandomize=True` to make failures reproducible across
runs (vs random seed = same property test passes locally, fails on
CI mysteriously). Full settings table (`max_examples`, `deadline`,
`phases`, `verbosity`):
[references/hypothesis-reference.md](references/hypothesis-reference.md).

## Step 7 - Round-trip and metamorphic properties

Two of the most useful property patterns:

### Round-trip

```python
import json

@given(st.dictionaries(st.text(), st.integers()))
def test_json_round_trip(d):
    assert json.loads(json.dumps(d)) == d
```

If `decode(encode(x)) == x` for all valid `x`, the encode/decode
pair is correct.

### Metamorphic (relating two computations on related inputs)

```python
@given(st.lists(st.integers()))
def test_sort_idempotent(xs):
    assert sorted(sorted(xs)) == sorted(xs)

@given(st.lists(st.integers()), st.integers())
def test_sort_commutes_with_offset(xs, offset):
    sorted_xs = sorted(xs)
    sorted_offset = sorted(x + offset for x in xs)
    assert all(s + offset == o for s, o in zip(sorted_xs, sorted_offset))
```

Metamorphic tests are powerful when the function's "correct
output" is hard to specify but its relationship to other inputs is
easy.

## Step 8 - pytest integration

Per [hyp-quickstart][hq]: "Hypothesis works seamlessly with pytest
fixtures and parametrize decorators."

```python
@pytest.fixture
def db_conn():
    # ... setup ...
    yield conn
    # ... teardown ...

@given(st.integers(0, 1000))
def test_with_fixture(db_conn, n):
    db_conn.insert(id=n)
    assert db_conn.find(id=n) == n
```

Hypothesis re-runs the test body with new `n` each time; the
fixture is set up once per test (per pytest's normal scope rules,
unless it's `function`-scoped - then once per generated case).

## Step 9 - CI integration

```yaml
- run: pytest --hypothesis-seed=42  # deterministic seed for reproducibility

# OR via @settings(derandomize=True)
```

When a property test fails, the failure includes the falsifying
example - copy that into a regression test:

```python
@given(...)
@example(n=42)   # the falsifying example from the prior run
def test_my_property(n):
    ...
```

`@example` cases run before generated ones; locks the regression in
permanently.

## References

- [references/hypothesis-reference.md](references/hypothesis-reference.md) - full
  strategies catalog, `@settings` table, anti-patterns, limitations.
- [hyp-quickstart][hq] - Hypothesis quickstart: `@given`,
  strategies, shrinking, composite, `assume()`, settings.
- `fast-check-testing`,
  `proptest-testing`,
  `jqwik-testing`,
  `quickcheck-testing` - 
  per-language siblings with similar shape.
- `schemathesis-fuzzing` - applies PBT to API schemas (different layer; same conceptual
  framework).
Pliki w paczce (2)
  • SKILL.md 7 KB
  • references/hypothesis-reference.md 5 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · testland/qa-skills100MIT
poemswe/co-researcher100MIT
testland/qa100MIT
danielrosehill/claude-data-analyst-plugin100MIT
rohitg00/skillkit100Apache-2.0
foryourhealth111-pixel/Vibe-Skills95Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki 0d2527888297 (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

  • 100pbt-strategy
    Pomaga pisać testy oparte na własnościach w Pythonie z Hypothesis: szuka niezmienników, pisze strategie @given i testuje systemy stanowe.
  • 100property-based-testing
    Generuje działający test oparty na właściwościach dla wskazanej funkcji: test odwracalności dla pary encode i decode albo test niezmienników dla postwarunków, z Hypothesis w Pythonie i fast-check w JavaScript lub TypeScript.
  • 95bitcoin-testing-property-based
    Stosuje testy właściwości (proptest, quickcheck, hypothesis) do parserów Bitcoin: serializacja transakcji, round-trip deskryptorów i spełnialność miniscriptu.
  • 95property-based-testing
    Pomaga pisać testy oparte na właściwościach z fast-check (TypeScript i JavaScript) oraz Hypothesis (Python): automatyczne generowanie przypadków i wyszukiwanie przypadków brzegowych.
  • 100property-based-testing
    Pisze testy oparte na własnościach z fast-check (TS/JS) i Hypothesis (Python): generowanie danych testowych, szukanie przypadków brzegowych i testy w stylu QuickCheck.
  • 100robust-testing
    Podpowiada, jak budować sensowne zestawy testów: testy oparte na właściwościach, relacje metamorficzne, testy integracyjne i fuzzing.

Uwagi i zgłoszenia

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