Mockista Laravel Package

Product Decisions This Supports

• Accelerated Test-Driven Development (TDD) & Quality Assurance

  • Reduces cognitive overhead for developers writing unit tests, particularly in complex Laravel applications with deep dependency chains (e.g., repositories, services, API clients). Mockista’s fluent syntax aligns with modern PHP practices, making TDD more accessible for teams transitioning from legacy codebases.
  • Enables shift-left testing by lowering the barrier to entry for writing comprehensive unit tests, which directly improves code quality and reduces production bugs.

• Cost Optimization: Build vs. Buy

  • Eliminates the need to build custom mocking utilities or maintain proprietary solutions, saving engineering time and reducing technical debt. Compared to alternatives like Mockery or Prophecy, Mockista offers a simpler, PHPUnit-native API with minimal learning curve, justifying its adoption as a "buy" decision.
  • Aligns with Laravel’s ecosystem by avoiding framework-specific mocking tools (e.g., Laravel’s createMock()), which can become outdated or fragmented.

• Roadmap: Scalable Microservices & API-First Development

  • Critical for microservices architectures where external dependencies (e.g., payment gateways, third-party APIs) must be mocked reliably. Mockista’s type-safe mocking and declarative syntax reduce flakiness in CI/CD pipelines, a key requirement for scaling API-driven products.
  • Supports contract testing by allowing teams to mock service interfaces without coupling to implementations, which is essential for event-driven architectures (e.g., Laravel Queues, Horizon).

• Use Cases

  • Legacy System Modernization: Isolate and test monolithic Laravel applications by mocking outdated or unstable dependencies (e.g., legacy databases, SOAP services).
  • Performance Testing: Simulate high-load scenarios by mocking slow or unreliable external services (e.g., external APIs, file storage) without hitting production endpoints.
  • Behavior-Driven Development (BDD): Reduce boilerplate in PestPHP or Behat tests by defining mock behaviors declaratively, improving collaboration between developers and non-technical stakeholders.
  • Security Testing: Mock sensitive operations (e.g., authentication, encryption) to test edge cases without exposing real credentials or data.

When to Consider This Package

• Adopt If:

  • Your team struggles with PHPUnit’s verbose mocking syntax (e.g., getMockBuilder(), expects(), willReturn()) and seeks a cleaner, more maintainable alternative.
  • You prioritize developer productivity in testing, especially for junior engineers or contractors who may find PHPUnit’s mocking intimidating.
  • Your project relies on mocking complex objects (e.g., nested dependencies, callbacks, or dynamic method calls) where PHPUnit’s native tools fall short.
  • You’re using Laravel or a PHP framework where PHPUnit is the default, and you want tighter integration (e.g., compatibility with Laravel’s MockFacade or createMock()).
  • You need type safety in mocks (e.g., enforcing return types, parameter validation) without sacrificing flexibility or readability.
  • Your CI/CD pipeline is bottlenecked by flaky tests due to unreliable mocks or external dependencies.

• Look Elsewhere If:

  • Your stack doesn’t use PHPUnit (e.g., you’re using PestPHP exclusively, which already improves mocking with its fake() and mock() helpers).
  • You require advanced mocking features not supported by Mockista, such as:
    • Partial mocking of specific methods in a class (use Laravel’s partialMock() or Mockery).
    • Stateful mocks or interaction tracking (e.g., verifying a method was called with specific arguments; use Mockery or Prophecy).
  • Your team prefers framework-specific solutions (e.g., Laravel’s createMock(), Symfony’s MockBuilder, or Mockery), which may offer deeper integration with Laravel’s service container or Eloquent ORM.
  • You’re in a high-performance context (e.g., microbenchmarks, kernel-level testing) where mocking overhead is critical. While Mockista adds minimal runtime impact, alternatives like native PHPUnit mocks may be more optimized.
  • You need distributed mocking (e.g., for testing gRPC, WebSocket interactions, or multi-process systems), which requires specialized tools like WireMock, VCR, or Pest’s fake().

