Inheritance diagram for SwitchableGroupInputTest:

Collaboration diagram for SwitchableGroupInputTest:

Public Member Functions
	setUp ()

	testWithDisabledDisablesChildren ()

	testWithRequiredDoesNotRequire ()

	testSwitchableGroupMayOnlyHaveGroupChildren ()

	testSwitchableGroupForwardsValuesOnWithValue ()

	testGroupOnlyDoesNotAcceptNonArrayValue ()

	testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength ()

	testGroupOnlyDoesAcceptKeyOnly ()

	testGroupOnlyDoesNotAcceptInvalidKey ()

	testGroupForwardsValuesOnGetValue ()

	testWithInputCallsChildrenAndAppliesOperations ()

	testWithInputDoesNotApplyOperationsOnError ()

	testErrorIsI18NOnError ()

	testWithInputDoesNotAcceptUnknownKeys ()

	testRender ()

	testRenderWithValue (SG $sg)

	testRenderWithValueByIndex ()

	testCommonRendering ()

Protected Member Functions
	buildFactory ()

Protected Attributes
	$child1

	$child2

	$nested_child

	$lng

Data Factory	$data_factory

Refinery	$refinery

ILIAS UI Component Input Field Group	$switchable_group

SwitchableGroup	$group

Detailed Description

Definition at line 48 of file SwitchableGroupInputTest.php.

Member Function Documentation

◆ buildFactory()

SwitchableGroupInputTest::buildFactory ( )

protected

Definition at line 119 of file SwitchableGroupInputTest.php.

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

                                      : I\Input\Field\Factory
     {
         return new I\Input\Field\Factory(
             $this->createMock(\ILIAS\UI\Implementation\Component\Input\Field\Node\Factory::class),
             $this->createMock(\ILIAS\UI\Implementation\Component\Input\UploadLimitResolver::class),
             new SignalGenerator(),
             $this->data_factory,
             $this->refinery,
             $this->lng
         );
     }

Here is the call graph for this function:

◆ setUp()

SwitchableGroupInputTest::setUp ( )

Definition at line 77 of file SwitchableGroupInputTest.php.

References ILIAS\Repository\lng(), ILIAS\Repository\refinery(), and ILIAS\UI\Implementation\Component\Input\Input\withNameFrom().

                            : void
     {
         $this->nested_child = $this->createMock(I\Input\Field\FormInputInternal::class);
         $this->child1 = $this->createMock(Group1::class);
         $this->child2 = $this->createMock(Group2::class);
         $this->data_factory = new Data\Factory();
         $this->refinery = new Refinery($this->data_factory, $this->createMock(ILIAS\Language\Language::class));
         $this->lng = $this->createMock(ILIAS\Language\Language::class);
 
         $this->nested_child
             ->method("withNameFrom")
             ->willReturn($this->nested_child);
 
         $this->child1
             ->method("withNameFrom")
             ->willReturn($this->child1);
         $this->child1
             ->method("getInputs")
             ->willReturn([$this->nested_child]);
 
         $this->child2
             ->method("withNameFrom")
             ->willReturn($this->child2);
         $this->child2
             ->method("getInputs")
             ->willReturn([$this->nested_child]);
 
         $this->switchable_group = (new SwitchableGroup(
             $this->data_factory,
             $this->refinery,
             $this->lng,
             ["child1" => $this->child1, "child2" => $this->child2],
             "LABEL",
             "BYLINE"
         ))->withNameFrom(new class () implements NameSource {
             public function getNewName(): string
             {
                 return "name0";
             }
         });
     }

Here is the call graph for this function:

◆ testCommonRendering()

SwitchableGroupInputTest::testCommonRendering ( )

Definition at line 510 of file SwitchableGroupInputTest.php.

References Vendor\Package\$f.

                                          : void
     {
         $f = $this->getFieldFactory();
         $label = "label";
 
         $group1 = $f->group([
             "field_1" => $f->text("f")
         ]);
         $group2 = $f->group([
             "field_2" => $f->text("f2")
         ]);
 
         $sg = $f->switchableGroup(
             [
                 "g1" => $group1,
                 "g2" => $group2
             ],
             $label
         )->withNameFrom((new DefNamesource()));
 
         $this->testWithError($sg);
         $this->testWithNoByline($sg);
         $this->testWithRequired($sg);
         $this->testWithDisabled($sg);
         $this->testWithAdditionalOnloadCodeRendersId($sg);
     }

