File: tests/ParametersTest.php

<?php

/*
 * This file is part of Chevere.
 *
 * (c) Rodolfo Berrios <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Chevere\Tests;

use BadMethodCallException;
use Chevere\Parameter\ArrayParameter;
use Chevere\Parameter\BoolParameter;
use Chevere\Parameter\FloatParameter;
use Chevere\Parameter\Interfaces\ParameterInterface;
use Chevere\Parameter\IntParameter;
use Chevere\Parameter\IterableParameter;
use Chevere\Parameter\NullParameter;
use Chevere\Parameter\ObjectParameter;
use Chevere\Parameter\Parameters;
use Chevere\Parameter\StringParameter;
use Chevere\Parameter\UnionParameter;
use Chevere\Tests\src\VariadicParameters;
use InvalidArgumentException;
use OutOfBoundsException;
use OverflowException;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use ReflectionMethod;
use function Chevere\Parameter\int;
use function Chevere\Parameter\reflectionToParameters;
use function Chevere\Parameter\string;

final class ParametersTest extends TestCase
{
    public function testConstructEmpty(): void
    {
        $name = 'name';
        $parameters = new Parameters();
        $this->assertCount(0, $parameters);
        $this->assertCount(0, $parameters->optionalKeys());
        $this->assertCount(0, $parameters->requiredKeys());
        $this->assertFalse($parameters->has($name));
        $this->assertFalse($parameters->isVariadic());
        $this->expectException(OutOfBoundsException::class);
        $parameters->get($name);
    }

    public function testAssertEmpty(): void
    {
        $name = 'name';
        $parameters = new Parameters();
        $this->expectException(OutOfBoundsException::class);
        $parameters->assertHas($name);
    }

    public function testConstruct(): void
    {
        $name = 'name';
        $parameter = new StringParameter();
        $parameters = new Parameters(...[
            $name => $parameter,
        ]);
        $this->assertCount(1, $parameters);
        $this->assertCount(0, $parameters->optionalKeys());
        $this->assertCount(1, $parameters->requiredKeys());
        $parameters->assertHas($name);
        $this->assertTrue($parameters->has($name));
        $this->assertTrue($parameters->requiredKeys()->contains($name));
        $this->assertSame($parameter, $parameters->get($name));
        $this->expectException(OverflowException::class);
        $parameters->withRequired(
            $name,
            $parameter,
        );
    }

    public function testConstructPositional(): void
    {
        $foo = string();
        $bar = int();
        $parameters = new Parameters($foo, $bar);
        $this->assertCount(2, $parameters);
        $this->assertTrue($parameters->has('0'));
        $this->assertTrue($parameters->has('1'));
        $this->assertSame($foo, $parameters->get('0'));
        $this->assertSame($bar, $parameters->get('1'));
    }

    public function testRequiredMissing(): void
    {
        $parameters = new Parameters();
        $this->assertFalse($parameters->has('foo'));
        $this->expectException(OutOfBoundsException::class);
        $this->expectExceptionMessage('Key `foo` not found');
        $parameters->required('foo');
    }

    public function testOptionalMissing(): void
    {
        $parameters = new Parameters();
        $this->assertFalse($parameters->has('foo'));
        $this->expectException(OutOfBoundsException::class);
        $this->expectExceptionMessage('Key `foo` not found');
        $parameters->optional('foo');
    }

    public function testRequiredCasting(): void
    {
        $parameter = string();
        $parameters = new Parameters(foo: $parameter);
        $this->assertTrue($parameters->has('foo'));
        $this->assertSame($parameter, $parameters->required('foo')->string());
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Parameter `foo` is required');
        $parameters->optional('foo');
    }

    public function testRequiredCastingPositional(): void
    {
        $parameter = string();
        $parameters = new Parameters($parameter);
        $this->assertTrue($parameters->has('0'));
        $this->assertSame($parameter, $parameters->required('0')->string());
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Parameter `0` is required');
        $parameters->optional('0');
    }

    public function testOptionalCasting(): void
    {
        $parameter = string();
        $parameters = (new Parameters())
            ->withOptional('foo', $parameter);
        $this->assertSame($parameter, $parameters->optional('foo')->string());
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Parameter `foo` is optional');
        $parameters->required('foo');
    }

    public function testWithRequiredOverflow(): void
    {
        $name = 'name';
        $parameter = new StringParameter();
        $parameters = new Parameters(
            ...[
                $name => $parameter,
            ]
        );
        $this->assertCount(1, $parameters);
        $this->assertCount(0, $parameters->optionalKeys());
        $this->assertCount(1, $parameters->requiredKeys());
        $parameters->assertHas($name);
        $this->assertTrue($parameters->has($name));
        $this->assertTrue($parameters->requiredKeys()->contains($name));
        $this->assertSame($parameter, $parameters->get($name));
        $parametersWith = $parameters->withRequired('test', $parameter);
        $this->assertNotSame($parameters, $parametersWith);
        $this->expectException(OverflowException::class);
        $parameters->withRequired(
            $name,
            $parameter,
        );
    }

    public function testWithout(): void
    {
        $parameters = (new Parameters())
            ->withRequired('a', string())
            ->withRequired('b', string())
            ->withRequired('c', string())
            ->withOptional('x', string())
            ->withOptional('y', string())
            ->withOptional('z', string());
        $parametersWith = $parameters->without('a', 'y');
        $this->assertNotSame($parameters, $parametersWith);
        $this->assertCount(4, $parametersWith);
        $this->assertSame(['b', 'c'], $parametersWith->requiredKeys()->toArray());
        $this->assertSame(['x', 'z'], $parametersWith->optionalKeys()->toArray());
    }

    public function testWithRequiredOptional(): void
    {
        $name = 'name';
        $parameter = new StringParameter();
        $parameters = new Parameters();
        $this->assertSame(false, $parameters->isVariadic());
        $parametersWith = $parameters->withOptional($name, $parameter);
        $this->assertNotSame($parameters, $parametersWith);
        $this->assertCount(1, $parametersWith);
        $this->assertCount(1, $parametersWith->optionalKeys());
        $this->assertCount(0, $parametersWith->requiredKeys());
        $this->assertTrue($parametersWith->has($name));
        $this->assertTrue($parametersWith->optionalKeys()->contains($name));
        $this->assertFalse($parametersWith->requiredKeys()->contains($name));
        $this->assertSame($parameter, $parametersWith->get($name));
        $this->expectException(OverflowException::class);
        $parametersWith->withOptional($name, $parameter);
    }

    public function testWithVariadicParameters(): void
    {
        $reflector = new ReflectionMethod(VariadicParameters::class, 'main');
        $parameters = reflectionToParameters($reflector);
        $this->assertTrue($parameters->isVariadic());
        $return = $parameters(
            _task: 'test',
            _priority: 2,
            _maxRetries: 3,
            foo: 'bar',
            bar: 'baz',
        );
        $this->assertSame(
            [
                '_task' => 'test',
                '_priority' => 2,
                '_maxRetries' => 3,
                'foo' => 'bar',
                'bar' => 'baz',
            ],
            $return->toArray()
        );
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage(
            <<<PLAIN
            [foo...argument]: Argument must be of type Stringable|string, true given
            PLAIN
        );
        $this->expectExceptionMessage(
            <<<PLAIN
            [bar...argument]: Argument must be of type Stringable|string, int given
            PLAIN
        );
        $parameters(
            _task: 'test',
            _priority: 0,
            _maxRetries: 0,
            foo: true,
            bar: 123,
        );
    }

    public static function dataProviderGetCast(): array
    {
        return [
            [new StringParameter(), 'string'],
            [new IntParameter(), 'int'],
            [new FloatParameter(), 'float'],
            [new BoolParameter(), 'bool'],
            [new ArrayParameter(), 'array'],
            [new ObjectParameter(), 'object'],
            [new NullParameter(), 'null', 'int'],
        ];
    }

    #[DataProvider('dataProviderGetCast')]
    public function testGetCast(
        ParameterInterface $parameter,
        string $type,
        string $error = 'null'
    ): void {
        $name = 'test';
        $parameters = new Parameters(...[
            $name => $parameter,
        ]);
        $this->assertSame(
            $parameter,
            $parameters->required($name)->{$type}()
        );
        $this->expectException(\TypeError::class);
        $parameters->required($name)->{$error}();
    }

    public function testGetUnion(): void
    {
        $name = 'test';
        $type1 = new StringParameter();
        $type2 = new IntParameter();
        $parameters = new Parameters($type1, $type2);
        $parameter = new UnionParameter($parameters);
        $parameters = new Parameters(...[
            $name => $parameter,
        ]);
        $this->assertSame(
            $parameter,
            $parameters->required($name)->union()
        );
        $this->expectException(\TypeError::class);
        $parameters->required($name)->null();
    }

    public function testGetIterable(): void
    {
        $name = 'test';
        $parameter = new IterableParameter(
            value: string(),
            key: int(),
        );
        $parameters = new Parameters(...[
            $name => $parameter,
        ]);
        $this->assertSame(
            $parameter,
            $parameters->required($name)->iterable()
        );
        $this->expectException(\TypeError::class);
        $parameters->required($name)->null();
    }

    public function testWithOptionalMinimum(): void
    {
        $parameters = (new Parameters())->withOptional('a', string());
        $parametersWith = $parameters->withOptionalMinimum(1);
        $this->assertNotSame($parameters, $parametersWith);
        $this->assertSame(1, $parametersWith->optionalMinimum());
    }

    public function testWithOptionalMinimumBadMethodCall(): void
    {
        $parameters = new Parameters();
        $this->expectException(BadMethodCallException::class);
        $parameters->withOptionalMinimum(1);
    }

    public function testWithOptionalMinimumInvalidArgument(): void
    {
        $parameters = (new Parameters())->withOptional('foo', string());
        $this->expectException(InvalidArgumentException::class);
        $parameters->withOptionalMinimum(2);
    }

    public function testWithOptionalMinimumInvalidArgumentNumber(): void
    {
        $parameters = (new Parameters())->withOptional('foo', string());
        $this->expectException(InvalidArgumentException::class);
        $parameters->withOptionalMinimum(-1);
    }

    public function testWithOptionalMinimumWithout(): void
    {
        $parameters = (new Parameters())
            ->withOptional('foo', string())
            ->withOptional('bar', string());
        $parametersWith = $parameters->withOptionalMinimum(1);
        $parametersWith = $parametersWith->without('foo');
        $parametersWith = $parametersWith->withOptionalMinimum(0);
        $this->expectNotToPerformAssertions();
        $parametersWith->without('bar');
    }

    public function testWithOptionalMinimumWithoutInvalidArgument(): void
    {
        $parameters = (new Parameters())->withOptional('foo', string());
        $parametersWith = $parameters->withOptionalMinimum(1);
        $this->expectException(InvalidArgumentException::class);
        $parametersWith->without('foo');
    }

    public function testWithMakeOptional(): void
    {
        $parameters = new Parameters(
            foo: string(),
            bar: int()
        );
        $parametersWith = $parameters->withMakeOptional('foo');
        $this->assertNotSame($parameters, $parametersWith);
        $this->assertCount(2, $parametersWith);
        $this->assertCount(1, $parametersWith->optionalKeys());
        $this->assertCount(1, $parametersWith->requiredKeys());
        $this->assertTrue($parametersWith->optionalKeys()->contains('foo'));
        $this->assertTrue($parametersWith->requiredKeys()->contains('bar'));
        $this->expectException(InvalidArgumentException::class);
        $parametersWith->withMakeOptional('foo');
    }

    public function testWithMakeRequired(): void
    {
        $parameters = (new Parameters())
            ->withOptional('foo', string())
            ->withOptional('bar', int());
        $parametersWith = $parameters->withMakeRequired('bar');
        $this->assertNotSame($parameters, $parametersWith);
        $this->assertCount(2, $parametersWith);
        $this->assertCount(1, $parametersWith->optionalKeys());
        $this->assertCount(1, $parametersWith->requiredKeys());
        $this->assertTrue($parametersWith->optionalKeys()->contains('foo'));
        $this->assertTrue($parametersWith->requiredKeys()->contains('bar'));
        $this->expectException(InvalidArgumentException::class);
        $parametersWith->withMakeRequired('bar');
    }

    public function testWithMerge(): void
    {
        $foo = string();
        $bar = int();
        $parametersFoo = new Parameters(foo: $foo);
        $parametersBar = (new Parameters())->withOptional('bar', $bar);
        $parameters = (new Parameters(foo: $foo))->withOptional('bar', $bar);
        $fooWithMerge = $parametersFoo->withMerge($parametersBar);
        $this->assertNotSame($parametersFoo, $fooWithMerge);
        $this->assertEquals($parameters, $fooWithMerge);
        $this->assertSame(['foo'], $fooWithMerge->requiredKeys()->toArray());
        $this->assertSame(['bar'], $fooWithMerge->optionalKeys()->toArray());
        $barWithMerge = $parametersBar->withMerge($parametersFoo);
        $this->assertSame(['foo'], $barWithMerge->requiredKeys()->toArray());
        $this->assertSame(['bar'], $barWithMerge->optionalKeys()->toArray());
    }

    public function withIsVariadic(): void
    {
        $parameters = new Parameters();
        $with = $parameters->withIsVariadic(true);
        $this->assertNotEquals($with, $parameters);
        $this->assertTrue($with->isVariadic());
    }
}