How to Pitch It (Stakeholders)

For Executives/Business Leaders

*"Mockista is a low-code tool that directly impacts our ability to ship high-quality software faster. By reducing the time engineers spend wrestling with flaky or verbose test mocks—potentially cutting test suite maintenance time by 30–50%—we can:

• Reduce production bugs by ensuring edge cases are tested reliably.
• Accelerate feature delivery by unblocking TDD/BDD workflows, especially for complex dependencies like APIs or legacy systems.
• Lower long-term costs by eliminating custom mocking solutions and reducing technical debt in our test suites.

This is a drop-in replacement for PHPUnit’s mocking, so the risk is minimal. Early adopters like [Team X] have already reduced their API test suite setup time by 30%, freeing them to focus on business logic. For a team of 10 engineers, that’s ~150 hours/year reclaimed—time we can reinvest in growth initiatives."*

For Engineering Leaders/Architects

*"Mockista addresses two critical pain points in our PHP test suite:

1. Legacy Technical Debt: Replaces brittle, verbose PHPUnit mocks (e.g., getMockBuilder() chains) with a fluent, readable API that reduces cognitive load.
   • Example: Replace this:

     $mock = $this->getMockBuilder(UserRepository::class)
         ->disableOriginalConstructor()
         ->onlyMethods(['find'])
         ->getMock();
     $mock->method('find')->willReturn($user);
     

     with this:

     $mock = Mockista::mock(UserRepository::class)
         ->when('find', $userId)->thenReturn($user);
     

2. Scalability: Simplifies mocking for complex dependencies (e.g., event dispatchers, database repositories) without sacrificing flexibility or type safety.

Why Mockista over alternatives?

• Tighter PHPUnit integration: Works seamlessly with Laravel’s testing helpers (e.g., MockFacade, createMock()).
• Modern PHP support: Aligns with PHP 8+ features (e.g., named arguments, attributes).
• Active maintenance: Unlike some older libraries, Mockista is actively developed (as of 2023).

Proposal:

• Pilot Phase: Have [Team Y] migrate their API service tests to Mockista and measure the impact on test suite stability and developer velocity.
• Training: Conduct a 1-hour workshop to onboard the team (template provided).
• Migration Plan: Phase out custom mocking utilities within 3 sprints and adopt Mockista as the standard for new unit tests.
• Risk Mitigation: Mockista is a drop-in replacement, so we can roll back to PHPUnit if needed. We’ll also add a test suite to validate Mockista’s output in CI.

Key Metrics to Track:

• Reduction in test suite maintenance time.
• Improvement in test coverage (especially for edge cases).
• Developer satisfaction surveys (e.g., ‘How easy is it to write mocks now?’)."*

For Developers

*"Tired of writing mocks like this?

$mock = $this->getMockBuilder(Service::class)
    ->disableOriginalConstructor()
    ->onlyMethods(['fetch'])
    ->getMock();
$mock->method('fetch')->willReturn($data);

Mockista lets you do this instead:

$mock = Mockista::mock(Service::class)
    ->when('fetch')->thenReturn($data);

Why switch? ✅ Less Boilerplate: No more disableOriginalConstructor() or onlyMethods(). ✅ Type Safety: Enforces return types and parameter validation (e.g., ->when('fetch', int $id)). ✅ Laravel-Friendly: Works with MockFacade, createMock(), and PestPHP. ✅ Future-Proof: Supports PHP 8+ features like named arguments and attributes.

How to Get Started:

1. Install via Composer:

   composer require janmarek/mockista
   

2. Replace PHPUnit mocks in your tests with Mockista’s syntax.
3. Run tests—no breaking changes!

Need Help?

• Check the migration guide.
• Ask in #testing-squad or open an issue on GitHub.
• Example: Mocking a Laravel repository:

  $mock = Mockista::mock(UserRepository::class)
      ->when('find',