CapabilityTest Class Reference

Inheritance diagram for CapabilityTest:

Collaboration diagram for CapabilityTest:

Public Member Functions
	testCapabilityPriority (bool $wopi_view, bool $wopi_edit, bool $infopage_first, array $user_permissions, Capabilities $expected_best)

Static Public Member Functions
static	tearDownAfterClass ()
static	environmentProvider ()

Data Fields
MockObject	$workspace_access_handler
MockObject	$type_resolver

Protected Member Functions
	setUp ()
	tearDown ()

Static Private Member Functions
static	updateREADME ()
static	arrayToMarkdownTable (array $data)

Private Attributes
MockObject	$file_info_repository
MockObject	$access
MockObject	$action_repository
CapabilityBuilder	$capability_builder

Static Private Attributes
static array	$readme_infos = []
static bool	$update_readme = false

Detailed Description

Definition at line 33 of file CapabilityTest.php.

Member Function Documentation

arrayToMarkdownTable()

static CapabilityTest::arrayToMarkdownTable ( array  $data )

staticprivate

Definition at line 316 of file CapabilityTest.php.

                                                             : string
    {
        // Check if the input array is valid
        if (empty($data) || !is_array($data[0])) {
            throw new InvalidArgumentException("Input must be a non-empty array of arrays.");
        }
 
        // Calculate the maximum width of each column
        $col_widths = array_map(
            static fn(int|string $col_index): int => max(
                array_map(
                    static fn(array $row): int => isset($row[$col_index]) ? mb_strlen((string) $row[$col_index]) : 0,
                    $data
                )
            ),
            array_keys($data[0])
        );
 
        // Function to pad a row's columns to match the maximum width
        $pad_row = static fn($row): array => array_map(static function ($value, $index) use ($col_widths): string {
            $value ??= ''; // Handle missing values
            return str_pad($value, $col_widths[$index], " ", STR_PAD_RIGHT);
        }, $row, array_keys($col_widths));
 
        // Format the header and rows
        $header = $pad_row($data[0]);
        $rows = array_map($pad_row, array_slice($data, 1));
 
        // Build the Markdown table
        $header_row = "| "
            . implode(" | ", $header)
            . " |";
        $sep_row = "| "
            . implode(" | ", array_map(static fn(int $width): string => str_repeat("-", $width), $col_widths))
            . " |";
        $data_rows = array_map(static fn($row): string => "| " . implode(" | ", $row) . " |", $rows);
 
        // Combine all parts
        return implode("\n", array_merge([$header_row, $sep_row], $data_rows));
    }

References $data.

environmentProvider()

static CapabilityTest::environmentProvider ( )

static

Definition at line 92 of file CapabilityTest.php.

                                                : \Iterator
    {
        yield 'testerei' => [
            true,
            true,
            true,
            [
                Permissions::READ,
                Permissions::WRITE,
                Permissions::VISIBLE,
                Permissions::EDIT_CONTENT,
                Permissions::VIEW_CONTENT
            ],
            Capabilities::FORCED_INFO_PAGE
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::READ,
                Permissions::WRITE,
                Permissions::VISIBLE,
                Permissions::EDIT_CONTENT,
                Permissions::VIEW_CONTENT
            ],
            Capabilities::VIEW_EXTERNAL
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::EDIT_CONTENT,
                Permissions::VIEW_CONTENT
            ],
            Capabilities::VIEW_EXTERNAL
        ];
        yield [
            false,
            false,
            true,
            [
                Permissions::READ,
                Permissions::VISIBLE
            ],
            Capabilities::FORCED_INFO_PAGE
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::EDIT_CONTENT,
            ],
            Capabilities::EDIT_EXTERNAL
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::READ,
            ],
            Capabilities::DOWNLOAD
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::WRITE,
                Permissions::READ,
            ],
            Capabilities::DOWNLOAD
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::WRITE,
            ],
            Capabilities::MANAGE_VERSIONS
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::VISIBLE,
            ],
            Capabilities::INFO_PAGE
        ];
        yield [
            true,
            true,
            true,
            [
                Permissions::WRITE,
                Permissions::READ,
            ],
            Capabilities::FORCED_INFO_PAGE
        ];
        yield [
            true,
            true,
            false,
            [
                Permissions::NONE,
            ],
            Capabilities::NONE
        ];
        yield 'docu_case' => [
            true,
            true,
            true,
            [
                Permissions::READ,
                Permissions::VISIBLE,
            ],
            Capabilities::FORCED_INFO_PAGE
        ];
    }

setUp()

CapabilityTest::setUp ( )

protected

Definition at line 49 of file CapabilityTest.php.

                              : void
    {
        if (!defined('ILIAS_HTTP_PATH')) {
            define('ILIAS_HTTP_PATH', 'https://ilias.unit.test');
        }
 
        $this->file_info_repository = $this->createMock(\ilObjFileInfoRepository::class);
        $this->access = $this->createMock(\ilAccessHandler::class);
        $ctrl = $this->createMock(\ilCtrlInterface::class);
        $this->action_repository = $this->createMock(ActionRepository::class);
        $http = $this->createMock(Services::class);
        $static_url = $this->createMock(URIBuilder::class);
        $this->type_resolver = $this->createMock(TypeResolver::class);
        $this->workspace_access_handler = $this->createMock(ilWorkspaceAccessHandler::class);
 
        $this->type_resolver->method('resolveTypeByObjectId')
                            ->withAnyParameters()
                            ->willReturn('file');
 
        $this->capability_builder = new CapabilityBuilder(
            $this->file_info_repository,
            $this->access,
            $ctrl,
            $this->action_repository,
            $http,
            $static_url,
            $this->type_resolver,
            $this->workspace_access_handler
        );
    }

