test: Add some tests for the Concise class

ollieread · ollieread · commit e97ddff54489 · 2025-02-21T22:42:17.000Z
diff --git a/src/Concise.php b/src/Concise.php
@@ -9,6 +9,7 @@
 use Illuminate\Database\RecordsNotFoundException;
 use Illuminate\Foundation\Application;
 use Illuminate\Support\Str;
+use InvalidArgumentException;
 use ReflectionClass;
 use RuntimeException;
 use Throwable;
@@ -40,13 +41,22 @@ public function __construct(Application $app)
      *
      * @template MapperObject of object
      *
-     * @param \Articulate\Concise\Contracts\Mapper<MapperObject> $mapper
-     * @param bool                                               $overwrite
+     * @param \Articulate\Concise\Contracts\Mapper<MapperObject>|class-string<\Articulate\Concise\Contracts\Mapper<MapperObject>> $mapper
+     * @param bool                                                                                                                $overwrite
      *
      * @return bool
      */
-    public function register(Mapper $mapper, bool $overwrite = false): bool
+    public function register(Mapper|string $mapper, bool $overwrite = false): bool
     {
+        if (is_string($mapper)) {
+            /** @phpstan-ignore function.alreadyNarrowedType */
+            if (! is_subclass_of($mapper, Mapper::class)) {
+                throw new InvalidArgumentException('Class [' . $mapper . '] is not a valid mapper.');
+            }
+
+            $mapper = new $mapper($this);
+        }
+
         if ($mapper instanceof EntityMapper) {
             if ($overwrite === false && isset($this->entityMappers[$mapper->class()])) {
                 return false;
@@ -83,6 +93,23 @@ public function entity(string $class): ?EntityMapper
         return $mapper;
     }
 
+    /**
+     * Get a registered component mapper for the provided class.
+     *
+     * @template ComponentObject of object
+     *
+     * @param class-string<ComponentObject> $class
+     *
+     * @return \Articulate\Concise\Contracts\Mapper<ComponentObject>|null
+     */
+    public function component(string $class): ?Mapper
+    {
+        /** @var \Articulate\Concise\Contracts\Mapper<ComponentObject>|null $mapper */
+        $mapper = $this->componentMappers[$class] ?? null;
+
+        return $mapper;
+    }
+
     /**
      * Get an entity repository for the provided class.
      *
@@ -164,6 +191,8 @@ function (object $proxy) use ($repository, $identity, $mapper) {
                     return $entity;
                 }
             );
+
+            $reflector->getProperty($mapper->identity())->setRawValueWithoutLazyInitialization($lazy, $identity);
         } catch (Throwable $e) {
             report($e);
 
diff --git a/src/EntityMapper.php b/src/EntityMapper.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types=1);
+
+namespace Articulate\Concise;
+
+use Illuminate\Support\Str;
+
+/**
+ * @template EntityObject of object
+ *
+ * @implements \Articulate\Concise\Contracts\EntityMapper<EntityObject>
+ */
+abstract class EntityMapper implements Contracts\EntityMapper
+{
+    /**
+     * @var \Articulate\Concise\Concise
+     */
+    protected Concise $concise;
+
+    public function __construct(Concise $concise)
+    {
+        $this->concise = $concise;
+    }
+
+    /**
+     * Get the custom repository class for the entity
+     *
+     * @return null
+     */
+    public function repository(): null
+    {
+        return null;
+    }
+
+    /**
+     * Get the connection the entity should use
+     *
+     * @return null
+     */
+    public function connection(): null
+    {
+        return null;
+    }
+
+    /**
+     * Get the entities' database table
+     *
+     * @return string
+     */
+    public function table(): string
+    {
+        return Str::snake(Str::pluralStudly(class_basename($this->class())));
+    }
+
+    /**
+     * Get the name of the identity field
+     *
+     * @return string
+     */
+    public function identity(): string
+    {
+        return 'id';
+    }
+
+}
diff --git a/tests/ConciseTest.php b/tests/ConciseTest.php
@@ -3,7 +3,110 @@
 
 namespace Articulate\Concise\Tests;
 
+use App\Components\AuthCredentials;
+use App\Components\Timestamps;
+use App\Entities\User;
+use App\Mappers\Components\AuthCredentialsMapper;
+use App\Mappers\Components\TimestampsMapper;
+use App\Mappers\Entities\UserMapper;
+use Articulate\Concise\Concise;
+use Articulate\Concise\EntityRepository;
+use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\Test;
+use ReflectionClass;
+use stdClass;
+
 class ConciseTest extends TestCase
 {
+    #[Test]
+    public function canManuallyRegisterEntityMappers(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(new UserMapper($concise)));
+        $this->assertInstanceOf(UserMapper::class, $concise->entity(User::class));
+    }
+
+    #[Test]
+    public function canManuallyRegisterComponentMappers(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(new AuthCredentialsMapper()));
+        $this->assertTrue($concise->register(new TimestampsMapper()));
+        $this->assertInstanceOf(AuthCredentialsMapper::class, $concise->component(AuthCredentials::class));
+        $this->assertInstanceOf(TimestampsMapper::class, $concise->component(Timestamps::class));
+    }
+
+    #[Test]
+    public function canManuallyRegisterEntityMappersByClass(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(UserMapper::class));
+        $this->assertInstanceOf(UserMapper::class, $concise->entity(User::class));
+    }
+
+    #[Test]
+    public function canManuallyRegisterComponentMappersByClass(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(AuthCredentialsMapper::class));
+        $this->assertTrue($concise->register(TimestampsMapper::class));
+        $this->assertInstanceOf(AuthCredentialsMapper::class, $concise->component(AuthCredentials::class));
+        $this->assertInstanceOf(TimestampsMapper::class, $concise->component(Timestamps::class));
+    }
+
+    #[Test]
+    public function throwsAnExceptionIfTheClassIsNotAMapper(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Class [stdClass] is not a valid mapper.');
+
+        $concise->register(stdClass::class);
+    }
+
+    #[Test]
+    public function doesNotOverwriteMappingsByDefault(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(new UserMapper($concise)));
+        $this->assertTrue($concise->register(new AuthCredentialsMapper()));
+        $this->assertTrue($concise->register(new TimestampsMapper()));
+
+        $this->assertFalse($concise->register(new UserMapper($concise)));
+        $this->assertFalse($concise->register(new AuthCredentialsMapper()));
+        $this->assertFalse($concise->register(new TimestampsMapper()));
+    }
+
+    #[Test]
+    public function usesADefaultRepository(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(new UserMapper($concise)));
+        $this->assertInstanceOf(EntityRepository::class, $concise->repository(User::class));
+    }
+
+    #[Test]
+    public function canCreateLazyObjects(): void
+    {
+        $concise = $this->app->make(Concise::class);
+
+        $this->assertTrue($concise->register(new UserMapper($concise)));
+
+        $lazy = $concise->lazy(User::class, 7);
+
+        $this->assertInstanceOf(User::class, $lazy);
+        $this->assertSame(7, $lazy->getId());
+        $this->assertTrue($lazy->hasId());
+
+        $reflector = new ReflectionClass($lazy);
 
+        $this->assertTrue($reflector->isUninitializedLazyObject($lazy));
+    }
 }
