ResultTest.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

require_once("vendor/composer/vendor/autoload.php");

use ILIAS\Data;
use PHPUnit\Framework\TestCase;

class ResultTest extends TestCase
{
    private ?Data\Factory $f;

    protected function setUp(): void
    {
        $this->f = new Data\Factory();
    }

    protected function tearDown(): void
    {
        $this->f = null;
    }

    public function testValue(): void
    {
        $result = $this->f->ok(3.154);
        $this->assertEquals(3.154, $result->value());
    }

    public function testNoValue(): void
    {
        $result = $this->f->error("Something went wrong");

        try {
            $result->value();
            $raised = false;
        } catch (Exception $e) {
            $raised = true;
        }

        $this->assertTrue($raised);
    }

    public function testIsOk(): void
    {
        $result = $this->f->ok(3.154);
        $this->assertTrue($result->isOk());
        $this->assertFalse($result->isError());
    }

    public function testError(): void
    {
        $result = $this->f->error("Something went wrong");
        $this->assertEquals("Something went wrong", $result->error());
    }

    public function testNoError(): void
    {
        $result = $this->f->ok(3.154);

        try {
            $result->error();
            $raised = false;
        } catch (LogicException $e) {
            $raised = true;
        }

        $this->assertTrue($raised);
    }

    public function testIsError(): void
    {
        $result = $this->f->error("Something went wrong");
        $this->assertTrue($result->isError());
        $this->assertFalse($result->isOk());
    }

    public function testValueOr(): void
    {
        $result = $this->f->ok(3.154);
        $this->assertEquals(3.154, $result->valueOr(5));
    }

    public function testValueOrDefault(): void
    {
        $result = $this->f->error("Something went wrong");
        $this->assertEquals(5, $result->valueOr(5));
    }

    public function testMapOk(): void
    {
        $result = $this->f->ok(3);
        $multiplicator = 3;
        $new_result = $result->map(function ($v) use ($multiplicator) {
            return $v * $multiplicator;
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertNotEquals($result, $new_result);
        $this->assertEquals(9, $new_result->value());
    }

    public function testMapError(): void
    {
        $result = $this->f->error("Something went wrong");
        $multiplicator = 3;
        $new_result = $result->map(function ($v) use ($multiplicator) {
            return $v * $multiplicator;
        });

        $this->assertEquals($result, $new_result);
    }

    public function testThenOk(): void
    {
        $result = $this->f->ok(3);
        $multiplicator = 3;
        $new_result = $result->then(function ($v) use ($multiplicator) {
            return $this->f->ok(($v * $multiplicator));
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertNotEquals($result, $new_result);
        $this->assertEquals(9, $new_result->value());
    }

    public function testThenCallableNull(): void
    {
        $result = $this->f->ok(3);
        $new_result = $result->then(function ($v) {
            return null;
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertEquals($result, $new_result);
    }

    public function testThenError(): void
    {
        $result = $this->f->error("Something went wrong");
        $multiplicator = 3;
        $new_result = $result->then(function ($v) use ($multiplicator) {
            return $this->f->ok(($v * $multiplicator));
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertEquals($result, $new_result);
    }

    public function testThenNoResult(): void
    {
        $result = $this->f->ok(3);

        try {
            $new_result = $result->then(function ($v) {
                return 4;
            });

            $raised = false;
        } catch (UnexpectedValueException $e) {
            $raised = true;
        }

        $this->assertTrue($raised);
    }

    public function testExceptError(): void
    {
        $result = $this->f->error("Something went wrong");
        $exception = "Something else went wrong";

        $new_result = $result->except(function ($v) use ($exception) {
            return $this->f->error($exception);
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertNotEquals($result, $new_result);
        $this->assertEquals("Something else went wrong", $new_result->error());
    }

    public function testExceptCallableNull(): void
    {
        $result = $this->f->error("Something went wrong");
        $exception = "Something else went wrong";

        $new_result = $result->except(function ($v) {
            return null;
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertEquals($result, $new_result);
    }

    public function testExceptOk(): void
    {
        $result = $this->f->ok(3);
        $exception = "Something else went wrong";

        $new_result = $result->except(function ($v) use ($exception) {
            return $this->f->error($exception);
        });

        $this->assertInstanceOf(Data\Result::class, $new_result);
        $this->assertEquals($result, $new_result);
    }

    public function testExceptNoResult(): void
    {
        $result = $this->f->error("Something went wrong");

        try {
            $new_result = $result->except(function ($v) {
                return "New error text";
            });

            $raised = false;
        } catch (UnexpectedValueException $e) {
            $raised = true;
        }

        $this->assertTrue($raised);
    }
}