Backed enums (#71)

* matcher for native backed enums

* Matcher backedEnumValue method. Correct typing of BackedEnumValueMatcher constructor input.

* Matcher backedEnumCase method.

* CR resolutions

* Moving test enums to subfolder.

src/MockeryTools/Enum/BackedEnumCaseMatcher.php

@@ -0,0 +1,38 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum;
+
+use BackedEnum;
+use Mockery\Matcher\MatcherInterface;
+
+/**
+ * @final
+ */
+class BackedEnumCaseMatcher implements MatcherInterface
+{
+    protected BackedEnum $expected;
+
+
+    public function __construct(BackedEnum $expected)
+    {
+        $this->expected = $expected;
+    }
+
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
+     *
+     * @param mixed $actual
+     */
+    public function match(&$actual): bool
+    {
+        return $actual === $this->expected;
+    }
+
+
+    public function __toString(): string
+    {
+        return '<EnumValue:' . $this->expected->value . '>';
+    }
+}

src/MockeryTools/Enum/BackedEnumCaseMatcherTest.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum;
+
+use BackedEnum;
+use BrandEmbassy\MockeryTools\Enum\__fixtures__\TestOnlyBackedIntEnum;
+use BrandEmbassy\MockeryTools\Enum\__fixtures__\TestOnlyBackedStringAnotherEnum;
+use BrandEmbassy\MockeryTools\Enum\__fixtures__\TestOnlyBackedStringEnum;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @final
+ */
+class BackedEnumCaseMatcherTest extends TestCase
+{
+    /**
+     * @dataProvider matchingDataProvider
+     */
+    public function testMatching(bool $expectedResult, BackedEnum $expectedEnumCase, BackedEnum $enumToMatch): void
+    {
+        $matcher = new BackedEnumCaseMatcher($expectedEnumCase);
+
+        $result = $matcher->match($enumToMatch);
+
+        Assert::assertSame($expectedResult, $result);
+    }
+
+
+    /**
+     * @return array<string, array<string, mixed>>
+     */
+    public static function matchingDataProvider(): array
+    {
+        return [
+            'Matching case (value string)' => [
+                'expectedResult' => true,
+                'expectedEnumValue' => TestOnlyBackedStringEnum::STRING_VALUE,
+                'enumToMatch' => TestOnlyBackedStringEnum::STRING_VALUE,
+            ],
+            'Matching case (integer case)' => [
+                'expectedResult' => true,
+                'expectedEnumValue' => TestOnlyBackedIntEnum::INTEGER_VALUE,
+                'enumToMatch' => TestOnlyBackedIntEnum::INTEGER_VALUE,
+            ],
+            'Not matching - same string, different enum' => [
+                'expectedResult' => false,
+                'expectedEnumValue' => TestOnlyBackedStringAnotherEnum::STRING_VALUE,
+                'enumToMatch' => TestOnlyBackedStringEnum::STRING_VALUE,
+            ],
+            'Not matching - string vs int, different enums' => [
+                'expectedResult' => false,
+                'expectedEnumValue' => TestOnlyBackedIntEnum::INTEGER_VALUE,
+                'enumToMatch' => TestOnlyBackedStringEnum::INTEGER_AS_STRING_VALUE,
+            ],
+        ];
+    }
+}

src/MockeryTools/Enum/BackedEnumValueMatcher.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum;
+
+use Mockery\Matcher\MatcherInterface;
+use ReflectionEnum;
+use function assert;
+
+/**
+ * @final
+ */
+class BackedEnumValueMatcher implements MatcherInterface
+{
+    protected int|string $expected;
+
+
+    public function __construct(string|int $expected)
+    {
+        $this->expected = $expected;
+    }
+
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
+     *
+     * @param mixed $actual
+     */
+    public function match(&$actual): bool
+    {
+        $rEnum = new ReflectionEnum($actual);
+        assert($rEnum->isBacked());
+
+        return $actual->value === $this->expected;
+    }
+
+
+    public function __toString(): string
+    {
+        return '<EnumValue:' . $this->expected . '>';
+    }
+}

src/MockeryTools/Enum/BackedEnumValueMatcherTest.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum;
+
+use BackedEnum;
+use BrandEmbassy\MockeryTools\Enum\__fixtures__\TestOnlyBackedIntEnum;
+use BrandEmbassy\MockeryTools\Enum\__fixtures__\TestOnlyBackedStringEnum;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @final
+ */
+class BackedEnumValueMatcherTest extends TestCase
+{
+    /**
+     * @dataProvider uuidDataProvider
+     */
+    public function testMatching(bool $expectedResult, string|int $expectedEnumValue, BackedEnum $enumToMatch): void
+    {
+        $matcher = new BackedEnumValueMatcher($expectedEnumValue);
+
+        $result = $matcher->match($enumToMatch);
+
+        Assert::assertSame($expectedResult, $result);
+    }
+
+
+    /**
+     * @return array<string, array<string, mixed>>
+     */
+    public static function uuidDataProvider(): array
+    {
+        return [
+            'Matching string value' => [
+                'expectedResult' => true,
+                'expectedEnumValue' => TestOnlyBackedStringEnum::STRING_VALUE->value,
+                'enumToMatch' => TestOnlyBackedStringEnum::STRING_VALUE,
+            ],
+            'Matching integer value' => [
+                'expectedResult' => true,
+                'expectedEnumValue' => TestOnlyBackedIntEnum::INTEGER_VALUE->value,
+                'enumToMatch' => TestOnlyBackedIntEnum::INTEGER_VALUE,
+            ],
+            'Not matching string values' => [
+                'expectedResult' => false,
+                'expectedEnumValue' => 'another-string-value-1',
+                'enumToMatch' => TestOnlyBackedStringEnum::STRING_VALUE,
+            ],
+            'Not matching data types' => [
+                'expectedResult' => false,
+                'expectedEnumValue' => TestOnlyBackedIntEnum::INTEGER_VALUE->value,
+                'enumToMatch' => TestOnlyBackedStringEnum::INTEGER_AS_STRING_VALUE,
+            ],
+        ];
+    }
+}

src/MockeryTools/Enum/EnumValueMatcherTest.php

@@ -2,8 +2,8 @@
 
 namespace BrandEmbassy\MockeryTools\Enum;
 
+use BrandEmbassy\MockeryTools\Enum\__fixtures__\TestOnlyEnum;
 use MabeEnum\Enum;
-use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\TestCase;
 
@@ -12,9 +12,6 @@
  */
 class EnumValueMatcherTest extends TestCase
 {
-    use MockeryPHPUnitIntegration;
-
-
     /**
      * @dataProvider uuidDataProvider
      *

src/MockeryTools/Enum/__fixtures__/TestOnlyBackedIntEnum.php

@@ -0,0 +1,8 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum\__fixtures__;
+
+enum TestOnlyBackedIntEnum: int
+{
+    case INTEGER_VALUE = 551;
+}

src/MockeryTools/Enum/__fixtures__/TestOnlyBackedStringAnotherEnum.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum\__fixtures__;
+
+enum TestOnlyBackedStringAnotherEnum: string
+{
+    case STRING_VALUE = 'string-value';
+    case INTEGER_AS_STRING_VALUE = '551';
+}

src/MockeryTools/Enum/__fixtures__/TestOnlyBackedStringEnum.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types = 1);
+
+namespace BrandEmbassy\MockeryTools\Enum\__fixtures__;
+
+enum TestOnlyBackedStringEnum: string
+{
+    case STRING_VALUE = 'string-value';
+    case INTEGER_AS_STRING_VALUE = '551';
+}

src/MockeryTools/Enum/TestOnlyEnum.php → src/MockeryTools/Enum/__fixtures__/TestOnlyEnum.php

@@ -1,6 +1,6 @@
 <?php declare(strict_types = 1);
 
-namespace BrandEmbassy\MockeryTools\Enum;
+namespace BrandEmbassy\MockeryTools\Enum\__fixtures__;
 
 use MabeEnum\Enum;
 

src/MockeryTools/Matcher/Matcher.php

@@ -2,9 +2,12 @@
 
 namespace BrandEmbassy\MockeryTools\Matcher;
 
+use BackedEnum;
 use BrandEmbassy\MockeryTools\DateTime\DateTimeAsAtomMatcher;
 use BrandEmbassy\MockeryTools\DateTime\DateTimeAsTimestampMatcher;
 use BrandEmbassy\MockeryTools\DateTime\DateTimeZoneNameMatcher;
+use BrandEmbassy\MockeryTools\Enum\BackedEnumCaseMatcher;
+use BrandEmbassy\MockeryTools\Enum\BackedEnumValueMatcher;
 use BrandEmbassy\MockeryTools\Enum\EnumValueMatcher;
 use BrandEmbassy\MockeryTools\Http\HttpRequestMatcher;
 use BrandEmbassy\MockeryTools\String\StringStartsWithMatcher;
@@ -52,6 +55,18 @@ public static function uri(string $expectedUri): UriMatcher
     }
 
 
+    public static function backedEnumCase(BackedEnum $expectedValue): BackedEnumCaseMatcher
+    {
+        return new BackedEnumCaseMatcher($expectedValue);
+    }
+
+
+    public static function backedEnumValue(string|int $expectedValue): BackedEnumValueMatcher
+    {
+        return new BackedEnumValueMatcher($expectedValue);
+    }
+
+
     /**
      * @param mixed $expectedValue
      */