diff --git a/tests/ImplicitRouteBindingTest.php b/tests/ImplicitRouteBindingTest.php
diff --git a/workbench/app/Mappers/Components/AuthCredentialsMapper.php b/workbench/app/Mappers/Components/AuthCredentialsMapper.php
@@ -4,10 +4,10 @@
 namespace App\Mappers\Components;
 
 use App\Components\AuthCredentials;
-use OLD\Contracts\Mapper;
+use Articulate\Concise\Contracts\Mapper;
 
 /**
- * @implements OLD\Contracts\Mapper<\App\Components\AuthCredentials>
+ * @implements \Articulate\Concise\Contracts\Mapper<\App\Components\AuthCredentials>
  */
 final class AuthCredentialsMapper implements Mapper
 {
diff --git a/workbench/app/Mappers/Components/TimestampsMapper.php b/workbench/app/Mappers/Components/TimestampsMapper.php
@@ -4,10 +4,10 @@
 namespace App\Mappers\Components;
 
 use App\Components\Timestamps;
-use OLD\Contracts\Mapper;
+use Articulate\Concise\Contracts\Mapper;
 
 /**
- * @implements OLD\Contracts\Mapper<\App\Components\Timestamps>
+ * @implements \Articulate\Concise\Contracts\Mapper<\App\Components\Timestamps>
  */
 final class TimestampsMapper implements Mapper
 {
diff --git a/workbench/app/Mappers/Entities/UserMapper.php b/workbench/app/Mappers/Entities/UserMapper.php
@@ -6,14 +6,13 @@
 use App\Components\AuthCredentials;
 use App\Components\Timestamps;
 use App\Entities\User;
-use App\Repositories\UserRepository;
+use Articulate\Concise\EntityMapper;
 use Illuminate\Support\Arr;
-use OLD\Support\BaseEntityMapper;
 
 /**
- * @extends OLD\Support\BaseEntityMapper<\App\Entities\User>
+ * @extends \Articulate\Concise\EntityMapper<\App\Entities\User>
  */
-final class UserMapper extends BaseEntityMapper
+final class UserMapper extends EntityMapper
 {
     /**
      * Get the object class.
@@ -25,16 +24,6 @@ public function class(): string
         return User::class;
     }
 
-    /**
-     * Get the repository class name.
-     *
-     * @return class-string<\App\Repositories\UserRepository>|null
-     */
-    public function repository(): ?string
-    {
-        return UserRepository::class;
-    }
-
     /**
      * Converts the given array of data into an object.
      *
@@ -51,14 +40,12 @@ public function toObject(array $data): object
         $user->setId($data['id'])
              ->setName($data['name'])
              ->setAuth(
-                 $this->concise->component(
-                     AuthCredentials::class,
+                 $this->concise->component(AuthCredentials::class)?->toObject(
                      Arr::only($data, ['email', 'password', 'remember_token', 'email_verified_at'])
                  )
              )
              ->setTimestamps(
-                 $this->concise->component(
-                     Timestamps::class,
+                 $this->concise->component(Timestamps::class)?->toObject(
                      Arr::only($data, ['created_at', 'updated_at'])
                  )
              );
@@ -86,8 +73,8 @@ public function toData(object $object): array
         }
 
         return array_merge(
-            $this->concise->data($object->getAuth()),
-            $this->concise->data($object->getTimestamps()),
+            $this->concise->component(AuthCredentials::class)?->toData($object->getAuth()),
+            $this->concise->component(Timestamps::class)?->toData($object->getTimestamps()),
             $data
         );
     }
