Introduce UnorderedParameterSets and ConsecutiveParameterSets rules for improved invocation parameter matching in MockObject #6407

src/Framework/MockObject/Exception/NoMoreParameterSetsConfiguredException.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject;
+
+use function sprintf;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class NoMoreParameterSetsConfiguredException extends \PHPUnit\Framework\Exception implements Exception
+{
+    public function __construct(Invocation $invocation, int $numberOfConfiguredParameterSets)
+    {
+        parent::__construct(
+            sprintf(
+                'Not enough parameter sets configured, only %d parameter sets given for %s::%s()',
+                $numberOfConfiguredParameterSets,
+                $invocation->className(),
+                $invocation->methodName(),
+            ),
+        );
+    }
+}

src/Framework/MockObject/Runtime/Interface/InvocationStubber.php

@@ -48,6 +48,16 @@ public function after(string $id): self;
      */
     public function with(mixed ...$arguments): self;
 
+    /**
+     * @return $this
+     */
+    public function withConsecutiveParameterSets(mixed ...$arguments): self;
+
+    /**
+     * @return $this
+     */
+    public function withParameterSetsInAnyOrder(mixed ...$arguments): self;
+
     /**
      * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
      *

src/Framework/MockObject/Runtime/InvocationStubberImplementation.php

@@ -139,6 +139,24 @@ public function with(mixed ...$arguments): InvocationStubber
         return $this;
     }
 
+    public function withConsecutiveParameterSets(mixed ...$arguments): InvocationStubber
+    {
+        $this->ensureParametersCanBeConfigured();
+
+        $this->matcher->setParametersRule(new Rule\ConsecutiveParameterSets($arguments));
+
+        return $this;
+    }
+
+    public function withParameterSetsInAnyOrder(mixed ...$arguments): InvocationStubber
+    {
+        $this->ensureParametersCanBeConfigured();
+
+        $this->matcher->setParametersRule(new Rule\UnorderedParameterSets($arguments));
+
+        return $this;
+    }
+
     /**
      * @throws MethodNameNotConfiguredException
      * @throws MethodParametersAlreadyConfiguredException

src/Framework/MockObject/Runtime/Rule/ConsecutiveParameterSets.php

@@ -0,0 +1,87 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject\Rule;
+
+use function array_shift;
+use function count;
+use function is_array;
+use function sprintf;
+use PHPUnit\Framework\ExpectationFailedException;
+use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
+use PHPUnit\Framework\MockObject\NoMoreParameterSetsConfiguredException;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class ConsecutiveParameterSets implements ParametersRule
+{
+    /**
+     * @var list<Parameters>
+     */
+    private array $stack = [];
+
+    /**
+     * @var list<Parameters>
+     */
+    private array $applied                       = [];
+    private int $numberOfConfiguredParameterSets = 0;
+
+    /**
+     * @param list<Parameters> $stack
+     */
+    public function __construct(array $stack)
+    {
+        foreach ($stack as $parameters) {
+            $this->stack[] = new Parameters(is_array($parameters) ? $parameters : [$parameters]);
+        }
+        $this->numberOfConfiguredParameterSets = count($stack);
+    }
+
+    public function apply(BaseInvocation $invocation): void
+    {
+        if ($this->stack === []) {
+            throw new NoMoreParameterSetsConfiguredException(
+                $invocation,
+                $this->numberOfConfiguredParameterSets,
+            );
+        }
+
+        $parameters      = array_shift($this->stack);
+        $this->applied[] = $parameters;
+        $parameters->apply($invocation);
+    }
+
+    /**
+     * Checks if the invocation $invocation matches the current rules. If it
+     * does the rule will get the invoked() method called which should check
+     * if an expectation is met.
+     *
+     * @throws ExpectationFailedException
+     */
+    public function verify(): void
+    {
+        if (count($this->applied) !== $this->numberOfConfiguredParameterSets &&
+            count($this->stack) > 0) {
+            throw new ExpectationFailedException(
+                sprintf(
+                    'Too much parameter sets given, %d from %d expected parameter sets have been called.',
+                    count($this->applied),
+                    $this->numberOfConfiguredParameterSets,
+                ),
+            );
+        }
+
+        foreach ($this->applied as $parameters) {
+            $parameters->verify();
+        }
+    }
+}

src/Framework/MockObject/Runtime/Rule/Parameters.php

@@ -11,6 +11,7 @@
 
 use function count;
 use function sprintf;
+use AllowDynamicProperties;
 use Exception;
 use PHPUnit\Framework\Constraint\Callback;
 use PHPUnit\Framework\Constraint\Constraint;
@@ -25,14 +26,15 @@
  *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
-final class Parameters implements ParametersRule
+#[AllowDynamicProperties] final class Parameters implements ParametersRule
 {
     /**
      * @var list<Constraint>
      */
     private array $parameters           = [];
     private ?BaseInvocation $invocation = null;
     private null|bool|ExpectationFailedException $parameterVerificationResult;
+    private bool $useAssertionCount = true;
 
     /**
      * @param array<mixed> $parameters
@@ -81,6 +83,11 @@ public function verify(): void
         $this->doVerify();
     }
 
+    public function useAssertionCount(bool $useAssertionCount): void
+    {
+        $this->useAssertionCount = $useAssertionCount;
+    }
+
     /**
      * @throws ExpectationFailedException
      */
@@ -149,6 +156,9 @@ private function guardAgainstDuplicateEvaluationOfParameterConstraints(): bool
 
     private function incrementAssertionCount(): void
     {
+        if ($this->useAssertionCount === false) {
+            return;
+        }
         Test::currentTestCase()->addToAssertionCount(1);
     }
 }

