Fixed #69, updated tests, updated documentation.

Author: TheCelavi

PhpUnit/AbstractContainerBuilderTestCase.php

@@ -174,15 +174,17 @@ protected function assertContainerBuilderHasServiceDefinitionWithArgument(
      * @param string $serviceId
      * @param string $method
      * @param array $arguments
+     * @param int|null $index
      */
     protected function assertContainerBuilderHasServiceDefinitionWithMethodCall(
         $serviceId,
         $method,
-        array $arguments = array()
+        array $arguments = array(),
+        $index = null
     ) {
         $definition = $this->container->findDefinition($serviceId);
 
-        self::assertThat($definition, new DefinitionHasMethodCallConstraint($method, $arguments));
+        self::assertThat($definition, new DefinitionHasMethodCallConstraint($method, $arguments, $index));
     }
 
     /**

PhpUnit/DefinitionHasMethodCallConstraint.php

@@ -10,13 +10,19 @@ class DefinitionHasMethodCallConstraint extends Constraint
 {
     private $methodName;
     private $arguments;
+    private $index;
 
-    public function __construct($methodName, array $arguments = array())
+    public function __construct($methodName, array $arguments = array(), $index = null)
     {
+        if ($index !== null && !is_int($index)) {
+            throw new \RuntimeException(sprintf('Expected value of integer type for method call index, "%s" given.', is_object($index) ? get_class($index) : gettype($index)));
+        }
+
         parent::__construct();
 
         $this->methodName = $methodName;
         $this->arguments = $arguments;
+        $this->index = $index;
     }
 
     public function evaluate($other, $description = '', $returnResult = false)
@@ -27,13 +33,17 @@ public function evaluate($other, $description = '', $returnResult = false)
             );
         }
 
-        foreach ($other->getMethodCalls() as $methodCall) {
-            list($method, $arguments) = $methodCall;
+        for ($i = 0; $i < $iMax = count($methodCalls = $other->getMethodCalls()); $i++) {
+            list($method, $arguments) = $methodCalls[$i];
 
             if ($method !== $this->methodName) {
                 continue;
             }
 
+            if (null !== $this->index && $i !== $this->index) {
+                continue;
+            }
+
             if ($this->equalArguments($this->arguments, $arguments)) {
                 return true;
             }
@@ -43,9 +53,10 @@ public function evaluate($other, $description = '', $returnResult = false)
             $this->fail(
                 $other,
                 sprintf(
-                    'None of the method calls matched the expected method "%s" with arguments %s',
+                    'None of the method calls matched the expected method "%s" with arguments %s with %s invocation order index',
                     $this->methodName,
-                    $this->exporter->export($this->arguments)
+                    $this->exporter->export($this->arguments),
+                    (null === $this->index) ? 'any' : sprintf('"%s"', $this->index)
                 )
             );
         }
@@ -56,7 +67,7 @@ public function evaluate($other, $description = '', $returnResult = false)
     public function toString()
     {
         return sprintf(
-            'has a method call to "%s" with the given arguments',
+            'has a method call to "%s" with the given arguments on any or explicitly stated invocation order index.',
             $this->methodName
         );
     }

README.md

@@ -311,9 +311,9 @@ the given index.</dd>
 <dt><code>assertContainerBuilderHasServiceDefinitionWithArgument($serviceId, $argumentIndex, $expectedValue)</code></dt>
 <dd>Assert that the <code>ContainerBuilder</code> for this test has a service definition with the given id, which has an argument at
 the given index, and its value is the given value.</dd>
-<dt><code>assertContainerBuilderHasServiceDefinitionWithMethodCall($serviceId, $method, array $arguments = array())</code></dt>
+<dt><code>assertContainerBuilderHasServiceDefinitionWithMethodCall($serviceId, $method, array $arguments = array(), $index = null)</code></dt>
 <dd>Assert that the <code>ContainerBuilder</code> for this test has a service definition with the given id, which has a method call to
-the given method with the given arguments.</dd>
+the given method with the given arguments. If index is provided, invocation index order of method call is asserted as well.</dd>
 <dt><code>assertContainerBuilderHasServiceDefinitionWithTag($serviceId, $tag, array $attributes = array())</code></dt>
 <dd>Assert that the <code>ContainerBuilder</code> for this test has a service definition with the given id, which has the given tag with the given arguments.</dd>
 <dt><code>assertContainerBuilderHasServiceDefinitionWithParent($serviceId, $parentServiceId)</code></dt>

Tests/PhpUnit/DefinitionHasMethodCallConstraintTest.php

@@ -12,9 +12,9 @@ class DefinitionHasMethodCallConstraintTest extends TestCase
      * @test
      * @dataProvider definitionProvider
      */
-    public function match(Definition $definition, $method, $arguments, $expectedToMatch)
+    public function match(Definition $definition, $method, $arguments, $index, $expectedToMatch)
     {
-        $constraint = new DefinitionHasMethodCallConstraint($method, $arguments);
+        $constraint = new DefinitionHasMethodCallConstraint($method, $arguments, $index);
 
         $this->assertSame($expectedToMatch, $constraint->evaluate($definition, '', true));
     }
@@ -25,25 +25,25 @@ public function definitionProvider()
 
         $definitionWithTwoMethodCalls = new Definition();
 
-        $method = 'add';
-
         $argumentsOfFirstCall = array('argument of first call');
-        $definitionWithTwoMethodCalls->addMethodCall($method, $argumentsOfFirstCall);
+        $definitionWithTwoMethodCalls->addMethodCall('methodCallOne', $argumentsOfFirstCall);
 
         $argumentsOfSecondCall = array('argument of second call');
-        $definitionWithTwoMethodCalls->addMethodCall($method, $argumentsOfSecondCall);
+        $definitionWithTwoMethodCalls->addMethodCall('methodCallTwo', $argumentsOfSecondCall);
 
         $otherArguments = array('some other argument');
 
         return array(
             // the definition has no method call
-            array($definitionWithNoMethodCalls, $method, array(), false),
-            // the definition has a call to this method, arguments match with the first call
-            array($definitionWithTwoMethodCalls, $method, $argumentsOfFirstCall, true),
-            // the definition has a call to this method, arguments match with the second call
-            array($definitionWithTwoMethodCalls, $method, $argumentsOfSecondCall, true),
+            array($definitionWithNoMethodCalls, 'noMethodCall', array(), null, false),
+            // the definition has a call to this method on any invocation index, arguments match with the first call
+            array($definitionWithTwoMethodCalls, 'methodCallOne', $argumentsOfFirstCall, null, true),
+            // the definition has a call to this method on first invocation index, arguments match with the second call
+            array($definitionWithTwoMethodCalls, 'methodCallTwo', $argumentsOfSecondCall, 1, true),
             // the definition has a call to this method, but the arguments don't match
-            array($definitionWithTwoMethodCalls, $method, $otherArguments, false),
+            array($definitionWithTwoMethodCalls, 'methodCallOne', $otherArguments, null, false),
+            // the definition has a call to this method, arguments match with the first call, but invocation index is wrong
+            array($definitionWithTwoMethodCalls, 'methodCallOne', $argumentsOfFirstCall, 1, false),
         );
     }
 
@@ -55,6 +55,6 @@ public function it_has_a_string_representation()
         $method = 'methodName';
         $constraint = new DefinitionHasMethodCallConstraint($method, array());
 
-        $this->assertSame('has a method call to "'.$method.'" with the given arguments', $constraint->toString());
+        $this->assertSame('has a method call to "'.$method.'" with the given arguments on any or explicitly stated invocation order index.', $constraint->toString());
     }
 }