create-prisma-php-app 1.0.0 → 1.0.1

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

@@ -1,199 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Converter\Time;
-
-use Brick\Math\BigInteger;
-use Mockery;
-use Ramsey\Uuid\Converter\Time\GenericTimeConverter;
-use Ramsey\Uuid\Converter\Time\PhpTimeConverter;
-use Ramsey\Uuid\Exception\InvalidArgumentException;
-use Ramsey\Uuid\Math\BrickMathCalculator;
-use Ramsey\Uuid\Test\TestCase;
-use Ramsey\Uuid\Type\Hexadecimal;
-
-use function sprintf;
-
-class PhpTimeConverterTest extends TestCase
-{
-    public function testCalculateTimeReturnsArrayOfTimeSegments(): void
-    {
-        $seconds = BigInteger::of(5);
-        $microseconds = BigInteger::of(3);
-
-        $calculatedTime = BigInteger::zero()
-            ->plus($seconds->multipliedBy(10000000))
-            ->plus($microseconds->multipliedBy(10))
-            ->plus(BigInteger::fromBase('01b21dd213814000', 16));
-
-        $maskLow = BigInteger::fromBase('ffffffff', 16);
-        $maskMid = BigInteger::fromBase('ffff', 16);
-        $maskHi = BigInteger::fromBase('0fff', 16);
-
-        $expected = sprintf('%04s', $calculatedTime->shiftedRight(48)->and($maskHi)->toBase(16));
-        $expected .= sprintf('%04s', $calculatedTime->shiftedRight(32)->and($maskMid)->toBase(16));
-        $expected .= sprintf('%08s', $calculatedTime->and($maskLow)->toBase(16));
-
-        $converter = new PhpTimeConverter();
-
-        /** @var numeric-string $numericSeconds */
-        $numericSeconds = (string) $seconds;
-
-        /** @var numeric-string $numericMicroseconds */
-        $numericMicroseconds = (string) $microseconds;
-
-        $returned = $converter->calculateTime($numericSeconds, $numericMicroseconds);
-
-        $this->assertSame($expected, $returned->toString());
-    }
-
-    public function testCalculateTimeThrowsExceptionWhenSecondsIsNotOnlyDigits(): void
-    {
-        /** @var Mockery\MockInterface & PhpTimeConverter $converter */
-        $converter = Mockery::mock(PhpTimeConverter::class)->makePartial();
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage(
-            'Value must be a signed integer or a string containing only digits '
-            . '0-9 and, optionally, a sign (+ or -)'
-        );
-
-        $converter->calculateTime('12.34', '5678');
-    }
-
-    public function testCalculateTimeThrowsExceptionWhenMicrosecondsIsNotOnlyDigits(): void
-    {
-        /** @var Mockery\MockInterface & PhpTimeConverter $converter */
-        $converter = Mockery::mock(PhpTimeConverter::class)->makePartial();
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage(
-            'Value must be a signed integer or a string containing only digits '
-            . '0-9 and, optionally, a sign (+ or -)'
-        );
-
-        $converter->calculateTime('1234', '56.78');
-    }
-
-    /**
-     * @dataProvider provideConvertTime
-     */
-    public function testConvertTime(Hexadecimal $uuidTimestamp, string $unixTimestamp, string $microseconds): void
-    {
-        $calculator = new BrickMathCalculator();
-        $fallbackConverter = new GenericTimeConverter($calculator);
-        $converter = new PhpTimeConverter($calculator, $fallbackConverter);
-
-        $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',
-            ],
-        ];
-    }
-
-    /**
-     * @param numeric-string $seconds
-     * @param numeric-string $microseconds
-     *
-     * @dataProvider provideCalculateTime
-     */
-    public function testCalculateTime(string $seconds, string $microseconds, string $expected): void
-    {
-        $calculator = new BrickMathCalculator();
-        $fallbackConverter = new GenericTimeConverter($calculator);
-        $converter = new PhpTimeConverter($calculator, $fallbackConverter);
-
-        $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 v1 UUIDs:
-            // 60038-03-11 05:36:10.955161
-            [
-                'seconds' => '1832455114570',
-                'microseconds' => '955161',
-                'expected' => 'fffffffffffffffa',
-            ],
-        ];
-    }
-}

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