src/Framework/MockObject/Runtime/Rule/UnorderedParameterSets.php

@@ -0,0 +1,110 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject\Rule;
+
+use function array_search;
+use function array_shift;
+use function count;
+use function implode;
+use function is_array;
+use function sprintf;
+use PHPUnit\Framework\ExpectationFailedException;
+use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
+use PHPUnit\Framework\MockObject\NoMoreParameterSetsConfiguredException;
+
+final class UnorderedParameterSets implements ParametersRule
+{
+    /**
+     * @var list<Parameters>
+     */
+    private array $stack = [];
+
+    /**
+     * @var list<Parameters>
+     */
+    private array $unapplied = [];
+
+    /**
+     * @var list<Parameters>
+     */
+    private array $applied                       = [];
+    private int $numberOfConfiguredParameterSets = 0;
+
+    /**
+     * @param list<Parameters> $stack
+     */
+    public function __construct(array $stack)
+    {
+        foreach ($stack as $parameters) {
+            $this->stack[] = new Parameters(is_array($parameters) ? $parameters : [$parameters]);
+        }
+        $this->unapplied                       = $this->stack;
+        $this->numberOfConfiguredParameterSets = count($stack);
+    }
+
+    public function apply(BaseInvocation $invocation): void
+    {
+        if ($this->unapplied === []) {
+            throw new NoMoreParameterSetsConfiguredException(
+                $invocation,
+                $this->numberOfConfiguredParameterSets,
+            );
+        }
+
+        $checkedParameters   = 0;
+        $unappliedParameters = count($this->unapplied);
+
+        while ($checkedParameters < $unappliedParameters) {
+            $checkedParameters++;
+            $parameters = array_shift($this->unapplied);
+
+            try {
+                $parameters->useAssertionCount(false);
+                $parameters->apply($invocation);
+
+                $this->applied[] = $parameters;
+
+                $parameters->useAssertionCount(true);
+                $parameters->apply($invocation);
+
+                break;
+            } catch (ExpectationFailedException $e) {
+                $this->unapplied[] = $parameters;
+            }
+        }
+    }
+
+    /**
+     * Checks if the invocation $invocation matches the current rules. If it
+     * does the rule will get the invoked() method called which should check
+     * if an expectation is met.
+     *
+     * @throws ExpectationFailedException
+     */
+    public function verify(): void
+    {
+        if (count($this->applied) !== $this->numberOfConfiguredParameterSets &&
+            count($this->unapplied) > 0) {
+            $unappliedIndexes = [];
+
+            foreach ($this->unapplied as $parameters) {
+                $unappliedIndexes[] = array_search($parameters, $this->stack, true);
+            }
+
+            throw new ExpectationFailedException(
+                sprintf(
+                    '%d from %d expected parameter sets were called, indexes [' . implode(', ', $unappliedIndexes) . '] were not called.',
+                    count($this->applied),
+                    $this->numberOfConfiguredParameterSets,
+                ),
+            );
+        }
+    }
+}

tests/end-to-end/regression/6407-multiple-arguments.phpt

@@ -0,0 +1,21 @@
+--TEST--
+https://github.com/sebastianbergmann/phpunit/issues/6407
+--FILE--
+<?php declare(strict_types=1);
+$_SERVER['argv'][] = '--do-not-cache-result';
+$_SERVER['argv'][] = '--no-configuration';
+$_SERVER['argv'][] = __DIR__ . '/6407/Issue6407MultipleArgumentTest.php';
+
+require_once __DIR__ . '/../../bootstrap.php';
+
+(new PHPUnit\TextUI\Application)->run($_SERVER['argv']);
+--EXPECTF--
+PHPUnit %s by Sebastian Bergmann and contributors.
+
+Runtime: %s
+
+..                                                                  2 / 2 (100%)
+
+Time: %s, Memory: %s
+
+OK (2 tests, 10 assertions)

tests/end-to-end/regression/6407-single-arguments.phpt

@@ -0,0 +1,21 @@
+--TEST--
+https://github.com/sebastianbergmann/phpunit/issues/6407
+--FILE--
+<?php declare(strict_types=1);
+$_SERVER['argv'][] = '--do-not-cache-result';
+$_SERVER['argv'][] = '--no-configuration';
+$_SERVER['argv'][] = __DIR__ . '/6407/Issue6407SingleArgumentTest.php';
+
+require_once __DIR__ . '/../../bootstrap.php';
+
+(new PHPUnit\TextUI\Application)->run($_SERVER['argv']);
+--EXPECTF--
+PHPUnit %s by Sebastian Bergmann and contributors.
+
+Runtime: %s
+
+..                                                                  2 / 2 (100%)
+
+Time: %s, Memory: %s
+
+OK (2 tests, 6 assertions)