Merge branch 'dev' into PHPUnit_8

Author: alezhu

.gitignore

@@ -9,3 +9,4 @@ composer.lock
 /.phpunit.result.cache
 
 /coverage
+/.phpunit.cache

README.md

@@ -1,2 +1,131 @@
-# phpunit-array-contains-asserts
-Provides PHPUnit assertions to test array contains data or structure
+# PHPUnit arrayContains asserts
+
+Provides PHPUnit assertions to test then array-like data contains expected data with expected structure.
+
+This PHPUnit extension was written for PHPUnit 10, but also has branches for PHPUnit 8 and PHPUnit 9 . If it doesn't
+work properly, please don't hesitate to open
+a [new Issue on GitHub](https://github.com/alezhu/phpunit-array-contains-asserts/issues), or, even better, create a Pull
+Request with a proposed fix .
+
+**Table of contents:**
+
+1. [Install](#install)
+2. [Usage](#usage)
+    1. [Constraint `ArrayContains`](#constraint-ArrayContains)
+    2. [Constraint `ArrayContainsOnly`](#constraint-ArrayContainsOnly)
+
+Install
+-------
+
+`PHPUnit arrayContains asserts` is available
+on [Packagist.org](https://packagist.org/packages/alezhu/phpunit-array-contains-asserts) and can be installed
+using [Composer](https://getcomposer.org/):
+
+```shell
+composer require --dev alezhu/phpunit-array-contains-asserts
+```
+
+Usage
+-----
+
+There are three (basically equivalent) options to use `PHPUnitArrayAssertions`:
+
+- By using the
+  static [class `Alezhu\PHPUnitArrayContainsAsserts\Assert`](https://github.com/alezhu/phpunit-array-contains-asserts/blob/main/src/Assert.php)
+- By using
+  the [trait `Alezhu\PHPUnitArrayContainsAsserts\ArrayContainsTrait`](https://github.com/alezhu/phpunit-array-contains-asserts/blob/main/src/ArrayContainsTrait.php)
+  in your test case
+- By creating
+  new [constraint instances](https://github.com/alezhu/phpunit-array-contains-asserts/tree/main/src/Constraint) (`Alezhu\PHPUnitArrayContainsAsserts\Constraint\…`)
+
+All options do the same, the only difference is that the static class and trait both
+throw [class `Alezhu\PHPUnitArrayContainsAsserts\Exception\InvalidArgumentTypeException`](https://github.com/alezhu/phpunit-array-contains-asserts/blob/main/src/Exception/InvalidArgumentTypeException.php) (
+or `PHPUnit\Framework\InvalidArgumentException` for PHPUnit 9 and 8) exceptions for
+invalid parameters.
+Creating new constraint instances is useful for advanced assertions, e.g. together
+with `PHPUnit\Framework\Constraint\LogicalAnd`.
+
+### Constraint `ArrayContains`
+
+The [`ArrayContains` constraint](https://github.com/alezhu/phpunit-array-contains-asserts/blob/main/src/Constraint/ArrayContains.php)
+asserts that an array contains all expected values (for non-associative arrays) or all expected keys with expected
+values (for associative arrays).
+
+Expected values can be set directly or via another PHPUnit constraints (`PHPUnit\Framework\Constraint\...`).
+
+Expected and actual data can be array or iterator or inherit ArrayObject or implements ArrayAccess+Countable interfaces.
+
+Expected and actual data must have same associative kind.
+
+**Usage:**
+
+```php
+use Alezhu\PHPUnitArrayContainsAsserts\Assert;
+use PHPUnit\Framework\Constraint\IsType;
+
+//Passed
+Assert::assertArrayContains(
+    [
+        "foo" => new isType(IsType::TYPE_STRING), 
+        "baz" => 1
+    ], 
+    [
+        "foo" => "value",
+        "bar" => true, 
+        "baz" => 1
+    ]
+); 
+//Not Passed
+Assert::assertArrayContains(
+    [
+        "foo" => new isType(IsType::TYPE_STRING), 
+        "baz" => 1
+    ], 
+    [
+        "foo" => "bar", 
+    ]
+); 
+```
+
+### Constraint `ArrayContainsOnly`
+
+The [`ArrayContainsOnly` constraint](https://github.com/alezhu/phpunit-array-contains-asserts/blob/main/src/Constraint/ArrayContainsOnly.php)
+asserts that an array contains **only** all expected values (for non-associative arrays) or ***only*** all expected keys
+with expected values (for associative arrays).
+
+Expected values can be set directly or via another PHPUnit constraints (`PHPUnit\Framework\Constraint\...`).
+
+Expected and actual data can be array or iterator or inherit ArrayObject or implements ArrayAccess+Countable interfaces.
+
+Expected and actual data must have same associative kind.
+
+**Usage:**
+
+```php
+use Alezhu\PHPUnitArrayContainsAsserts\Assert;
+use PHPUnit\Framework\Constraint\IsType;
+
+//Passed
+Assert::assertArrayContainsOnly(
+    [
+        "foo" => new isType(IsType::TYPE_STRING), 
+        "baz" => 1
+    ], 
+    [
+        "foo" => "value",
+        "baz" => 1
+    ]
+); 
+//Not Passed
+Assert::assertArrayContainsOnly(
+    [
+        "foo" => new isType(IsType::TYPE_STRING), 
+        "baz" => 1
+    ], 
+    [
+        "foo" => "bar",
+        "bar" => true, 
+        "baz" => 1         
+    ]
+); 
+```

tests/Alezhu/PHPUnitArrayContainsAsserts/Constraint/ArrayContainsTest.php

@@ -4,6 +4,7 @@
 
 use Alezhu\PHPUnitArrayContainsAsserts\Constraint\ArrayContains;
 use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\Constraint\IsType;
 use PHPUnit\Framework\ExpectationFailedException;
 use PHPUnit\Framework\TestCase;
 use SebastianBergmann\Exporter\Exporter;
@@ -36,7 +37,7 @@ public function test_matches_unassoc_should_be_valid_if_all_expected_values_in_r
 
     public function test_matches_assoc_should_be_valid_if_all_expected_values_in_result()
     {
-        $instance = new ArrayContains(["foo" => self::isType("string"), "bar" => 1]);
+        $instance = new ArrayContains(["foo" => self::isType(IsType::TYPE_STRING), "bar" => 1]);
         $result = $instance->evaluate(["bar" => 1, "foo" => "value", "baz" => true], '', true);
         self::assertTrue($result);
     }
@@ -79,7 +80,7 @@ public function test_matches_assoc_should_raise_exception_if_some_of_expected_ke
     {
         $this->expectException(ExpectationFailedException::class);
         $result = ["bar" => "value"];
-        $instance = new ArrayContains(["foo" => self::isType("string"), "bar" => 1]);
+        $instance = new ArrayContains(["foo" => self::isType(IsType::TYPE_STRING), "bar" => 1]);
         $exporter = new Exporter();
         $this->expectExceptionMessage(
             sprintf(
@@ -95,7 +96,7 @@ public function test_matches_assoc_should_raise_exception_if_some_of_expected_va
     {
         $this->expectException(ExpectationFailedException::class);
         $result = ["bar" => "value", "foo" => "value"];
-        $instance = new ArrayContains(["foo" => self::isType("string"), "bar" => 1]);
+        $instance = new ArrayContains(["foo" => self::isType(IsType::TYPE_STRING), "bar" => 1]);
         $exporter = new Exporter();
         $this->expectExceptionMessage(
             sprintf(

tests/ArrayContainsTraitTest.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Alezhu\PHPUnitArrayContainsAsserts\Tests;
+
+
+use Alezhu\PHPUnitArrayContainsAsserts\Assert;
+use Alezhu\PHPUnitArrayContainsAsserts\Exception\InvalidArgumentTypeException;
+use PHPUnit\Framework\TestCase;
+
+class ArrayContainsTraitTest extends TestCase
+{
+    public function test_assertArrayContains_should_be_valid_for_valid_arguments()
+    {
+        Assert::assertArrayContains(["foo" => "bar", "baz" => 1], ["foo" => "bar", "baz" => 1]);
+    }
+
+    public function test_assertArrayContainsOnly_should_be_valid_for_valid_arguments()
+    {
+        Assert::assertArrayContainsOnly(["foo" => "bar", "baz" => 1], ["foo" => "bar", "baz" => 1]);
+    }
+
+    public function test_assertArrayContains_should_raise_exception_if_passed_not_array_like_subset()
+    {
+        $this->expectException(InvalidArgumentTypeException::class);
+        $this->expectExceptionMessage("Argument #1 must be array or ArrayAccess or Iterator");
+
+        Assert::assertArrayContains("string", []);
+    }
+
+    public function test_assertArrayContains_should_raise_exception_if_passed_not_array_like_actual()
+    {
+        $this->expectException(InvalidArgumentTypeException::class);
+        $this->expectExceptionMessage("Argument #2 must be array or ArrayAccess or Iterator");
+
+        Assert::assertArrayContains([], "string");
+    }
+
+    public function test_assertArrayContainsOnly_should_raise_exception_if_passed_not_array_like_subset()
+    {
+        $this->expectException(InvalidArgumentTypeException::class);
+        $this->expectExceptionMessage("Argument #1 must be array or ArrayAccess or Iterator");
+
+        Assert::assertArrayContainsOnly("string", []);
+    }
+
+    public function test_assertArrayContainsOnly_should_raise_exception_if_passed_not_array_like_actual()
+    {
+        $this->expectException(InvalidArgumentTypeException::class);
+        $this->expectExceptionMessage("Argument #2 must be array or ArrayAccess or Iterator");
+
+        Assert::assertArrayContainsOnly([], "string");
+    }
+}