Bridge Infection Laravel Package

Product Decisions This Supports

• Strategic Shift to Modern Testing Tools: Enables adoption of Testo as a PHPUnit alternative, aligning with a broader move toward lightweight, composable testing frameworks. Mutation testing via Infection becomes a natural extension of this shift, reinforcing test quality as a first-class concern.
• Mutation Testing as a Quality Gate: Validates test suite effectiveness in CI/CD pipelines, reducing production bugs by catching untested edge cases. Critical for high-assurance applications (e.g., fintech, healthcare, or Laravel-based SaaS platforms).
• Build vs. Buy: Eliminates the need to maintain a custom Infection adapter for Testo, saving engineering time. The auto-discovery mechanism reduces friction for teams already using Testo.
• Use Cases:
  • Test Suite Health Metrics: Quantify test effectiveness (e.g., "85% mutant kill rate") to justify test investments.
  • Onboarding New Developers: Highlight gaps in test coverage where mutants survive, accelerating ramp-up.
  • Legacy Code Modernization: Identify flaky or incomplete tests in older Laravel modules before refactoring.
  • Compliance/Regulatory Projects: Demonstrate rigorous testing via mutation scores for audits.

When to Consider This Package

• Adopt if:

  • Your team has committed to Testo as the primary testing framework (or is evaluating it as a PHPUnit replacement).
  • You prioritize mutation testing to catch logic errors missed by unit tests (e.g., boundary conditions, edge cases).
  • Your CI/CD pipeline can accommodate high computational overhead (mutation testing is 10–50x slower than unit tests).
  • You need zero-configuration integration with Infection, leveraging auto-discovery via infection/extension-installer.
  • Your project uses Testo’s coverage XML (testo/codecov) for test attribution, and you want Infection to consume it natively.
  • You’re open to modern PHP tooling and willing to monitor Testo’s roadmap for feature parity with PHPUnit.

• Look elsewhere if:

  • You’re stuck with PHPUnit due to legacy tooling, CI integrations, or team familiarity. Use infection/phpunit instead.
  • Your project lacks test coverage infrastructure (e.g., no testo/codecov or equivalent).
  • You need advanced Infection features like custom mutant strategies or parallelization, which may not yet be supported in Testo.
  • Your team cannot tolerate CI slowdowns—mutation testing is resource-intensive and may require dedicated pipelines or hardware.
  • You prefer mature, battle-tested tools over niche adapters (e.g., PHPUnit + Infection has broader community support).
  • Your Laravel tests rely heavily on framework-specific features (e.g., HTTP tests with middleware, database transactions) that may not translate cleanly to mutation testing.

How to Pitch It (Stakeholders)

For Executives: *"This package lets us supercharge our test suite by adding mutation testing—a gold standard for catching bugs traditional tests miss. Here’s why it’s a no-brainer:

• Proactive bug prevention: Infection introduces artificial bugs ('mutants') to see if our tests catch them. If they don’t, we know our tests are incomplete.
• Zero engineering overhead: It’s a plug-and-play bridge between Infection and Testo—just install it and configure Infection to use Testo. No custom code needed.
• Future-proofing: As we modernize our stack with Testo, this keeps us aligned with cutting-edge PHP testing tools.
• CI/CD impact: We’ll run mutation tests nightly or in dedicated pipelines to avoid slowing down production builds. Think of it as a ‘stress test’ for our test suite. Cost: Minimal—just a Composer package. Risk: Low, since it’s auto-discovered and integrates with our existing Testo setup. This is a high-ROI upgrade for code quality."*

For Engineering/Dev Teams: *"If we’re using Testo (or planning to), this bridge lets Infection run mutation tests with zero config. Here’s the breakdown:

• How it works:
  • Infection (mutation tester) talks to Testo (our test runner) via this adapter.
  • Uses Testo’s --filter and --teamcity flags under the hood.
  • Reads coverage data from testo/codecov to map mutants to tests.
• Pros:
  • No manual setup: Auto-detected by Infection’s plugin system.
  • Modern stack: Avoids PHPUnit-specific hacks while keeping Infection’s power.
  • CI-friendly: Works with existing Testo workflows (e.g., --teamcity for CI logs).
• Cons/Caveats:
  • Performance hit: Mutation tests are slow (expect 10–30x unit test runtime). Run them in CI nightly or on a subset of tests first.
  • Testo maturity: It’s newer than PHPUnit, so edge cases (e.g., Laravel HTTP tests) might need debugging.
  • Debugging: If a mutant survives, you’ll need to parse Testo’s output alongside Infection’s logs. Recommendation: Start with a proof-of-concept—run Infection locally on a small test suite to validate integration before rolling it into CI. If we’re all-in on Testo, this is a must-have for catching subtle bugs."*

For QA/Testing Teams: *"This tool will expose gaps in our test suite we’ve never seen before. Here’s how it helps you:

• Find weak tests: If a mutant (fake bug) survives, that test is either missing or ineffective.
• Prioritize test improvements: Focus on areas with low mutant kill rates (e.g., ‘only 60% of mutants died here’).
• Leverage Testo’s strengths: Since we’re already using Testo, this adds mutation testing without switching frameworks. Action items:

1. Run Infection locally on a critical module to see how many mutants survive.
2. Triage survivors: Are they false positives (e.g., equivalent mutants), or real test gaps?
3. Advocate for CI integration: Start with nightly runs, then expand to PR checks if performance allows. Example: If our login flow has a mutant that changes a password validation regex but our tests don’t catch it, this tool will flag it—saving us from a production bug."*