◆ testErrorIsI18NOnError()

SwitchableGroupInputTest::testErrorIsI18NOnError ( )

Definition at line 351 of file SwitchableGroupInputTest.php.

References ILIAS\Repository\lng().

                                             : void
     {
         $this->assertNotSame($this->child1, $this->child2);
 
         $input_data = $this->createMock(InputData::class);
 
         $input_data
             ->expects($this->once())
             ->method("getOr")
             ->with("name0")
             ->willReturn("child2");
 
         $this->child2
             ->method("withInput")
             ->willReturn($this->child2);
         $this->child2
             ->method("getContent")
             ->willReturn($this->data_factory->error(""));
 
         $i18n = "THERE IS SOME ERROR IN THIS GROUP";
         $this->lng
             ->expects($this->once())
             ->method("txt")
             ->with("ui_error_in_group")
             ->willReturn($i18n);
 
         $switchable_group = $this->switchable_group
             ->withInput($input_data);
 
         $this->assertTrue($switchable_group->getContent()->isError());
         $this->assertEquals($i18n, $switchable_group->getContent()->error());
     }

Here is the call graph for this function:

◆ testGroupForwardsValuesOnGetValue()

SwitchableGroupInputTest::testGroupForwardsValuesOnGetValue ( )

Definition at line 234 of file SwitchableGroupInputTest.php.

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

◆ testGroupOnlyDoesAcceptKeyOnly()

SwitchableGroupInputTest::testGroupOnlyDoesAcceptKeyOnly ( )

Definition at line 220 of file SwitchableGroupInputTest.php.

                                                     : void
     {
         $new_group = $this->switchable_group->withValue("child1");
         $this->assertEquals(["child1" => $this->child1, "child2" => $this->child2], $new_group->getInputs());
         $this->assertInstanceOf(SwitchableGroup::class, $new_group);
         $this->assertNotSame($this->switchable_group, $new_group);
     }

◆ testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength()

SwitchableGroupInputTest::testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength ( )

Definition at line 214 of file SwitchableGroupInputTest.php.

                                                                          : void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->switchable_group->withValue([1, 2, 3]);
     }

◆ testGroupOnlyDoesNotAcceptInvalidKey()

SwitchableGroupInputTest::testGroupOnlyDoesNotAcceptInvalidKey ( )

Definition at line 228 of file SwitchableGroupInputTest.php.

                                                           : void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->switchable_group->withValue("child3");
     }

◆ testGroupOnlyDoesNotAcceptNonArrayValue()

SwitchableGroupInputTest::testGroupOnlyDoesNotAcceptNonArrayValue ( )

Definition at line 208 of file SwitchableGroupInputTest.php.

References null.

                                                              : void
     {
         $this->expectException(InvalidArgumentException::class);
         $this->switchable_group->withValue(null);
     }

◆ testRender()

SwitchableGroupInputTest::testRender ( )

Definition at line 416 of file SwitchableGroupInputTest.php.

