Property-Based Testing
Expert knowledge for property-based testing - automatically generating test cases to verify code properties rather than testing specific examples.
When to Use This Skill
| Use this skill when... | Use another skill instead when... |
|---|---|
| Testing mathematical properties (commutative, associative) | Writing specific example-based unit tests |
| Testing encode/decode roundtrips | Setting up test runner configuration |
| Finding edge cases automatically | Doing E2E browser testing |
| Validating data transformations and invariants | Analyzing test quality or smells |
| Testing API contracts with generated data | Running mutation testing |
Core Expertise
Property-Based Testing Concept
- Traditional testing: Test specific examples
- Property-based testing: Test properties that should hold for all inputs
- Generators: Automatically create diverse test inputs
- Shrinking: Minimize failing cases to simplest example
- Coverage: Explore edge cases humans might miss
When to Use Property-Based Testing
- Mathematical operations (commutative, associative properties)
- Encoders/decoders (roundtrip properties)
- Parsers and serializers
- Data transformations
- API contracts
- Invariants and constraints
TypeScript/JavaScript (fast-check)
Installation
# Using Bun
bun add -d fast-check
# Using npm
npm install -D fast-checkBasic Example
import { test } from 'vitest'
import * as fc from 'fast-check'
// Property-based test
test('reverse twice returns original - property based', () => {
fc.assert(
fc.property(
fc.array(fc.integer()), // Generate random arrays of integers
(arr) => {
expect(reverse(reverse(arr))).toEqual(arr)
}
)
)
})
// fast-check automatically generates 100s of test cases!Key Generators (Quick Reference)
| Generator | Description |
|---|---|
fc.integer() | Any integer (with optional min/max) |
fc.nat() | Natural numbers (>= 0) |
fc.float() / fc.double() | Floating-point numbers |
fc.string() | Any string (with optional length) |
fc.emailAddress() | Email format strings |
fc.array(arb) | Arrays of arbitrary type |
fc.record({...}) | Object with typed fields |
fc.boolean() | Boolean values |
fc.constantFrom(...) | Pick from options |
fc.tuple(...) | Fixed-size tuples |
fc.oneof(...) | Union types |
fc.option(arb) | Value or null |
fc.date() | Date objects |
Common Properties to Test
| Property | Pattern | Example |
|---|---|---|
| Roundtrip | f(g(x)) = x | encode/decode, serialize/parse |
| Idempotence | f(f(x)) = f(x) | sort, normalize, format |
| Commutativity | f(a,b) = f(b,a) | add, merge, union |
| Associativity | f(f(a,b),c) = f(a,f(b,c)) | add, concat |
| Identity | f(x, id) = x | multiply by 1, add 0 |
| Inverse | f(g(x)) = x | encrypt/decrypt |
Configuration
fc.assert(property, {
numRuns: 1000, // Run 1000 tests (default: 100)
seed: 42, // Reproducible tests
endOnFailure: true, // Stop after first failure
})Preconditions
fc.pre(b !== 0) // Skip cases where b is 0Python (Hypothesis)
Installation
# Using uv
uv add --dev hypothesis
# Using pip
pip install hypothesisBasic Example
from hypothesis import given, strategies as st
@given(st.lists(st.integers()))
def test_reverse_twice_property(arr):
assert reverse(reverse(arr)) == arr
# Hypothesis automatically generates 100s of test cases!Key Strategies (Quick Reference)
| Strategy | Description |
|---|---|
st.integers() | Any integer (with optional bounds) |
st.floats() | Floating-point numbers |
st.text() | Any string (with optional size) |
st.binary() | Byte strings |
st.lists(strat) | Lists of given strategy |
st.sets(strat) | Unique value sets |
st.dictionaries(k, v) | Dictionaries |
st.booleans() | Boolean values |
st.sampled_from(...) | Pick from options |
st.tuples(...) | Fixed-size tuples |
st.one_of(...) | Union types |
st.dates() / st.datetimes() | Date/time values |
st.builds(Class,...) | Build objects from strategies |
Configuration
from hypothesis import given, settings, strategies as st
@settings(max_examples=1000, deadline=None)
@given(st.lists(st.integers()))
def test_with_custom_settings(arr):
assert sort(arr) == sorted(arr)Assumptions
from hypothesis import assume
assume(b != 0) # Skip cases where b is 0Stateful Testing
Hypothesis supports stateful testing via RuleBasedStateMachine for testing sequences of operations against invariants.
Agentic Optimizations
| Context | Command |
|---|---|
| Quick TS test | bunx vitest --dots --bail=1 --grep 'property' |
| Quick Python test | uv run pytest -x -q --tb=short -k 'property' |
| CI TS test | bunx vitest run --reporter=junit --grep 'property' |
| CI Python test | uv run pytest --hypothesis-show-statistics -q |
| Reproducible | fc.assert(prop, {seed: 42}) or @settings(derandomize=True) |
| Fast iteration | fc.assert(prop, {numRuns: 50}) or @settings(max_examples=50) |
For detailed examples, advanced patterns, and best practices, see REFERENCE.md.
See Also
vitest-testing- Unit testing frameworkpython-testing- Python pytest testingtest-quality-analysis- Detecting test smellsmutation-testing- Validate test effectiveness
References
- fast-check: https://fast-check.dev/
- Hypothesis: https://hypothesis.readthedocs.io/
- Property-Based Testing: https://fsharpforfunandprofit.com/posts/property-based-testing/