Fix: Test data providers directly

.github/workflows/integrate.yaml

@@ -10,8 +10,8 @@ on: # yamllint disable-line rule:truthy
 
 env:
   ERGEBNIS_BOT_NAME: "ergebnis-bot"
-  MIN_COVERED_MSI: 95
-  MIN_MSI: 66
+  MIN_COVERED_MSI: 91
+  MIN_MSI: 91
   PHP_EXTENSIONS: "mbstring"
 
 jobs:

Makefile

@@ -1,5 +1,5 @@
-MIN_COVERED_MSI:=95
-MIN_MSI:=66
+MIN_COVERED_MSI:=91
+MIN_MSI:=91
 
 .PHONY: it
 it: coding-standards static-code-analysis tests ## Runs the coding-standards, static-code-analysis, and tests targets

phpstan-baseline.neon

@@ -545,6 +545,11 @@ parameters:
 			count: 1
 			path: test/AutoReview/TestCodeTest.php
 
+		-
+			message: "#^Parameter \\#1 \\$argument of class ReflectionClass constructor expects class\\-string\\<T of object\\>\\|T of object, string given\\.$#"
+			count: 2
+			path: test/Unit/DataProvider/AbstractProviderTestCase.php
+
 		-
 			message: "#^Method Ergebnis\\\\Test\\\\Util\\\\Test\\\\Unit\\\\Exception\\\\EmptyValuesTest\\:\\:faker\\(\\) is protected, but since the containing class is final, it can be private\\.$#"
 			count: 1

phpstan.neon

@@ -5,7 +5,7 @@ parameters:
 	checkMissingIterableValueType: false
 	ergebnis:
 		classesAllowedToBeExtended:
-			- Ergebnis\Test\Util\DataProvider\AbstractDataProvider
+			- Ergebnis\Test\Util\Test\Unit\DataProvider\AbstractProviderTestCase
 			- InvalidArgumentException
 	excludes_analyse:
 		- %currentWorkingDirectory%/test/Fixture/

test/Unit/DataProvider/AbstractProviderTestCase.php