@@ -1,202 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Converter\Time;
-
-use Ramsey\Uuid\Converter\Time\UnixTimeConverter;
-use Ramsey\Uuid\Math\BrickMathCalculator;
-use Ramsey\Uuid\Test\TestCase;
-use Ramsey\Uuid\Type\Hexadecimal;
-
-class UnixTimeConverterTest extends TestCase
-{
-    /**
-     * @dataProvider provideConvertTime
-     */
-    public function testConvertTime(Hexadecimal $uuidTimestamp, string $unixTimestamp, string $microseconds): void
-    {
-        $calculator = new BrickMathCalculator();
-        $converter = new UnixTimeConverter($calculator);
-
-        $result = $converter->convertTime($uuidTimestamp);
-
-        $this->assertSame($unixTimestamp, $result->getSeconds()->toString());
-        $this->assertSame($microseconds, $result->getMicroseconds()->toString());
-    }
-
-    /**
-     * @return array<array{uuidTimestamp: Hexadecimal, unixTimestamp: string, microseconds: string}>
-     */
-    public function provideConvertTime(): array
-    {
-        return [
-            [
-                'uuidTimestamp' => new Hexadecimal('017F22E279B0'),
-                'unixTimestamp' => '1645557742',
-                'microseconds' => '0',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('01384fc480fb'),
-                'unixTimestamp' => '1341368074',
-                'microseconds' => '491000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('016f8ca10161'),
-                'unixTimestamp' => '1578612359',
-                'microseconds' => '521000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('5dbe85111a5f'),
-                'unixTimestamp' => '103072857659',
-                'microseconds' => '999000',
-            ],
-
-            // This is the last possible time supported by v7 UUIDs (2 ^ 48 - 1).
-            // 10889-08-02 05:31:50.655 +00:00
-            [
-                'uuidTimestamp' => new Hexadecimal('ffffffffffff'),
-                'unixTimestamp' => '281474976710',
-                'microseconds' => '655000',
-            ],
-
-            // This is the earliest possible date supported by v7 UUIDs.
-            // It is the Unix Epoch (big surprise!).
-            // 1970-01-01 00:00:00.0 +00:00
-            [
-                'uuidTimestamp' => new Hexadecimal('000000000000'),
-                'unixTimestamp' => '0',
-                'microseconds' => '0',
-            ],
-
-            [
-                'uuidTimestamp' => new Hexadecimal('000000000001'),
-                'unixTimestamp' => '0',
-                'microseconds' => '1000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('00000000000f'),
-                'unixTimestamp' => '0',
-                'microseconds' => '15000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('000000000064'),
-                'unixTimestamp' => '0',
-                'microseconds' => '100000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('0000000003e7'),
-                'unixTimestamp' => '0',
-                'microseconds' => '999000',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('0000000003e8'),
-                'unixTimestamp' => '1',
-                'microseconds' => '0',
-            ],
-            [
-                'uuidTimestamp' => new Hexadecimal('0000000003e9'),
-                'unixTimestamp' => '1',
-                'microseconds' => '1000',
-            ],
-        ];
-    }
-
-    /**
-     * @param numeric-string $seconds
-     * @param numeric-string $microseconds
-     * @param non-empty-string $expected
-     *
-     * @dataProvider provideCalculateTime
-     */
-    public function testCalculateTime(string $seconds, string $microseconds, string $expected): void
-    {
-        $calculator = new BrickMathCalculator();
-        $converter = new UnixTimeConverter($calculator);
-
-        $result = $converter->calculateTime($seconds, $microseconds);
-
-        $this->assertSame($expected, $result->toString());
-    }
-
-    /**
-     * @return array<array{seconds: numeric-string, microseconds: numeric-string, expected: non-empty-string}>
-     */
-    public function provideCalculateTime(): array
-    {
-        return [
-            [
-                'seconds' => '1645557742',
-                'microseconds' => '0',
-                'expected' => '017f22e279b0',
-            ],
-            [
-                'seconds' => '1341368074',
-                'microseconds' => '491000',
-                'expected' => '01384fc480fb',
-            ],
-            [
-                'seconds' => '1578612359',
-                'microseconds' => '521023',
-                'expected' => '016f8ca10161',
-            ],
-            [
-                'seconds' => '103072857659',
-                'microseconds' => '999499',
-                'expected' => '5dbe85111a5f',
-            ],
-            [
-                'seconds' => '103072857659',
-                'microseconds' => '999999',
-                'expected' => '5dbe85111a5f',
-            ],
-
-            // This is the earliest possible date supported by v7 UUIDs.
-            // It is the Unix Epoch (big surprise!): 1970-01-01 00:00:00.0 +00:00
-            [
-                'seconds' => '0',
-                'microseconds' => '0',
-                'expected' => '000000000000',
-            ],
-
-            // This is the last possible time supported by v7 UUIDs (2 ^ 48 - 1):
-            // 10889-08-02 05:31:50.655 +00:00
-            [
-                'seconds' => '281474976710',
-                'microseconds' => '655000',
-                'expected' => 'ffffffffffff',
-            ],
-
-            [
-                'seconds' => '0',
-                'microseconds' => '1000',
-                'expected' => '000000000001',
-            ],
-            [
-                'seconds' => '0',
-                'microseconds' => '15000',
-                'expected' => '00000000000f',
-            ],
-            [
-                'seconds' => '0',
-                'microseconds' => '100000',
-                'expected' => '000000000064',
-            ],
-            [
-                'seconds' => '0',
-                'microseconds' => '999000',
-                'expected' => '0000000003e7',
-            ],
-            [
-                'seconds' => '1',
-                'microseconds' => '0',
-                'expected' => '0000000003e8',
-            ],
-            [
-                'seconds' => '1',
-                'microseconds' => '1000',
-                'expected' => '0000000003e9',
-            ],
-        ];
-    }
-}

