ArrayHasItemWith: Allow passing a static value as constraint

Author: PhrozenByte

README.md

@@ -229,7 +229,7 @@ $this->assertSequentialArray($data, 4, null, $this->is(IsType::TYPE_STRING));
 
 The [`ArrayHasItemWith` constraint](https://github.com/PhrozenByte/phpunit-array-asserts/blob/master/src/Constraint/ArrayHasItemWith.php) asserts that an array has a item at a given index and that its value passes another constraint.
 
-Accepts both native arrays and `Traversable` objects. The constraint will fail if the array has less items than required. The index of the item to check (parameter `$index`), and the constraint its value must pass (parameter `$constraint`) are passed in the constructor.
+Accepts both native arrays and `Traversable` objects. The constraint will fail if the array has less items than required. The index of the item to check (parameter `$index`), and the constraint its value must pass (parameter `$constraint`) are passed in the constructor. The constraint can either be an arbitrary `Constraint` instance (e.g. `PHPUnit\Framework\Constraint\StringContains`), or any static value, requiring an exact match of the value.
 
 This constraint will fully traverse any `Traversable` object given. This also means that any `Generator` will be fully exhausted. It doesn't restore an `Iterator`'s pointer to its previous state.
 
@@ -240,16 +240,16 @@ The `ArrayAssertsTrait` trait exposes two public methods for the `ArrayHasItemWi
 ```php
 // using `\PhrozenByte\PHPUnitArrayAsserts\ArrayAssertsTrait` trait
 ArrayAssertsTrait::assertArrayHasItemWith(
-    int $index,               // the index of the item to check
-    Constraint $constraint,   // the constraint the item's value is applied to
-    array|Traversable $array, // the array to check
-    string $message = ''      // additional information about the test
+    int $index,                   // the index of the item to check
+    Constraint|mixed $constraint, // the constraint the item's value is applied to
+    array|Traversable $array,     // the array to check
+    string $message = ''          // additional information about the test
 );
 
 // using new instance of `\PhrozenByte\PHPUnitArrayAsserts\Constraint\ArrayHasItemWith`
 new ArrayHasItemWith(
     int $index,
-    Constraint $constraint
+    Constraint|mixed $constraint
 );
 ```
 
@@ -266,20 +266,20 @@ $data = [
 ];
 
 // asserts that `$data` contains "Life, the Universe and Everything" as third item (i.e. at index 2)
-$this->assertArrayHasItemWith(2, $this->identicalTo("Life, the Universe and Everything"));
+$this->assertArrayHasItemWith(2, "Life, the Universe and Everything");
 ```
 
 **Debugging:**
 
 ```php
 $data = [];
 
-$this->assertArrayHasItemWith(2, $this->identicalTo('Arthur Dent'), $data);
+$this->assertArrayHasItemWith(2, 'Arthur Dent', $data);
 
 // Will fail with the following message:
 //
 //     Failed asserting that Array &0 () is an array that
-//     has a value at index 2 which is identical to 'Arthur Dent'.
+//     has a value at index 2 which is equal to 'Arthur Dent'.
 ```
 
 Example

src/ArrayAssertsTrait.php

@@ -190,37 +190,32 @@ public static function sequentialArray(int $minItems, int $maxItems = null, $con
      * passes another constraint.
      *
      * @param int               $index      the index of the item to check
-     * @param Constraint        $constraint the constraint the item's value is applied to
+     * @param Constraint|mixed  $constraint the constraint the item's value is applied to
      * @param array|Traversable $array      the array to check
      * @param string            $message    additional information about the test
      *
      * @throws ExpectationFailedException
      * @throws InvalidArgumentException
      * @throws Exception
      */
-    public static function assertArrayHasItemWith(
-        int $index,
-        Constraint $constraint,
-        $array,
-        string $message = ''
-    ): void {
+    public static function assertArrayHasItemWith(int $index, $constraint, $array, string $message = ''): void
+    {
         if (!(is_array($array) || ($array instanceof Traversable))) {
             throw InvalidArgumentException::create(3, 'array or Traversable');
         }
-
         $constraint = new ArrayHasItemWith($index, $constraint);
         PHPUnitAssert::assertThat($array, $constraint, $message);
     }
 
     /**
      * Returns a new instance of the ArrayHasItemWith constraint.
      *
-     * @param int        $index      the index of the item to check
-     * @param Constraint $constraint the constraint the item's value is applied to
+     * @param int              $index      the index of the item to check
+     * @param Constraint|mixed $constraint the constraint the item's value is applied to
      *
      * @return ArrayHasItemWith
      */
-    public static function arrayHasItemWith(int $index, Constraint $constraint): ArrayHasItemWith
+    public static function arrayHasItemWith(int $index, $constraint): ArrayHasItemWith
     {
         return new ArrayHasItemWith($index, $constraint);
     }

src/Constraint/ArrayHasItemWith.php

@@ -20,6 +20,7 @@
 namespace PhrozenByte\PHPUnitArrayAsserts\Constraint;
 
 use PHPUnit\Framework\Constraint\Constraint;
+use PHPUnit\Framework\Constraint\IsEqual;
 use Traversable;
 
 /**
@@ -34,7 +35,9 @@
  * Iterator's pointer to its previous state.
  *
  * The index of the item to check, and the constraint its value must pass are
- * passed in the constructor.
+ * passed in the constructor. The constraint can either be an arbitrary
+ * `Constraint` instance (e.g. `PHPUnit\Framework\Constraint\StringContains`),
+ * or any static value, requiring an exact match of the value.
  */
 class ArrayHasItemWith extends Constraint
 {
@@ -47,13 +50,13 @@ class ArrayHasItemWith extends Constraint
     /**
      * ArrayHasItemWith constructor.
      *
-     * @param int        $index      the index of the item to check
-     * @param Constraint $constraint the constraint the item's value is applied to
+     * @param int              $index      the index of the item to check
+     * @param Constraint|mixed $constraint the constraint the item's value is applied to
      */
-    public function __construct(int $index, Constraint $constraint)
+    public function __construct(int $index, $constraint)
     {
         $this->index = $index;
-        $this->constraint = $constraint;
+        $this->constraint = !($constraint instanceof Constraint) ? new IsEqual($constraint) : $constraint;
     }
 
     /**

tests/Unit/Constraint/ArrayHasItemWithTest.php

@@ -37,11 +37,11 @@ class ArrayHasItemWithTest extends TestCase
     /**
      * @dataProvider dataProviderSelfDescribing
      *
-     * @param int        $index
-     * @param Constraint $constraint
-     * @param string     $expectedDescription
+     * @param int              $index
+     * @param Constraint|mixed $constraint
+     * @param string           $expectedDescription
      */
-    public function testSelfDescribing(int $index, Constraint $constraint, string $expectedDescription): void
+    public function testSelfDescribing(int $index, $constraint, string $expectedDescription): void
     {
         $mockedConstraint = $this->mockConstraint($constraint, [ 'toString' => $this->once() ]);
 
@@ -60,17 +60,13 @@ public function dataProviderSelfDescribing(): array
     /**
      * @dataProvider dataProviderEvaluate
      *
-     * @param int        $index
-     * @param Constraint $constraint
-     * @param mixed      $other
-     * @param mixed      $expectedEvaluationValue
+     * @param int              $index
+     * @param Constraint|mixed $constraint
+     * @param mixed            $other
+     * @param mixed            $expectedEvaluationValue
      */
-    public function testEvaluate(
-        int $index,
-        Constraint $constraint,
-        $other,
-        $expectedEvaluationValue
-    ): void {
+    public function testEvaluate(int $index, $constraint, $other, $expectedEvaluationValue): void
+    {
         $mockedConstraint = $this->mockConstraint(
             $constraint,
             [ 'evaluate' => $this->once() ],
@@ -96,15 +92,15 @@ public function dataProviderEvaluate(): array
     /**
      * @dataProvider dataProviderEvaluateFail
      *
-     * @param int        $index
-     * @param Constraint $constraint
-     * @param mixed      $other
-     * @param mixed      $expectedEvaluationValue
-     * @param string     $expectedExceptionMessage
+     * @param int              $index
+     * @param Constraint|mixed $constraint
+     * @param mixed            $other
+     * @param mixed            $expectedEvaluationValue
+     * @param string           $expectedExceptionMessage
      */
     public function testEvaluateFail(
         int $index,
-        Constraint $constraint,
+        $constraint,
         $other,
         $expectedEvaluationValue,
         string $expectedExceptionMessage
@@ -135,17 +131,13 @@ public function dataProviderEvaluateFail(): array
     /**
      * @dataProvider dataProviderPreEvaluateFail
      *
-     * @param int        $index
-     * @param Constraint $constraint
-     * @param mixed      $other
-     * @param string     $expectedExceptionMessage
+     * @param int              $index
+     * @param Constraint|mixed $constraint
+     * @param mixed            $other
+     * @param string           $expectedExceptionMessage
      */
-    public function testPreEvaluateFail(
-        int $index,
-        Constraint $constraint,
-        $other,
-        string $expectedExceptionMessage
-    ): void {
+    public function testPreEvaluateFail(int $index, $constraint, $other, string $expectedExceptionMessage): void
+    {
         $mockedConstraint = $this->mockConstraint($constraint);
 
         $itemConstraint = new ArrayHasItemWith($index, $mockedConstraint);
@@ -168,11 +160,11 @@ public function dataProviderPreEvaluateFail(): array
     /**
      * @dataProvider dataProviderCountable
      *
-     * @param int        $index
-     * @param Constraint $constraint
-     * @param int        $expectedCount
+     * @param int              $index
+     * @param Constraint|mixed $constraint
+     * @param int              $expectedCount
      */
-    public function testCountable(int $index, Constraint $constraint, int $expectedCount): void
+    public function testCountable(int $index, $constraint, int $expectedCount): void
     {
         $mockedConstraint = $this->mockConstraint($constraint, [ 'count' => $this->once() ]);
 

tests/data/ArrayHasItemWithTest.yml

@@ -37,6 +37,9 @@
                 toString: matches something
                 matches: false
                 count: 2
+    paramsIndexStatic: &paramsIndexStatic
+        index: 0
+        constraint: static value
     constraintMatches: &constraintMatches
         constraint: { options: { matches: true } }
 
@@ -47,6 +50,8 @@ testSelfDescribing:
         expectedDescription: is an array that has a value at index 1 which is funny
     -   <<: *paramsIndexZero
         expectedDescription: is an array that has a value at index 0 which matches something
+    -   <<: *paramsIndexStatic
+        expectedDescription: is an array that has a value at index 0 which is equal to 'static value'
 
 testEvaluate:
     -   <<: *paramsIndexTwo
@@ -66,6 +71,11 @@ testEvaluate:
             ~object: ArrayIterator
             array: { 2: "foo", 1: "bar", 0: "baz" }
         expectedEvaluationValue: foo
+    -   <<: *paramsIndexStatic
+        other:
+            item: static value
+            other: 42
+        expectedEvaluationValue: static value
     -   index: 10
         constraint:
             ~object: PhrozenByte\PHPUnitArrayAsserts\Tests\Utils\TestConstraint
@@ -89,6 +99,13 @@ testEvaluateFail:
         expectedEvaluationValue: foo
         expectedExceptionMessage: |-
             Failed asserting that %s is an array that has a value at index 0 which matches something.
+    -   <<: *paramsIndexStatic
+        other:
+            item: other value
+            other: 42
+        expectedEvaluationValue: other value
+        expectedExceptionMessage: |-
+            Failed asserting that %s is an array that has a value at index 0 which is equal to 'static value'.
 
 testPreEvaluateFail:
     -   <<: *paramsIndexTwo
@@ -133,3 +150,5 @@ testCountable:
         expectedCount: 2
     -   <<: *paramsIndexZero
         expectedCount: 3
+    -   <<: *paramsIndexStatic
+        expectedCount: 2