Improve behat tests

Author: Kirill Nesmeyanov

behat.yml

@@ -5,7 +5,10 @@ default:
         - '%paths.base%/tests/Feature'
       contexts:
         # Executors
-        - TypeLang\Mapper\Tests\Context\Execution\MapTypeContext
+        - TypeLang\Mapper\Tests\Context\Assert\TypeCastAssertions
+        - TypeLang\Mapper\Tests\Context\Assert\TypeMatchAssertions
+        - TypeLang\Mapper\Tests\Context\Assert\TypeStatementAssertions
+        - TypeLang\Mapper\Tests\Context\Assert\ValueAssertions
         # Providers
         - TypeLang\Mapper\Tests\Context\Provider\ConfigurationContext
         - TypeLang\Mapper\Tests\Context\Provider\MappingContext

tests/Context/Assert/TypeCastAssertions.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Context\Assert;
+
+use Behat\Step\Then;
+use TypeLang\Mapper\Tests\Context\Context;
+use TypeLang\Mapper\Tests\Context\Provider\MappingContext;
+use TypeLang\Mapper\Tests\Context\Provider\TypeContext;
+
+/**
+ * @api
+ * @see http://behat.org/en/latest/quick_start.html
+ */
+final class TypeCastAssertions extends Context
+{
+    #[Then('/^cast of "(?P<input>.+?)" must return (?P<expected>.+?)$/')]
+    public function thenCast(string $inputCode, string $expectedCode): void
+    {
+        $inputValue = eval(\sprintf('return %s;', $inputCode));
+
+        $type = $this->from(TypeContext::class)
+            ->getCurrent();
+
+        $context = $this->from(MappingContext::class)
+            ->setContextByValue($inputValue);
+
+        $values = $this->from(ValueAssertions::class);
+
+        try {
+            $actualValue = $type->cast($inputValue, $context);
+
+            $values->assertCompareWithCode(
+                expected: $expectedCode,
+                actual: $actualValue,
+                message: \vsprintf('Type %s expects "%s" to be "%s" after casting:', [
+                    $type::class,
+                    $inputCode,
+                    $expectedCode,
+                ]),
+            );
+        } catch (\Throwable $e) {
+            $values->assertCompareWithCode(
+                expected: $expectedCode,
+                actual: $e,
+            );
+        }
+    }
+}

tests/Context/Assert/TypeMatchAssertions.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Context\Assert;
+
+use Behat\Step\Then;
+use PHPUnit\Framework\Assert;
+use TypeLang\Mapper\Tests\Context\Context;
+use TypeLang\Mapper\Tests\Context\Provider\MappingContext;
+use TypeLang\Mapper\Tests\Context\Provider\TypeContext;
+
+/**
+ * @api
+ * @see http://behat.org/en/latest/quick_start.html
+ */
+final class TypeMatchAssertions extends Context
+{
+    #[Then('/^match of "(?P<value>.+?)" must return (?P<status>false|true)$/')]
+    public function thenMatch(string $code, string $status): void
+    {
+        $value = eval(\sprintf('return %s;', $code));
+
+        $type = $this->from(TypeContext::class)
+            ->getCurrent();
+
+        $context = $this->from(MappingContext::class)
+            ->setContextByValue($value);
+
+        $actual = $type->match($value, $context);
+
+        $message = \vsprintf('Type %s expects matching of %s to be %s, got %s', [
+            $type::class,
+            $code,
+            $status,
+            $actual ? 'true' : 'false',
+        ]);
+
+        if (\strtolower($status) === 'true') {
+            Assert::assertTrue($actual, $message);
+        } else {
+            Assert::assertFalse($actual, $message);
+        }
+    }
+}

tests/Context/Assert/TypeStatementAssertions.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Context\Assert;
+
+use Behat\Step\Then;
+use PHPUnit\Framework\Assert;
+use TypeLang\Mapper\Tests\Context\Context;
+use TypeLang\Mapper\Tests\Context\Provider\PlatformContext;
+use TypeLang\Mapper\Tests\Context\Provider\TypeContext;
+use TypeLang\Printer\PrettyPrinter;
+
+/**
+ * @api
+ * @see http://behat.org/en/latest/quick_start.html
+ */
+final class TypeStatementAssertions extends Context
+{
+    #[Then('/^the type must be defined$/')]
+    public function thenTypeMustBeDefined(): void
+    {
+        $statement = $this->from(TypeContext::class)
+            ->getStatement();
+
+        $platform = $this->from(PlatformContext::class)
+            ->getCurrent();
+
+        foreach ($platform->getTypes() as $builder) {
+            if ($builder->isSupported($statement)) {
+                return;
+            }
+        }
+
+        Assert::fail(\vsprintf('The type "%s" is not defined in "%s" platform', [
+            (new PrettyPrinter())->print($statement),
+            $platform->getName(),
+        ]));
+    }
+}

