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. |
| Skill | quickcheck-testing | Haskell QuickCheck (the original) + ScalaCheck: quickCheck / forAll + Arbitrary typeclass + shrink. |
| Agent | property-based-tool-selector | Reads project markers (package.json / pyproject.toml / pom.xml / Cargo.toml / *.cabal / mix.exs) and recommends one library per language: fast-check (JS/TS), Hypothesis (Python), jqwik (JVM), proptest (Rust), QuickCheck (Haskell / Erlang / Elixir). |
| Agent | property-based-test-author | Authors one property-based test per stated invariant (roundtrip / idempotence / conservation / monotonicity / commutativity / inverse / reference). Picks tool via property-based-tool-selector 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. |
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`, `any::<T>()`, 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.
quickcheck-testing
Authors property-based tests for Haskell using QuickCheck (the original PBT library) and for Scala via ScalaCheck (the JVM port) - wires `quickCheck` (Haskell) / `forAll` (ScalaCheck) drivers, defines `Arbitrary` instances or generators, uses `shrink` to find minimal counterexamples, and integrates with HSpec / Tasty (Haskell) or specs2 / ScalaTest. Use when the codebase is Haskell or Scala and the team wants the canonical PBT library that the entire family (Hypothesis / fast-check / proptest / jqwik) was inspired by.
Agents
property-based-test-author
Action-taking agent that authors ONE property-based test per invariant - picks tool via property-based-tool-selector (or accepts an override), then emits a fast-check / Hypothesis / jqwik / proptest / QuickCheck 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.
property-based-tool-selector
Action-taking agent that reads a target project's language + test framework (from `package.json`, `pyproject.toml`, `pom.xml` / `build.gradle*`, `Cargo.toml`, `*.cabal` / `mix.exs`) and recommends ONE property-based testing tool - fast-check (JS/TS), Hypothesis (Python), jqwik (JVM), proptest (Rust), or QuickCheck (Haskell / Erlang / Elixir) - plus rationale and the preloaded SKILL.md to read next. Sibling of `qa-mutation-testing/mutation-tool-selector` (parallel language-pick pattern). Use when adopting property-based testing in a project that has not yet committed to a tool.
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.