create-prisma-php-app 1.0.0

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

@@ -0,0 +1,151 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+use Ramsey\Uuid\Rfc4122\FieldsInterface;
+use Ramsey\Uuid\Rfc4122\UuidInterface;
+use Ramsey\Uuid\Rfc4122\UuidV7;
+use Ramsey\Uuid\Rfc4122\UuidV8;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Uuid;
+
+use function Ramsey\Uuid\v1;
+use function Ramsey\Uuid\v2;
+use function Ramsey\Uuid\v3;
+use function Ramsey\Uuid\v4;
+use function Ramsey\Uuid\v5;
+use function Ramsey\Uuid\v6;
+use function Ramsey\Uuid\v7;
+use function Ramsey\Uuid\v8;
+
+class FunctionsTest extends TestCase
+{
+    public function testV1ReturnsVersion1UuidString(): void
+    {
+        $v1 = v1();
+
+        /** @var UuidInterface $uuid */
+        $uuid = Uuid::fromString($v1);
+
+        $this->assertIsString($v1);
+        $this->assertSame(Version::Time, $uuid->getFields()->getVersion());
+    }
+
+    public function testV2ReturnsVersion2UuidString(): void
+    {
+        $v2 = v2(
+            Uuid::DCE_DOMAIN_PERSON,
+            new IntegerObject('1004'),
+            new Hexadecimal('aabbccdd0011'),
+            63
+        );
+
+        /** @var FieldsInterface $fields */
+        $fields = Uuid::fromString($v2)->getFields();
+
+        $this->assertIsString($v2);
+        $this->assertSame(Version::DceSecurity, $fields->getVersion());
+    }
+
+    public function testV3ReturnsVersion3UuidString(): void
+    {
+        $ns = Uuid::fromString(Uuid::NAMESPACE_URL);
+        $v3 = v3($ns, 'https://example.com/foo');
+
+        /** @var UuidInterface $uuid */
+        $uuid = Uuid::fromString($v3);
+
+        $this->assertIsString($v3);
+        $this->assertSame(Version::HashMd5, $uuid->getFields()->getVersion());
+    }
+
+    public function testV4ReturnsVersion4UuidString(): void
+    {
+        $v4 = v4();
+
+        /** @var UuidInterface $uuid */
+        $uuid = Uuid::fromString($v4);
+
+        $this->assertIsString($v4);
+        $this->assertSame(Version::Random, $uuid->getFields()->getVersion());
+    }
+
+    public function testV5ReturnsVersion5UuidString(): void
+    {
+        $ns = Uuid::fromString(Uuid::NAMESPACE_URL);
+        $v5 = v5($ns, 'https://example.com/foo');
+
+        /** @var UuidInterface $uuid */
+        $uuid = Uuid::fromString($v5);
+
+        $this->assertIsString($v5);
+        $this->assertSame(Version::HashSha1, $uuid->getFields()->getVersion());
+    }
+
+    public function testV6ReturnsVersion6UuidString(): void
+    {
+        $v6 = v6(
+            new Hexadecimal('aabbccdd0011'),
+            1234
+        );
+
+        /** @var FieldsInterface $fields */
+        $fields = Uuid::fromString($v6)->getFields();
+
+        $this->assertIsString($v6);
+        $this->assertSame(Version::ReorderedTime, $fields->getVersion());
+    }
+
+    public function testV7ReturnsVersion7UuidString(): void
+    {
+        $v7 = v7();
+
+        /** @var UuidV7 $uuid */
+        $uuid = Uuid::fromString($v7);
+
+        /** @var FieldsInterface $fields */
+        $fields = $uuid->getFields();
+
+        $this->assertIsString($v7);
+        $this->assertSame(Version::UnixTime, $fields->getVersion());
+        $this->assertInstanceOf(DateTimeInterface::class, $uuid->getDateTime());
+    }
+
+    public function testV7WithCustomDateTimeReturnsVersion7UuidString(): void
+    {
+        $dateTime = new DateTimeImmutable('2022-09-14T22:44:33+00:00');
+
+        $v7 = v7($dateTime);
+
+        /** @var UuidV7 $uuid */
+        $uuid = Uuid::fromString($v7);
+
+        /** @var FieldsInterface $fields */
+        $fields = $uuid->getFields();
+
+        $this->assertIsString($v7);
+        $this->assertSame(Version::UnixTime, $fields->getVersion());
+        $this->assertInstanceOf(DateTimeInterface::class, $uuid->getDateTime());
+        $this->assertSame(1663195473, $uuid->getDateTime()->getTimestamp());
+    }
+
+    public function testV8ReturnsVersion8UuidString(): void
+    {
+        $v8 = v8("\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff");
+
+        /** @var UuidV8 $uuid */
+        $uuid = Uuid::fromString($v8);
+
+        /** @var FieldsInterface $fields */
+        $fields = $uuid->getFields();
+
+        $this->assertIsString($v8);
+        $this->assertSame(Version::Custom, $fields->getVersion());
+    }
+}

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