References $http, $static_url, and ILIAS\Repository\access().

Here is the call graph for this function:

tearDown()

CapabilityTest::tearDown ( )

protected

Definition at line 80 of file CapabilityTest.php.

                                 : void
    {
    }

tearDownAfterClass()

static CapabilityTest::tearDownAfterClass ( )

static

Definition at line 84 of file CapabilityTest.php.

                                               : void
    {
        if (!self::$update_readme) {
            return;
        }
        self::updateREADME();
    }

References updateREADME().

Here is the call graph for this function:

testCapabilityPriority()

CapabilityTest::testCapabilityPriority	(	bool	$wopi_view,
		bool	$wopi_edit,
		bool	$infopage_first,
		array	$user_permissions,
		Capabilities	$expected_best
	)

Definition at line 218 of file CapabilityTest.php.

     : void {
        static $id;
        $permissions = $user_permissions;
 
        $id++;
 
        $context = new Context(
            $id,
            $id,
            Context::CONTEXT_REPO
        );
 
        $this->access->method('checkAccess')
                     ->willReturnCallback(
                         function (string $permission) use ($permissions): bool {
                             $checked_permissions = explode(',', $permission);
                             $common_permissions = array_intersect(
                                 array_map(static fn(Permissions $p): string => $p->value, $permissions),
                                 $checked_permissions
                             );
                             return $common_permissions !== [];
                         }
                     );
 
        $file_info = $this->createMock(\ilObjFileInfo::class);
        $file_info->method('shouldDownloadDirectly')
                  ->willReturn(!$infopage_first);
 
        $this->file_info_repository->method('getByObjectId')
                                   ->with($context->getObjectId())
                                   ->willReturn($file_info);
 
        $this->action_repository->method('hasEditActionForSuffix')
                                ->willReturn($wopi_edit);
 
        $this->action_repository->method('hasViewActionForSuffix')
                                ->willReturn($wopi_view);
 
        $capabilities = $this->capability_builder->get($context);
        $best = $capabilities->getBest();
 
        $this->assertEquals($expected_best, $best->getCapability());
 
        self::$readme_infos[] = [
            implode(', ', array_map(fn(Permissions $p): string => $p->value, $permissions)), // permissions
            ($wopi_view ? 'Yes' : 'No'),
            ($wopi_edit ? 'Yes' : 'No'),
            ($infopage_first ? 'Info-Page' : 'Open'),
            $best->getCapability()->name
        ];
    }

updateREADME()

static CapabilityTest::updateREADME ( )

staticprivate

Definition at line 276 of file CapabilityTest.php.

                                          : void
    {
        // UPDATE README
        $readme_file = __DIR__ . '/../../docs/README.md';
        $readme_content = file_get_contents($readme_file);
 
        $table = [
            [
                'User\'s Permissions',
                'WOPI View Action av.',
                'WOPI Edit Action av.',
                'Click-Setting',
                'Expected Capability'
            ]
        ];
        $readme_infos = self::$readme_infos;
        // sort $readme_infos by last column
        usort($readme_infos, static function ($a, $b): int {
            $a_string = implode('', array_reverse($a));
            $b_string = implode('', array_reverse($b));
 
            return strcmp($a_string, $b_string);
        });
 
        $table = array_merge($table, $readme_infos);
 
        // Define the markers for the block
        $start_marker = "<!-- START CAPABILITY_TABLE -->";
        $end_marker = "<!-- END CAPABILITY_TABLE -->";
 
        // Prepare the new block content
        $new_block = $start_marker . "\n\n" . self::arrayToMarkdownTable($table) . "\n\n" . $end_marker;
 
        // Replace the content between the markers
        $pattern = '/' . preg_quote($start_marker, '/') . '.*?' . preg_quote($end_marker, '/') . '/s';
        $readme_content = preg_replace($pattern, $new_block, $readme_content);
 
        file_put_contents($readme_file, $readme_content);
    }

References Vendor\Package\$a, and Vendor\Package\$b.

Referenced by tearDownAfterClass().

Here is the caller graph for this function:

Field Documentation

$access

MockObject CapabilityTest::$access

private

Definition at line 41 of file CapabilityTest.php.

$action_repository

MockObject CapabilityTest::$action_repository

private

Definition at line 42 of file CapabilityTest.php.

$capability_builder

CapabilityBuilder CapabilityTest::$capability_builder

private

Definition at line 43 of file CapabilityTest.php.

$file_info_repository

MockObject CapabilityTest::$file_info_repository

private

Definition at line 40 of file CapabilityTest.php.

$readme_infos

array CapabilityTest::$readme_infos = []

staticprivate

Definition at line 45 of file CapabilityTest.php.

$type_resolver

MockObject CapabilityTest::$type_resolver

Definition at line 39 of file CapabilityTest.php.

$update_readme

bool CapabilityTest::$update_readme = false

staticprivate

Definition at line 47 of file CapabilityTest.php.

$workspace_access_handler

MockObject CapabilityTest::$workspace_access_handler

Definition at line 38 of file CapabilityTest.php.

---

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

• components/ILIAS/File/tests/Capabilities/CapabilityTest.php