OptionalGroupInputTest Class Reference

Inheritance diagram for OptionalGroupInputTest:

Collaboration diagram for OptionalGroupInputTest:

Public Member Functions
	setUp ()
	testWithDisabledDisablesChildren ()
	testWithRequiredDoesNotRequire ()
	testThatOptionalGroupIsNotRequiredBecauseOfItsChildren ()
	testOptionalGroupMayOnlyHaveInputChildren ()
	testOptionalGroupForwardsValuesOnWithValue ()
	testGroupOnlyDoesNoAcceptNonArrayValue ()
	testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength ()
	testGroupAcceptsNullButDoesNotForward ()
	testGroupForwardsValuesOnGetValue ()
	testWithInputCallsChildrenAndAppliesOperations ()
	testWithInputDoesNotApplyOperationsOnError ()
	testWithInputDoesNotCallChildrenWhenUnchecked ()
Public Member Functions inherited from ILIAS_UI_TestBase
	setUp ()
	tearDown ()
	getUIFactory ()
	getTemplateFactory ()
	getResourceRegistry ()
	getLanguage ()
	getJavaScriptBinding ()
	getRefinery ()
	getImagePathResolver ()
	getDataFactory ()
	getDefaultRenderer (JavaScriptBinding $js_binding=null, array $with_stub_renderings=[])
	getDecoratedRenderer (Renderer $default)
	normalizeHTML (string $html)
	assertHTMLEquals (string $expected_html_as_string, string $html_as_string)

Protected Attributes
	$child1
	$child2
Data Factory	$data_factory
	$language
Refinery	$refinery
ILIAS UI Component Input Field Group	$optional_group
OptionalGroup	$group

Additional Inherited Members
Protected Member Functions inherited from ILIAS_UI_TestBase
	brutallyTrimHTML (string $html)
	A more radical version of normalizeHTML. More...
	brutallyTrimSignals (string $html)
	A naive replacement of all il_signal-ids with dots to ease comparisons of rendered output. More...

Detailed Description

Definition at line 39 of file OptionalGroupInputTest.php.

Member Function Documentation

setUp()

OptionalGroupInputTest::setUp

(

)

Reimplemented from ILIAS_UI_TestBase.

Definition at line 62 of file OptionalGroupInputTest.php.

                           : void
    {
        $this->child1 = $this->createMock(Input11::class);
        $this->child2 = $this->createMock(Input12::class);
        $this->data_factory = new Data\Factory();
        $this->language = $this->createMock(ilLanguage::class);
        $this->refinery = new ILIAS\Refinery\Factory($this->data_factory, $this->language);
 
        $this->child1
            ->method("withNameFrom")
            ->willReturn($this->child1);
        $this->child2
            ->method("withNameFrom")
            ->willReturn($this->child2);
 
        $this->optional_group = (new OptionalGroup(
            $this->data_factory,
            $this->refinery,
            $this->language,
            [$this->child1, $this->child2],
            "LABEL",
            "BYLINE"
        ))->withNameFrom(new class () implements NameSource {
            public function getNewName(): string
            {
                return "name0";
            }
        });
    }

References ILIAS\UI\examples\Symbol\Glyph\Language\language(), ILIAS\Repository\refinery(), and ILIAS\UI\Implementation\Component\Input\ViewControl\withNameFrom().

Here is the call graph for this function:

testGroupAcceptsNullButDoesNotForward()

OptionalGroupInputTest::testGroupAcceptsNullButDoesNotForward

(

)

Definition at line 203 of file OptionalGroupInputTest.php.

                                                           : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $this->child1
            ->expects($this->never())
            ->method("withValue");
        $this->child1
            ->expects($this->never())
            ->method("isClientSideValueOk");
        $this->child2
            ->expects($this->never())
            ->method("withValue");
        $this->child2
            ->expects($this->never())
            ->method("isClientSideValueOk");
 
        $new_group = $this->optional_group->withValue(null);
 
        $this->assertEquals([$this->child1, $this->child2], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
        $this->assertEquals(null, $new_group->getValue());
    }

testGroupForwardsValuesOnGetValue()

OptionalGroupInputTest::testGroupForwardsValuesOnGetValue

(

)

Definition at line 228 of file OptionalGroupInputTest.php.

                                                       : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $this->child1
            ->expects($this->once())
            ->method("getValue")
            ->with()
            ->willReturn("one");
        $this->child2
            ->expects($this->once())
            ->method("getValue")
            ->with()
            ->willReturn("two");
 
        $vals = $this->optional_group->getValue();
 
        $this->assertEquals(["one", "two"], $vals);
    }

testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength()

OptionalGroupInputTest::testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength

(

)

