create-prisma-php-app 1.0.0 → 1.0.1

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

@@ -1,258 +0,0 @@
-<?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\OrderedTimeCodec;
-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\Exception\UnsupportedOperationException;
-use Ramsey\Uuid\Math\BrickMathCalculator;
-use Ramsey\Uuid\Nonstandard\Fields as NonstandardFields;
-use Ramsey\Uuid\Nonstandard\UuidBuilder;
-use Ramsey\Uuid\Rfc4122\Fields;
-use Ramsey\Uuid\Rfc4122\UuidBuilder as Rfc4122UuidBuilder;
-use Ramsey\Uuid\Test\TestCase;
-use Ramsey\Uuid\Uuid;
-use Ramsey\Uuid\UuidFactory;
-use Ramsey\Uuid\UuidInterface;
-
-use function hex2bin;
-use function pack;
-use function serialize;
-use function str_replace;
-use function unserialize;
-
-class OrderedTimeCodecTest extends TestCase
-{
-    private UuidBuilderInterface & MockObject $builder;
-    private UuidInterface & MockObject $uuid;
-    private Fields $fields;
-
-    /**
-     * @var non-empty-string
-     */
-    private string $uuidString = '58e0a7d7-eebc-11d8-9669-0800200c9a66';
-
-    /**
-     * @var non-empty-string
-     */
-    private string $optimizedHex = '11d8eebc58e0a7d796690800200c9a66';
-
-    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('58e0a7d7eebc11d896690800200c9a66');
-
-        $this->fields = new Fields($bytes);
-    }
-
-    protected function tearDown(): void
-    {
-        parent::tearDown();
-        unset($this->builder, $this->uuid, $this->fields);
-    }
-
-    public function testEncodeUsesFieldsArray(): void
-    {
-        $this->uuid->expects($this->once())
-            ->method('getFields')
-            ->willReturn($this->fields);
-        $codec = new OrderedTimeCodec($this->builder);
-        $codec->encode($this->uuid);
-    }
-
-    public function testEncodeReturnsFormattedString(): void
-    {
-        $this->uuid->method('getFields')
-            ->willReturn($this->fields);
-        $codec = new OrderedTimeCodec($this->builder);
-        $result = $codec->encode($this->uuid);
-        $this->assertSame($this->uuidString, $result);
-    }
-
-    public function testEncodeBinary(): void
-    {
-        $expected = hex2bin($this->optimizedHex);
-
-        $numberConverter = Mockery::mock(NumberConverterInterface::class);
-        $timeConverter = Mockery::mock(TimeConverterInterface::class);
-        $builder = new Rfc4122UuidBuilder($numberConverter, $timeConverter);
-        $codec = new OrderedTimeCodec($builder);
-
-        $factory = new UuidFactory();
-        $factory->setCodec($codec);
-
-        $uuid = $factory->fromString($this->uuidString);
-
-        $this->assertSame($expected, $codec->encodeBinary($uuid));
-    }
-
-    public function testDecodeBytesThrowsExceptionWhenBytesStringNotSixteenCharacters(): void
-    {
-        $string = '61';
-        $codec = new OrderedTimeCodec($this->builder);
-
-        /** @var non-empty-string $bytes */
-        $bytes = pack('H*', $string);
-
-        $this->expectException(\InvalidArgumentException::class);
-        $this->expectExceptionMessage('$bytes string should contain 16 characters.');
-        $codec->decodeBytes($bytes);
-    }
-
-    public function testDecodeReturnsUuidFromBuilder(): void
-    {
-        $string = 'uuid:58e0a7d7-eebc-11d8-9669-0800200c9a66';
-        $this->builder->method('build')
-            ->willReturn($this->uuid);
-        $codec = new OrderedTimeCodec($this->builder);
-        $result = $codec->decode($string);
-        $this->assertSame($this->uuid, $result);
-    }
-
-    public function testDecodeBytesRearrangesFields(): void
-    {
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin($this->optimizedHex);
-
-        $calculator = new BrickMathCalculator();
-        $numberConverter = new GenericNumberConverter($calculator);
-        $timeConverter = Mockery::mock(TimeConverterInterface::class);
-        $builder = new Rfc4122UuidBuilder($numberConverter, $timeConverter);
-        $codec = new OrderedTimeCodec($builder);
-
-        $factory = new UuidFactory();
-        $factory->setCodec($codec);
-
-        $expectedUuid = $factory->fromString($this->uuidString);
-        $uuidReturned = $codec->decodeBytes($bytes);
-
-        $this->assertTrue($uuidReturned->equals($expectedUuid));
-    }
-
-    public function testEncodeBinaryThrowsExceptionForNonRfc4122Uuid(): void
-    {
-        $nonRfc4122Uuid = '58e0a7d7-eebc-11d8-d669-0800200c9a66';
-
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin(str_replace('-', '', $nonRfc4122Uuid));
-
-        $fields = new NonstandardFields($bytes);
-        $numberConverter = Mockery::mock(NumberConverterInterface::class);
-        $timeConverter = Mockery::mock(TimeConverterInterface::class);
-        $builder = new Rfc4122UuidBuilder($numberConverter, $timeConverter);
-        $codec = new OrderedTimeCodec($builder);
-
-        $uuid = Mockery::mock(UuidInterface::class, [
-            'getVariant' => 0,
-            'toString' => $nonRfc4122Uuid,
-            'getFields' => $fields,
-        ]);
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage(
-            'Expected RFC 4122 version 1 (time-based) UUID'
-        );
-
-        $codec->encodeBinary($uuid);
-    }
-
-    public function testEncodeBinaryThrowsExceptionForNonTimeBasedUuid(): void
-    {
-        $nonTimeBasedUuid = '58e0a7d7-eebc-41d8-9669-0800200c9a66';
-
-        $numberConverter = Mockery::mock(NumberConverterInterface::class);
-        $timeConverter = Mockery::mock(TimeConverterInterface::class);
-        $builder = new Rfc4122UuidBuilder($numberConverter, $timeConverter);
-        $codec = new OrderedTimeCodec($builder);
-
-        $factory = new UuidFactory();
-        $factory->setCodec($codec);
-
-        $uuid = $factory->fromString($nonTimeBasedUuid);
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage(
-            'Expected RFC 4122 version 1 (time-based) UUID'
-        );
-
-        $codec->encodeBinary($uuid);
-    }
-
-    public function testDecodeBytesThrowsExceptionsForNonRfc4122Uuid(): void
-    {
-        $nonRfc4122OptimizedHex = '11d8eebc58e0a7d716690800200c9a66';
-
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin($nonRfc4122OptimizedHex);
-
-        $calculator = new BrickMathCalculator();
-        $numberConverter = new GenericNumberConverter($calculator);
-        $timeConverter = new GenericTimeConverter($calculator);
-        $builder = new UuidBuilder($numberConverter, $timeConverter);
-
-        $codec = new OrderedTimeCodec($builder);
-
-        $this->expectException(UnsupportedOperationException::class);
-        $this->expectExceptionMessage(
-            'Attempting to decode a non-time-based UUID using OrderedTimeCodec'
-        );
-
-        $codec->decodeBytes($bytes);
-    }
-
-    public function testDecodeBytesThrowsExceptionsForNonTimeBasedUuid(): void
-    {
-        $nonTimeBasedOptimizedHex = '41d8eebc58e0a7d796690800200c9a66';
-
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin($nonTimeBasedOptimizedHex);
-
-        $numberConverter = Mockery::mock(NumberConverterInterface::class);
-        $timeConverter = Mockery::mock(TimeConverterInterface::class);
-        $builder = new Rfc4122UuidBuilder($numberConverter, $timeConverter);
-        $codec = new OrderedTimeCodec($builder);
-
-        $factory = new UuidFactory();
-        $factory->setCodec($codec);
-
-        $this->expectException(UnsupportedOperationException::class);
-        $this->expectExceptionMessage(
-            'Attempting to decode a non-time-based UUID using OrderedTimeCodec'
-        );
-
-        $codec->decodeBytes($bytes);
-    }
-
-    public function testSerializationDoesNotUseOrderedTimeCodec(): void
-    {
-        $expected = '9ec692cc-67c8-11eb-ae93-0242ac130002';
-
-        $codec = new OrderedTimeCodec(
-            (new UuidFactory())->getUuidBuilder()
-        );
-        $decoded = $codec->decode($expected);
-        $serialized = serialize($decoded);
-
-        /** @var \Ramsey\Uuid\Rfc4122\UuidInterface $unserializedUuid */
-        $unserializedUuid = unserialize($serialized);
-
-        /** @var \Ramsey\Uuid\Rfc4122\UuidInterface $expectedUuid */
-        $expectedUuid = Uuid::fromString($expected);
-
-        $this->assertSame($expectedUuid->getFields()->getVersion(), $unserializedUuid->getFields()->getVersion());
-        $this->assertTrue($expectedUuid->equals($unserializedUuid));
-    }
-}

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