@@ -0,0 +1,166 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Copyright (c) 2017-2020 Andreas Möller
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE.md file that was distributed with this source code.
+ *
+ * @see https://github.com/ergebnis/test-util
+ */
+
+namespace Ergebnis\Test\Util\Test\Unit\DataProvider;
+
+use Ergebnis\Test\Util;
+use PHPUnit\Framework;
+
+/**
+ * @internal
+ */
+abstract class AbstractProviderTestCase extends Framework\TestCase
+{
+    use Util\Helper;
+
+    /**
+     * @param array<string, mixed>             $values
+     * @param \Generator<string, array<mixed>> $provider
+     */
+    final protected static function assertProvidesDataForValues(array $values, \Generator $provider): void
+    {
+        self::assertExpectedValuesAreNotEmpty($values);
+
+        $expected = \iterator_to_array(self::provideDataForValues($values));
+
+        $provided = \iterator_to_array($provider);
+
+        self::assertProvidedDataIsNotEmpty($provided);
+
+        self::assertEquals(
+            $expected,
+            $provided,
+            'Failed asserting that a generator yields data for expected values.'
+        );
+    }
+
+    /**
+     * @param \Closure                         $test
+     * @param \Generator<string, array<mixed>> $provider
+     */
+    final protected static function assertProvidesDataForValuesWhere(\Closure $test, \Generator $provider): void
+    {
+        $provided = \iterator_to_array($provider);
+
+        self::assertProvidedDataIsNotEmpty($provided);
+        self::assertProvidedDataContainsArraysWhereFirstElementPassesTest($test, $provided);
+    }
+
+    /**
+     * @param \Closure                         $test
+     * @param \Generator<string, array<mixed>> $provider
+     */
+    final protected static function assertProvidesDataForValuesWhereNot(\Closure $test, \Generator $provider): void
+    {
+        $provided = \iterator_to_array($provider);
+
+        self::assertProvidedDataIsNotEmpty($provided);
+        self::assertProvidedDataContainsArraysWhereFirstElementDoesNotPassTest($test, $provided);
+    }
+
+    /**
+     * @param array $actual
+     */
+    final protected static function assertProvidedDataIsNotEmpty(array $actual): void
+    {
+        self::assertNotEmpty($actual, 'Failed asserting that provided values are not empty.');
+    }
+
+    /**
+     * @param array $values
+     */
+    private static function assertExpectedValuesAreNotEmpty(array $values): void
+    {
+        self::assertNotEmpty($values, 'Failed asserting that expected values are not empty.');
+    }
+
+    /**
+     * @param \Closure             $test
+     * @param array<string, mixed> $provided
+     */
+    private static function assertProvidedDataContainsArraysWhereFirstElementPassesTest(\Closure $test, array $provided): void
+    {
+        self::assertProvidedDataContainsArraysWithOneElement($provided);
+
+        $value = \array_map(static function (array $set) {
+            return \array_shift($set);
+        }, $provided);
+
+        $tested = \array_filter($value, static function ($value) use ($test): bool {
+            return true === $test($value);
+        });
+
+        self::assertEquals(
+            $value,
+            $tested,
+            'Failed asserting that the first value in each array passed the test.'
+        );
+    }
+
+    /**
+     * @param \Closure             $test
+     * @param array<string, mixed> $provided
+     */
+    private static function assertProvidedDataContainsArraysWhereFirstElementDoesNotPassTest(\Closure $test, array $provided): void
+    {
+        self::assertProvidedDataContainsArraysWithOneElement($provided);
+
+        $value = \array_map(static function (array $set) {
+            return \array_shift($set);
+        }, $provided);
+
+        $tested = \array_filter($value, static function ($value) use ($test): bool {
+            return false === $test($value);
+        });
+
+        self::assertEquals(
+            $value,
+            $tested,
+            'Failed asserting that the first value in each array does not pass the test.'
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $provided
+     */
+    private static function assertProvidedDataContainsArraysWithOneElement(array $provided): void
+    {
+        self::assertProvidedDataContainsArraysOnly($provided);
+
+        $setsWhereNumberOfProvidedArgumentsIsNotOne = \array_filter($provided, static function (array $set): bool {
+            return 1 !== \count($set);
+        });
+
+        self::assertEquals(
+            [],
+            $setsWhereNumberOfProvidedArgumentsIsNotOne,
+            'Failed asserting that each set in the provided data contains only a single value.'
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $provided
+     */
+    private static function assertProvidedDataContainsArraysOnly(array $provided): void
+    {
+        $values = \array_filter($provided, static function ($set): bool {
+            return !\is_array($set);
+        });
+
+        self::assertEquals(
+            [],
+            $values,
+            'Failed asserting that each value is an array.'
+        );
+    }
+}

test/Unit/DataProvider/BooleanProviderTest.php

@@ -13,14 +13,14 @@
 
 namespace Ergebnis\Test\Util\Test\Unit\DataProvider;
 
-use PHPUnit\Framework;
+use Ergebnis\Test\Util\DataProvider\BooleanProvider;
 
 /**
  * @internal
  *
  * @covers \Ergebnis\Test\Util\DataProvider\BooleanProvider
  */
-final class BooleanProviderTest extends Framework\TestCase
+final class BooleanProviderTest extends AbstractProviderTestCase
 {
     /**
      * @dataProvider \Ergebnis\Test\Util\DataProvider\BooleanProvider::arbitrary()
@@ -32,6 +32,18 @@ public function testArbitraryProvidesBoolean($value): void
         self::assertIsBool($value);
     }
 
+    public function testArbitraryReturnsGeneratorThatProvidesBooleanValues(): void
+    {
+        $values = [
+            'boolean-false' => false,
+            'boolean-true' => true,
+        ];
+
+        $provider = BooleanProvider::arbitrary();
+
+        self::assertProvidesDataForValues($values, $provider);
+    }
+
     /**
      * @dataProvider \Ergebnis\Test\Util\DataProvider\BooleanProvider::false()
      *
@@ -42,6 +54,17 @@ public function testFalseProvidesFalse($value): void
         self::assertFalse($value);
     }
 
+    public function testFalseReturnsGeneratorThatProvidesFalse(): void
+    {
+        $values = [
+            'boolean-false' => false,
+        ];
+
+        $provider = BooleanProvider::false();
+
+        self::assertProvidesDataForValues($values, $provider);
+    }
+
     /**
      * @dataProvider \Ergebnis\Test\Util\DataProvider\BooleanProvider::true()
      *
@@ -51,4 +74,15 @@ public function testTrueProvidesTrue($value): void
     {
         self::assertTrue($value);
     }
+
+    public function testTrueReturnsGeneratorThatProvidesTrue(): void
+    {
+        $values = [
+            'boolean-true' => true,
+        ];
+
+        $provider = BooleanProvider::true();
+
+        self::assertProvidesDataForValues($values, $provider);
+    }
 }

test/Unit/DataProvider/NullProviderTest.php

@@ -13,14 +13,14 @@
 
 namespace Ergebnis\Test\Util\Test\Unit\DataProvider;
 
-use PHPUnit\Framework;
+use Ergebnis\Test\Util\DataProvider\NullProvider;
 
 /**
  * @internal
  *
  * @covers \Ergebnis\Test\Util\DataProvider\NullProvider
  */
-final class NullProviderTest extends Framework\TestCase
+final class NullProviderTest extends AbstractProviderTestCase
 {
     /**
      * @dataProvider \Ergebnis\Test\Util\DataProvider\NullProvider::null()
@@ -31,4 +31,15 @@ public function testNullProvidesNull($value): void
     {
         self::assertNull($value);
     }
+
+    public function testNullReturnsGeneratorThatProvidesNull(): void
+    {
+        $values = [
+            'null' => null,
+        ];
+
+        $provider = NullProvider::null();
+
+        self::assertProvidesDataForValues($values, $provider);
+    }
 }