Test RootTypeResolver

src/TypeResolver/ResolveException.php

@@ -12,4 +12,12 @@ public static function logicError(string $error): self
     {
         return new self(sprintf('Logic error: %s', $error));
     }
+
+    /**
+     * @param class-string $typeId
+     */
+    public static function nodeTypeIdNotInContainer(string $typeId): self
+    {
+        return new self(sprintf('Node type ID %s is not in a container (or not publicly accessible)', $typeId));
+    }
 }

src/TypeResolver/RootTypeResolver.php

@@ -19,8 +19,15 @@ public function __construct(
         private ContainerInterface $container,
     ) {}
 
+    /**
+     * @throws ResolveException
+     */
     public function resolve(MutationNode|QueryNode $node, Ast $ast): callable
     {
+        if (!$this->container->has($node->typeId)) {
+            throw ResolveException::nodeTypeIdNotInContainer($node->typeId);
+        }
+
         return function ($rootValue, array $args) use ($node, $ast) {
             /** @var array<string, mixed> $args */
             return $this->container->get($node->typeId)->{$node->methodName}(

tests/Doubles/Container/TestContainer.php

@@ -9,11 +9,16 @@
 final class TestContainer implements ContainerInterface
 {
     /**
-     * @var array<string, mixed>
+     * @var array<string, object>
      */
     public array $services = [];
 
-    public function get(string $id): mixed
+    public function set(string $id, object $service): void
+    {
+        $this->services[$id] = $service;
+    }
+
+    public function get(string $id): ?object
     {
         return $this->services[$id] ?? null;
     }

tests/Doubles/InputType/TestResolvableInputType.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Test\Doubles\InputType;
+
+use Jerowork\GraphqlAttributeSchema\Attribute\Field;
+use Jerowork\GraphqlAttributeSchema\Attribute\InputType;
+
+#[InputType]
+final readonly class TestResolvableInputType
+{
+    public function __construct(
+        #[Field]
+        public string $name,
+    ) {}
+}

tests/Doubles/Mutation/TestMutation.php

@@ -7,6 +7,7 @@
 use Jerowork\GraphqlAttributeSchema\Attribute\Arg;
 use Jerowork\GraphqlAttributeSchema\Attribute\Mutation;
 use DateTimeImmutable;
+use DateTimeInterface;
 
 #[Mutation(description: 'Test mutation')]
 final readonly class TestMutation
@@ -18,6 +19,10 @@ public function __invoke(
         #[Arg(name: 'mutationId', description: 'Mutation ID')]
         ?string $id,
     ): string {
-        return '';
+        return sprintf(
+            'Mutation has been called with date %s and id %s',
+            $date->format(DateTimeInterface::RFC3339_EXTENDED),
+            $id,
+        );
     }
 }

tests/Doubles/Mutation/TestResolvableMutation.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Test\Doubles\Mutation;
+
+use Jerowork\GraphqlAttributeSchema\Attribute\Mutation;
+use Jerowork\GraphqlAttributeSchema\Test\Doubles\InputType\TestResolvableInputType;
+
+#[Mutation]
+final readonly class TestResolvableMutation
+{
+    public function __invoke(string $id, TestResolvableInputType $input): string
+    {
+        return sprintf(
+            'Mutation has been called with id %s and input with name %s',
+            $id,
+            $input->name,
+        );
+    }
+}

tests/TypeBuilder/RootTypeBuilderTest.php

@@ -22,6 +22,7 @@
  */
 final class RootTypeBuilderTest extends TestCase
 {
+    private TestContainer $container;
     private RootTypeBuilder $builder;
 
     #[Override]
@@ -31,13 +32,17 @@ protected function setUp(): void
 
         $this->builder = new RootTypeBuilder(
             new TypeBuilder([]),
-            new RootTypeResolver(new TestContainer()),
+            new RootTypeResolver(
+                $this->container = new TestContainer(),
+            ),
         );
     }
 
     #[Test]
     public function itShouldBuildRootNode(): void
     {
+        $this->container->set(TestMutation::class, new TestMutation());
+
         $type = $this->builder->build(
             new MutationNode(
                 TestMutation::class,

tests/TypeResolver/RootTypeResolverTest.php

@@ -0,0 +1,173 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Jerowork\GraphqlAttributeSchema\Test\TypeResolver;
+
+use Jerowork\GraphqlAttributeSchema\Parser\Ast;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\ArgNode;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\FieldNode;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\FieldNodeType;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\InputTypeNode;
+use Jerowork\GraphqlAttributeSchema\Parser\Node\MutationNode;
+use Jerowork\GraphqlAttributeSchema\Test\Doubles\Container\TestContainer;
+use Jerowork\GraphqlAttributeSchema\Test\Doubles\InputType\TestResolvableInputType;
+use Jerowork\GraphqlAttributeSchema\Test\Doubles\Mutation\TestResolvableMutation;
+use Jerowork\GraphqlAttributeSchema\TypeResolver\ResolveException;
+use Jerowork\GraphqlAttributeSchema\TypeResolver\RootTypeResolver;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+use Override;
+
+/**
+ * @internal
+ */
+final class RootTypeResolverTest extends TestCase
+{
+    private TestContainer $container;
+    private RootTypeResolver $rootTypeResolver;
+
+    #[Override]
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->rootTypeResolver = new RootTypeResolver(
+            $this->container = new TestContainer(),
+        );
+    }
+
+    #[Test]
+    public function itShouldGuardIfNodeTypeIdIsInContainer(): void
+    {
+        self::expectException(ResolveException::class);
+        self::expectExceptionMessage('Node type ID ' . TestResolvableMutation::class . ' is not in a container');
+
+        $this->rootTypeResolver->resolve(
+            new MutationNode(
+                TestResolvableMutation::class,
+                'Test',
+                null,
+                [],
+                null,
+                'string',
+                true,
+                '__invoke',
+            ),
+            new Ast(),
+        );
+    }
+
+    #[Test]
+    public function itShouldGuardIfNodeIsInAst(): void
+    {
+        $this->container->set(TestResolvableMutation::class, new TestResolvableMutation());
+
+        self::expectException(ResolveException::class);
+        self::expectExceptionMessage('Node ' . TestResolvableInputType::class . ' not found for typeId');
+
+        $type = $this->rootTypeResolver->resolve(
+            new MutationNode(
+                TestResolvableMutation::class,
+                'Test',
+                null,
+                [
+                    new ArgNode(
+                        null,
+                        'string',
+                        'id',
+                        null,
+                        true,
+                        'id',
+                    ),
+                    new ArgNode(
+                        TestResolvableInputType::class,
+                        null,
+                        'input',
+                        null,
+                        true,
+                        'input',
+                    ),
+                ],
+                null,
+                'string',
+                true,
+                '__invoke',
+            ),
+            new Ast(),
+        );
+
+        $type('rootValue', [
+            'id' => '45963d07-796c-44d5-8f1b-5e92ae6225a9',
+            'input' => [
+                'name' => 'Foobar',
+            ],
+        ]);
+    }
+
+    #[Test]
+    public function itShouldResolve(): void
+    {
+        $this->container->set(TestResolvableMutation::class, new TestResolvableMutation());
+
+        $type = $this->rootTypeResolver->resolve(
+            new MutationNode(
+                TestResolvableMutation::class,
+                'Test',
+                null,
+                [
+                    new ArgNode(
+                        null,
+                        'string',
+                        'id',
+                        null,
+                        true,
+                        'id',
+                    ),
+                    new ArgNode(
+                        TestResolvableInputType::class,
+                        null,
+                        'input',
+                        null,
+                        true,
+                        'input',
+                    ),
+                ],
+                null,
+                'string',
+                true,
+                '__invoke',
+            ),
+            new Ast(
+                new InputTypeNode(
+                    TestResolvableInputType::class,
+                    'TestResolvableInput',
+                    null,
+                    [
+                        new FieldNode(
+                            null,
+                            'string',
+                            'name',
+                            null,
+                            true,
+                            [],
+                            FieldNodeType::Property,
+                            null,
+                            'name',
+                        ),
+                    ],
+                ),
+            ),
+        );
+
+        self::assertSame(
+            'Mutation has been called with id 45963d07-796c-44d5-8f1b-5e92ae6225a9 and input with name Foobar',
+            $type('rootValue', [
+                'id' => '45963d07-796c-44d5-8f1b-5e92ae6225a9',
+                'input' => [
+                    'name' => 'Foobar',
+                ],
+            ]),
+        );
+    }
+}