LogicalOrTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\Data\Factory as DataFactory;
use ILIAS\Refinery\Factory as Refinery;
use ILIAS\Refinery\Logical\LogicalOr;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\DataProvider;
 
class LogicalOrTest extends TestCase
{
    #[DataProvider('constraintsProvider')]
    public function testAccept(LogicalOr $constraint, mixed $okValue, mixed $errorValue): void
    {
        $this->assertTrue($constraint->accepts($okValue));
        $this->assertFalse($constraint->accepts($errorValue));
    }
 
    #[DataProvider('constraintsProvider')]
    public function testCheck(LogicalOr $constraint, mixed $okValue, mixed $errorValue): void
    {
        $raised = false;
 
        try {
            $constraint->check($errorValue);
        } catch (UnexpectedValueException $e) {
            $raised = true;
        }
 
        $this->assertTrue($raised);
 
        try {
            $constraint->check($okValue);
            $raised = false;
        } catch (UnexpectedValueException $e) {
            $raised = true;
        }
 
        $this->assertFalse($raised);
    }
 
    #[DataProvider('constraintsProvider')]
    public function testProblemWith(LogicalOr $constraint, mixed $okValue, mixed $errorValue): void
    {
        $this->assertNull($constraint->problemWith($okValue));
        $this->assertIsString($constraint->problemWith($errorValue));
    }
 
    #[DataProvider('constraintsProvider')]
    public function testRestrict(LogicalOr $constraint, mixed $okValue, mixed $errorValue): void
    {
        $rf = new DataFactory();
        $ok = $rf->ok($okValue);
        $ok2 = $rf->ok($errorValue);
        $error = $rf->error('text');
 
        $result = $constraint->applyTo($ok);
        $this->assertTrue($result->isOk());
 
        $result = $constraint->applyTo($ok2);
        $this->assertTrue($result->isError());
 
        $result = $constraint->applyTo($error);
        $this->assertSame($error, $result);
    }
 
    #[DataProvider('constraintsProvider')]
    public function testWithProblemBuilder(LogicalOr $constraint, mixed $okValue, mixed $errorValue): void
    {
        $new_constraint = $constraint->withProblemBuilder(static function (): string {
            return "This was a vault";
        });
        $this->assertEquals("This was a vault", $new_constraint->problemWith($errorValue));
    }
 
    public static function constraintsProvider(): array
    {
        $language = new class () implements \ILIAS\Language\Language {
            public function txt(string|\ILIAS\Language\LanguageIdentifier $a_topic, ?int $n = null): string
            {
                return is_string($a_topic) ? $a_topic : (string) $a_topic->value;
            }
            public function loadLanguageModule(string $a_module): void
            {
            }
            public function getLangKey(): string
            {
                return '';
            }
            public function toJS($key): void
            {
            }
        };
        $data_factory = new DataFactory();
 
        $refinery = new Refinery($data_factory, $language);
        return [
            [
                $refinery->logical()->logicalOr([
                    $refinery->int()->isLessThan(6),
                    $refinery->int()->isGreaterThan(100)
                ]),
                '5',
                8
            ],
            [
                $refinery->logical()->logicalOr([$refinery->int()->isGreaterThan(5), $refinery->int()->isLessThan(2)]),
                7,
                3
            ]
        ];
    }
}