Definition at line 197 of file OptionalGroupInputTest.php.

                                                                         : void
    {
        $this->expectException(InvalidArgumentException::class);
        $this->optional_group->withValue([1]);
    }

testGroupOnlyDoesNoAcceptNonArrayValue()

OptionalGroupInputTest::testGroupOnlyDoesNoAcceptNonArrayValue

(

)

Definition at line 191 of file OptionalGroupInputTest.php.

                                                            : void
    {
        $this->expectException(InvalidArgumentException::class);
        $this->optional_group->withValue(1);
    }

testOptionalGroupForwardsValuesOnWithValue()

OptionalGroupInputTest::testOptionalGroupForwardsValuesOnWithValue

(

)

Definition at line 159 of file OptionalGroupInputTest.php.

                                                                : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $this->child1
            ->expects($this->once())
            ->method("withValue")
            ->with(1)
            ->willReturn($this->child2);
        $this->child1
            ->expects($this->once())
            ->method("isClientSideValueOk")
            ->with(1)
            ->willReturn(true);
        $this->child2
            ->expects($this->once())
            ->method("withValue")
            ->with(2)
            ->willReturn($this->child1);
        $this->child2
            ->expects($this->once())
            ->method("isClientSideValueOk")
            ->with(2)
            ->willReturn(true);
 
        $new_group = $this->optional_group->withValue([1,2]);
 
        $this->assertEquals([$this->child2, $this->child1], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
    }

testOptionalGroupMayOnlyHaveInputChildren()

OptionalGroupInputTest::testOptionalGroupMayOnlyHaveInputChildren

(

)

Definition at line 145 of file OptionalGroupInputTest.php.

    {
        $this->expectException(InvalidArgumentException::class);
 
        $this->group = new OptionalGroup(
            $this->data_factory,
            $this->refinery,
            $this->language,
            ["foo", "bar"],
            "LABEL",
            "BYLINE"
        );
    }

References ILIAS\UI\examples\Symbol\Glyph\Language\language(), and ILIAS\Repository\refinery().

Here is the call graph for this function:

testThatOptionalGroupIsNotRequiredBecauseOfItsChildren()

OptionalGroupInputTest::testThatOptionalGroupIsNotRequiredBecauseOfItsChildren

(

)

