test: relation

Author: Ark4ne

src/Descriptors/Relations/Relation.php

@@ -63,22 +63,37 @@ public function whenIncluded(): static
         return $this;
     }
 
+    /**
+     * @see \Illuminate\Http\Resources\ConditionallyLoadsAttributes::whenLoaded
+     *
+     * @param string|null $relation
+     *
+     * @return $this
+     */
     public function whenLoaded(string $relation = null): static
     {
         return $this->when(fn(
             Request $request,
             Model $model,
             string $attribute
-        ): bool => $model->relationLoaded($relation ?? $this->relation ?? $attribute));
+        ): bool => $model->relationLoaded($relation ?? (is_string($this->relation) ? $this->relation : $attribute)));
     }
 
+    /**
+     * @see \Illuminate\Http\Resources\ConditionallyLoadsAttributes::whenPivotLoadedAs
+     *
+     * @param string      $table
+     * @param string|null $accessor
+     *
+     * @return $this
+     */
     public function whenPivotLoaded(string $table, string $accessor = null): static
     {
         return $this->when(fn(
             Request $request,
             Model $model,
             string $attribute
-        ): bool => ($pivot = $model->{$accessor ?? $this->relation ?? $attribute})
+        ): bool => ($pivot = $model->{$accessor ?? (is_string($this->relation) ? $this->relation : $attribute)})
             && (
                 $pivot instanceof $table ||
                 $pivot->getTable() === $table

tests/Support/Reflect.php

@@ -23,4 +23,13 @@ public static function set($object, string $property, $value)
 
         $reflectProperty->setValue($object, $value);
     }
+
+    public static function get($object, string $property): mixed
+    {
+        $reflect = new ReflectionClass($object);
+        $reflectProperty = $reflect->getProperty($property);
+        $reflectProperty->setAccessible(true);
+
+        return $reflectProperty->getValue($object);
+    }
 }

tests/Unit/Descriptors/RelationTest.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Test\Unit\Descriptors;
+
+use Ark4ne\JsonApi\Descriptors\Relations\RelationOne;
+use Ark4ne\JsonApi\Resources\Relationship;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\MissingValue;
+use stdClass;
+use Test\app\Http\Resources\UserResource;
+use Test\Support\Reflect;
+use Test\TestCase;
+
+class RelationTest extends TestCase
+{
+    public function testIncluded()
+    {
+        $stub = new RelationOne(UserResource::class, fn() => null);
+
+        $relation = $stub->resolveFor(new Request, new class extends Model {
+        }, 'null');
+
+        $this->assertInstanceOf(Relationship::class, $relation);
+        $this->assertFalse(Reflect::get($relation, 'whenIncluded'));
+
+        $stub->whenIncluded();
+        $relation = $stub->resolveFor(new Request, new class extends Model {
+        }, 'null');
+
+        $this->assertInstanceOf(Relationship::class, $relation);
+        $this->assertTrue(Reflect::get($relation, 'whenIncluded'));
+    }
+
+    public function testMeta()
+    {
+        $stub = new RelationOne(UserResource::class, fn() => null);
+
+        $relation = $stub->resolveFor(new Request, new class extends Model {
+        }, 'null');
+
+        $this->assertInstanceOf(Relationship::class, $relation);
+        $this->assertEmpty(Reflect::get($relation, 'meta'));
+
+        $stub->meta(fn() => ['test']);
+        $relation = $stub->resolveFor(new Request, new class extends Model {
+        }, 'null');
+
+        $this->assertInstanceOf(Relationship::class, $relation);
+        $this->assertInstanceOf(\Closure::class, Reflect::get($relation, 'meta'));
+        $this->assertEquals(['test'], Reflect::get($relation, 'meta')());
+    }
+
+    public function testLinks()
+    {
+        $stub = new RelationOne(UserResource::class, fn() => null);
+
+        $relation = $stub->resolveFor(new Request, new class extends Model {
+        }, 'null');
+
+        $this->assertInstanceOf(Relationship::class, $relation);
+        $this->assertEmpty(Reflect::get($relation, 'links'));
+
+        $stub->links(fn() => ['test']);
+        $relation = $stub->resolveFor(new Request, new class extends Model {
+        }, 'null');
+
+        $this->assertInstanceOf(Relationship::class, $relation);
+        $this->assertInstanceOf(\Closure::class, Reflect::get($relation, 'links'));
+        $this->assertEquals(['test'], Reflect::get($relation, 'links')());
+    }
+
+    public function dataWhenLoaded() {
+        return [
+            ['attr', null, 'attr'],
+            ['attr', fn() => null, 'attr'],
+            ['field', 'field', 'attr'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataWhenLoaded
+     */
+    public function testWhenLoaded($expectedAttr, $relation, $invokedAttr)
+    {
+        $mockModel = $this->getMockForAbstractClass(Model::class, mockedMethods: ['relationLoaded']);
+        $mockModel->expects(self::once())->method('relationLoaded')->with($expectedAttr)->willReturn(false);
+
+        $stub = new RelationOne(UserResource::class, $relation);
+        $stub->whenLoaded();
+
+        $check = Reflect::invoke($stub, 'check', new Request, $mockModel, $invokedAttr);
+        $this->assertFalse($check);
+    }
+
+    public function dataWhenPivotLoaded() {
+        return [
+            ['attr', null, 'attr'],
+            ['attr', fn() => null, 'attr'],
+            ['field', 'field', 'attr'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataWhenPivotLoaded
+     */
+    public function testWhenPivotLoaded($expectedAttr, $relation, $invokedAttr)
+    {
+        $model = new class extends Model {};
+
+        $model->$expectedAttr = new stdClass;
+        $stub = new RelationOne(UserResource::class, $relation);
+        $stub->whenPivotLoaded(stdClass::class);
+
+        $check = Reflect::invoke($stub, 'check', new Request, $model, $invokedAttr);
+        $this->assertTrue($check);
+    }
+}