ResolverTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Component\Tests\Dependencies;
 
use PHPUnit\Framework\TestCase;
use ILIAS\Component\Dependencies\Resolver;
use ILIAS\Component\Dependencies as D;
use ILIAS\Component\Component;
 
class ResolverTest extends TestCase
{
    protected Resolver $resolver;
 
    public function setUp(): void
    {
        $this->resolver = new Resolver();
    }
 
    public function testEmptyComponentSet(): void
    {
        $result = $this->resolver->resolveDependencies([]);
 
        $this->assertEquals([], $result);
    }
 
    public function testResolvePull(): void
    {
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $pull = new D\In(D\InType::PULL, $name);
        $provide = new D\Out(D\OutType::PROVIDE, $name, null, []);
 
        $c1 = new D\OfComponent($component, $pull);
        $c2 = new D\OfComponent($component, $provide);
 
        $result = $this->resolver->resolveDependencies([], $c1, $c2);
 
        $pull = new D\In(D\InType::PULL, $name);
        $provide = new D\Out(D\OutType::PROVIDE, $name, null, []);
        $pull->addResolution($provide);
 
        $c1 = new D\OfComponent($component, $pull);
        $c2 = new D\OfComponent($component, $provide);
 
        $this->assertEquals([$c1, $c2], $result);
    }
 
    public function testPullFailsNotExistent(): void
    {
        $this->expectException(\LogicException::class);
 
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $pull = new D\In(D\InType::PULL, $name);
 
        $c1 = new D\OfComponent($component, $pull);
 
        $this->resolver->resolveDependencies([], $c1);
    }
 
    public function testPullFailsDuplicate(): void
    {
        $this->expectException(\LogicException::class);
 
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $pull = new D\In(D\InType::PULL, $name);
        $provide1 = new D\Out(D\OutType::PROVIDE, $name, null, []);
        $provide2 = new D\Out(D\OutType::PROVIDE, $name, null, []);
 
        $c1 = new D\OfComponent($component, $pull);
        $c2 = new D\OfComponent($component, $provide1);
        $c3 = new D\OfComponent($component, $provide2);
 
        $this->resolver->resolveDependencies([], $c1, $c2, $c3);
    }
 
    public function testEmptySeek(): void
    {
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $seek = new D\In(D\InType::SEEK, $name);
 
        $c1 = new D\OfComponent($component, $seek);
 
        $result = $this->resolver->resolveDependencies([], $c1);
 
        $this->assertEquals([$c1], $result);
    }
 
    public function testResolveSeek(): void
    {
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $seek = new D\In(D\InType::SEEK, $name);
        $contribute1 = new D\Out(D\OutType::CONTRIBUTE, $name, null, []);
        $contribute2 = new D\Out(D\OutType::CONTRIBUTE, $name, null, []);
 
        $c1 = new D\OfComponent($component, $seek);
        $c2 = new D\OfComponent($component, $contribute1);
        $c3 = new D\OfComponent($component, $contribute2);
 
        $result = $this->resolver->resolveDependencies([], $c1, $c2, $c3);
 
 
        $seek = new D\In(D\InType::SEEK, $name);
        $contribute1 = new D\Out(D\OutType::CONTRIBUTE, $name, null, []);
        $contribute2 = new D\Out(D\OutType::CONTRIBUTE, $name, null, []);
        $seek->addResolution($contribute1);
        $seek->addResolution($contribute2);
 
        $c1 = new D\OfComponent($component, $seek);
        $c2 = new D\OfComponent($component, $contribute1);
        $c3 = new D\OfComponent($component, $contribute2);
 
        $this->assertEquals([$c1, $c2, $c3], $result);
    }
 
    public function testResolveUseOneOption(): void
    {
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $use = new D\In(D\InType::USE, $name);
        $implement = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement);
 
        $result = $this->resolver->resolveDependencies([], $c1, $c2);
 