Definition at line 132 of file OptionalGroupInputTest.php.

                                                                            : void
    {
        $this->assertNotSame($this->child1, $this->child2);
        $this->child1->method('isRequired')->willReturn(true);
        $this->child2->method('isRequired')->willReturn(true);
 
        $new_group = $this->optional_group;
 
        $this->assertEquals([$this->child1, $this->child2], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertFalse($new_group->isRequired());
    }

References $optional_group.

testWithDisabledDisablesChildren()

OptionalGroupInputTest::testWithDisabledDisablesChildren

(

)

Definition at line 92 of file OptionalGroupInputTest.php.

                                                      : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $this->child1
            ->expects($this->once())
            ->method("withDisabled")
            ->with(true)
            ->willReturn($this->child2);
        $this->child2
            ->expects($this->once())
            ->method("withDisabled")
            ->with(true)
            ->willReturn($this->child1);
 
        $new_group = $this->optional_group->withDisabled(true);
 
        $this->assertEquals([$this->child2, $this->child1], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
    }

testWithInputCallsChildrenAndAppliesOperations()

OptionalGroupInputTest::testWithInputCallsChildrenAndAppliesOperations

(

)

Definition at line 248 of file OptionalGroupInputTest.php.

                                                                    : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $input_data = $this->createMock(InputData::class);
 
        $input_data
            ->expects($this->once())
            ->method("getOr")
            ->with("name0", null)
            ->willReturn("checked");
 
        $this->child1
            ->expects($this->once())
            ->method("withInput")
            ->with($input_data)
            ->willReturn($this->child2);
        $this->child1
            ->expects($this->once())
            ->method("getContent")
            ->with()
            ->willReturn($this->data_factory->ok("one"));
        $this->child2
            ->expects($this->once())
            ->method("withInput")
            ->with($input_data)
            ->willReturn($this->child1);
        $this->child2
            ->expects($this->once())
            ->method("getContent")
            ->with()
            ->willReturn($this->data_factory->ok("two"));
 
        $called = false;
        $new_group = $this->optional_group
            ->withAdditionalTransformation($this->refinery->custom()->transformation(function ($v) use (&$called): string {
                $called = true;
                $this->assertEquals(["two", "one"], $v);
                return "result";
            }))
            ->withInput($input_data);
 
        $this->assertTrue($called);
        $this->assertEquals([$this->child2, $this->child1], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
        $this->assertEquals($this->data_factory->ok("result"), $new_group->getContent());
    }

References function, and ILIAS\Repository\refinery().

Here is the call graph for this function:

testWithInputDoesNotApplyOperationsOnError()

OptionalGroupInputTest::testWithInputDoesNotApplyOperationsOnError

(

)

Definition at line 297 of file OptionalGroupInputTest.php.

                                                                : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $input_data = $this->createMock(InputData::class);
 
        $input_data
            ->expects($this->once())
            ->method("getOr")
            ->with("name0", null)
            ->willReturn("checked");
 
        $this->child1
            ->expects($this->once())
            ->method("withInput")
            ->with($input_data)
            ->willReturn($this->child2);
        $this->child1
            ->expects($this->once())
            ->method("getContent")
            ->willReturn($this->data_factory->error(""));
        $this->child2
            ->expects($this->once())
            ->method("withInput")
            ->with($input_data)
            ->willReturn($this->child1);
        $this->child2
            ->expects($this->once())
            ->method("getContent")
            ->willReturn($this->data_factory->ok("two"));
 
        $i18n = "THERE IS SOME ERROR IN THIS GROUP";
        $this->language
            ->expects($this->once())
            ->method("txt")
            ->with("ui_error_in_group")
            ->willReturn($i18n);
 
        $new_group = $this->optional_group
            ->withAdditionalTransformation($this->refinery->custom()->transformation(function (): void {
                $this->fail("This should not happen.");
            }))
            ->withInput($input_data);
 
        $this->assertEquals([$this->child2, $this->child1], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
        $this->assertTrue($new_group->getContent()->isError());
    }

References function, ILIAS\UI\examples\Symbol\Glyph\Language\language(), and ILIAS\Repository\refinery().

Here is the call graph for this function:

testWithInputDoesNotCallChildrenWhenUnchecked()

OptionalGroupInputTest::testWithInputDoesNotCallChildrenWhenUnchecked

(

)

Definition at line 347 of file OptionalGroupInputTest.php.

                                                                   : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $input_data = $this->createMock(InputData::class);
 
        $input_data
            ->expects($this->once())
            ->method("getOr")
            ->with("name0", null)
            ->willReturn(null);
 
        $this->child1
            ->expects($this->never())
            ->method("withInput");
        $this->child1
            ->expects($this->never())
            ->method("getContent");
        $this->child2
            ->expects($this->never())
            ->method("withInput");
        $this->child2
            ->expects($this->never())
            ->method("getContent");
 
        $called = false;
        $new_group = $this->optional_group
            ->withAdditionalTransformation($this->refinery->custom()->transformation(function ($v) use (&$called): string {
                $called = true;
                $this->assertEquals(null, $v);
                return "result";
            }))
            ->withInput($input_data);
 
        $this->assertTrue($called);
        $this->assertEquals([$this->child1, $this->child2], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
        $this->assertEquals($this->data_factory->ok("result"), $new_group->getContent());
    }

References function, and ILIAS\Repository\refinery().

Here is the call graph for this function:

testWithRequiredDoesNotRequire()

OptionalGroupInputTest::testWithRequiredDoesNotRequire

(

)

Definition at line 114 of file OptionalGroupInputTest.php.

                                                    : void
    {
        $this->assertNotSame($this->child1, $this->child2);
 
        $this->child1
            ->expects($this->never())
            ->method("withRequired");
        $this->child2
            ->expects($this->never())
            ->method("withRequired");
 
        $new_group = $this->optional_group->withRequired(true);
 
        $this->assertEquals([$this->child1, $this->child2], $new_group->getInputs());
        $this->assertInstanceOf(OptionalGroup::class, $new_group);
        $this->assertNotSame($this->optional_group, $new_group);
    }

Field Documentation

$child1

OptionalGroupInputTest::$child1

protected

Definition at line 44 of file OptionalGroupInputTest.php.

$child2

OptionalGroupInputTest::$child2

protected

Definition at line 49 of file OptionalGroupInputTest.php.

$data_factory

Data Factory OptionalGroupInputTest::$data_factory

protected

Definition at line 51 of file OptionalGroupInputTest.php.

$group

OptionalGroup OptionalGroupInputTest::$group

protected

Definition at line 60 of file OptionalGroupInputTest.php.

$language

OptionalGroupInputTest::$language

protected

Definition at line 56 of file OptionalGroupInputTest.php.

$optional_group

ILIAS UI Component Input Field Group OptionalGroupInputTest::$optional_group

protected

Definition at line 59 of file OptionalGroupInputTest.php.

Referenced by testThatOptionalGroupIsNotRequiredBecauseOfItsChildren().

$refinery

Refinery OptionalGroupInputTest::$refinery

protected

Definition at line 58 of file OptionalGroupInputTest.php.

---

The documentation for this class was generated from the following file:

• tests/UI/Component/Input/Field/OptionalGroupInputTest.php