package/vendor/ramsey/uuid/tests/Encoder/TimestampFirstCombCodecTest.php

@@ -1,105 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Encoder;
-
-use Mockery;
-use PHPUnit\Framework\MockObject\MockObject;
-use Ramsey\Uuid\Builder\UuidBuilderInterface;
-use Ramsey\Uuid\Codec\CodecInterface;
-use Ramsey\Uuid\Codec\TimestampFirstCombCodec;
-use Ramsey\Uuid\Rfc4122\Fields;
-use Ramsey\Uuid\Test\TestCase;
-use Ramsey\Uuid\UuidInterface;
-
-use function hex2bin;
-use function implode;
-
-class TimestampFirstCombCodecTest extends TestCase
-{
-    /**
-     * @var CodecInterface
-     */
-    private $codec;
-
-    /**
-     * @var MockObject & UuidBuilderInterface
-     */
-    private $builderMock;
-
-    protected function setUp(): void
-    {
-        $this->builderMock = $this->getMockBuilder(UuidBuilderInterface::class)->getMock();
-        $this->codec = new TimestampFirstCombCodec($this->builderMock);
-    }
-
-    public function testEncoding(): void
-    {
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin('ff6f8cb0c57d11e19b210800200c9a66');
-        $fields = new Fields($bytes);
-
-        $uuidMock = Mockery::mock(UuidInterface::class, [
-            'getFields' => $fields,
-        ]);
-
-        $encodedUuid = $this->codec->encode($uuidMock);
-
-        $this->assertSame('0800200c-9a66-11e1-9b21-ff6f8cb0c57d', $encodedUuid);
-    }
-
-    public function testBinaryEncoding(): void
-    {
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin('ff6f8cb0c57d11e19b210800200c9a66');
-        $fields = new Fields($bytes);
-
-        $uuidMock = Mockery::mock(UuidInterface::class, [
-            'getFields' => $fields,
-        ]);
-
-        $encodedUuid = $this->codec->encodeBinary($uuidMock);
-
-        $this->assertSame(hex2bin('0800200c9a6611e19b21ff6f8cb0c57d'), $encodedUuid);
-    }
-
-    public function testDecoding(): void
-    {
-        $this->builderMock->expects($this->exactly(1))
-            ->method('build')
-            ->with(
-                $this->codec,
-                hex2bin(implode('', [
-                    'time_low' => 'ff6f8cb0',
-                    'time_mid' => 'c57d',
-                    'time_hi_and_version' => '11e1',
-                    'clock_seq_hi_and_reserved' => '9b',
-                    'clock_seq_low' => '21',
-                    'node' => '0800200c9a66',
-                ]))
-            );
-        $this->codec->decode('0800200c-9a66-11e1-9b21-ff6f8cb0c57d');
-    }
-
-    public function testBinaryDecoding(): void
-    {
-        $this->builderMock->expects($this->exactly(1))
-            ->method('build')
-            ->with(
-                $this->codec,
-                hex2bin(implode('', [
-                    'time_low' => 'ff6f8cb0',
-                    'time_mid' => 'c57d',
-                    'time_hi_and_version' => '11e1',
-                    'clock_seq_hi_and_reserved' => '9b',
-                    'clock_seq_low' => '21',
-                    'node' => '0800200c9a66',
-                ]))
-            );
-
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin('0800200c9a6611e19b21ff6f8cb0c57d');
-        $this->codec->decodeBytes($bytes);
-    }
-}

