qa-property-based
Property-based testing libraries: 5 skills covering Hypothesis (Python), fast-check (JS/TS), proptest (Rust), jqwik (JVM), and QuickCheck (Haskell) + ScalaCheck - each ships authoring + run + shrinking + CI integration - plus 3 agents (property-based-test-author, property-based-tool-selector, vacuous-property-critic).
Install this plugin
/plugin install qa-property-based@testland-qaqa-property-based
Property-based testing for the QuickCheck-derived family. Per ISTQB: PBT is "a test approach in which test results are verified using specified relations between inputs and expected results of a test case." Each skill ships authoring + run + shrinking + CI integration for its language's canonical PBT library.
Components
| Type | Name | Description |
|---|---|---|
| Skill | hypothesis-testing | Python Hypothesis: @given + strategies + composite + assume() + settings + pytest integration. |
| Skill | fast-check-testing | JS/TS fast-check: fc.assert(fc.property(...)) + arbitraries + combinators + race-condition detection + model-based testing. |
| Skill | proptest-testing | Rust proptest: proptest! macro + regex-string strategies + prop_compose! + failure persistence. |
| Skill | jqwik-testing | JVM jqwik: @Property + @ForAll + Arbitraries API + @Provide + JUnit 5 integration. |
| Agent | property-based-test-author | Authors one property-based test per stated invariant (roundtrip / idempotence / conservation / monotonicity / commutativity / inverse / reference). Picks the tool from the decision table below or accepts an override. Refuses to encode "test with random inputs" as a property - that's fuzzing or parameterized unit testing, not property-based. |
| Agent | vacuous-property-critic | Adversarial read-only critic that detects vacuous and trivially-passing property tests in fast-check and Hypothesis suites. Flags over-restrictive preconditions (assume() / fc.pre() / .filter() discarding most inputs), missing or trivial assertions, under-powered generators, and implementation-restatement oracles. Emits BLOCK / PASS verdict with per-finding redesign recommendations. |
Choosing a library
One canonical property-based library per language - detect the language from the project root and pick the matching row:
| Project signal | Language | Library | Skill |
|---|---|---|---|
package.json (with or without TypeScript) | JavaScript / TypeScript | fast-check | fast-check-testing |
pyproject.toml / setup.py | Python | Hypothesis | hypothesis-testing |
pom.xml / build.gradle* | JVM (Java, Kotlin) | jqwik (JUnit 5 platform-native - JUnit 4 doesn't run it; on Kotest, its built-in property module is the alternative) | jqwik-testing |
Cargo.toml | Rust | proptest | proptest-testing |
Languages outside this table (Haskell, Erlang, Elixir, Scala, Go, .NET, Ruby, Swift) are not covered by this plugin - look for language-native alternatives (QuickCheck ports, ScalaCheck, gopter, FsCheck, Rantly, SwiftCheck). A one-off "run the function with random inputs" ask is not a property - use a parameterized unit test; property-based testing earns its keep when there's a meaningful invariant (roundtrip, idempotence, conservation, monotonicity) to assert.
Install
/plugin marketplace add testland/qa
/plugin install qa-property-based@testland-qaSkills
fast-check-testing
Authors property-based tests in JavaScript / TypeScript using fast-check - wires `fc.assert(fc.property(arbitrary, ...))`, picks arbitraries (`fc.integer`, `fc.string`, `fc.array`, `fc.tuple`, `fc.record`), uses `.map()` / `.chain()` / `.filter()` to build domain arbitraries, and integrates with Jest / Vitest / Mocha / Jasmine / AVA / Tape. Use when a JS/TS codebase needs PBT to catch edge cases - fast-check has been used to find bugs in major libraries (`query-string`, etc.) and is trusted by Jest, Jasmine, fp-ts, Ramda.
hypothesis-testing
Authors property-based tests in Python using Hypothesis - wires `@given` with `strategies` (`st.integers`, `st.text`, `st.lists`, `st.from_regex`, `st.composite`), uses `assume()` / `.filter()` for preconditions, configures via `@settings(max_examples=..., deadline=...)`, and exploits Hypothesis's automatic shrinking to find the falsifying example. Integrates with pytest fixtures + parametrize. Use when a Python project needs PBT to catch edge cases the example-based tests miss - bug clusters around input ranges / boundary values / interaction between fields.
jqwik-testing
Authors property-based tests for the JVM (Java + Kotlin) using jqwik - wires `@Property` test methods, `@ForAll` parameter annotations, `Arbitraries.integers/strings/etc` generators, custom `@Provide` arbitraries, and the JUnit 5 platform integration. Use when a JVM project needs PBT - alternative to JUnit-QuickCheck and Vavr's property-checking; tightly integrates with JUnit 5 so property tests run alongside conventional unit tests in the same Maven / Gradle pipeline.
proptest-testing
Authors property-based tests in Rust using proptest - wires the `proptest!` macro, defines strategies (`prop::collection::vec`, type-driven `any` strategies, regex-based string strategies), uses the strategy-per-value model (vs QuickCheck's per-type) for flexible composition, and exploits proptest's automatic shrinking + persistence of failed cases (regression test artifact). Use when a Rust codebase needs PBT - pairs especially well with parsers, serializers, and any function with a structured input domain.
Agents
property-based-test-author
Action-taking agent that authors ONE property-based test per invariant - picks the tool from the plugin README's per-language decision table (or accepts an override), then emits a fast-check / Hypothesis / jqwik / proptest property using the chosen library's arbitraries / strategies / generators. Encodes the invariant (roundtrip, idempotence, conservation, monotonicity, commutativity) as a property the framework can shrink against. Sibling of the per-language unit-test authors in qa-unit-tests-{net,js,jvm,python,go-rust}. Use when adding one property-based test that encodes a stated invariant.
vacuous-property-critic
Adversarial read-only critic that detects vacuous and trivially-passing property-based tests across fast-check (JS/TS) and Hypothesis (Python) test suites. Flags four failure modes: over-restrictive preconditions discarding most generated inputs (Hypothesis `HealthCheck.filter_too_much`, fast-check `maxSkipsPerRun` exhaustion); properties with no meaningful assertion (assert true / return true / empty body); generators too narrow to exercise the stated invariant; and assertions that restate the implementation rather than verify an independent property. Emits a BLOCK / PASS verdict with per-finding severity and a redesign recommendation for each flagged test. Use when a PBT suite is first being introduced, after a property test passes on CI but never reports a counterexample, or when reviewing a PR that adds or modifies `@given` / `fc.property` tests.