DMapTest.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\Data;

use ILIAS\Data\Description\Description;
use ILIAS\Data\Description\DValue;
use ILIAS\Data\Description\DMap;
use PHPUnit\Framework\TestCase;

class DMapTest extends TestCase
{
    protected DMap $m;
    protected DValue $k;
    protected Description $v;

    public function setUp(): void
    {
        $this->k = $this->createMock(DValue::class);
        $this->v = $this->createMock(Description::class);
        $this->m = new DMap(
            $this->createMock(\ILIAS\Data\Text\SimpleDocumentMarkdown::class),
            $this->k,
            $this->v
        );
    }

    public function testObviouslyNotMatching($data): void
    {
        $res = $this->m->getPrimitiveRepresentation($data);

        $this->assertInstanceOf(\Closure::class, $res);
        $errors = iterator_to_array($res());
        $this->assertCount(1, $errors);
        $this->assertTrue(is_string($errors[0]));
    }

    public static function obviousNoMatchProvider(): array
    {
        return [
            [1], ["1"], [null], [true], [new \StdClass()], [new \DateTimeImmutable()]
        ];
    }

    public function testEmptyMatches(): void
    {
        $res = $this->m->getPrimitiveRepresentation([]);

        $this->assertEquals([], $res);
    }

    public function testForwardsToSubDescriptions(): void
    {
        $data = [
            "a" => 1,
            "b" => 2
        ];

        $keys = ["c", "d"];
        $this->k->expects($this->exactly(2))
            ->method("getPrimitiveRepresentation")
            ->willReturnCallback(function ($v) use (&$keys) {
                array_push($keys, $v);
                return array_shift($keys);
            });

        $values = [3, 4];
        $this->v->expects($this->exactly(2))
            ->method("getPrimitiveRepresentation")
            ->willReturnCallback(function ($v) use (&$values) {
                array_push($values, $v);
                return array_shift($values);
            });

        $expected = [
            "c" => 3,
            "d" => 4
        ];

        $res = $this->m->getPrimitiveRepresentation($data);

        $this->assertEquals($expected, $res);
        $this->assertEquals(["a", "b"], $keys);
        $this->assertEquals([1, 2], $values);
    }

    public function testFailsOnKeyFailure(): void
    {
        $data = ["a" => 1];

        $this->v
            ->method("getPrimitiveRepresentation")
            ->willReturn(1);

        $this->k
            ->method("getPrimitiveRepresentation")
            ->willReturn(fn() => yield "FAILURE");

        $res = $this->m->getPrimitiveRepresentation($data);

        $this->assertInstanceOf(\Closure::class, $res);
        $errors = iterator_to_array($res());
        $this->assertCount(1, $errors);
        $this->assertTrue(is_string($errors[0]));
        $this->assertTrue(str_contains($errors[0], "FAILURE"));
    }

    public function testFailsOnValueFailure(): void
    {
        $data = ["a" => 1];

        $this->v
            ->method("getPrimitiveRepresentation")
            ->willReturn(fn() => yield "FAILURE");

        $this->k
            ->method("getPrimitiveRepresentation")
            ->willReturn("a");

        $res = $this->m->getPrimitiveRepresentation($data);

        $this->assertInstanceOf(\Closure::class, $res);
        $errors = iterator_to_array($res());
        $this->assertCount(1, $errors);
        $this->assertTrue(is_string($errors[0]));
        $this->assertTrue(str_contains($errors[0], "FAILURE"));
    }
}