package/vendor/ramsey/uuid/tests/Encoder/TimestampLastCombCodecTest.php

@@ -1,106 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Test\Encoder;
-
-use Mockery;
-use PHPUnit\Framework\MockObject\MockObject;
-use Ramsey\Uuid\Builder\UuidBuilderInterface;
-use Ramsey\Uuid\Codec\CodecInterface;
-use Ramsey\Uuid\Codec\TimestampLastCombCodec;
-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;
-
-class TimestampLastCombCodecTest extends TestCase
-{
-    /**
-     * @var CodecInterface
-     */
-    private $codec;
-
-    /**
-     * @var MockObject & UuidBuilderInterface
-     */
-    private $builderMock;
-
-    protected function setUp(): void
-    {
-        $this->builderMock = $this->getMockBuilder(UuidBuilderInterface::class)->getMock();
-        $this->codec = new TimestampLastCombCodec($this->builderMock);
-    }
-
-    public function testEncoding(): void
-    {
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin('0800200c9a6611e19b21ff6f8cb0c57d');
-        $fields = new Fields($bytes);
-
-        $uuidMock = Mockery::mock(UuidInterface::class, [
-            'getFields' => $fields,
-        ]);
-
-        $encodedUuid = $this->codec->encode($uuidMock);
-
-        $this->assertSame('0800200c-9a66-11e1-9b21-ff6f8cb0c57d', $encodedUuid);
-    }
-
-    public function testBinaryEncoding(): void
-    {
-        $fields = Mockery::mock(FieldsInterface::class, [
-            'getBytes' => hex2bin('0800200c9a6611e19b21ff6f8cb0c57d'),
-        ]);
-
-        /** @var MockObject & UuidInterface $uuidMock */
-        $uuidMock = $this->getMockBuilder(UuidInterface::class)->getMock();
-        $uuidMock->expects($this->any())->method('getFields')->willReturn($fields);
-
-        $encodedUuid = $this->codec->encodeBinary($uuidMock);
-
-        $this->assertSame(hex2bin('0800200c9a6611e19b21ff6f8cb0c57d'), $encodedUuid);
-    }
-
-    public function testDecoding(): void
-    {
-        $this->builderMock->expects($this->exactly(1))
-            ->method('build')
-            ->with(
-                $this->codec,
-                hex2bin(implode('', [
-                    'time_low' => '0800200c',
-                    'time_mid' => '9a66',
-                    'time_hi_and_version' => '11e1',
-                    'clock_seq_hi_and_reserved' => '9b',
-                    'clock_seq_low' => '21',
-                    'node' => 'ff6f8cb0c57d',
-                ]))
-            );
-        $this->codec->decode('0800200c-9a66-11e1-9b21-ff6f8cb0c57d');
-    }
-
-    public function testBinaryDecoding(): void
-    {
-        $this->builderMock->expects($this->exactly(1))
-            ->method('build')
-            ->with(
-                $this->codec,
-                hex2bin(implode('', [
-                    'time_low' => '0800200c',
-                    'time_mid' => '9a66',
-                    'time_hi_and_version' => '11e1',
-                    'clock_seq_hi_and_reserved' => '9b',
-                    'clock_seq_low' => '21',
-                    'node' => 'ff6f8cb0c57d',
-                ]))
-            );
-
-        /** @var non-empty-string $bytes */
-        $bytes = (string) hex2bin('0800200c9a6611e19b21ff6f8cb0c57d');
-        $this->codec->decodeBytes($bytes);
-    }
-}