ArrayHasKeyWith: Allow passing a static value as constraint

Author: PhrozenByte

README.md

@@ -118,7 +118,7 @@ $this->assertAssociativeArray([
 
 The [`ArrayHasKeyWith` constraint](https://github.com/PhrozenByte/phpunit-array-asserts/blob/master/src/Constraint/ArrayHasKeyWith.php) asserts that an array has a given key and that its value passes another constraint.
 
-Accepts both native arrays and `ArrayAccess` objects. The constraint (parameter `$constraint`) will fail if the key (parameter `$key`) doesn't exist in the array. The item's key and the constraint the value must pass are passed in the constructor.
+Accepts both native arrays and `ArrayAccess` objects. The constraint (parameter `$constraint`) will fail if the key (parameter `$key`) doesn't exist in the array. The item's key, and the constraint the value must pass 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.
 
 The `ArrayAssertsTrait` trait exposes two public methods for the `ArrayHasKeyWith` constraint: Use `ArrayAssertsTrait::assertArrayHasKeyWith()` to perform an assertion, and `ArrayAssertsTrait::arrayHasKeyWith()` to create a new instance of the `ArrayHasKeyWith` constraint.
 
@@ -127,16 +127,16 @@ The `ArrayAssertsTrait` trait exposes two public methods for the `ArrayHasKeyWit
 ```php
 // using `\PhrozenByte\PHPUnitArrayAsserts\ArrayAssertsTrait` trait
 ArrayAssertsTrait::assertArrayHasKeyWith(
-    string|int $key,          // the key of the item to check
-    Constraint $constraint,   // the constraint the item's value is applied to
-    array|ArrayAccess $array, // the array to check
-    string $message = ''      // additional information about the test
+    string|int $key,              // the key of the item to check
+    Constraint|mixed $constraint, // the constraint the item's value is applied to
+    array|ArrayAccess $array,     // the array to check
+    string $message = ''          // additional information about the test
 );
 
 // using new instance of `\PhrozenByte\PHPUnitArrayAsserts\Constraint\ArrayHasKeyWith`
 new ArrayHasKeyWith(
     string|int $key,
-    Constraint $constraint
+    Constraint|mixed $constraint
 );
 ```
 
@@ -150,20 +150,20 @@ $data = [
 ];
 
 // asserts that $data has the item `name` with the value "Arthur Dent"
-$this->assertArrayHasKeyWith('name', $this->identicalTo('Arthur Dent'), $data);
+$this->assertArrayHasKeyWith('name', 'Arthur Dent', $data);
 ```
 
 **Debugging:**
 
 ```php
 $data = [];
 
-$this->assertArrayHasKeyWith('answer', $this->identicalTo(42), $data);
+$this->assertArrayHasKeyWith('answer', 42, $data);
 
 // Will fail with the following message:
 //
 //     Failed asserting that Array &0 () is an array that
-//     has the key 'answer' whose value is identical to 42.
+//     has the key 'answer' whose value is equal to 42.
 ```
 
 ### Constraint `SequentialArray`

src/ArrayAssertsTrait.php

@@ -107,35 +107,35 @@ public static function associativeArray(
      * constraint.
      *
      * @param int|string        $key        the key 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|ArrayAccess $array      the array to check
      * @param string            $message    additional information about the test
      *
      * @throws ExpectationFailedException
      * @throws InvalidArgumentException
      * @throws Exception
      */
-    public static function assertArrayHasKeyWith($key, Constraint $constraint, $array, string $message = ''): void
+    public static function assertArrayHasKeyWith($key, $constraint, $array, string $message = ''): void
     {
         if (!(is_array($array) || ($array instanceof ArrayAccess))) {
             throw InvalidArgumentException::create(3, 'array or ArrayAccess');
         }
 
-        $constraint = new ArrayHasKeyWith($key, $constraint);
-        PHPUnitAssert::assertThat($array, $constraint, $message);
+        $itemConstraint = new ArrayHasKeyWith($key, $constraint);
+        PHPUnitAssert::assertThat($array, $itemConstraint, $message);
     }
 
     /**
      * Returns a new instance of the ArrayHasKeyWith constraint.
      *
-     * @param int|string $key        the key of the item to check
-     * @param Constraint $constraint the constraint the item's value is applied to
+     * @param int|string       $key        the key of the item to check
+     * @param Constraint|mixed $constraint the constraint the item's value is applied to
      *
      * @return ArrayHasKeyWith
      *
      * @throws InvalidArgumentException
      */
-    public static function arrayHasKeyWith($key, Constraint $constraint): ArrayHasKeyWith
+    public static function arrayHasKeyWith($key, $constraint): ArrayHasKeyWith
     {
         return new ArrayHasKeyWith($key, $constraint);
     }

src/Constraint/ArrayHasKeyWith.php

@@ -21,6 +21,7 @@
 
 use ArrayAccess;
 use PHPUnit\Framework\Constraint\Constraint;
+use PHPUnit\Framework\Constraint\IsEqual;
 use PHPUnit\Framework\InvalidArgumentException;
 
 /**
@@ -31,7 +32,9 @@
  * if the key doesn't exist in the array.
  *
  * The item's key and the constraint the value must pass are passed in the
- * constructor.
+ * 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 ArrayHasKeyWith extends Constraint
 {
@@ -44,19 +47,19 @@ class ArrayHasKeyWith extends Constraint
     /**
      * ArrayHasKeyWith constructor.
      *
-     * @param int|string $key        the key of the item to check
-     * @param Constraint $constraint the constraint the item's value is applied to
+     * @param int|string       $key        the key of the item to check
+     * @param Constraint|mixed $constraint the constraint the item's value is applied to
      *
      * @throws InvalidArgumentException
      */
-    public function __construct($key, Constraint $constraint)
+    public function __construct($key, $constraint)
     {
         if (!(is_int($key) || is_string($key))) {
             throw InvalidArgumentException::create(1, 'integer or string');
         }
 
         $this->key = $key;
-        $this->constraint = $constraint;
+        $this->constraint = !($constraint instanceof Constraint) ? new IsEqual($constraint) : $constraint;
     }
 
     /**

tests/Unit/Constraint/ArrayHasKeyWithTest.php

@@ -37,14 +37,14 @@ class ArrayHasKeyWithTest extends TestCase
     /**
      * @dataProvider dataProviderInvalidParameters
      *
-     * @param string|int $key
-     * @param Constraint $constraint
-     * @param string     $expectedException
-     * @param string     $expectedExceptionMessage
+     * @param string|int       $key
+     * @param Constraint|mixed $constraint
+     * @param string           $expectedException
+     * @param string           $expectedExceptionMessage
      */
     public function testInvalidParameters(
         $key,
-        Constraint $constraint,
+        $constraint,
         string $expectedException,
         string $expectedExceptionMessage
     ): void {
@@ -64,11 +64,11 @@ public function dataProviderInvalidParameters(): array
     /**
      * @dataProvider dataProviderSelfDescribing
      *
-     * @param string|int $key
-     * @param Constraint $constraint
-     * @param string     $expectedDescription
+     * @param string|int       $key
+     * @param Constraint|mixed $constraint
+     * @param string           $expectedDescription
      */
-    public function testSelfDescribing($key, Constraint $constraint, string $expectedDescription): void
+    public function testSelfDescribing($key, $constraint, string $expectedDescription): void
     {
         $mockedConstraint = $this->mockConstraint($constraint, [ 'toString' => $this->once() ]);
 
@@ -87,17 +87,13 @@ public function dataProviderSelfDescribing(): array
     /**
      * @dataProvider dataProviderEvaluate
      *
-     * @param string|int $key
-     * @param Constraint $constraint
-     * @param mixed      $other
-     * @param mixed      $expectedEvaluationValue
+     * @param string|int       $key
+     * @param Constraint|mixed $constraint
+     * @param mixed            $other
+     * @param mixed            $expectedEvaluationValue
      */
-    public function testEvaluate(
-        $key,
-        Constraint $constraint,
-        $other,
-        $expectedEvaluationValue
-    ): void {
+    public function testEvaluate($key, $constraint, $other, $expectedEvaluationValue): void
+    {
         $mockedConstraint = $this->mockConstraint(
             $constraint,
             [ 'evaluate' => $this->once() ],
@@ -123,15 +119,15 @@ public function dataProviderEvaluate(): array
     /**
      * @dataProvider dataProviderEvaluateFail
      *
-     * @param string|int $key
-     * @param Constraint $constraint
-     * @param mixed      $other
-     * @param mixed      $expectedEvaluationValue
-     * @param string     $expectedExceptionMessage
+     * @param string|int       $key
+     * @param Constraint|mixed $constraint
+     * @param mixed            $other
+     * @param mixed            $expectedEvaluationValue
+     * @param string           $expectedExceptionMessage
      */
     public function testEvaluateFail(
         $key,
-        Constraint $constraint,
+        $constraint,
         $other,
         $expectedEvaluationValue,
         string $expectedExceptionMessage
@@ -162,12 +158,12 @@ public function dataProviderEvaluateFail(): array
     /**
      * @dataProvider dataProviderPreEvaluateFail
      *
-     * @param string|int $key
-     * @param Constraint $constraint
-     * @param mixed      $other
-     * @param string     $expectedExceptionMessage
+     * @param string|int       $key
+     * @param Constraint|mixed $constraint
+     * @param mixed            $other
+     * @param string           $expectedExceptionMessage
      */
-    public function testPreEvaluateFail($key, Constraint $constraint, $other, string $expectedExceptionMessage): void
+    public function testPreEvaluateFail($key, $constraint, $other, string $expectedExceptionMessage): void
     {
         $mockedConstraint = $this->mockConstraint($constraint);
 
@@ -191,11 +187,11 @@ public function dataProviderPreEvaluateFail(): array
     /**
      * @dataProvider dataProviderCountable
      *
-     * @param string|int $key
-     * @param Constraint $constraint
-     * @param int        $expectedCount
+     * @param string|int       $key
+     * @param Constraint|mixed $constraint
+     * @param int              $expectedCount
      */
-    public function testCountable($key, Constraint $constraint, int $expectedCount): void
+    public function testCountable($key, $constraint, int $expectedCount): void
     {
         $mockedConstraint = $this->mockConstraint($constraint, [ 'count' => $this->once() ]);
 

tests/data/ArrayHasKeyWithTest.yml

@@ -37,6 +37,9 @@
                 toString: matches something
                 matches: false
                 count: 2
+    paramsKeyStatic: &paramsKeyStatic
+        key: item
+        constraint: static value
     constraintMatches: &constraintMatches
         constraint: { options: { matches: true } }
 
@@ -57,6 +60,8 @@ testSelfDescribing:
         expectedDescription: is an array that has the key 'one' whose value is funny
     -   <<: *paramsKeyZero
         expectedDescription: is an array that has the key 0 whose value matches something
+    -   <<: *paramsKeyStatic
+        expectedDescription: is an array that has the key 'item' whose value is equal to 'static value'
 
 testEvaluate:
     -   <<: *paramsKeyTwo
@@ -81,6 +86,11 @@ testEvaluate:
             ~object: PhrozenByte\PHPUnitArrayAsserts\Tests\Utils\ArrayAccessible
             data: [ 1, 2, 3 ]
         expectedEvaluationValue: 1
+    -   <<: *paramsKeyStatic
+        other:
+            item: static value
+            other: 42
+        expectedEvaluationValue: static value
     -   key: 789
         constraint:
             ~object: PhrozenByte\PHPUnitArrayAsserts\Tests\Utils\TestConstraint
@@ -124,6 +134,12 @@ testPreEvaluateFail:
         other: ~
         expectedExceptionMessage: |-
             Failed asserting that %s is an array that has the key 0 whose value matches something.
+    -   <<: *paramsKeyStatic
+        other:
+            item: other value
+            other: 42
+        expectedExceptionMessage: |-
+            Failed asserting that %s is an array that has the key 'item' whose value is equal to 'static value'.
     -   key: non-existing
         constraint:
             ~object: PhrozenByte\PHPUnitArrayAsserts\Tests\Utils\TestConstraint
@@ -155,3 +171,5 @@ testCountable:
         expectedCount: 2
     -   <<: *paramsKeyZero
         expectedCount: 3
+    -   <<: *paramsKeyStatic
+        expectedCount: 2