create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/tests/Generator/DefaultTimeGeneratorTest.php

@@ -0,0 +1,202 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Exception;
+use Mockery;
+use Mockery\MockInterface;
+use PHPUnit\Framework\MockObject\MockObject;
+use Ramsey\Uuid\BinaryUtils;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\RandomSourceException;
+use Ramsey\Uuid\Exception\TimeSourceException;
+use Ramsey\Uuid\FeatureSet;
+use Ramsey\Uuid\Generator\DefaultTimeGenerator;
+use Ramsey\Uuid\Provider\NodeProviderInterface;
+use Ramsey\Uuid\Provider\Time\FixedTimeProvider;
+use Ramsey\Uuid\Provider\TimeProviderInterface;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Time;
+use phpmock\mockery\PHPMockery;
+
+use function hex2bin;
+
+class DefaultTimeGeneratorTest extends TestCase
+{
+    private TimeProviderInterface & MockInterface $timeProvider;
+    private NodeProviderInterface & MockObject $nodeProvider;
+    private TimeConverterInterface & MockObject $timeConverter;
+
+    /**
+     * @var non-empty-string
+     */
+    private string $nodeId = '122f80ca9e06';
+
+    /**
+     * @var int[]
+     */
+    private array $currentTime;
+
+    private Hexadecimal $calculatedTime;
+
+    /**
+     * @var int<0, 16383>
+     */
+    private int $clockSeq = 4066;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->nodeProvider = $this->getMockBuilder(NodeProviderInterface::class)->getMock();
+        $this->timeConverter = $this->getMockBuilder(TimeConverterInterface::class)->getMock();
+        $this->currentTime = ['sec' => 1458733431, 'usec' => 877449];
+        $this->calculatedTime = new Hexadecimal('03cb98e083cb98e0');
+
+        $time = new Time($this->currentTime['sec'], $this->currentTime['usec']);
+        $this->timeProvider = Mockery::mock(TimeProviderInterface::class, [
+            'getTime' => $time,
+        ]);
+    }
+
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        unset($this->timeProvider, $this->nodeProvider, $this->timeConverter);
+        Mockery::close();
+    }
+
+    public function testGenerateUsesNodeProviderWhenNodeIsNull(): void
+    {
+        $this->nodeProvider->expects($this->once())
+            ->method('getNode')
+            ->willReturn(new Hexadecimal('122f80ca9e06'));
+        $this->timeConverter->expects($this->once())
+            ->method('calculateTime')
+            ->with($this->currentTime['sec'], $this->currentTime['usec'])
+            ->willReturn($this->calculatedTime);
+        $defaultTimeGenerator = new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+        $defaultTimeGenerator->generate(null, $this->clockSeq);
+    }
+
+    public function testGenerateUsesTimeProvidersCurrentTime(): void
+    {
+        $this->timeConverter->expects($this->once())
+            ->method('calculateTime')
+            ->with($this->currentTime['sec'], $this->currentTime['usec'])
+            ->willReturn($this->calculatedTime);
+        $defaultTimeGenerator = new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+        $defaultTimeGenerator->generate($this->nodeId, $this->clockSeq);
+    }
+
+    public function testGenerateCalculatesTimeWithConverter(): void
+    {
+        $this->timeConverter->expects($this->once())
+            ->method('calculateTime')
+            ->with($this->currentTime['sec'], $this->currentTime['usec'])
+            ->willReturn($this->calculatedTime);
+        $defaultTimeGenerator = new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+        $defaultTimeGenerator->generate($this->nodeId, $this->clockSeq);
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateDoesNotApplyVersionAndVariant(): void
+    {
+        $expectedBytes = hex2bin('83cb98e098e003cb0fe2122f80ca9e06');
+
+        $this->timeConverter->method('calculateTime')
+            ->with($this->currentTime['sec'], $this->currentTime['usec'])
+            ->willReturn($this->calculatedTime);
+
+        $binaryUtils = Mockery::mock('alias:' . BinaryUtils::class);
+        $binaryUtils->shouldNotReceive('applyVersion');
+        $binaryUtils->shouldNotReceive('applyVariant');
+
+        $defaultTimeGenerator = new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+
+        $this->assertSame($expectedBytes, $defaultTimeGenerator->generate($this->nodeId, $this->clockSeq));
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateUsesRandomSequenceWhenClockSeqNull(): void
+    {
+        PHPMockery::mock('Ramsey\Uuid\Generator', 'random_int')
+            ->once()
+            ->with(0, 0x3fff)
+            ->andReturn(9622);
+        $this->timeConverter->expects($this->once())
+            ->method('calculateTime')
+            ->with($this->currentTime['sec'], $this->currentTime['usec'])
+            ->willReturn($this->calculatedTime);
+        $defaultTimeGenerator = new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+        $defaultTimeGenerator->generate($this->nodeId);
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateThrowsExceptionWhenExceptionThrownByRandomint(): void
+    {
+        PHPMockery::mock('Ramsey\Uuid\Generator', 'random_int')
+            ->once()
+            ->andThrow(new Exception('Could not gather sufficient random data'));
+
+        $defaultTimeGenerator = new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+
+        $this->expectException(RandomSourceException::class);
+        $this->expectExceptionMessage('Could not gather sufficient random data');
+
+        $defaultTimeGenerator->generate($this->nodeId);
+    }
+
+    public function testDefaultTimeGeneratorThrowsExceptionForLargeGeneratedValue(): void
+    {
+        $timeProvider = new FixedTimeProvider(new Time('1832455114570', '955162'));
+        $featureSet = new FeatureSet();
+        $timeGenerator = new DefaultTimeGenerator(
+            $featureSet->getNodeProvider(),
+            $featureSet->getTimeConverter(),
+            $timeProvider
+        );
+
+        $this->expectException(TimeSourceException::class);
+        $this->expectExceptionMessage(
+            'The generated time of \'10000000000000004\' is larger than expected'
+        );
+
+        $timeGenerator->generate();
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/NameGeneratorFactoryTest.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Ramsey\Uuid\Generator\DefaultNameGenerator;
+use Ramsey\Uuid\Generator\NameGeneratorFactory;
+use Ramsey\Uuid\Test\TestCase;
+
+class NameGeneratorFactoryTest extends TestCase
+{
+    public function testGetGenerator(): void
+    {
+        $factory = new NameGeneratorFactory();
+
+        $this->assertInstanceOf(DefaultNameGenerator::class, $factory->getGenerator());
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/PeclUuidNameGeneratorTest.php

@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Ramsey\Uuid\BinaryUtils;
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\Generator\PeclUuidNameGenerator;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Uuid;
+
+use function hash;
+use function pack;
+use function substr;
+use function substr_replace;
+use function unpack;
+
+class PeclUuidNameGeneratorTest extends TestCase
+{
+    /**
+     * @param non-empty-string $ns
+     * @param non-empty-string $algorithm
+     *
+     * @dataProvider provideNamesForHashingTest
+     * @requires extension uuid
+     */
+    public function testPeclUuidNameGeneratorHashesName(string $ns, string $name, string $algorithm): void
+    {
+        $namespace = Uuid::fromString($ns);
+        $version = $algorithm === 'md5' ? Version::HashMd5 : Version::HashSha1;
+        $expectedBytes = substr(hash($algorithm, $namespace->getBytes() . $name, true), 0, 16);
+
+        // Need to add the version and variant, since ext-uuid already includes
+        // these in the values returned.
+        /** @var array $unpackedTime */
+        $unpackedTime = unpack('n*', substr($expectedBytes, 6, 2));
+        $timeHi = (int) $unpackedTime[1];
+        $timeHiAndVersion = pack('n*', BinaryUtils::applyVersion($timeHi, $version));
+
+        /** @var array $unpackedClockSeq */
+        $unpackedClockSeq = unpack('n*', substr($expectedBytes, 8, 2));
+        $clockSeqHi = (int) $unpackedClockSeq[1];
+        $clockSeqHiAndReserved = pack('n*', BinaryUtils::applyVariant($clockSeqHi));
+
+        $expectedBytes = substr_replace($expectedBytes, $timeHiAndVersion, 6, 2);
+        $expectedBytes = substr_replace($expectedBytes, $clockSeqHiAndReserved, 8, 2);
+
+        $generator = new PeclUuidNameGenerator();
+        $generatedBytes = $generator->generate($namespace, $name, $algorithm);
+
+        $this->assertSame(
+            $expectedBytes,
+            $generatedBytes,
+            'Expected: ' . bin2hex($expectedBytes) . '; Received: ' . bin2hex($generatedBytes)
+        );
+    }
+
+    /**
+     * @return array<array{ns: string, name: string, algorithm: string}>
+     */
+    public function provideNamesForHashingTest(): array
+    {
+        return [
+            [
+                'ns' => Uuid::NAMESPACE_URL,
+                'name' => 'https://example.com/foobar',
+                'algorithm' => 'md5',
+            ],
+            [
+                'ns' => Uuid::NAMESPACE_URL,
+                'name' => 'https://example.com/foobar',
+                'algorithm' => 'sha1',
+            ],
+            [
+                'ns' => Uuid::NAMESPACE_OID,
+                'name' => '1.3.6.1.4.1.343',
+                'algorithm' => 'sha1',
+            ],
+            [
+                'ns' => Uuid::NAMESPACE_OID,
+                'name' => '1.3.6.1.4.1.52627',
+                'algorithm' => 'md5',
+            ],
+            [
+                'ns' => 'd988ae29-674e-48e7-b93c-2825e2a96fbe',
+                'name' => 'foobar',
+                'algorithm' => 'sha1',
+            ],
+        ];
+    }
+
+    public function testGenerateThrowsException(): void
+    {
+        $namespace = Uuid::fromString('cd998804-c661-4264-822c-00cada75a87b');
+        $generator = new PeclUuidNameGenerator();
+
+        $this->expectException(NameException::class);
+        $this->expectExceptionMessage(
+            'Unable to hash namespace and name with algorithm \'aBadAlgorithm\''
+        );
+
+        /** @phpstan-ignore-next-line */
+        $generator->generate($namespace, 'a test name', 'aBadAlgorithm');
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/PeclUuidRandomGeneratorTest.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Ramsey\Uuid\Generator\PeclUuidRandomGenerator;
+use Ramsey\Uuid\Rfc4122\Fields;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Uuid;
+
+class PeclUuidRandomGeneratorTest extends TestCase
+{
+    /**
+     * @requires extension uuid
+     */
+    public function testGenerateCreatesUuidUsingPeclUuidMethods(): void
+    {
+        $generator = new PeclUuidRandomGenerator();
+        $bytes = $generator->generate(10);
+        $uuid = Uuid::fromBytes($bytes);
+
+        /** @var Fields $fields */
+        $fields = $uuid->getFields();
+
+        $this->assertSame(16, strlen($bytes));
+        $this->assertSame(Version::Random, $fields->getVersion());
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/PeclUuidTimeGeneratorTest.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Ramsey\Uuid\Generator\PeclUuidTimeGenerator;
+use Ramsey\Uuid\Rfc4122\Fields;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Uuid;
+
+class PeclUuidTimeGeneratorTest extends TestCase
+{
+    /**
+     * @requires extension uuid
+     */
+    public function testGenerateCreatesUuidUsingPeclUuidMethods(): void
+    {
+        $generator = new PeclUuidTimeGenerator();
+        $bytes = $generator->generate();
+        $uuid = Uuid::fromBytes($bytes);
+
+        /** @var Fields $fields */
+        $fields = $uuid->getFields();
+
+        $this->assertSame(16, strlen($bytes));
+        $this->assertSame(Version::Time, $fields->getVersion());
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/RandomBytesGeneratorTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Exception;
+use Ramsey\Uuid\Exception\RandomSourceException;
+use Ramsey\Uuid\Generator\RandomBytesGenerator;
+use Ramsey\Uuid\Test\TestCase;
+use phpmock\mockery\PHPMockery;
+
+use function hex2bin;
+
+class RandomBytesGeneratorTest extends TestCase
+{
+    /**
+     * @return array<array{positive-int, string}>
+     */
+    public function lengthAndHexDataProvider(): array
+    {
+        return [
+            [6, '4f17dd046fb8'],
+            [10, '4d25f6fe5327cb04267a'],
+            [12, '1ea89f83bd49cacfdf119e24'],
+        ];
+    }
+
+    /**
+     * @param positive-int $length
+     *
+     * @throws Exception
+     *
+     * @dataProvider lengthAndHexDataProvider
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateReturnsRandomBytes(int $length, string $hex): void
+    {
+        $bytes = hex2bin($hex);
+
+        PHPMockery::mock('Ramsey\Uuid\Generator', 'random_bytes')
+            ->once()
+            ->with($length)
+            ->andReturn($bytes);
+
+        $generator = new RandomBytesGenerator();
+
+        $this->assertSame($bytes, $generator->generate($length));
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateThrowsExceptionWhenExceptionThrownByRandombytes(): void
+    {
+        PHPMockery::mock('Ramsey\Uuid\Generator', 'random_bytes')
+            ->once()
+            ->with(16)
+            ->andThrow(new Exception('Could not gather sufficient random data'));
+
+        $generator = new RandomBytesGenerator();
+
+        $this->expectException(RandomSourceException::class);
+        $this->expectExceptionMessage('Could not gather sufficient random data');
+
+        $generator->generate(16);
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/RandomGeneratorFactoryTest.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Ramsey\Uuid\Generator\RandomBytesGenerator;
+use Ramsey\Uuid\Generator\RandomGeneratorFactory;
+use Ramsey\Uuid\Test\TestCase;
+
+class RandomGeneratorFactoryTest extends TestCase
+{
+    public function testFactoryReturnsRandomBytesGenerator(): void
+    {
+        $generator = (new RandomGeneratorFactory())->getGenerator();
+
+        $this->assertInstanceOf(RandomBytesGenerator::class, $generator);
+    }
+}

package/vendor/ramsey/uuid/tests/Generator/TimeGeneratorFactoryTest.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use PHPUnit\Framework\MockObject\MockObject;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Generator\TimeGeneratorFactory;
+use Ramsey\Uuid\Generator\TimeGeneratorInterface;
+use Ramsey\Uuid\Provider\NodeProviderInterface;
+use Ramsey\Uuid\Provider\TimeProviderInterface;
+use Ramsey\Uuid\Test\TestCase;
+
+class TimeGeneratorFactoryTest extends TestCase
+{
+    public function testGeneratorReturnsNewGenerator(): void
+    {
+        /** @var MockObject & TimeProviderInterface $timeProvider */
+        $timeProvider = $this->getMockBuilder(TimeProviderInterface::class)->getMock();
+
+        /** @var MockObject & NodeProviderInterface $nodeProvider */
+        $nodeProvider = $this->getMockBuilder(NodeProviderInterface::class)->getMock();
+
+        /** @var MockObject & TimeConverterInterface $timeConverter */
+        $timeConverter = $this->getMockBuilder(TimeConverterInterface::class)->getMock();
+
+        $factory = new TimeGeneratorFactory($nodeProvider, $timeConverter, $timeProvider);
+        $generator = $factory->getGenerator();
+
+        $this->assertInstanceOf(TimeGeneratorInterface::class, $generator);
+    }
+}