add tests

tests/Feature/ExampleTest.php

@@ -1,8 +0,0 @@
-<?php declare(strict_types=1);
-
-test(
-    'example',
-    function (): void {
-        expect(true)->toBeTrue();
-    },
-);

tests/Pest.php

@@ -1,5 +1,6 @@
 <?php declare(strict_types=1);
 
+use Mockery\MockInterface;
 use Tests\TestCase;
 
 /*
@@ -24,7 +25,12 @@ uses(TestCase::class)->in('Feature', 'Unit');
 | global functions to help you to reduce the number of lines of code in your test files.
 |
 */
-function something(): void
+/**
+ * @template T of object
+ * @param class-string<T> $className
+ * @return MockInterface&T
+ */
+function createMock(string $className): MockInterface
 {
-    // ..
+    return Mockery::mock($className);
 }

tests/TestCase.php

@@ -2,9 +2,15 @@
 
 namespace Tests;
 
+use Lubiana\DoctrineUlid\Types\UlidType;
+use Override;
 use PHPUnit\Framework\TestCase as BaseTestCase;
 
 abstract class TestCase extends BaseTestCase
 {
-    //
+    #[Override]
+    protected function setUp(): void
+    {
+        UlidType::register();
+    }
 }

tests/Unit/ExampleTest.php

@@ -1,8 +0,0 @@
-<?php declare(strict_types=1);
-
-test(
-    'example',
-    function (): void {
-        expect(true)->toBeTrue();
-    },
-);

tests/Unit/UlidGeneratorTest.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types=1);
+
+use Doctrine\ORM\EntityManager;
+use Lubiana\DoctrineUlid\IdGenerator\UlidGenerator;
+use Symfony\Component\Uid\Factory\UlidFactory;
+use Symfony\Component\Uid\Ulid;
+
+test(
+    'UlidGenerator constructs without factory and generate Id',
+    function (): void {
+        $ulidGenerator = new UlidGenerator;
+        $em = createMock(EntityManager::class);
+        $id = $ulidGenerator->generateId($em, null);
+        expect($id)
+            ->toBeInstanceOf(Ulid::class);
+    },
+);
+
+test(
+    'UlidGenerator constructs with factory and generate Id',
+    function (): void {
+        $factory = Mockery::mock(UlidFactory::class);
+        $ulid = new Ulid;
+        $factory->shouldReceive('create')
+            ->andReturn($ulid)
+            ->once();
+        $ulidGenerator = new UlidGenerator($factory);
+        $em = Mockery::mock(EntityManager::class);
+        $id = $ulidGenerator->generateId($em, null);
+        expect($id)
+            ->toBe($ulid);
+    },
+);

tests/Unit/UlidTypeTest.php

@@ -0,0 +1,148 @@
+<?php declare(strict_types=1);
+
+use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+use Doctrine\DBAL\Platforms\SQLitePlatform;
+use Doctrine\DBAL\Types\Exception\InvalidType;
+use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
+use Doctrine\DBAL\Types\Type;
+use Lubiana\DoctrineUlid\Types\UlidType;
+use Symfony\Component\Uid\Ulid;
+
+it(
+    'returns correct sql declaration on postgresql',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new PostgreSQLPlatform;
+
+        // If platform supports guid type, declaration is guid type.
+        $declaration = $ulidType->getSQLDeclaration([], $platform);
+        expect($declaration)
+            ->toBe('UUID');
+    },
+);
+
+it(
+    'returns correct sql declaration on sqlite',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SqlitePlatform;
+
+        // If platform supports guid type, declaration is guid type.
+        $declaration = $ulidType->getSQLDeclaration([], $platform);
+        expect($declaration)
+            ->toBe('BLOB');
+    },
+);
+
+it(
+    'can convert string to a Ulid object',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $stringUlid = '01FGRM9X8ACP5D6HZG9K31D6CZ';
+        $phpValue = $ulidType->convertToPHPValue($stringUlid, $platform);
+        expect(
+            $phpValue,
+        )->toBeInstanceOf(Ulid::class)->and((string) $phpValue)->toBe($stringUlid);
+    },
+);
+
+it(
+    'throws if value is not string during conversion to PHP Value',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $nonStringValue = 123;
+        expect(
+            static fn(): mixed
+                => $ulidType->convertToPHPValue($nonStringValue, $platform),
+        )->toThrow(
+            InvalidType::class,
+        );
+    },
+);
+
+it(
+    'throws if value is not a valid Ulid string during conversion to PHP Value',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $invalidUlidString = 'invalid-ulid-string';
+        expect(
+            static fn(): mixed
+                => $ulidType->convertToPHPValue($invalidUlidString, $platform),
+        )->toThrow(
+            ValueNotConvertible::class,
+        );
+    },
+);
+
+it(
+    'can convert Ulid object to database value',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $ulidObject = new Ulid;
+        $databaseValue = $ulidType->convertToDatabaseValue($ulidObject, $platform);
+        expect($databaseValue)
+            ->toBe($ulidObject->toBinary());
+    },
+);
+
+it(
+    'can convert Ulid string to a database value',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $ulidObject = new Ulid;
+        $ulidBinary = $ulidObject->toBinary();
+        $databaseValue = $ulidType->convertToDatabaseValue(
+            (string) $ulidObject,
+            $platform,
+        );
+        expect($databaseValue)
+            ->toBe($ulidBinary);
+    },
+);
+
+it(
+    'will return null when value is null',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $nullValue = null;
+        $databaseValue = $ulidType->convertToDatabaseValue($nullValue, $platform);
+        expect($databaseValue)
+            ->toBe(null);
+    },
+);
+
+it(
+    'throws if value is not string during conversion to Database Value',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $nonStringValue = 123;
+        expect(
+            static fn(): mixed
+                => $ulidType->convertToDatabaseValue($nonStringValue, $platform),
+        )->toThrow(
+            InvalidType::class,
+        );
+    },
+);
+
+it(
+    'throws if value is not a valid Ulid string during conversion to Database Value',
+    function (): void {
+        $ulidType = Type::getType(UlidType::NAME);
+        $platform = new SQLitePlatform;
+        $invalidUlidString = 'invalid-ulid-string';
+        expect(
+            static fn(): mixed
+                => $ulidType->convertToDatabaseValue($invalidUlidString, $platform),
+        )->toThrow(
+            ValueNotConvertible::class,
+        );
+    },
+);