@@ -1,149 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Codec;
-
-use InvalidArgumentException;
-use Mockery;
-use PHPUnit\Framework\MockObject\MockObject;
-use Ramsey\Uuid\Builder\UuidBuilderInterface;
-use Ramsey\Uuid\Codec\StringCodec;
-use Ramsey\Uuid\Rfc4122\Fields;
-use Ramsey\Uuid\Rfc4122\FieldsInterface;
-use Ramsey\Uuid\Test\TestCase;
-use Ramsey\Uuid\UuidInterface;
-
-use function hex2bin;
-use function implode;
-use function pack;
-
-class StringCodecTest extends TestCase
-{
-    private UuidBuilderInterface & MockObject $builder;
-    private UuidInterface & MockObject $uuid;
-    private Fields $fields;
-
-    /**
-     * @var non-empty-string
-     */
-    private string $uuidString = '12345678-1234-4bcd-abef-1234abcd4321';
-
-    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('1234567812344bcdabef1234abcd4321');
-        $this->fields = new Fields($bytes);
-    }
-
-    protected function tearDown(): void
-    {
-        parent::tearDown();
-        unset($this->builder, $this->uuid, $this->fields);
-    }
-
-    public function testEncodeUsesFieldsArray(): void
-    {
-        $this->uuid->expects($this->once())
-            ->method('getFields')
-            ->willReturn($this->fields);
-        $codec = new StringCodec($this->builder);
-        $codec->encode($this->uuid);
-    }
-
-    public function testEncodeReturnsFormattedString(): void
-    {
-        $this->uuid->method('getFields')
-            ->willReturn($this->fields);
-        $codec = new StringCodec($this->builder);
-        $result = $codec->encode($this->uuid);
-        $this->assertSame($this->uuidString, $result);
-    }
-
-    public function testEncodeBinaryReturnsBinaryString(): void
-    {
-        $expected = hex2bin('123456781234abcdabef1234abcd4321');
-
-        $fields = Mockery::mock(FieldsInterface::class, [
-            'getBytes' => hex2bin('123456781234abcdabef1234abcd4321'),
-        ]);
-
-        $this->uuid->method('getFields')->willReturn($fields);
-
-        $codec = new StringCodec($this->builder);
-        $result = $codec->encodeBinary($this->uuid);
-        $this->assertSame($expected, $result);
-    }
-
-    public function testDecodeUsesBuilderOnFields(): void
-    {
-        $fields = [
-            'time_low' => $this->fields->getTimeLow()->toString(),
-            'time_mid' => $this->fields->getTimeMid()->toString(),
-            'time_hi_and_version' => $this->fields->getTimeHiAndVersion()->toString(),
-            'clock_seq_hi_and_reserved' => $this->fields->getClockSeqHiAndReserved()->toString(),
-            'clock_seq_low' => $this->fields->getClockSeqLow()->toString(),
-            'node' => $this->fields->getNode()->toString(),
-        ];
-
-        $bytes = hex2bin(implode('', $fields));
-
-        $string = 'uuid:12345678-1234-4bcd-abef-1234abcd4321';
-        $this->builder->expects($this->once())
-            ->method('build')
-            ->with($this->isInstanceOf(StringCodec::class), $bytes);
-        $codec = new StringCodec($this->builder);
-        $codec->decode($string);
-    }
-
-    public function testDecodeThrowsExceptionOnInvalidUuid(): void
-    {
-        $string = 'invalid-uuid';
-        $codec = new StringCodec($this->builder);
-
-        $this->expectException(InvalidArgumentException::class);
-        $codec->decode($string);
-    }
-
-    public function testDecodeReturnsUuidFromBuilder(): void
-    {
-        $string = 'uuid:12345678-1234-abcd-abef-1234abcd4321';
-        $this->builder->method('build')
-            ->willReturn($this->uuid);
-        $codec = new StringCodec($this->builder);
-        $result = $codec->decode($string);
-        $this->assertSame($this->uuid, $result);
-    }
-
-    public function testDecodeBytesThrowsExceptionWhenBytesStringNotSixteenCharacters(): void
-    {
-        $string = '61';
-
-        /** @var non-empty-string $bytes */
-        $bytes = pack('H*', $string);
-
-        $codec = new StringCodec($this->builder);
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('$bytes string should contain 16 characters.');
-        $codec->decodeBytes($bytes);
-    }
-
-    public function testDecodeBytesReturnsUuid(): void
-    {
-        $string = '123456781234abcdabef1234abcd4321';
-
-        /** @var non-empty-string $bytes */
-        $bytes = pack('H*', $string);
-
-        $codec = new StringCodec($this->builder);
-        $this->builder->method('build')
-            ->willReturn($this->uuid);
-        $result = $codec->decodeBytes($bytes);
-        $this->assertSame($this->uuid, $result);
-    }
-}

