create-prisma-php-app 1.0.0

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

@@ -0,0 +1,214 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Rfc4122;
+
+use DateTimeInterface;
+use Mockery;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\Number\GenericNumberConverter;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\Time\GenericTimeConverter;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Generator\DceSecurityGenerator;
+use Ramsey\Uuid\Generator\DefaultTimeGenerator;
+use Ramsey\Uuid\Math\BrickMathCalculator;
+use Ramsey\Uuid\Provider\Dce\SystemDceSecurityProvider;
+use Ramsey\Uuid\Provider\Node\StaticNodeProvider;
+use Ramsey\Uuid\Provider\Time\FixedTimeProvider;
+use Ramsey\Uuid\Rfc4122\FieldsInterface;
+use Ramsey\Uuid\Rfc4122\UuidV2;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer;
+use Ramsey\Uuid\Type\Time;
+use Ramsey\Uuid\Uuid;
+use Ramsey\Uuid\UuidFactory;
+
+use const PHP_VERSION_ID;
+
+class UuidV2Test 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 UuidV2 must represent a '
+            . 'version 2 (DCE Security) UUID'
+        );
+
+        new UuidV2($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideTestVersions(): array
+    {
+        return [
+            ['version' => Version::Time],
+            ['version' => Version::HashMd5],
+            ['version' => Version::Random],
+            ['version' => Version::HashSha1],
+            ['version' => Version::ReorderedTime],
+            ['version' => Version::UnixTime],
+            ['version' => Version::Custom],
+        ];
+    }
+
+    /**
+     * @param positive-int $domain
+     *
+     * @dataProvider provideLocalDomainAndIdentifierForTests
+     */
+    public function testGetLocalDomainAndIdentifier(
+        int $domain,
+        Integer $identifier,
+        Time $time,
+        int $expectedDomain,
+        string $expectedDomainName,
+        string $expectedIdentifier,
+        string $expectedTimestamp,
+        string $expectedTime
+    ): void {
+        $calculator = new BrickMathCalculator();
+        $genericConverter = new GenericTimeConverter($calculator);
+        $numberConverter = new GenericNumberConverter($calculator);
+        $nodeProvider = new StaticNodeProvider(new Hexadecimal('1234567890ab'));
+        $timeProvider = new FixedTimeProvider($time);
+        $timeGenerator = new DefaultTimeGenerator($nodeProvider, $genericConverter, $timeProvider);
+        $dceProvider = new SystemDceSecurityProvider();
+        $dceGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceProvider);
+
+        $factory = new UuidFactory();
+        $factory->setTimeGenerator($timeGenerator);
+        $factory->setDceSecurityGenerator($dceGenerator);
+
+        /** @var UuidV2 $uuid */
+        $uuid = $factory->uuid2($domain, $identifier);
+
+        /** @var FieldsInterface $fields */
+        $fields = $uuid->getFields();
+
+        $this->assertSame($expectedDomain, $uuid->getLocalDomain());
+        $this->assertSame($expectedDomainName, $uuid->getLocalDomainName());
+        $this->assertInstanceOf(Integer::class, $uuid->getLocalIdentifier());
+        $this->assertSame($expectedIdentifier, $uuid->getLocalIdentifier()->toString());
+        $this->assertSame($expectedTimestamp, $fields->getTimestamp()->toString());
+        $this->assertInstanceOf(DateTimeInterface::class, $uuid->getDateTime());
+        $this->assertSame($expectedTime, $uuid->getDateTime()->format('U.u'));
+        $this->assertSame('1334567890ab', $fields->getNode()->toString());
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideLocalDomainAndIdentifierForTests(): array
+    {
+        // https://github.com/php/php-src/issues/7758
+        $isGH7758Fixed = PHP_VERSION_ID >= 80107;
+
+        return [
+            [
+                'domain' => Uuid::DCE_DOMAIN_PERSON,
+                'identifier' => new Integer('12345678'),
+                'time' => new Time(0, 0),
+                'expectedDomain' => 0,
+                'expectedDomainName' => 'person',
+                'expectedIdentifier' => '12345678',
+                'expectedTimestamp' => '1b21dd200000000',
+                'expectedTime' => $isGH7758Fixed ? '-33.276237' : '-32.723763',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_GROUP,
+                'identifier' => new Integer('87654321'),
+                'time' => new Time(0, 0),
+                'expectedDomain' => 1,
+                'expectedDomainName' => 'group',
+                'expectedIdentifier' => '87654321',
+                'expectedTimestamp' => '1b21dd200000000',
+                'expectedTime' => $isGH7758Fixed ? '-33.276237' : '-32.723763',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_ORG,
+                'identifier' => new Integer('1'),
+                'time' => new Time(0, 0),
+                'expectedDomain' => 2,
+                'expectedDomainName' => 'org',
+                'expectedIdentifier' => '1',
+                'expectedTimestamp' => '1b21dd200000000',
+                'expectedTime' => $isGH7758Fixed ? '-33.276237' : '-32.723763',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_PERSON,
+                'identifier' => new Integer('0'),
+                'time' => new Time(1583208664, 444109),
+                'expectedDomain' => 0,
+                'expectedDomainName' => 'person',
+                'expectedIdentifier' => '0',
+                'expectedTimestamp' => '1ea5d0500000000',
+                'expectedTime' => '1583208664.444109',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_PERSON,
+                'identifier' => new Integer('2147483647'),
+                'time' => new Time(1583208879, 500000),
+                'expectedDomain' => 0,
+                'expectedDomainName' => 'person',
+                'expectedIdentifier' => '2147483647',
+                // This time is the same as in the previous test because of the
+                // loss of precision by setting the lowest 32 bits to zeros.
+                'expectedTimestamp' => '1ea5d0500000000',
+                'expectedTime' => '1583208664.444109',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_PERSON,
+                'identifier' => new Integer('4294967295'),
+                'time' => new Time(1583208879, 500000),
+                'expectedDomain' => 0,
+                'expectedDomainName' => 'person',
+                'expectedIdentifier' => '4294967295',
+                // This time is the same as in the previous test because of the
+                // loss of precision by setting the lowest 32 bits to zeros.
+                'expectedTimestamp' => '1ea5d0500000000',
+                'expectedTime' => '1583208664.444109',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_PERSON,
+                'identifier' => new Integer('4294967295'),
+                'time' => new Time(1583209093, 940838),
+                'expectedDomain' => 0,
+                'expectedDomainName' => 'person',
+                'expectedIdentifier' => '4294967295',
+                // This time is the same as in the previous test because of the
+                // loss of precision by setting the lowest 32 bits to zeros.
+                'expectedTimestamp' => '1ea5d0500000000',
+                'expectedTime' => '1583208664.444109',
+            ],
+            [
+                'domain' => Uuid::DCE_DOMAIN_PERSON,
+                'identifier' => new Integer('4294967295'),
+                'time' => new Time(1583209093, 940839),
+                'expectedDomain' => 0,
+                'expectedDomainName' => 'person',
+                'expectedIdentifier' => '4294967295',
+                'expectedTimestamp' => '1ea5d0600000000',
+                'expectedTime' => '1583209093.940838',
+            ],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/Rfc4122/UuidV3Test.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\UuidV3;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+
+class UuidV3Test 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 UuidV3 must represent a '
+            . 'version 3 (name-based, MD5-hashed) UUID'
+        );
+
+        new UuidV3($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideTestVersions(): array
+    {
+        return [
+            ['version' => Version::Time],
+            ['version' => Version::DceSecurity],
+            ['version' => Version::Random],
+            ['version' => Version::HashSha1],
+            ['version' => Version::ReorderedTime],
+            ['version' => Version::UnixTime],
+            ['version' => Version::Custom],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/Rfc4122/UuidV4Test.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\UuidV4;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+
+class UuidV4Test 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 UuidV4 must represent a '
+            . 'version 4 (random) UUID'
+        );
+
+        new UuidV4($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideTestVersions(): array
+    {
+        return [
+            ['version' => Version::Time],
+            ['version' => Version::DceSecurity],
+            ['version' => Version::HashMd5],
+            ['version' => Version::HashSha1],
+            ['version' => Version::ReorderedTime],
+            ['version' => Version::UnixTime],
+            ['version' => Version::Custom],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/Rfc4122/UuidV5Test.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\UuidV5;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+
+class UuidV5Test 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 UuidV5 must represent a '
+            . 'version 5 (named-based, SHA1-hashed) UUID'
+        );
+
+        new UuidV5($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideTestVersions(): array
+    {
+        return [
+            ['version' => Version::Time],
+            ['version' => Version::DceSecurity],
+            ['version' => Version::HashMd5],
+            ['version' => Version::Random],
+            ['version' => Version::ReorderedTime],
+            ['version' => Version::UnixTime],
+            ['version' => Version::Custom],
+        ];
+    }
+}

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

@@ -0,0 +1,221 @@
+<?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\Lazy\LazyUuidFromString;
+use Ramsey\Uuid\Rfc4122\FieldsInterface;
+use Ramsey\Uuid\Rfc4122\UuidV6;
+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 UuidV6Test 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 UuidV6 must represent a '
+            . 'version 6 (reordered time) UUID'
+        );
+
+        new UuidV6($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::UnixTime],
+            ['version' => Version::Custom],
+        ];
+    }
+
+    /**
+     * @param non-empty-string $uuid
+     *
+     * @dataProvider provideUuidV6WithOddMicroseconds
+     */
+    public function testGetDateTimeProperlyHandlesLongMicroseconds(string $uuid, string $expected): void
+    {
+        /** @var UuidV6 $object */
+        $object = Uuid::fromString($uuid);
+
+        $date = $object->getDateTime();
+
+        $this->assertInstanceOf(DateTimeImmutable::class, $date);
+        $this->assertSame($expected, $date->format('U.u'));
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideUuidV6WithOddMicroseconds(): array
+    {
+        return [
+            [
+                'uuid' => '1b21dd21-4814-6000-9669-00007ffffffe',
+                'expected' => '1.677722',
+            ],
+            [
+                'uuid' => '1b21dd21-3714-6000-9669-00007ffffffe',
+                'expected' => '0.104858',
+            ],
+            [
+                'uuid' => '1b21dd21-3713-6000-9669-00007ffffffe',
+                'expected' => '0.105267',
+            ],
+            [
+                'uuid' => '1b21dd21-2e8a-6980-8d4f-acde48001122',
+                'expected' => '-1.000000',
+            ],
+        ];
+    }
+
+    /**
+     * @param non-empty-string $uuidv6
+     * @param non-empty-string $uuidv1
+     *
+     * @dataProvider provideUuidV1UuidV6Equivalents
+     */
+    public function testToUuidV1(string $uuidv6, string $uuidv1): void
+    {
+        /** @var UuidV6 $uuid6 */
+        $uuid6 = Uuid::fromString($uuidv6);
+        $uuid1 = $uuid6->toUuidV1();
+
+        $this->assertSame($uuidv6, $uuid6->toString());
+        $this->assertSame($uuidv1, $uuid1->toString());
+
+        $this->assertSame(
+            $uuid6->getDateTime()->format('U.u'),
+            $uuid1->getDateTime()->format('U.u')
+        );
+    }
+
+    /**
+     * @param non-empty-string $uuidv6
+     * @param non-empty-string $uuidv1
+     *
+     * @dataProvider provideUuidV1UuidV6Equivalents
+     */
+    public function testFromUuidV1(string $uuidv6, string $uuidv1): void
+    {
+        /** @var LazyUuidFromString $uuid */
+        $uuid = Uuid::fromString($uuidv1);
+        $uuid1 = $uuid->toUuidV1();
+        $uuid6 = UuidV6::fromUuidV1($uuid1);
+
+        $this->assertSame($uuidv1, $uuid1->toString());
+        $this->assertSame($uuidv6, $uuid6->toString());
+
+        $this->assertSame(
+            $uuid1->getDateTime()->format('U.u'),
+            $uuid6->getDateTime()->format('U.u')
+        );
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function provideUuidV1UuidV6Equivalents(): array
+    {
+        return [
+            [
+                'uuidv6' => '1b21dd21-4814-6000-9669-00007ffffffe',
+                'uuidv1' => '14814000-1dd2-11b2-9669-00007ffffffe',
+            ],
+            [
+                'uuidv6' => '1b21dd21-3714-6000-9669-00007ffffffe',
+                'uuidv1' => '13714000-1dd2-11b2-9669-00007ffffffe',
+            ],
+            [
+                'uuidv6' => '1b21dd21-3713-6000-9669-00007ffffffe',
+                'uuidv1' => '13713000-1dd2-11b2-9669-00007ffffffe',
+            ],
+            [
+                'uuidv6' => '1b21dd21-2e8a-6980-8d4f-acde48001122',
+                'uuidv1' => '12e8a980-1dd2-11b2-8d4f-acde48001122',
+            ],
+        ];
+    }
+
+    public function testGetDateTimeThrowsException(): void
+    {
+        $fields = Mockery::mock(FieldsInterface::class, [
+            'getVersion' => Version::ReorderedTime,
+            '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 UuidV6($fields, $numberConverter, $codec, $timeConverter);
+
+        $this->expectException(DateTimeException::class);
+
+        $uuid->getDateTime();
+    }
+
+    /**
+     * @link https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#appendix-B.1
+     */
+    public function testUsingDraftPeabodyUuidV6TestVector(): void
+    {
+        $testVector = '1EC9414C-232A-6B00-B3C8-9E6BDECED846';
+
+        /** @var UuidV6 $uuidv6 */
+        $uuidv6 = Uuid::fromString($testVector);
+
+        $uuidv1 = $uuidv6->toUuidV1();
+
+        /** @var FieldsInterface $fields */
+        $fields = $uuidv6->getFields();
+
+        $this->assertSame('1ec9414c', $fields->getTimeLow()->toString());
+        $this->assertSame('232a', $fields->getTimeMid()->toString());
+        $this->assertSame('6b00', $fields->getTimeHiAndVersion()->toString());
+        $this->assertSame('b3', $fields->getClockSeqHiAndReserved()->toString());
+        $this->assertSame('c8', $fields->getClockSeqLow()->toString());
+        $this->assertSame('9e6bdeced846', $fields->getNode()->toString());
+        $this->assertSame(1645557742, $uuidv6->getDateTime()->getTimestamp());
+
+        $this->assertSame(
+            'c232ab00-9414-11ec-b3c8-9e6bdeced846',
+            $uuidv1->toString(),
+        );
+    }
+}