create-prisma-php-app 1.0.0

package/vendor/phpoption/phpoption/tests/PhpOption/Tests/LazyOptionTest.php

@@ -0,0 +1,200 @@
+<?php
+
+namespace PhpOption\Tests;
+
+use PhpOption\LazyOption;
+use PhpOption\None;
+use PhpOption\Option;
+use PhpOption\Some;
+use PHPUnit\Framework\TestCase;
+
+class LazyOptionTest extends TestCase
+{
+    private static function createSubject($default = null): object
+    {
+        return new class ($default) {
+            private $default;
+
+            public function __construct($default)
+            {
+                $this->default = $default;
+            }
+
+            public function execute($v = null): Option
+            {
+                return Option::fromValue($v ?? $this->default);
+            }
+        };
+    }
+
+    private static function createInvalidSubject(): object
+    {
+        return new class {
+            public function execute($v = null)
+            {
+                return null;
+            }
+        };
+    }
+
+    public function testGetWithArgumentsAndConstructor(): void
+    {
+        $some = LazyOption::create([self::createSubject(), 'execute'], ['foo']);
+
+        self::assertSame('foo', $some->get());
+        self::assertSame('foo', $some->getOrElse(null));
+        self::assertSame('foo', $some->getOrCall('does_not_exist'));
+        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
+        self::assertFalse($some->isEmpty());
+    }
+
+    public function testGetWithArgumentsAndCreate(): void
+    {
+        $some = new LazyOption([self::createSubject(), 'execute'], ['foo']);
+
+        self::assertSame('foo', $some->get());
+        self::assertSame('foo', $some->getOrElse(null));
+        self::assertSame('foo', $some->getOrCall('does_not_exist'));
+        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
+        self::assertFalse($some->isEmpty());
+    }
+
+    public function testGetWithoutArgumentsAndConstructor(): void
+    {
+        $some = new LazyOption([self::createSubject('foo'), 'execute']);
+
+        self::assertSame('foo', $some->get());
+        self::assertSame('foo', $some->getOrElse(null));
+        self::assertSame('foo', $some->getOrCall('does_not_exist'));
+        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
+        self::assertFalse($some->isEmpty());
+    }
+
+    public function testGetWithoutArgumentsAndCreate(): void
+    {
+        $option = LazyOption::create([self::createSubject('foo'), 'execute']);
+
+        self::assertTrue($option->isDefined());
+        self::assertFalse($option->isEmpty());
+        self::assertSame('foo', $option->get());
+        self::assertSame('foo', $option->getOrElse(null));
+        self::assertSame('foo', $option->getOrCall('does_not_exist'));
+        self::assertSame('foo', $option->getOrThrow(new \RuntimeException('does_not_exist')));
+    }
+
+    public function testCallbackReturnsNull(): void
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('RuntimeException');
+            $this->expectExceptionMessage('None has no value');
+        } else {
+            $this->setExpectedException('RuntimeException', 'None has no value');
+        }
+
+        $option = LazyOption::create([self::createSubject(), 'execute']);
+
+        self::assertFalse($option->isDefined());
+        self::assertTrue($option->isEmpty());
+        self::assertSame('alt', $option->getOrElse('alt'));
+        self::assertSame('alt', $option->getOrCall(function () {
+            return 'alt';
+        }));
+
+        $option->get();
+    }
+
+    public function testExceptionIsThrownIfCallbackReturnsNonOption(): void
+    {
+        $option = LazyOption::create([self::createInvalidSubject(), 'execute']);
+
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('RuntimeException');
+            $this->expectExceptionMessage('Expected instance of PhpOption\Option');
+        } else {
+            $this->setExpectedException('RuntimeException', 'Expected instance of PhpOption\Option');
+        }
+
+        $option->isDefined();
+    }
+
+    public function testInvalidCallbackAndConstructor(): void
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('InvalidArgumentException');
+            $this->expectExceptionMessage('Invalid callback given');
+        } else {
+            $this->setExpectedException('InvalidArgumentException', 'Invalid callback given');
+        }
+
+        new LazyOption('invalidCallback');
+    }
+
+    public function testInvalidCallbackAndCreate(): void
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('InvalidArgumentException');
+            $this->expectExceptionMessage('Invalid callback given');
+        } else {
+            $this->setExpectedException('InvalidArgumentException', 'Invalid callback given');
+        }
+
+        LazyOption::create('invalidCallback');
+    }
+
+    public function testifDefined(): void
+    {
+        $called = false;
+        $self = $this;
+        LazyOption::fromValue('foo')->ifDefined(function ($v) use (&$called, $self) {
+            $called = true;
+            $self->assertSame('foo', $v);
+        });
+        self::assertTrue($called);
+    }
+
+    public function testForAll(): void
+    {
+        $called = false;
+        $self = $this;
+        self::assertInstanceOf(Some::class, LazyOption::fromValue('foo')->forAll(function ($v) use (&$called, $self) {
+            $called = true;
+            $self->assertSame('foo', $v);
+        }));
+        self::assertTrue($called);
+    }
+
+    public function testOrElse(): void
+    {
+        $some = Some::create('foo');
+        $lazy = LazyOption::create(function () use ($some) {
+            return $some;
+        });
+        self::assertSame($some, $lazy->orElse(None::create()));
+        self::assertSame($some, $lazy->orElse(Some::create('bar')));
+    }
+
+    public function testFoldLeftRight(): void
+    {
+        $callback = function () {
+        };
+
+        $option = self::getMockForAbstractClass(Option::class);
+        $option->expects(self::once())
+            ->method('foldLeft')
+            ->with(5, $callback)
+            ->will(self::returnValue(6));
+        $lazyOption = new LazyOption(function () use ($option) {
+            return $option;
+        });
+        self::assertSame(6, $lazyOption->foldLeft(5, $callback));
+
+        $option->expects(self::once())
+            ->method('foldRight')
+            ->with(5, $callback)
+            ->will(self::returnValue(6));
+        $lazyOption = new LazyOption(function () use ($option) {
+            return $option;
+        });
+        self::assertSame(6, $lazyOption->foldRight(5, $callback));
+    }
+}