tests/Context/Assert/ValueAssertions.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Context\Assert;
+
+use PHPUnit\Framework\Assert;
+use TypeLang\Mapper\Exception\Mapping\InvalidValueException;
+use TypeLang\Mapper\Tests\Context\Context;
+
+/**
+ * @api
+ * @see http://behat.org/en/latest/quick_start.html
+ */
+final class ValueAssertions extends Context
+{
+    public function assertCompareWithCode(string $expected, mixed $actual, string $message = ''): void
+    {
+        if (\str_starts_with($expected, '<error:') && \str_ends_with($expected, '>')) {
+            $expected = \trim(\substr($expected, 7, -1));
+
+            Assert::assertInstanceOf(InvalidValueException::class, $actual);
+            Assert::assertStringContainsString($expected, $actual->getMessage());
+
+            return;
+        }
+
+        if ($actual instanceof \Throwable) {
+            throw $actual;
+        }
+
+        $expectedValue = eval(\sprintf('return %s;', $expected));
+
+        if (\is_float($expectedValue) && \is_nan($expectedValue)) {
+            Assert::assertNan($actual, $message);
+        } elseif (\is_object($expectedValue) || \is_object($actual)) {
+            Assert::assertEquals($expectedValue, $actual, $message);
+        } else {
+            Assert::assertSame($expectedValue, $actual, $message);
+        }
+    }
+}

tests/Context/Execution/MapTypeContext.php

@@ -4,7 +4,6 @@
 
 namespace TypeLang\Mapper\Tests\Context\Provider;
 
-use PHPUnit\Framework\Assert;
 use TypeLang\Mapper\Runtime\Configuration;
 use TypeLang\Mapper\Runtime\ConfigurationInterface;
 use TypeLang\Mapper\Tests\Context\Context;

tests/Context/Provider/ConfigurationContext.php

@@ -47,6 +47,16 @@ public function setCurrent(PlatformInterface $platform): PlatformInterface
         return $this->current = $platform;
     }
 
+    #[Given('/^platform "(?P<platform>[a-zA-Z0-9_\x80-\xff\\\\]+?)"$/')]
+    public function givenPlatform(string $platform): void
+    {
+        // @phpstan-ignore-next-line
+        $this->setCurrent(new $platform(
+            $this->from(MetadataContext::class)
+                ->getDriver(),
+        ));
+    }
+
     #[Given('no platform')]
     #[Given('empty platform')]
     public function givenEmptyPlatform(): void

tests/Context/Provider/PlatformContext.php

@@ -9,6 +9,7 @@
 use TypeLang\Mapper\Tests\Context\Context;
 use TypeLang\Mapper\Tests\Extension\ContextArgumentTransformerExtension\AsTestingContext;
 use TypeLang\Mapper\Type\TypeInterface;
+use TypeLang\Parser\Node\Stmt\TypeStatement;
 
 /**
  * @api
@@ -19,6 +20,8 @@ final class TypeContext extends Context
 {
     private ?TypeInterface $current = null;
 
+    private ?TypeStatement $statement = null;
+
     /**
      * @api
      */
@@ -37,14 +40,41 @@ public function setCurrent(TypeInterface $type): TypeInterface
         return $this->current = $type;
     }
 
-    #[Given('/^type "(?P<type>[a-zA-Z0-9_\x80-\xff\\\\]+?)"$/')]
-    public function givenType(string $type): void
+    /**
+     * @api
+     */
+    public function getStatement(): TypeStatement
+    {
+        Assert::assertNotNull($this->statement, 'Type statement is not set');
+
+        return $this->statement;
+    }
+
+    /**
+     * @api
+     */
+    public function setStatement(TypeStatement $type): TypeStatement
+    {
+        return $this->statement = $type;
+    }
+
+    #[Given('/^type statement "(?P<type>.+?)"$/')]
+    public function givenTypeStatement(string $type): void
+    {
+        $parser = $this->from(TypeParserContext::class)
+            ->getCurrent();
+
+        $this->setStatement($parser->getStatementByDefinition($type));
+    }
+
+    #[Given('/^type "(?P<class>[a-zA-Z0-9_\x80-\xff\\\\]+?)"$/')]
+    public function givenType(string $class): void
     {
-        $this->givenTypeWith($type);
+        $this->givenTypeWith($class);
     }
 
-    #[Given('/^type "(?P<type>[a-zA-Z0-9_\x80-\xff\\\\]+?)" with (?P<args>.+?)$/')]
-    public function givenTypeWith(string $type, string $args = '{}'): void
+    #[Given('/^type "(?P<class>[a-zA-Z0-9_\x80-\xff\\\\]+?)" with (?P<args>.+?)$/')]
+    public function givenTypeWith(string $class, string $args = '{}'): void
     {
         try {
             $arguments = \json_decode($args, true, flags: \JSON_THROW_ON_ERROR);
@@ -53,6 +83,6 @@ public function givenTypeWith(string $type, string $args = '{}'): void
         }
 
         // @phpstan-ignore-next-line
-        $this->setCurrent(new $type(...$arguments));
+        $this->setCurrent(new $class(...$arguments));
     }
 }