create-prisma-php-app 1.0.0

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

@@ -0,0 +1,381 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test;
+
+use Ramsey\Uuid\BinaryUtils;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Variant;
+
+use function bin2hex;
+use function dechex;
+use function hex2bin;
+
+class BinaryUtilsTest extends TestCase
+{
+    /**
+     * @dataProvider provideVersionTestValues
+     */
+    public function testApplyVersion(int $timeHi, Version $version, int $expectedInt, string $expectedHex): void
+    {
+        $this->assertSame($expectedInt, BinaryUtils::applyVersion($timeHi, $version));
+        $this->assertSame($expectedHex, dechex(BinaryUtils::applyVersion($timeHi, $version)));
+    }
+
+    /**
+     * @dataProvider provideVariantTestValues
+     */
+    public function testApplyVariant(int $clockSeq, Variant $variant, int $expectedInt, string $expectedHex): void
+    {
+        $this->assertSame($expectedInt, BinaryUtils::applyVariant($clockSeq, $variant));
+        $this->assertSame($expectedHex, dechex(BinaryUtils::applyVariant($clockSeq, $variant)));
+    }
+
+    /**
+     * @param non-empty-string $bytes
+     *
+     * @dataProvider provideVersionAndVariantTestValues
+     */
+    public function testApplyVersionAndVariant(
+        string $bytes,
+        Version $version,
+        string $expectedHex
+    ): void {
+        $this->assertSame($expectedHex, bin2hex(BinaryUtils::applyVersionAndVariant($bytes, $version)));
+    }
+
+    /**
+     * @return array<array{timeHi: int, version: Version, expectedInt: int, expectedHex: string}>
+     */
+    public function provideVersionTestValues(): array
+    {
+        return [
+            [
+                'timeHi' => 1001,
+                'version' => Version::Time,
+                'expectedInt' => 5097,
+                'expectedHex' => '13e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::DceSecurity,
+                'expectedInt' => 9193,
+                'expectedHex' => '23e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::HashMd5,
+                'expectedInt' => 13289,
+                'expectedHex' => '33e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::Random,
+                'expectedInt' => 17385,
+                'expectedHex' => '43e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::HashSha1,
+                'expectedInt' => 21481,
+                'expectedHex' => '53e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::ReorderedTime,
+                'expectedInt' => 25577,
+                'expectedHex' => '63e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::UnixTime,
+                'expectedInt' => 29673,
+                'expectedHex' => '73e9',
+            ],
+            [
+                'timeHi' => 1001,
+                'version' => Version::Custom,
+                'expectedInt' => 33769,
+                'expectedHex' => '83e9',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::Time,
+                'expectedInt' => 8191,
+                'expectedHex' => '1fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::DceSecurity,
+                'expectedInt' => 12287,
+                'expectedHex' => '2fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::HashMd5,
+                'expectedInt' => 16383,
+                'expectedHex' => '3fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::Random,
+                'expectedInt' => 20479,
+                'expectedHex' => '4fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::HashSha1,
+                'expectedInt' => 24575,
+                'expectedHex' => '5fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::ReorderedTime,
+                'expectedInt' => 28671,
+                'expectedHex' => '6fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::UnixTime,
+                'expectedInt' => 32767,
+                'expectedHex' => '7fff',
+            ],
+            [
+                'timeHi' => 65535,
+                'version' => Version::Custom,
+                'expectedInt' => 36863,
+                'expectedHex' => '8fff',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::Time,
+                'expectedInt' => 4096,
+                'expectedHex' => '1000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::DceSecurity,
+                'expectedInt' => 8192,
+                'expectedHex' => '2000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::HashMd5,
+                'expectedInt' => 12288,
+                'expectedHex' => '3000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::Random,
+                'expectedInt' => 16384,
+                'expectedHex' => '4000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::HashSha1,
+                'expectedInt' => 20480,
+                'expectedHex' => '5000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::ReorderedTime,
+                'expectedInt' => 24576,
+                'expectedHex' => '6000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::UnixTime,
+                'expectedInt' => 28672,
+                'expectedHex' => '7000',
+            ],
+            [
+                'timeHi' => 0,
+                'version' => Version::Custom,
+                'expectedInt' => 32768,
+                'expectedHex' => '8000',
+            ],
+        ];
+    }
+
+    /**
+     * @return array<array{clockSeq: int, variant: Variant, expectedInt: int, expectedHex: string}>
+     */
+    public function provideVariantTestValues(): array
+    {
+        return [
+            [
+                'clockSeq' => 0,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 32768,
+                'expectedHex' => '8000',
+            ],
+            [
+                'clockSeq' => 4096,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 36864,
+                'expectedHex' => '9000',
+            ],
+            [
+                'clockSeq' => 8192,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 40960,
+                'expectedHex' => 'a000',
+            ],
+            [
+                'clockSeq' => 12288,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 45056,
+                'expectedHex' => 'b000',
+            ],
+            [
+                'clockSeq' => 4095,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 36863,
+                'expectedHex' => '8fff',
+            ],
+            [
+                'clockSeq' => 8191,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 40959,
+                'expectedHex' => '9fff',
+            ],
+            [
+                'clockSeq' => 12287,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 45055,
+                'expectedHex' => 'afff',
+            ],
+            [
+                'clockSeq' => 16383,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 49151,
+                'expectedHex' => 'bfff',
+            ],
+            [
+                'clockSeq' => 16384,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 32768,
+                'expectedHex' => '8000',
+            ],
+            [
+                'clockSeq' => 20480,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 36864,
+                'expectedHex' => '9000',
+            ],
+            [
+                'clockSeq' => 24576,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 40960,
+                'expectedHex' => 'a000',
+            ],
+            [
+                'clockSeq' => 28672,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 45056,
+                'expectedHex' => 'b000',
+            ],
+            [
+                'clockSeq' => 32768,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 32768,
+                'expectedHex' => '8000',
+            ],
+            [
+                'clockSeq' => 36864,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 36864,
+                'expectedHex' => '9000',
+            ],
+            [
+                'clockSeq' => 40960,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 40960,
+                'expectedHex' => 'a000',
+            ],
+            [
+                'clockSeq' => 45056,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 45056,
+                'expectedHex' => 'b000',
+            ],
+            [
+                'clockSeq' => 36863,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 36863,
+                'expectedHex' => '8fff',
+            ],
+            [
+                'clockSeq' => 40959,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 40959,
+                'expectedHex' => '9fff',
+            ],
+            [
+                'clockSeq' => 45055,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 45055,
+                'expectedHex' => 'afff',
+            ],
+            [
+                'clockSeq' => 49151,
+                'variant' => Variant::Rfc4122,
+                'expectedInt' => 49151,
+                'expectedHex' => 'bfff',
+            ],
+        ];
+    }
+
+    /**
+     * @return array<array{bytes: non-empty-string, version: Version, expectedHex: non-empty-string}>
+     */
+    public function provideVersionAndVariantTestValues(): array
+    {
+        /** @var non-empty-string $bytes */
+        $bytes = hex2bin('426a25b74e975e743af1700fa4e42455');
+
+        return [
+            [
+                'bytes' => $bytes,
+                'version' => Version::Time,
+                'expectedHex' => '426a25b74e971e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::DceSecurity,
+                'expectedHex' => '426a25b74e972e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::HashMd5,
+                'expectedHex' => '426a25b74e973e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::Random,
+                'expectedHex' => '426a25b74e974e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::HashSha1,
+                'expectedHex' => '426a25b74e975e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::ReorderedTime,
+                'expectedHex' => '426a25b74e976e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::UnixTime,
+                'expectedHex' => '426a25b74e977e74baf1700fa4e42455',
+            ],
+            [
+                'bytes' => $bytes,
+                'version' => Version::Custom,
+                'expectedHex' => '426a25b74e978e74baf1700fa4e42455',
+            ],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/Builder/FallbackBuilderTest.php

@@ -0,0 +1,198 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Builder;
+
+use DateTimeInterface;
+use Mockery;
+use Ramsey\Uuid\Builder\FallbackBuilder;
+use Ramsey\Uuid\Builder\UuidBuilderInterface;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Codec\StringCodec;
+use Ramsey\Uuid\Converter\Number\GenericNumberConverter;
+use Ramsey\Uuid\Converter\Time\GenericTimeConverter;
+use Ramsey\Uuid\Converter\Time\PhpTimeConverter;
+use Ramsey\Uuid\Exception\BuilderNotFoundException;
+use Ramsey\Uuid\Exception\UnableToBuildUuidException;
+use Ramsey\Uuid\Guid\GuidBuilder;
+use Ramsey\Uuid\Math\BrickMathCalculator;
+use Ramsey\Uuid\Nonstandard\UuidBuilder as NonstandardUuidBuilder;
+use Ramsey\Uuid\Rfc4122\UuidBuilder as Rfc4122UuidBuilder;
+use Ramsey\Uuid\Rfc4122\UuidV1;
+use Ramsey\Uuid\Rfc4122\UuidV2;
+use Ramsey\Uuid\Rfc4122\UuidV6;
+use Ramsey\Uuid\Test\TestCase;
+
+class FallbackBuilderTest extends TestCase
+{
+    public function testBuildThrowsExceptionAfterAllConfiguredBuildersHaveErrored(): void
+    {
+        $codec = Mockery::mock(CodecInterface::class);
+        $bytes = 'foobar';
+
+        $builder1 = Mockery::mock(UuidBuilderInterface::class);
+        $builder1
+            ->shouldReceive('build')
+            ->once()
+            ->with($codec, $bytes)
+            ->andThrow(UnableToBuildUuidException::class);
+
+        $builder2 = Mockery::mock(UuidBuilderInterface::class);
+        $builder2
+            ->shouldReceive('build')
+            ->once()
+            ->with($codec, $bytes)
+            ->andThrow(UnableToBuildUuidException::class);
+
+        $builder3 = Mockery::mock(UuidBuilderInterface::class);
+        $builder3
+            ->shouldReceive('build')
+            ->once()
+            ->with($codec, $bytes)
+            ->andThrow(UnableToBuildUuidException::class);
+
+        $fallbackBuilder = new FallbackBuilder([$builder1, $builder2, $builder3]);
+
+        $this->expectException(BuilderNotFoundException::class);
+        $this->expectExceptionMessage(
+            'Could not find a suitable builder for the provided codec and fields'
+        );
+
+        $fallbackBuilder->build($codec, $bytes);
+    }
+
+    /**
+     * @param non-empty-string $bytes
+     *
+     * @dataProvider provideBytes
+     */
+    public function testSerializationOfBuilderCollection(string $bytes): void
+    {
+        $calculator = new BrickMathCalculator();
+        $genericNumberConverter = new GenericNumberConverter($calculator);
+        $genericTimeConverter = new GenericTimeConverter($calculator);
+        $phpTimeConverter = new PhpTimeConverter($calculator, $genericTimeConverter);
+
+        // Use the GenericTimeConverter.
+        $guidBuilder = new GuidBuilder($genericNumberConverter, $genericTimeConverter);
+        $rfc4122Builder = new Rfc4122UuidBuilder($genericNumberConverter, $genericTimeConverter);
+        $nonstandardBuilder = new NonstandardUuidBuilder($genericNumberConverter, $genericTimeConverter);
+
+        // Use the PhpTimeConverter.
+        $guidBuilder2 = new GuidBuilder($genericNumberConverter, $phpTimeConverter);
+        $rfc4122Builder2 = new Rfc4122UuidBuilder($genericNumberConverter, $phpTimeConverter);
+        $nonstandardBuilder2 = new NonstandardUuidBuilder($genericNumberConverter, $phpTimeConverter);
+
+        /** @var list<UuidBuilderInterface> $unserializedBuilderCollection */
+        $unserializedBuilderCollection = unserialize(serialize([
+            $guidBuilder,
+            $guidBuilder2,
+            $rfc4122Builder,
+            $rfc4122Builder2,
+            $nonstandardBuilder,
+            $nonstandardBuilder2,
+        ]));
+
+        foreach ($unserializedBuilderCollection as $builder) {
+            $codec = new StringCodec($builder);
+
+            $this->assertInstanceOf(UuidBuilderInterface::class, $builder);
+
+            try {
+                $uuid = $builder->build($codec, $bytes);
+
+                if (($uuid instanceof UuidV1) || ($uuid instanceof UuidV2) || ($uuid instanceof UuidV6)) {
+                    $this->assertInstanceOf(DateTimeInterface::class, $uuid->getDateTime());
+                }
+            } catch (UnableToBuildUuidException $exception) {
+                switch ($exception->getMessage()) {
+                    case 'The byte string received does not contain a valid version':
+                    case 'The byte string received does not conform to the RFC 4122 variant':
+                    case 'The byte string received does not conform to the RFC 4122 or Microsoft Corporation variants':
+                        // This is expected; ignoring.
+                        break;
+                    default:
+                        throw $exception;
+                }
+            }
+        }
+    }
+
+    /**
+     * @return array<array{bytes: string|false}>
+     */
+    public function provideBytes(): array
+    {
+        return [
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1110b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1111b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1112b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1113b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1114b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1115b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1116b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e1117b210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e111eb210800200c9a66'),
+            ],
+            [
+                // GUID bytes
+                'bytes' => hex2bin('b08c6fff7dc5e111fb210800200c9a66'),
+            ],
+            [
+                // Version 1 bytes
+                'bytes' => hex2bin('ff6f8cb0c57d11e19b210800200c9a66'),
+            ],
+            [
+                // Version 2 bytes
+                'bytes' => hex2bin('000001f55cde21ea84000242ac130003'),
+            ],
+            [
+                // Version 3 bytes
+                'bytes' => hex2bin('ff6f8cb0c57d31e1bb210800200c9a66'),
+            ],
+            [
+                // Version 4 bytes
+                'bytes' => hex2bin('ff6f8cb0c57d41e1ab210800200c9a66'),
+            ],
+            [
+                // Version 5 bytes
+                'bytes' => hex2bin('ff6f8cb0c57d51e18b210800200c9a66'),
+            ],
+            [
+                // Version 6 bytes
+                'bytes' => hex2bin('ff6f8cb0c57d61e18b210800200c9a66'),
+            ],
+            [
+                // NIL bytes
+                'bytes' => hex2bin('00000000000000000000000000000000'),
+            ],
+        ];
+    }
+}

package/vendor/ramsey/uuid/tests/Codec/GuidStringCodecTest.php

@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Codec;
+
+use Mockery;
+use PHPUnit\Framework\MockObject\MockObject;
+use Ramsey\Uuid\Builder\UuidBuilderInterface;
+use Ramsey\Uuid\Codec\GuidStringCodec;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Guid\Fields;
+use Ramsey\Uuid\Guid\Guid;
+use Ramsey\Uuid\Guid\GuidBuilder;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\UuidInterface;
+
+use function hex2bin;
+use function pack;
+
+class GuidStringCodecTest extends TestCase
+{
+    private UuidBuilderInterface & MockObject $builder;
+    private UuidInterface & MockObject $uuid;
+    private Fields $fields;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->builder = $this->getMockBuilder(UuidBuilderInterface::class)->getMock();
+        $this->uuid = $this->getMockBuilder(UuidInterface::class)->getMock();
+
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin('785634123412cd4babef1234abcd4321');
+        $this->fields = new Fields($bytes);
+    }
+
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        unset($this->builder, $this->fields, $this->uuid);
+    }
+
+    public function testEncodeUsesFieldsArray(): void
+    {
+        $this->uuid->expects($this->once())
+            ->method('getFields')
+            ->willReturn($this->fields);
+        $codec = new GuidStringCodec($this->builder);
+        $codec->encode($this->uuid);
+    }
+
+    public function testEncodeReturnsFormattedString(): void
+    {
+        $this->uuid->method('getFields')
+            ->willReturn($this->fields);
+        $codec = new GuidStringCodec($this->builder);
+        $result = $codec->encode($this->uuid);
+        $this->assertSame('12345678-1234-4bcd-abef-1234abcd4321', $result);
+    }
+
+    public function testEncodeBinary(): void
+    {
+        /** @var non-empty-string $expectedBytes */
+        $expectedBytes = (string) hex2bin('785634123412cd4babef1234abcd4321');
+
+        $fields = new Fields($expectedBytes);
+        $codec = new GuidStringCodec($this->builder);
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $timeConverter = Mockery::mock(TimeConverterInterface::class);
+
+        $uuid = new Guid($fields, $numberConverter, $codec, $timeConverter);
+
+        $bytes = $codec->encodeBinary($uuid);
+
+        $this->assertSame($expectedBytes, $bytes);
+    }
+
+    public function testDecodeReturnsGuid(): void
+    {
+        $string = 'uuid:12345678-1234-4bcd-abef-1234abcd4321';
+
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $timeConverter = Mockery::mock(TimeConverterInterface::class);
+        $builder = new GuidBuilder($numberConverter, $timeConverter);
+        $codec = new GuidStringCodec($builder);
+        $guid = $codec->decode($string);
+
+        $this->assertInstanceOf(Guid::class, $guid);
+        $this->assertSame('12345678-1234-4bcd-abef-1234abcd4321', $guid->toString());
+    }
+
+    public function testDecodeReturnsUuidFromBuilder(): void
+    {
+        $string = 'uuid:78563412-3412-cd4b-abef-1234abcd4321';
+        $this->builder->method('build')
+            ->willReturn($this->uuid);
+
+        $codec = new GuidStringCodec($this->builder);
+        $result = $codec->decode($string);
+        $this->assertSame($this->uuid, $result);
+    }
+
+    public function testDecodeBytesReturnsUuid(): void
+    {
+        $string = '1234567812344bcd4bef1234abcd4321';
+
+        /** @var non-empty-string $bytes */
+        $bytes = pack('H*', $string);
+
+        $codec = new GuidStringCodec($this->builder);
+        $this->builder->method('build')
+            ->willReturn($this->uuid);
+        $result = $codec->decodeBytes($bytes);
+        $this->assertSame($this->uuid, $result);
+    }
+}