package/vendor/phpoption/phpoption/tests/PhpOption/Tests/NoneTest.php

@@ -0,0 +1,153 @@
+<?php
+
+namespace PhpOption\Tests;
+
+use PhpOption\None;
+use PhpOption\Some;
+use PHPUnit\Framework\TestCase;
+
+class NoneTest extends TestCase
+{
+    public function testGet(): void
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('RuntimeException');
+        } else {
+            $this->setExpectedException('RuntimeException');
+        }
+
+        $none = None::create();
+        $none->get();
+    }
+
+    public function testGetOrElse(): void
+    {
+        $none = None::create();
+        self::assertSame('foo', $none->getOrElse('foo'));
+    }
+
+    public function testGetOrCall(): void
+    {
+        $none = None::create();
+        self::assertSame('foo', $none->getOrCall(function () {
+            return 'foo';
+        }));
+    }
+
+    public function testGetOrThrow(): void
+    {
+        if (method_exists($this, 'expectException')) {
+            $this->expectException('RuntimeException');
+            $this->expectExceptionMessage('Not Found!');
+        } else {
+            $this->setExpectedException('RuntimeException', 'Not Found!');
+        }
+
+        None::create()->getOrThrow(new \RuntimeException('Not Found!'));
+    }
+
+    public function testIsEmpty(): void
+    {
+        $none = None::create();
+        self::assertTrue($none->isEmpty());
+    }
+
+    public function testOrElse(): void
+    {
+        $option = Some::create('foo');
+        self::assertSame($option, None::create()->orElse($option));
+    }
+
+    public function testifDefined(): void
+    {
+        $none = None::create();
+
+        self::assertNull($none->ifDefined(function () {
+            throw new \LogicException('Should never be called.');
+        }));
+    }
+
+    public function testForAll(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->forAll(function () {
+            throw new \LogicException('Should never be called.');
+        }));
+    }
+
+    public function testMap(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->map(function () {
+            throw new \LogicException('Should not be called.');
+        }));
+    }
+
+    public function testFlatMap(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->flatMap(function () {
+            throw new \LogicException('Should not be called.');
+        }));
+    }
+
+    public function testFilter(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->filter(function () {
+            throw new \LogicException('Should not be called.');
+        }));
+    }
+
+    public function testFilterNot(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->filterNot(function () {
+            throw new \LogicException('Should not be called.');
+        }));
+    }
+
+    public function testSelect(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->select(null));
+    }
+
+    public function testReject(): void
+    {
+        $none = None::create();
+
+        self::assertSame($none, $none->reject(null));
+    }
+
+    public function testForeach(): void
+    {
+        $none = None::create();
+
+        $called = 0;
+        foreach ($none as $value) {
+            $called++;
+        }
+
+        self::assertSame(0, $called);
+    }
+
+    public function testFoldLeftRight(): void
+    {
+        $none = None::create();
+
+        self::assertSame(1, $none->foldLeft(1, function () {
+            $this->fail();
+        }));
+
+        self::assertSame(1, $none->foldRight(1, function () {
+            $this->fail();
+        }));
+    }
+}

