create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/tests/Rfc4122/UuidV7Test.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Rfc4122;
+
+use DateTimeImmutable;
+use Mockery;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\DateTimeException;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface;
+use Ramsey\Uuid\Rfc4122\UuidV7;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Time;
+use Ramsey\Uuid\Uuid;
+
+class UuidV7Test extends TestCase
+{
+    /**
+     * @dataProvider provideTestVersions
+     */
+    public function testConstructorThrowsExceptionWhenFieldsAreNotValidForType(Version $version): void
+    {
+        $fields = Mockery::mock(FieldsInterface::class, [
+            'getVersion' => $version,
+        ]);
+
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $codec = Mockery::mock(CodecInterface::class);
+        $timeConverter = Mockery::mock(TimeConverterInterface::class);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Fields used to create a UuidV7 must represent a '
+            . 'version 7 (Unix Epoch time) UUID'
+        );
+
+        new UuidV7($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * @return array<array{version: Version}>
+     */
+    public function provideTestVersions(): array
+    {
+        return [
+            ['version' => Version::Time],
+            ['version' => Version::DceSecurity],
+            ['version' => Version::HashMd5],
+            ['version' => Version::Random],
+            ['version' => Version::HashSha1],
+            ['version' => Version::ReorderedTime],
+            ['version' => Version::Custom],
+        ];
+    }
+
+    /**
+     * @param non-empty-string $uuid
+     *
+     * @dataProvider provideUuidV7WithMicroseconds
+     */
+    public function testGetDateTimeProperlyHandlesMicroseconds(string $uuid, string $expected): void
+    {
+        /** @var UuidV7 $object */
+        $object = Uuid::fromString($uuid);
+
+        $date = $object->getDateTime();
+
+        $this->assertInstanceOf(DateTimeImmutable::class, $date);
+        $this->assertSame($expected, $date->format('U.u'));
+    }
+
+    /**
+     * @return array<array{uuid: string, expected: numeric-string}>
+     */
+    public function provideUuidV7WithMicroseconds(): array
+    {
+        return [
+            [
+                'uuid' => '00000000-0001-71b2-9669-00007ffffffe',
+                'expected' => '0.001000',
+            ],
+            [
+                'uuid' => '00000000-000f-71b2-9669-00007ffffffe',
+                'expected' => '0.015000',
+            ],
+            [
+                'uuid' => '00000000-0064-71b2-9669-00007ffffffe',
+                'expected' => '0.100000',
+            ],
+            [
+                'uuid' => '00000000-03e7-71b2-9669-00007ffffffe',
+                'expected' => '0.999000',
+            ],
+            [
+                'uuid' => '00000000-03e8-71b2-9669-00007ffffffe',
+                'expected' => '1.000000',
+            ],
+            [
+                'uuid' => '00000000-03e9-71b2-9669-00007ffffffe',
+                'expected' => '1.001000',
+            ],
+        ];
+    }
+
+    public function testGetDateTimeThrowsException(): void
+    {
+        $fields = Mockery::mock(FieldsInterface::class, [
+            'getVersion' => Version::UnixTime,
+            'getTimestamp' => new Hexadecimal('0'),
+        ]);
+
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $codec = Mockery::mock(CodecInterface::class);
+
+        $timeConverter = Mockery::mock(TimeConverterInterface::class, [
+            'convertTime' => new Time('0', '1234567'),
+        ]);
+
+        $uuid = new UuidV7($fields, $numberConverter, $codec, $timeConverter);
+
+        $this->expectException(DateTimeException::class);
+
+        $uuid->getDateTime();
+    }
+}

package/vendor/ramsey/uuid/tests/Rfc4122/UuidV8Test.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Rfc4122;
+
+use Mockery;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface;
+use Ramsey\Uuid\Rfc4122\UuidV8;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+
+class UuidV8Test extends TestCase
+{
+    /**
+     * @dataProvider provideTestVersions
+     */
+    public function testConstructorThrowsExceptionWhenFieldsAreNotValidForType(Version $version): void
+    {
+        $fields = Mockery::mock(FieldsInterface::class, [
+            'getVersion' => $version,
+        ]);
+
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $codec = Mockery::mock(CodecInterface::class);
+        $timeConverter = Mockery::mock(TimeConverterInterface::class);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Fields used to create a UuidV8 must represent a '
+            . 'version 8 (custom) UUID'
+        );
+
+        new UuidV8($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * @return array<array{version: Version}>
+     */
+    public function provideTestVersions(): array
+    {
+        return [
+            ['version' => Version::Time],
+            ['version' => Version::DceSecurity],
+            ['version' => Version::HashMd5],
+            ['version' => Version::Random],
+            ['version' => Version::HashSha1],
+            ['version' => Version::ReorderedTime],
+            ['version' => Version::UnixTime],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/Rfc4122/ValidatorTest.php

@@ -0,0 +1,122 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Rfc4122;
+
+use Ramsey\Uuid\Rfc4122\Validator;
+use Ramsey\Uuid\Test\TestCase;
+
+use function array_merge;
+use function in_array;
+use function strtoupper;
+
+class ValidatorTest extends TestCase
+{
+    /**
+     * @dataProvider provideValuesForValidation
+     */
+    public function testValidate(string $value, bool $expected): void
+    {
+        $variations = [];
+        $variations[] = $value;
+        $variations[] = 'urn:uuid:' . $value;
+        $variations[] = '{' . $value . '}';
+
+        foreach ($variations as $variation) {
+            $variations[] = strtoupper($variation);
+        }
+
+        $validator = new Validator();
+
+        foreach ($variations as $variation) {
+            $this->assertSame(
+                $expected,
+                $validator->validate($variation),
+                sprintf(
+                    'Expected "%s" to be %s',
+                    $variation,
+                    $expected ? 'valid' : 'not valid',
+                ),
+            );
+        }
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideValuesForValidation(): array
+    {
+        $hexMutations = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f'];
+        $trueVersions = [1, 2, 3, 4, 5, 6, 7, 8];
+        $trueVariants = [8, 9, 'a', 'b'];
+
+        $testValues = [];
+
+        foreach ($hexMutations as $version) {
+            foreach ($hexMutations as $variant) {
+                $testValues[] = [
+                    'value' => "ff6f8cb0-c57d-{$version}1e1-{$variant}b21-0800200c9a66",
+                    'expected' => in_array($variant, $trueVariants, true) && in_array($version, $trueVersions, true),
+                ];
+            }
+        }
+
+        return array_merge($testValues, [
+            [
+                'value' => 'zf6f8cb0-c57d-11e1-9b21-0800200c9a66',
+                'expected' => false,
+            ],
+            [
+                'value' => '3f6f8cb0-c57d-11e1-9b21-0800200c9a6',
+                'expected' => false,
+            ],
+            [
+                'value' => 'af6f8cb-c57d-11e1-9b21-0800200c9a66',
+                'expected' => false,
+            ],
+            [
+                'value' => 'af6f8cb0c57d11e19b210800200c9a66',
+                'expected' => false,
+            ],
+            [
+                'value' => 'ff6f8cb0-c57da-51e1-9b21-0800200c9a66',
+                'expected' => false,
+            ],
+            [
+                'value' => "ff6f8cb0-c57d-11e1-1b21-0800200c9a66\n",
+                'expected' => false,
+            ],
+            [
+                'value' => "\nff6f8cb0-c57d-11e1-1b21-0800200c9a66",
+                'expected' => false,
+            ],
+            [
+                'value' => "\nff6f8cb0-c57d-11e1-1b21-0800200c9a66\n",
+                'expected' => false,
+            ],
+            [
+                'value' => '00000000-0000-0000-0000-000000000000',
+                'expected' => true,
+            ],
+            [
+                'value' => 'ffffffff-ffff-ffff-ffff-ffffffffffff',
+                'expected' => true,
+            ],
+            [
+                'value' => 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF',
+                'expected' => true,
+            ],
+        ]);
+    }
+
+    public function testGetPattern(): void
+    {
+        $expectedPattern = '\A[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-'
+            . '[1-8][0-9A-Fa-f]{3}-[ABab89][0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}\z';
+
+        $validator = new Validator();
+
+        $this->assertSame($expectedPattern, $validator->getPattern());
+    }
+}

package/vendor/ramsey/uuid/tests/Rfc4122/VariantTraitTest.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Rfc4122;
+
+use Mockery;
+use Ramsey\Uuid\Exception\InvalidBytesException;
+use Ramsey\Uuid\Rfc4122\Fields;
+use Ramsey\Uuid\Rfc4122\VariantTrait;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Variant;
+
+use function hex2bin;
+use function str_replace;
+
+class VariantTraitTest extends TestCase
+{
+    /**
+     * @dataProvider invalidBytesProvider
+     */
+    public function testGetVariantThrowsExceptionForWrongNumberOfBytes(string $bytes): void
+    {
+        /** @var Fields $trait */
+        $trait = Mockery::mock(VariantTrait::class, [
+            'getBytes' => $bytes,
+            'isMax' => false,
+            'isNil' => false,
+        ]);
+
+        $this->expectException(InvalidBytesException::class);
+        $this->expectExceptionMessage('Invalid number of bytes');
+
+        $trait->getVariant();
+    }
+
+    /**
+     * @return array<array{string}>
+     */
+    public function invalidBytesProvider(): array
+    {
+        return [
+            ['not16Bytes_abcd'],
+            ['not16Bytes_abcdef'],
+        ];
+    }
+
+    /**
+     * @dataProvider uuidVariantProvider
+     */
+    public function testGetVariant(string $uuid, int $expectedVariant): void
+    {
+        $bytes = (string) hex2bin(str_replace('-', '', $uuid));
+
+        /** @var Fields $trait */
+        $trait = Mockery::mock(VariantTrait::class, [
+            'getBytes' => $bytes,
+            'isMax' => false,
+            'isNil' => false,
+        ]);
+
+        $this->assertSame(Variant::from($expectedVariant), $trait->getVariant());
+    }
+
+    /**
+     * @return array<array{string, int}>
+     */
+    public function uuidVariantProvider(): array
+    {
+        return [
+            ['ff6f8cb0-c57d-11e1-0b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-1b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-2b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-3b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-4b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-5b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-6b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-7b21-0800200c9a66', 0],
+            ['ff6f8cb0-c57d-11e1-8b21-0800200c9a66', 2],
+            ['ff6f8cb0-c57d-11e1-9b21-0800200c9a66', 2],
+            ['ff6f8cb0-c57d-11e1-ab21-0800200c9a66', 2],
+            ['ff6f8cb0-c57d-11e1-bb21-0800200c9a66', 2],
+            ['ff6f8cb0-c57d-11e1-cb21-0800200c9a66', 6],
+            ['ff6f8cb0-c57d-11e1-db21-0800200c9a66', 6],
+            ['ff6f8cb0-c57d-11e1-eb21-0800200c9a66', 7],
+            ['ff6f8cb0-c57d-11e1-fb21-0800200c9a66', 7],
+
+            // The following are the same UUIDs in GUID byte order. Dashes have
+            // been removed in the tests to distinguish these from string
+            // representations, which are never in GUID byte order.
+            ['b08c6fff7dc5e1110b210800200c9a66', 0],
+            ['b08c6fff7dc5e1111b210800200c9a66', 0],
+            ['b08c6fff7dc5e1112b210800200c9a66', 0],
+            ['b08c6fff7dc5e1113b210800200c9a66', 0],
+            ['b08c6fff7dc5e1114b210800200c9a66', 0],
+            ['b08c6fff7dc5e1115b210800200c9a66', 0],
+            ['b08c6fff7dc5e1116b210800200c9a66', 0],
+            ['b08c6fff7dc5e1117b210800200c9a66', 0],
+            ['b08c6fff7dc5e1118b210800200c9a66', 2],
+            ['b08c6fff7dc5e1119b210800200c9a66', 2],
+            ['b08c6fff7dc5e111ab210800200c9a66', 2],
+            ['b08c6fff7dc5e111bb210800200c9a66', 2],
+            ['b08c6fff7dc5e111cb210800200c9a66', 6],
+            ['b08c6fff7dc5e111db210800200c9a66', 6],
+            ['b08c6fff7dc5e111eb210800200c9a66', 7],
+            ['b08c6fff7dc5e111fb210800200c9a66', 7],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/TestCase.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test;
+
+use Mockery;
+use PHPUnit\Framework\TestCase as PhpUnitTestCase;
+
+use function current;
+use function pack;
+use function unpack;
+
+class TestCase extends PhpUnitTestCase
+{
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        Mockery::close();
+    }
+
+    public static function isLittleEndianSystem(): bool
+    {
+        /** @var array $unpacked */
+        $unpacked = unpack('v', pack('S', 0x00FF));
+
+        return current($unpacked) === 0x00FF;
+    }
+}