References Vendor\Package\$f, and ILIAS\Repository\ui().

                                 : SG
     {
         $f = $this->buildFactory();
         $label = "label";
         $byline = "byline";
 
         $group1 = $f->group([
             "field_1" => $f->text("f", "some field")
         ]);
         $group2 = $f->group([
             "field_2" => $f->text("f2", "some other field")
         ]);
 
         $sg = $f->switchableGroup(
             [
                 "g1" => $group1,
                 "g2" => $group2
             ],
             $label,
             $byline
         );
 
         $expected = <<<EOT
 <fieldset class="c-input" data-il-ui-component="switchable-group-field-input" data-il-ui-input-name="" tabindex="0">
     <label>label</label>
     <div class="c-input__field">
         <fieldset class="c-input" data-il-ui-component="group-field-input" data-il-ui-input-name="">
             <label for="id_1">
                 <input type="radio" id="id_1" value="g1" />
                 <span></span>
             </label>
             <div class="c-input__field">
                 <fieldset class="c-input" data-il-ui-component="text-field-input" data-il-ui-input-name=""><label
                         for="id_2">f</label>
                     <div class="c-input__field"><input id="id_2" type="text" class="c-field-text" /></div>
                     <div class="c-input__help-byline">some field</div>
                 </fieldset>
             </div>
         </fieldset>
         <fieldset class="c-input" data-il-ui-component="group-field-input" data-il-ui-input-name="">
             <label for="id_3">
                 <input type="radio" id="id_3" value="g2" />
                 <span></span>
             </label>
             <div class="c-input__field">
                 <fieldset class="c-input" data-il-ui-component="text-field-input" data-il-ui-input-name=""><label
                         for="id_4">f2</label>
                     <div class="c-input__field"><input id="id_4" type="text" class="c-field-text" /></div>
                     <div class="c-input__help-byline">some other field</div>
                 </fieldset>
             </div>
         </fieldset>
     </div>
     <div class="c-input__help-byline">byline</div>
 </fieldset>
 EOT;
         $this->assertEquals(
             $this->brutallyTrimHTML($expected),
             $this->render($sg)
         );
         return $sg;
     }

Here is the call graph for this function:

◆ testRenderWithValue()

SwitchableGroupInputTest::testRenderWithValue ( SG $sg )

Definition at line 480 of file SwitchableGroupInputTest.php.

References $r.

                                                : void
     {
         $r = $this->getDefaultRenderer();
         $html = $this->render($sg->withValue('g2'));
         $expected = '<label for="id_3"><input type="radio" id="id_3" value="g2" checked="checked" />';
         $this->assertStringContainsString($expected, $this->render($sg->withValue('g2')));
     }

◆ testRenderWithValueByIndex()

SwitchableGroupInputTest::testRenderWithValueByIndex ( )

Definition at line 488 of file SwitchableGroupInputTest.php.

References Vendor\Package\$f.

                                                 : void
     {
         $f = $this->buildFactory();
         $label = "label";
         $byline = "byline";
 
         $group1 = $f->group([
             "field_1" => $f->text("f", "some field")
         ]);
         $group2 = $f->group([
             "field_2" => $f->text("f2", "some other field")
         ]);
         $empty_group_title = 'empty group, the title';
         $empty_group_byline = 'empty group, the byline';
         $group3 = $f->group([], $empty_group_title, $empty_group_byline);
 
         $sg = $f->switchableGroup([$group1, $group2, $group3], $label, $byline);
 
         $expected = '<label for="id_3"><input type="radio" id="id_3" value="1" checked="checked" />';
         $this->assertStringContainsString($expected, $this->render($sg->withValue('1')));
     }

◆ testSwitchableGroupForwardsValuesOnWithValue()

SwitchableGroupInputTest::testSwitchableGroupForwardsValuesOnWithValue ( )

Definition at line 185 of file SwitchableGroupInputTest.php.

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

◆ testSwitchableGroupMayOnlyHaveGroupChildren()

SwitchableGroupInputTest::testSwitchableGroupMayOnlyHaveGroupChildren ( )

Definition at line 171 of file SwitchableGroupInputTest.php.

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

                                                                  : void
     {
         $this->expectException(InvalidArgumentException::class);
 
         $this->group = new SwitchableGroup(
             $this->data_factory,
             $this->refinery,
             $this->lng,
             [$this->createMock(I\Input\Field\FormInput::class)],
             "LABEL",
             "BYLINE"
         );
     }

Here is the call graph for this function:

◆ testWithDisabledDisablesChildren()

SwitchableGroupInputTest::testWithDisabledDisablesChildren ( )

Definition at line 131 of file SwitchableGroupInputTest.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->switchable_group->withDisabled(true);
 
         $this->assertEquals(["child1" => $this->child2, "child2" => $this->child1], $new_group->getInputs());
         $this->assertInstanceOf(SwitchableGroup::class, $new_group);
         $this->assertNotSame($this->switchable_group, $new_group);
     }

◆ testWithInputCallsChildrenAndAppliesOperations()

SwitchableGroupInputTest::testWithInputCallsChildrenAndAppliesOperations ( )

