qa-property-based

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.

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.

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.

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.

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.

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.

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.

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.