TaskTestTBD.php

Go to the documentation of this file.

<?php
 
use PHPUnit\Framework\Attributes\BackupGlobals;
use PHPUnit\Framework\Attributes\BackupStaticProperties;
use PHPUnit\Framework\Attributes\PreserveGlobalState;
use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
use ILIAS\BackgroundTasks\Implementation\TaskManager\SyncTaskManager;
use ILIAS\BackgroundTasks\Exceptions\InvalidArgumentException;
use ILIAS\BackgroundTasks\Implementation\Bucket\BasicBucket;
use ILIAS\BackgroundTasks\Implementation\Bucket\BucketMock;
use ILIAS\BackgroundTasks\Implementation\TaskManager\MockObserver;
use ILIAS\BackgroundTasks\Implementation\Tasks\Aggregation\ConcatenationJob;
use ILIAS\BackgroundTasks\Implementation\Tasks\PlusJob;
use ILIAS\BackgroundTasks\Implementation\Values\AggregationValues\ListValue;
use ILIAS\BackgroundTasks\Implementation\Values\ScalarValues\IntegerValue;
use ILIAS\BackgroundTasks\Implementation\Values\ScalarValues\StringValue;
use ILIAS\BackgroundTasks\Bucket;
use ILIAS\BackgroundTasks\Persistence;
use ILIAS\DI\Container;
use ILIAS\BackgroundTasks\Dependencies\DependencyMap\BaseDependencyMap;
use ILIAS\BackgroundTasks\Dependencies\Injector;
use ILIAS\BackgroundTasks\Types\SingleType;
use PHPUnit\Framework\TestCase;
 
require_once("vendor/composer/vendor/autoload.php");
 
#[BackupGlobals(false)]
#[BackupStaticProperties(false)]
#[PreserveGlobalState(false)]
#[RunTestsInSeparateProcesses]
class TaskTest extends TestCase
{
    public function testPlusTask(): void
    {
        $dic = new Container();
 
        $factory = new Injector($dic, new BaseDependencyMap());
 
        $a = new IntegerValue();
        $a->setValue(1);
        $b = new IntegerValue();
        $b->setValue(2);
        $c = new IntegerValue();
        $c->setValue(3);
 
        $t1 = $factory->createInstance(PlusJob::class);
        $t1->setInput([$a, $b]);
 
        $t2 = $factory->createInstance(PlusJob::class);
        $t2->setInput([$t1, $c]);
 
        $this->assertTrue($t2->getOutputType()->equals(new SingleType(IntegerValue::class)));
 
        $taskManager = new SyncTaskManager(Mockery::mock(Persistence::class));
        $finalValue = $taskManager->executeTask($t2, new MockObserver());
        $this->assertEquals(6, $finalValue->getValue());
    }
 
    public function testValueWrapper(): void
    {
        $dic = new Container();
        $dic[Bucket::class] = (fn($c): BucketMock => new BucketMock());
        $factory = new Injector($dic, new BaseDependencyMap());
 
        $t = $factory->createInstance(PlusJob::class);
        $t->setInput([1, 4]);
 
        $taskManager = new SyncTaskManager(Mockery::mock(Persistence::class));
        $finalValue = $taskManager->executeTask($t, new MockObserver());
        $this->assertEquals(5, $finalValue->getValue());
    }
 
    public function testTypeCheck(): void
    {
        $this->expectException(InvalidArgumentException::class);
 
        $dic = new Container();
        $dic[Bucket::class] = (fn($c): BucketMock => new BucketMock());
        $factory = new Injector($dic, new BaseDependencyMap());
 
        $a = new IntegerValue(1);
        $b = new StringValue("hello");
 
        $t1 = $factory->createInstance(PlusJob::class);
        $t1->setInput([$a, $b]);
    }
 
    public function testAggregation(): void
    {
        $dic = new Container();
        $factory = new Injector($dic, new BaseDependencyMap());
 
        $list = new ListValue();
        $list->setValue([1, "hello", 3.0]);
 
        $t1 = $factory->createInstance(ConcatenationJob::class);
        $t1->setInput([$list]);
 
        $output = $t1->run([$list], new MockObserver());
        $this->assertEquals("1, hello, 3", $output->getValue());
    }
 
    public function testUnfoldTask(): void
    {
        $dic = new Container();
        $dic[Bucket::class] = (fn($c): BasicBucket => new BasicBucket());
 
        $factory = new Injector($dic, new BaseDependencyMap());
 
        $t0 = $factory->createInstance(PlusJob::class);
        $t0->setInput([1, 1]);
 
        $t1 = $factory->createInstance(PlusJob::class);
        $t1->setInput([$t0, 2]);
 
        $t25 = $factory->createInstance(PlusJob::class);
        $t25->setInput([2, 2]);
 
        $t2 = $factory->createInstance(PlusJob::class);
        $t2->setInput([$t1, $t25]);
 
        $this->assertTrue($t2->getOutputType()->equals(new SingleType(IntegerValue::class)));
 
        $list = $t2->unfoldTask();
        $this->assertEquals($list, [$t2, $t1, $t0, $t25]);
 
        $taskManager = new SyncTaskManager(Mockery::mock(Persistence::class));
        $finalValue = $taskManager->executeTask($t2, new MockObserver());
        $this->assertEquals(8, $finalValue->getValue());
    }
}