property-mutation-testing-expert

property-mutation-testing-expert — vibes-plug Skill

English | Bahasa Indonesia

---

English

Orchestration & Integration

Connects and orchestrates with e2e-testing-expert, autonomous-tdd-debugger, ai-code-review-autonomous, formal-spec-z3-verifier, anti-slop, typescript-expert, python-programming-expert, and production-ready-hardener to enforce mathematically rigorous test quality across the entire codebase.

Description

Production guide for two advanced testing techniques that frontier AI models unlock at unprecedented scale: (1) Property-Based Testing — generating thousands of randomized test inputs guided by algebraic properties and invariants, catching edge cases that example-based tests miss; and (2) Mutation Testing — systematically introducing bugs into the codebase and verifying that the test suite catches every one of them, measuring the actual "kill rate" of your tests. Together, these techniques expose false confidence in code coverage percentages.

Trigger Conditions

Activate this skill when:

• Code coverage is high (>80%) but bugs still escape to production (false confidence in tests).
• Building financial, medical, or safety-critical logic where correctness is non-negotiable.
• The AI agent is generating test suites and needs to verify they actually catch real bugs.
• Implementing data transformations, serialization/deserialization, or mathematical computations.
• Auditing test quality during production-ready-hardener or zero-tech-debt-auditor phases.

---

Core Concepts & Patterns

1. Property-Based Testing with fast-check (TypeScript)

Instead of writing example-based tests (expect(add(2, 3)).toBe(5)), define universal properties that must hold for ALL inputs:

import fc from 'fast-check';
import { describe, it, expect } from 'vitest';

describe('Array sorting properties', () => {
  it('output has the same length as input', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const sorted = [...arr].sort((a, b) => a - b);
        expect(sorted.length).toBe(arr.length);
      })
    );
  });

  it('output is ordered (monotonically non-decreasing)', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const sorted = [...arr].sort((a, b) => a - b);
        for (let i = 1; i < sorted.length; i++) {
          expect(sorted[i]).toBeGreaterThanOrEqual(sorted[i - 1]);
        }
      })
    );
  });

  it('output is a permutation of input (same elements)', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const sorted = [...arr].sort((a, b) => a - b);
        const inputCounts = countElements(arr);
        const outputCounts = countElements(sorted);
        expect(outputCounts).toEqual(inputCounts);
      })
    );
  });

  it('sorting is idempotent (sorting twice = sorting once)', () => {
    fc.assert(
      fc.property(fc.array(fc.integer()), (arr) => {
        const sortOnce = [...arr].sort((a, b) => a - b);
        const sortTwice = [...sortOnce].sort((a, b) => a - b);
        expect(sortTwice).toEqual(sortOnce);
      })
    );
  });
});

function countElements(arr: number[]): Map<number, number> {
  const counts = new Map<number, number>();
  for (const item of arr) {
    counts.set(item, (counts.get(item) ?? 0) + 1);
  }
  return counts;
}