Definition at line 252 of file SwitchableGroupInputTest.php.

References ILIAS\Repository\refinery().

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

Here is the call graph for this function:

◆ testWithInputDoesNotAcceptUnknownKeys()

SwitchableGroupInputTest::testWithInputDoesNotAcceptUnknownKeys ( )

Definition at line 384 of file SwitchableGroupInputTest.php.

References ILIAS\Repository\refinery().

                                                            : void
     {
         $this->expectException(InvalidArgumentException::class);
 
         $input_data = $this->createMock(InputData::class);
 
         $input_data
             ->expects($this->once())
             ->method("getOr")
             ->with("name0")
             ->willReturn(123);
 
         $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");
 
         $this->switchable_group
             ->withAdditionalTransformation($this->refinery->custom()->transformation(function () use (&$called): void {
                 $this->fail("This should not happen.");
             }))
             ->withInput($input_data);
     }

Here is the call graph for this function:

◆ testWithInputDoesNotApplyOperationsOnError()

SwitchableGroupInputTest::testWithInputDoesNotApplyOperationsOnError ( )

Definition at line 304 of file SwitchableGroupInputTest.php.

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

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

Here is the call graph for this function:

◆ testWithRequiredDoesNotRequire()

SwitchableGroupInputTest::testWithRequiredDoesNotRequire ( )

Definition at line 153 of file SwitchableGroupInputTest.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->switchable_group->withRequired(true);
 
         $this->assertEquals(["child1" => $this->child1, "child2" => $this->child2], $new_group->getInputs());
         $this->assertInstanceOf(SwitchableGroup::class, $new_group);
         $this->assertNotSame($this->switchable_group, $new_group);
     }

Field Documentation

◆ $child1

SwitchableGroupInputTest::$child1

protected

Definition at line 55 of file SwitchableGroupInputTest.php.

◆ $child2

SwitchableGroupInputTest::$child2

protected

Definition at line 60 of file SwitchableGroupInputTest.php.

◆ $data_factory

Data Factory SwitchableGroupInputTest::$data_factory

protected

Definition at line 72 of file SwitchableGroupInputTest.php.

◆ $group

SwitchableGroup SwitchableGroupInputTest::$group

protected

Definition at line 75 of file SwitchableGroupInputTest.php.

◆ $lng

SwitchableGroupInputTest::$lng

protected

Definition at line 70 of file SwitchableGroupInputTest.php.

◆ $nested_child

SwitchableGroupInputTest::$nested_child

protected

Definition at line 65 of file SwitchableGroupInputTest.php.

◆ $refinery

Refinery SwitchableGroupInputTest::$refinery

protected

Definition at line 73 of file SwitchableGroupInputTest.php.

◆ $switchable_group

ILIAS UI Component Input Field Group SwitchableGroupInputTest::$switchable_group

protected

Definition at line 74 of file SwitchableGroupInputTest.php.

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

components/ILIAS/UI/tests/Component/Input/Field/SwitchableGroupInputTest.php

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ buildFactory()

◆ setUp()

◆ testCommonRendering()

◆ testErrorIsI18NOnError()

◆ testGroupForwardsValuesOnGetValue()

◆ testGroupOnlyDoesAcceptKeyOnly()

◆ testGroupOnlyDoesNoAcceptArrayValuesWithWrongLength()

◆ testGroupOnlyDoesNotAcceptInvalidKey()

◆ testGroupOnlyDoesNotAcceptNonArrayValue()

◆ testRender()

◆ testRenderWithValue()

◆ testRenderWithValueByIndex()

◆ testSwitchableGroupForwardsValuesOnWithValue()

◆ testSwitchableGroupMayOnlyHaveGroupChildren()

◆ testWithDisabledDisablesChildren()

◆ testWithInputCallsChildrenAndAppliesOperations()

◆ testWithInputDoesNotAcceptUnknownKeys()

◆ testWithInputDoesNotApplyOperationsOnError()

◆ testWithRequiredDoesNotRequire()

Field Documentation

◆ $child1

◆ $child2

◆ $data_factory

◆ $group

◆ $lng

◆ $nested_child

◆ $refinery

◆ $switchable_group