package/vendor/phpoption/phpoption/tests/PhpOption/Tests/OptionTest.php

@@ -0,0 +1,160 @@
+<?php
+
+namespace PhpOption\Tests;
+
+use ArrayAccess;
+use LogicException;
+use PhpOption\LazyOption;
+use PhpOption\None;
+use PhpOption\Option;
+use PhpOption\Some;
+use PHPUnit\Framework\TestCase;
+
+class OptionTest extends TestCase
+{
+    public function testfromValueWithDefaultNoneValue(): void
+    {
+        self::assertInstanceOf(None::class, Option::fromValue(null));
+        self::assertInstanceOf(Some::class, Option::fromValue('value'));
+    }
+
+    public function testFromValueWithFalseNoneValue(): void
+    {
+        self::assertInstanceOf(None::class, Option::fromValue(false, false));
+        self::assertInstanceOf(Some::class, Option::fromValue('value', false));
+        self::assertInstanceOf(Some::class, Option::fromValue(null, false));
+    }
+
+    public function testFromArraysValue(): void
+    {
+        self::assertEquals(None::create(), Option::fromArraysValue('foo', 'bar'));
+        self::assertEquals(None::create(), Option::fromArraysValue(null, 'bar'));
+        self::assertEquals(None::create(), Option::fromArraysValue(['foo' => 'bar'], 'baz'));
+        self::assertEquals(None::create(), Option::fromArraysValue(['foo' => null], 'foo'));
+        self::assertEquals(new Some('foo'), Option::fromArraysValue(['foo' => 'foo'], 'foo'));
+
+        $object = new SomeArrayObject();
+        $object['foo'] = 'foo';
+        self::assertEquals(new Some('foo'), Option::fromArraysValue($object, 'foo'));
+    }
+
+    public function testFromReturn(): void
+    {
+        $null = function () {
+        };
+        $false = function () {
+            return false;
+        };
+        $some = function () {
+            return 'foo';
+        };
+
+        self::assertTrue(Option::fromReturn($null)->isEmpty());
+        self::assertFalse(Option::fromReturn($false)->isEmpty());
+        self::assertTrue(Option::fromReturn($false, [], false)->isEmpty());
+        self::assertTrue(Option::fromReturn($some)->isDefined());
+        self::assertFalse(Option::fromReturn($some, [], 'foo')->isDefined());
+    }
+
+    public function testOrElse(): void
+    {
+        $a = new Some('a');
+        $b = new Some('b');
+
+        self::assertSame('a', $a->orElse($b)->get());
+    }
+
+    public function testOrElseWithNoneAsFirst(): void
+    {
+        $a = None::create();
+        $b = new Some('b');
+
+        self::assertSame('b', $a->orElse($b)->get());
+    }
+
+    public function testOrElseWithLazyOptions(): void
+    {
+        $throws = function () {
+            throw new LogicException('Should never be called.');
+        };
+
+        $a = new Some('a');
+        $b = new LazyOption($throws);
+
+        self::assertSame('a', $a->orElse($b)->get());
+    }
+
+    public function testOrElseWithMultipleAlternatives(): void
+    {
+        $throws = new LazyOption(function () {
+            throw new LogicException('Should never be called.');
+        });
+        $returns = new LazyOption(function () {
+            return new Some('foo');
+        });
+
+        $a = None::create();
+
+        self::assertSame('foo', $a->orElse($returns)->orElse($throws)->get());
+    }
+
+    public function testLift(): void
+    {
+        $f = function ($a, $b) {
+            return $a + $b;
+        };
+
+        $fL = Option::lift($f);
+
+        $a = new Some(1);
+        $b = new Some(5);
+        $n = None::create();
+
+        self::assertSame(6, $fL($a, $b)->get());
+        self::assertSame(6, $fL($b, $a)->get());
+        self::assertSame($n, $fL($a, $n));
+        self::assertSame($n, $fL($n, $a));
+        self::assertSame($n, $fL($n, $n));
+    }
+
+    public function testLiftDegenerate(): void
+    {
+        $f = function () {
+        };
+
+        $fL1 = Option::lift($f);
+        $fL2 = Option::lift($f, false);
+
+        self::assertEquals(None::create(), $fL1());
+        self::assertEquals(Some::create(null), $fL2());
+    }
+}
+
+class SomeArrayObject implements ArrayAccess
+{
+    private $data = [];
+
+    #[\ReturnTypeWillChange]
+    public function offsetExists($offset)
+    {
+        return isset($this->data[$offset]);
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetGet($offset)
+    {
+        return $this->data[$offset];
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetSet($offset, $value)
+    {
+        $this->data[$offset] = $value;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetUnset($offset)
+    {
+        unset($this->data[$offset]);
+    }
+}

package/vendor/phpoption/phpoption/tests/PhpOption/Tests/SomeTest.php

@@ -0,0 +1,194 @@
+<?php
+
+namespace PhpOption\Tests;
+
+use PhpOption\None;
+use PhpOption\Option;
+use PhpOption\Some;
+use PHPUnit\Framework\TestCase;
+
+class SomeTest extends TestCase
+{
+    public function testGet(): void
+    {
+        $some = new Some('foo');
+        self::assertSame('foo', $some->get());
+        self::assertSame('foo', $some->getOrElse(null));
+        self::assertSame('foo', $some->getOrCall('does_not_exist'));
+        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('Not found')));
+        self::assertFalse($some->isEmpty());
+    }
+
+    public function testCreate(): void
+    {
+        $some = Some::create('foo');
+        self::assertSame('foo', $some->get());
+        self::assertSame('foo', $some->getOrElse(null));
+        self::assertSame('foo', $some->getOrCall('does_not_exist'));
+        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('Not found')));
+        self::assertFalse($some->isEmpty());
+    }
+
+    public function testOrElse(): void
+    {
+        $some = Some::create('foo');
+        self::assertSame($some, $some->orElse(None::create()));
+        self::assertSame($some, $some->orElse(Some::create('bar')));
+    }
+
+    public function testifDefined(): void
+    {
+        $called = false;
+        $self = $this;
+        $some = new Some('foo');
+        $some->ifDefined(function ($v) use (&$called, $self) {
+            $called = true;
+            $self->assertSame('foo', $v);
+        });
+        self::assertTrue($called);
+    }
+
+    public function testForAll(): void
+    {
+        $called = false;
+        $self = $this;
+        $some = new Some('foo');
+        self::assertSame($some, $some->forAll(function ($v) use (&$called, $self) {
+            $called = true;
+            $self->assertSame('foo', $v);
+        }));
+        self::assertTrue($called);
+    }
+
+    public function testMap(): void
+    {
+        $some = new Some('foo');
+        self::assertSame('o', $some->map(function ($v) {
+            return substr($v, 1, 1);
+        })->get());
+    }
+
+    public function testFlatMap(): void
+    {
+        $repo = new Repository(['foo']);
+
+        self::assertSame(['name' => 'foo'], $repo->getLastRegisteredUsername()
+                                                        ->flatMap([$repo, 'getUser'])
+                                                        ->getOrCall([$repo, 'getDefaultUser']));
+    }
+
+    public function testFilter(): void
+    {
+        $some = new Some('foo');
+
+        self::assertInstanceOf(None::class, $some->filter(function ($v) {
+            return 0 === strlen($v);
+        }));
+        self::assertSame($some, $some->filter(function ($v) {
+            return strlen($v) > 0;
+        }));
+    }
+
+    public function testFilterNot(): void
+    {
+        $some = new Some('foo');
+
+        self::assertInstanceOf(None::class, $some->filterNot(function ($v) {
+            return strlen($v) > 0;
+        }));
+        self::assertSame($some, $some->filterNot(function ($v) {
+            return strlen($v) === 0;
+        }));
+    }
+
+    public function testSelect(): void
+    {
+        $some = new Some('foo');
+
+        self::assertSame($some, $some->select('foo'));
+        self::assertInstanceOf(None::class, $some->select('bar'));
+        self::assertInstanceOf(None::class, $some->select(true));
+    }
+
+    public function testReject(): void
+    {
+        $some = new Some('foo');
+
+        self::assertSame($some, $some->reject(null));
+        self::assertSame($some, $some->reject(true));
+        self::assertInstanceOf(None::class, $some->reject('foo'));
+    }
+
+    public function testFoldLeftRight(): void
+    {
+        $some = new Some(5);
+
+        $testObj = $this;
+        self::assertSame(6, $some->foldLeft(1, function ($a, $b) use ($testObj) {
+            $testObj->assertSame(1, $a);
+            $testObj->assertSame(5, $b);
+
+            return $a + $b;
+        }));
+
+        self::assertSame(6, $some->foldRight(1, function ($a, $b) use ($testObj) {
+            $testObj->assertSame(1, $b);
+            $testObj->assertSame(5, $a);
+
+            return $a + $b;
+        }));
+    }
+
+    public function testForeach(): void
+    {
+        $some = new Some('foo');
+
+        $called = 0;
+        $extractedValue = null;
+        foreach ($some as $value) {
+            $extractedValue = $value;
+            $called++;
+        }
+
+        self::assertSame('foo', $extractedValue);
+        self::assertSame(1, $called);
+    }
+}
+
+// For the interested reader of these tests, we have gone some great lengths
+// to come up with a non-contrived example that might also be used in the
+// real-world, and not only for testing purposes :)
+class Repository
+{
+    private $users;
+
+    public function __construct(array $users = [])
+    {
+        $this->users = $users;
+    }
+
+    // A fast ID lookup, probably cached, sometimes we might not need the entire user.
+    public function getLastRegisteredUsername(): Option
+    {
+        if (empty($this->users)) {
+            return None::create();
+        }
+
+        return new Some(end($this->users));
+    }
+
+    // Returns a user object (we will live with an array here).
+    public function getUser($name): Option
+    {
+        if (in_array($name, $this->users, true)) {
+            return new Some(['name' => $name]);
+        }
+
+        return None::create();
+    }
+
+    public function getDefaultUser(): array
+    {
+        return ['name' => 'muhuhu'];
+    }
+}