package/vendor/ramsey/uuid/tests/Converter/Number/GenericNumberConverterTest.php

@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Converter\Number;
-
-use Ramsey\Uuid\Converter\Number\GenericNumberConverter;
-use Ramsey\Uuid\Math\BrickMathCalculator;
-use Ramsey\Uuid\Test\TestCase;
-
-class GenericNumberConverterTest extends TestCase
-{
-    public function testFromHex(): void
-    {
-        $calculator = new BrickMathCalculator();
-        $converter = new GenericNumberConverter($calculator);
-
-        $this->assertSame('65535', $converter->fromHex('ffff'));
-    }
-
-    public function testToHex(): void
-    {
-        $calculator = new BrickMathCalculator();
-        $converter = new GenericNumberConverter($calculator);
-
-        $this->assertSame('ffff', $converter->toHex('65535'));
-    }
-}

package/vendor/ramsey/uuid/tests/Converter/Time/GenericTimeConverterTest.php

@@ -1,147 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Converter\Time;
-
-use Ramsey\Uuid\Converter\Time\GenericTimeConverter;
-use Ramsey\Uuid\Math\BrickMathCalculator;
-use Ramsey\Uuid\Test\TestCase;
-use Ramsey\Uuid\Type\Hexadecimal;
-
-class GenericTimeConverterTest extends TestCase
-{
-    /**
-     * @param numeric-string $seconds
-     * @param numeric-string $microseconds
-     *
-     * @dataProvider provideCalculateTime
-     */
-    public function testCalculateTime(string $seconds, string $microseconds, string $expected): void
-    {
-        $calculator = new BrickMathCalculator();
-        $converter = new GenericTimeConverter($calculator);
-
-        $result = $converter->calculateTime($seconds, $microseconds);
-
-        $this->assertSame($expected, $result->toString());
-    }
-
-    /**
-     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
-     */
-    public function provideCalculateTime(): array
-    {
-        return [
-            [
-                'seconds' => '-12219146756',
-                'microseconds' => '0',
-                'expected' => '000001540901e600',
-            ],
-            [
-                'seconds' => '103072857659',
-                'microseconds' => '999999',
-                'expected' => '0fffffffff9785f6',
-            ],
-            [
-                'seconds' => '1578612359',
-                'microseconds' => '521023',
-                'expected' => '01ea333764c71df6',
-            ],
-
-            // This is the earliest possible date supported by v1 UUIDs:
-            // 1582-10-15 00:00:00.000000
-            [
-                'seconds' => '-12219292800',
-                'microseconds' => '0',
-                'expected' => '0000000000000000',
-            ],
-
-            // This is the last possible time supported by the GenericTimeConverter:
-            // 60038-03-11 05:36:10.955161
-            // When a UUID is created from this time, however, the highest 4 bits
-            // are replaced with the version (1), so we lose fidelity and cannot
-            // accurately decompose the date from the UUID.
-            [
-                'seconds' => '1832455114570',
-                'microseconds' => '955161',
-                'expected' => 'fffffffffffffffa',
-            ],
-
-            // This is technically the last possible time supported by v1 UUIDs:
-            // 5236-03-31 21:21:00.684697
-            // All dates above this will lose fidelity, since the highest 4 bits
-            // are replaced with the UUID version (1). As a result, we cannot
-            // accurately decompose the date from UUIDs created from dates
-            // greater than this one.
-            [
-                'seconds' => '103072857660',
-                'microseconds' => '684697',
-                'expected' => '0ffffffffffffffa',
-            ],
-        ];
-    }
-
-    /**
-     * @dataProvider provideConvertTime
-     */
-    public function testConvertTime(Hexadecimal $uuidTimestamp, string $unixTimestamp, string $microseconds): void
-    {
-        $calculator = new BrickMathCalculator();
-        $converter = new GenericTimeConverter($calculator);
-
-        $result = $converter->convertTime($uuidTimestamp);
-
-        $this->assertSame($unixTimestamp, $result->getSeconds()->toString());
-        $this->assertSame($microseconds, $result->getMicroseconds()->toString());
-    }
-
-    /**
-     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
-     */
-    public function provideConvertTime(): array
-    {
-        return [
-            [
-                'uuidTimestamp' => new Hexadecimal('1e1c57dff6f8cb0'),
-                'unixTimestamp' => '1341368074',
-                'microseconds' => '491000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('1ea333764c71df6'),
-                'unixTimestamp' => '1578612359',
-                'microseconds' => '521023',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('fffffffff9785f6'),
-                'unixTimestamp' => '103072857659',
-                'microseconds' => '999999',
-            ],
-
-            // This is the last possible time supported by v1 UUIDs. When
-            // converted to a Unix timestamp, the microseconds are lost.
-            // 60038-03-11 05:36:10.955161
-            [
-                'uuidTimestamp' => new Hexadecimal('fffffffffffffffa'),
-                'unixTimestamp' => '1832455114570',
-                'microseconds' => '955161',
-            ],
-
-            // This is the earliest possible date supported by v1 UUIDs:
-            // 1582-10-15 00:00:00.000000
-            [
-                'uuidTimestamp' => new Hexadecimal('000000000000'),
-                'unixTimestamp' => '-12219292800',
-                'microseconds' => '0',
-            ],
-
-            // This is the Unix epoch:
-            // 1970-01-01 00:00:00.000000
-            [
-                'uuidTimestamp' => new Hexadecimal('1b21dd213814000'),
-                'unixTimestamp' => '0',
-                'microseconds' => '0',
-            ],
-        ];
-    }
-}