        $use = new D\In(D\InType::USE, $name);
        $implement = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
        $use->addResolution($implement);
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement);
 
        $this->assertEquals([$c1, $c2], $result);
    }
 
    public function testUseFailsNotExistent(): void
    {
        $this->expectException(\LogicException::class);
 
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $use = new D\In(D\InType::USE, $name);
 
        $c1 = new D\OfComponent($component, $use);
 
        $this->resolver->resolveDependencies([], $c1);
    }
 
    public function testUseFailsDuplicate(): void
    {
        $this->expectException(\LogicException::class);
 
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $use = new D\In(D\InType::USE, $name);
        $implement1 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
        $implement2 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement1);
        $c3 = new D\OfComponent($component, $implement2);
 
        $this->resolver->resolveDependencies([], $c1, $c2, $c3);
    }
 
    public function testUseDisambiguateDuplicateSpecific(): void
    {
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $use = new D\In(D\InType::USE, $name);
        $implement1 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
        $implement2 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\OtherClass"], []);
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement1);
        $c3 = new D\OfComponent($component, $implement2);
 
        $disambiguation = [
            get_class($component) => [
                TestInterface::class => "Some\\OtherClass"
            ]
        ];
 
        $result = $this->resolver->resolveDependencies($disambiguation, $c1, $c2, $c3);
 
        $use = new D\In(D\InType::USE, $name);
        $implement1 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
        $implement2 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\OtherClass"], []);
        $use->addResolution($implement2);
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement1);
        $c3 = new D\OfComponent($component, $implement2);
 
        $this->assertEquals([$c1, $c2, $c3], $result);
    }
 
    public function testUseDisambiguateDuplicateGeneric(): void
    {
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
 
        $use = new D\In(D\InType::USE, $name);
        $implement1 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
        $implement2 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\OtherClass"], []);
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement1);
        $c3 = new D\OfComponent($component, $implement2);
 
        $disambiguation = [
            "*" => [
                TestInterface::class => "Some\\OtherClass"
            ]
        ];
 
        $result = $this->resolver->resolveDependencies($disambiguation, $c1, $c2, $c3);
 
        $use = new D\In(D\InType::USE, $name);
        $implement1 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\Class"], []);
        $implement2 = new D\Out(D\OutType::IMPLEMENT, $name, ["class" => "Some\\OtherClass"], []);
        $use->addResolution($implement2);
 
 
        $c1 = new D\OfComponent($component, $use);
        $c2 = new D\OfComponent($component, $implement1);
        $c3 = new D\OfComponent($component, $implement2);
 
        $this->assertEquals([$c1, $c2, $c3], $result);
    }
 
    public function testFindSimpleCycle(): void
    {
        $this->expectException(\LogicException::class);
 
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
        $name2 = TestInterface2::class;
 
        $pull = new D\In(D\InType::PULL, $name);
        $provide = new D\Out(D\OutType::PROVIDE, $name2, "Some\\Class", [$pull], []);
        $c1 = new D\OfComponent($component, $pull, $provide);
 
        $pull = new D\In(D\InType::PULL, $name2);
        $provide = new D\Out(D\OutType::PROVIDE, $name, "Some\\OtherClass", [$pull], []);
        $c2 = new D\OfComponent($component, $pull, $provide);
 
 
        $result = $this->resolver->resolveDependencies([], $c1, $c2);
    }
 
    public function testFindLongerCycle(): void
    {
        $this->expectException(\LogicException::class);
 
        $component = $this->createMock(Component::class);
 
        $name = TestInterface::class;
        $name2 = TestInterface2::class;
        $name3 = TestInterface3::class;
 
        $pull = new D\In(D\InType::PULL, $name);
        $provide = new D\Out(D\OutType::PROVIDE, $name2, "Some\\Class", [$pull], []);
        $c1 = new D\OfComponent($component, $pull, $provide);
 
        $pull = new D\In(D\InType::PULL, $name2);
        $provide = new D\Out(D\OutType::PROVIDE, $name3, "Some\\OtherClass", [$pull], []);
        $c2 = new D\OfComponent($component, $pull, $provide);
 
        $pull = new D\In(D\InType::PULL, $name3);
        $provide = new D\Out(D\OutType::PROVIDE, $name, "Some\\OtherOtherClass", [$pull], []);
        $c3 = new D\OfComponent($component, $pull, $provide);
 
 
        $result = $this->resolver->resolveDependencies([], $c1, $c2, $c3);
    }
}