@@ -0,0 +1,134 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Exception;
+use PHPUnit\Framework\MockObject\MockObject;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Generator\CombGenerator;
+use Ramsey\Uuid\Generator\RandomGeneratorInterface;
+use Ramsey\Uuid\Test\TestCase;
+
+use function bin2hex;
+use function dechex;
+use function hex2bin;
+use function str_pad;
+
+use const STR_PAD_LEFT;
+
+class CombGeneratorTest extends TestCase
+{
+    /**
+     * @var int
+     */
+    private $timestampBytes = 6;
+
+    public function testGenerateUsesRandomGeneratorWithLengthMinusTimestampBytes(): void
+    {
+        $length = 10;
+        $expectedLength = $length - $this->timestampBytes;
+
+        /** @var MockObject & RandomGeneratorInterface $randomGenerator */
+        $randomGenerator = $this->getMockBuilder(RandomGeneratorInterface::class)->getMock();
+        $randomGenerator->expects($this->once())
+            ->method('generate')
+            ->with($expectedLength);
+
+        /** @var MockObject & NumberConverterInterface $converter */
+        $converter = $this->getMockBuilder(NumberConverterInterface::class)->getMock();
+
+        $generator = new CombGenerator($randomGenerator, $converter);
+        $generator->generate($length);
+    }
+
+    public function testGenerateCalculatesPaddedHexStringFromCurrentTimestamp(): void
+    {
+        /** @var MockObject & RandomGeneratorInterface $randomGenerator */
+        $randomGenerator = $this->getMockBuilder(RandomGeneratorInterface::class)->getMock();
+
+        /** @var MockObject & NumberConverterInterface $converter */
+        $converter = $this->getMockBuilder(NumberConverterInterface::class)->getMock();
+        $converter->expects($this->once())
+            ->method('toHex')
+            ->with($this->isType('string'));
+
+        $generator = new CombGenerator($randomGenerator, $converter);
+        $generator->generate(10);
+    }
+
+    public function testGenerateReturnsBinaryStringCreatedFromGeneratorAndConverter(): void
+    {
+        $length = 20;
+        $hash = dechex(1234567891);
+        $timeHash = dechex(1458147405);
+
+        /** @var MockObject & RandomGeneratorInterface $randomGenerator */
+        $randomGenerator = $this->getMockBuilder(RandomGeneratorInterface::class)->getMock();
+        $randomGenerator->method('generate')
+            ->with($length - $this->timestampBytes)
+            ->willReturn($hash);
+
+        /** @var MockObject & NumberConverterInterface $converter */
+        $converter = $this->getMockBuilder(NumberConverterInterface::class)->getMock();
+        $converter->method('toHex')
+            ->with($this->isType('string'))
+            ->willReturn($timeHash);
+
+        $time = str_pad($timeHash, 12, '0', STR_PAD_LEFT);
+        $expected = hex2bin(str_pad(bin2hex($hash), $length - $this->timestampBytes, '0')) . hex2bin($time);
+
+        $generator = new CombGenerator($randomGenerator, $converter);
+        $returned = $generator->generate($length);
+        $this->assertIsString($returned);
+        $this->assertSame($expected, $returned);
+    }
+
+    /**
+     * @return array<array<positive-int>>
+     */
+    public function lengthLessThanSix(): array
+    {
+        return [[1], [2], [3], [4], [5]];
+    }
+
+    /**
+     * @param positive-int $length
+     *
+     * @throws Exception
+     *
+     * @dataProvider lengthLessThanSix
+     */
+    public function testGenerateWithLessThanTimestampBytesThrowsException(int $length): void
+    {
+        /** @var MockObject & RandomGeneratorInterface $randomGenerator */
+        $randomGenerator = $this->getMockBuilder(RandomGeneratorInterface::class)->getMock();
+
+        /** @var MockObject & NumberConverterInterface $converter */
+        $converter = $this->getMockBuilder(NumberConverterInterface::class)->getMock();
+
+        $generator = new CombGenerator($randomGenerator, $converter);
+
+        $this->expectException(InvalidArgumentException::class);
+        $generator->generate($length);
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function testGenerateWithOddNumberOverTimestampBytesCausesError(): void
+    {
+        /** @var MockObject & RandomGeneratorInterface $randomGenerator */
+        $randomGenerator = $this->getMockBuilder(RandomGeneratorInterface::class)->getMock();
+
+        /** @var MockObject & NumberConverterInterface $converter */
+        $converter = $this->getMockBuilder(NumberConverterInterface::class)->getMock();
+
+        $generator = new CombGenerator($randomGenerator, $converter);
+
+        $this->expectError();
+        $generator->generate(7);
+    }
+}

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

@@ -0,0 +1,282 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Mockery;
+use Ramsey\Uuid\Converter\Number\GenericNumberConverter;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\Time\GenericTimeConverter;
+use Ramsey\Uuid\Exception\DceSecurityException;
+use Ramsey\Uuid\Generator\DceSecurityGenerator;
+use Ramsey\Uuid\Generator\DefaultTimeGenerator;
+use Ramsey\Uuid\Generator\TimeGeneratorInterface;
+use Ramsey\Uuid\Math\BrickMathCalculator;
+use Ramsey\Uuid\Provider\DceSecurityProviderInterface;
+use Ramsey\Uuid\Provider\NodeProviderInterface;
+use Ramsey\Uuid\Provider\Time\FixedTimeProvider;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Type\Time;
+use Ramsey\Uuid\Uuid;
+
+use function bin2hex;
+use function substr;
+
+class DceSecurityGeneratorTest extends TestCase
+{
+    /**
+     * @param non-empty-string $node
+     * @param positive-int $providedDomain
+     *
+     * @dataProvider provideValuesForDceSecurityGenerator
+     */
+    public function testGenerateBytesReplacesBytesWithDceValues(
+        int | string $uid,
+        int | string $gid,
+        string $node,
+        int $seconds,
+        int $microseconds,
+        int $providedDomain,
+        ?IntegerObject $providedId,
+        ?Hexadecimal $providedNode,
+        string $expectedId,
+        string $expectedDomain,
+        string $expectedNode,
+        string $expectedTimeMidHi
+    ): void {
+        /** @var DceSecurityProviderInterface $dceSecurityProvider */
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class, [
+            'getUid' => new IntegerObject($uid),
+            'getGid' => new IntegerObject($gid),
+        ]);
+
+        /** @var NodeProviderInterface $nodeProvider */
+        $nodeProvider = Mockery::mock(NodeProviderInterface::class, [
+            'getNode' => new Hexadecimal($node),
+        ]);
+
+        $timeProvider = new FixedTimeProvider(new Time($seconds, $microseconds));
+
+        $calculator = new BrickMathCalculator();
+        $numberConverter = new GenericNumberConverter($calculator);
+        $timeConverter = new GenericTimeConverter($calculator);
+        $timeGenerator = new DefaultTimeGenerator($nodeProvider, $timeConverter, $timeProvider);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $bytes = $dceSecurityGenerator->generate($providedDomain, $providedId, $providedNode);
+
+        $this->assertSame($expectedId, bin2hex(substr($bytes, 0, 4)));
+        $this->assertSame($expectedDomain, bin2hex(substr($bytes, 9, 1)));
+        $this->assertSame($expectedNode, bin2hex(substr($bytes, 10)));
+        $this->assertSame($expectedTimeMidHi, bin2hex(substr($bytes, 4, 4)));
+    }
+
+    /**
+     * @return array<array{uid: int|string, node: string, seconds: int, microseconds: int, providedDomain: int, providedId: IntegerObject|null, providedNode: null, expectedId: string, expectedDomain: string, expectedNode: string, expectedTimeMidHi: string}>
+     */
+    public function provideValuesForDceSecurityGenerator(): array
+    {
+        return [
+            [
+                'uid' => '1001',
+                'gid' => '2001',
+                'node' => '001122334455',
+                'seconds' => 1579132397,
+                'microseconds' => 500000,
+                'providedDomain' => Uuid::DCE_DOMAIN_PERSON,
+                'providedId' => null,
+                'providedNode' => null,
+                'expectedId' => '000003e9',
+                'expectedDomain' => '00',
+                'expectedNode' => '001122334455',
+                'expectedTimeMidHi' => '37f201ea',
+            ],
+            [
+                'uid' => '1001',
+                'gid' => '2001',
+                'node' => '001122334455',
+                'seconds' => 1579132397,
+                'microseconds' => 500000,
+                'providedDomain' => Uuid::DCE_DOMAIN_GROUP,
+                'providedId' => null,
+                'providedNode' => null,
+                'expectedId' => '000007d1',
+                'expectedDomain' => '01',
+                'expectedNode' => '001122334455',
+                'expectedTimeMidHi' => '37f201ea',
+            ],
+            [
+                'uid' => 0,
+                'gid' => 0,
+                'node' => '001122334455',
+                'seconds' => 1579132397,
+                'microseconds' => 500000,
+                'providedDomain' => Uuid::DCE_DOMAIN_ORG,
+                'providedId' => new IntegerObject('4294967295'),
+                'providedNode' => null,
+                'expectedId' => 'ffffffff',
+                'expectedDomain' => '02',
+                'expectedNode' => '001122334455',
+                'expectedTimeMidHi' => '37f201ea',
+            ],
+        ];
+    }
+
+    public function testGenerateThrowsExceptionForInvalidDomain(): void
+    {
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $timeGenerator = Mockery::mock(TimeGeneratorInterface::class);
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+
+        $generator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $this->expectException(DceSecurityException::class);
+        $this->expectExceptionMessage('Local domain must be a valid DCE Security domain');
+
+        $generator->generate(42);
+    }
+
+    public function testGenerateThrowsExceptionForOrgWithoutIdentifier(): void
+    {
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+        $timeGenerator = Mockery::mock(TimeGeneratorInterface::class);
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+
+        $generator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $this->expectException(DceSecurityException::class);
+        $this->expectExceptionMessage('A local identifier must be provided for the org domain');
+
+        $generator->generate(Uuid::DCE_DOMAIN_ORG);
+    }
+
+    public function testClockSequenceLowerBounds(): void
+    {
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+        $nodeProvider = Mockery::mock(NodeProviderInterface::class);
+        $timeProvider = new FixedTimeProvider(new Time(1583527677, 111984));
+
+        $calculator = new BrickMathCalculator();
+        $numberConverter = new GenericNumberConverter($calculator);
+        $timeConverter = new GenericTimeConverter($calculator);
+        $timeGenerator = new DefaultTimeGenerator($nodeProvider, $timeConverter, $timeProvider);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $bytes = $dceSecurityGenerator->generate(
+            Uuid::DCE_DOMAIN_ORG,
+            new IntegerObject(1001),
+            new Hexadecimal('0123456789ab'),
+            0
+        );
+
+        $hex = bin2hex($bytes);
+
+        $this->assertSame('000003e9', substr($hex, 0, 8));
+        $this->assertSame('5feb01ea', substr($hex, 8, 8));
+        $this->assertSame('00', substr($hex, 16, 2));
+        $this->assertSame('02', substr($hex, 18, 2));
+        $this->assertSame('0123456789ab', substr($hex, 20));
+    }
+
+    public function testClockSequenceUpperBounds(): void
+    {
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+        $nodeProvider = Mockery::mock(NodeProviderInterface::class);
+        $timeProvider = new FixedTimeProvider(new Time(1583527677, 111984));
+
+        $calculator = new BrickMathCalculator();
+        $numberConverter = new GenericNumberConverter($calculator);
+        $timeConverter = new GenericTimeConverter($calculator);
+        $timeGenerator = new DefaultTimeGenerator($nodeProvider, $timeConverter, $timeProvider);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $bytes = $dceSecurityGenerator->generate(
+            Uuid::DCE_DOMAIN_ORG,
+            new IntegerObject(1001),
+            new Hexadecimal('0123456789ab'),
+            63
+        );
+
+        $hex = bin2hex($bytes);
+
+        $this->assertSame('000003e9', substr($hex, 0, 8));
+        $this->assertSame('5feb01ea', substr($hex, 8, 8));
+        $this->assertSame('3f', substr($hex, 16, 2));
+        $this->assertSame('02', substr($hex, 18, 2));
+        $this->assertSame('0123456789ab', substr($hex, 20));
+    }
+
+    public function testExceptionThrownWhenClockSequenceTooLow(): void
+    {
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+        $timeGenerator = Mockery::mock(TimeGeneratorInterface::class);
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $this->expectException(DceSecurityException::class);
+        $this->expectExceptionMessage(
+            'Clock sequence out of bounds; it must be a value between 0 and 63'
+        );
+
+        // @phpstan-ignore-next-line
+        $dceSecurityGenerator->generate(Uuid::DCE_DOMAIN_ORG, null, null, -1);
+    }
+
+    public function testExceptionThrownWhenClockSequenceTooHigh(): void
+    {
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+        $timeGenerator = Mockery::mock(TimeGeneratorInterface::class);
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $this->expectException(DceSecurityException::class);
+        $this->expectExceptionMessage(
+            'Clock sequence out of bounds; it must be a value between 0 and 63'
+        );
+
+        // @phpstan-ignore-next-line
+        $dceSecurityGenerator->generate(Uuid::DCE_DOMAIN_ORG, null, null, 64);
+    }
+
+    public function testExceptionThrownWhenLocalIdTooLow(): void
+    {
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+        $timeGenerator = Mockery::mock(TimeGeneratorInterface::class);
+        $numberConverter = Mockery::mock(NumberConverterInterface::class);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $this->expectException(DceSecurityException::class);
+        $this->expectExceptionMessage(
+            'Local identifier out of bounds; it must be a value between 0 and 4294967295'
+        );
+
+        $dceSecurityGenerator->generate(Uuid::DCE_DOMAIN_ORG, new IntegerObject(-1));
+    }
+
+    public function testExceptionThrownWhenLocalIdTooHigh(): void
+    {
+        $dceSecurityProvider = Mockery::mock(DceSecurityProviderInterface::class);
+        $timeGenerator = Mockery::mock(TimeGeneratorInterface::class);
+
+        $calculator = new BrickMathCalculator();
+        $numberConverter = new GenericNumberConverter($calculator);
+
+        $dceSecurityGenerator = new DceSecurityGenerator($numberConverter, $timeGenerator, $dceSecurityProvider);
+
+        $this->expectException(DceSecurityException::class);
+        $this->expectExceptionMessage(
+            'Local identifier out of bounds; it must be a value between 0 and 4294967295'
+        );
+
+        $dceSecurityGenerator->generate(Uuid::DCE_DOMAIN_ORG, new IntegerObject('4294967296'));
+    }
+}

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

@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\Generator\DefaultNameGenerator;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Uuid;
+
+use function hash;
+
+class DefaultNameGeneratorTest extends TestCase
+{
+    /**
+     * @param non-empty-string $ns
+     * @param non-empty-string $algorithm
+     *
+     * @dataProvider provideNamesForHashingTest
+     */
+    public function testDefaultNameGeneratorHashesName(string $ns, string $name, string $algorithm): void
+    {
+        $namespace = Uuid::fromString($ns);
+        $expectedBytes = hash($algorithm, $namespace->getBytes() . $name, true);
+
+        $generator = new DefaultNameGenerator();
+
+        $this->assertSame($expectedBytes, $generator->generate($namespace, $name, $algorithm));
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    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_URL,
+                'name' => 'https://example.com/foobar',
+                'algorithm' => 'sha256',
+            ],
+            [
+                '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 DefaultNameGenerator();
+
+        $this->expectException(NameException::class);
+        $this->expectExceptionMessage(
+            'Unable to hash namespace and name with algorithm \'aBadAlgorithm\''
+        );
+
+        $generator->generate($namespace, 'a test name', 'aBadAlgorithm');
+    }
+}