ilSessionTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\DI\Container;
use PHPUnit\Framework\TestCase;
 
class ilSessionTest extends TestCase
{
    private ?Container $dic_backup = null;
 
    protected function setUp(): void
    {
        global $DIC;
 
        $this->dic_backup = $DIC;
 
        if (!isset($DIC)) {
            $DIC = new Container();
        }
 
        $this->setGlobalVariable(
            'ilDB',
            $this->createMock(ilDBInterface::class)
        );
 
        parent::setUp();
    }
 
    protected function tearDown(): void
    {
        global $DIC;
 
        $DIC = $this->dic_backup;
 
        parent::tearDown();
    }
 
    protected function setGlobalVariable(string $name, $value): void
    {
        global $DIC;
 
        $GLOBALS[$name] = $value;
 
        unset($DIC[$name]);
        $DIC[$name] = static function (Container $c) use ($name) {
            return $GLOBALS[$name];
        };
    }
 
    public function testBasicSessionBehaviour(): void
    {
        global $DIC;
 
        $this->setGlobalVariable(
            'ilClientIniFile',
            $this->getMockBuilder(ilIniFile::class)->disableOriginalConstructor()->getMock()
        );
 
        $settings = $this->getMockBuilder(ilSetting::class)->getMock();
        $settings
            ->expects($this->once())
            ->method('get')
            ->willReturnCallback(
                function ($arg) {
                    if ($arg === 'session_statistics') {
                        return '0';
                    }
 
                    throw new RuntimeException($arg);
                }
            );
        $this->setGlobalVariable(
            'ilSetting',
            $settings
        );
 
        $ilDB = $DIC['ilDB'];
        $ilDB
            ->expects($this->atLeastOnce())
            ->method('update')
            ->with('usr_session')
            ->willReturn(1);
 
        $consecutive_quote = [
            '123456',
            '123456',
            '123456',
            'e10adc3949ba59abbe56e057f20f883e',
            '123456',
            'e10adc3949ba59abbe56e057f20f883e',
            'e10adc3949ba59abbe56e057f20f883e',
            '123456',
            '123456',
            '123456',
            time() - 100,
            'e10adc3949ba59abbe56e057f20f883e',
            17,
            'e10adc3949ba59abbe56e057f20f883e'
        ];
        $ilDB
            ->expects($this->exactly(count($consecutive_quote)))
            ->method('quote')
            ->with(
                $this->callback(function ($value) use (&$consecutive_quote) {
                    if (count($consecutive_quote) === 4) {
                        $this->assertGreaterThan(array_shift($consecutive_quote), $value);
                    } else {
                        $this->assertSame(array_shift($consecutive_quote), $value);
                    }
                    return true;
                })
            )->willReturnOnConsecutiveCalls(
                '123456',
                '123456',
                '123456',
                'e10adc3949ba59abbe56e057f20f883e',
                'e10adc3949ba59abbe56e057f20f883e',
                '123456',
                'e10adc3949ba59abbe56e057f20f883e',
                'e10adc3949ba59abbe56e057f20f883e',
                '123456',
                '123456',
                '123456',
                (string) time(),
                'e10adc3949ba59abbe56e057f20f883e',
                '17',
                'e10adc3949ba59abbe56e057f20f883e'
            );
        $ilDB
            ->expects($this->exactly(6))
            ->method('numRows')
            ->willReturn(1, 1, 1, 0, 1, 0);
 
        $consecutive_select = [
            'SELECT 1 FROM usr_session WHERE session_id = 123456',
            'SELECT 1 FROM usr_session WHERE session_id = 123456',
            'SELECT data FROM usr_session WHERE session_id = 123456',
            'SELECT * FROM usr_session WHERE session_id = e10adc3949ba59abbe56e057f20f883e',
            'SELECT * FROM usr_session WHERE session_id = e10adc3949ba59abbe56e057f20f883e',
            'SELECT 1 FROM usr_session WHERE session_id = 123456',
            'SELECT data FROM usr_session WHERE session_id = e10adc3949ba59abbe56e057f20f883e',
            'SELECT 1 FROM usr_session WHERE session_id = 123456',
            'SELECT session_id, expires FROM usr_session WHERE expires < 123456',
            'SELECT 1 FROM usr_session WHERE session_id = ',
            'SELECT 1 FROM usr_session WHERE session_id = 17'
        ];
        $ilDB
            ->expects($this->exactly(count($consecutive_select)))
            ->method('query')
            ->with(
                $this->callback(function ($value) use (&$consecutive_select) {
                    if (count($consecutive_select) === 2) {
                        $this->assertStringStartsWith(array_shift($consecutive_select), $value);
                    } else {
                        $this->assertSame(array_shift($consecutive_select), $value);
                    }
                    return true;
                })
            )->willReturnOnConsecutiveCalls(
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class),
                $this->createMock(ilDBStatement::class)
            );
        $ilDB
            ->expects($this->exactly(4))
            ->method('fetchAssoc')->willReturn(
                ['data' => 'Testdata'],
                [],
                ['data' => 'Testdata'],
                []
            );
        $ilDB
            ->expects($this->once())
            ->method('fetchObject')->willReturn(
                (object) [
                    'data' => 'Testdata'
                ]
            );
 
        $consecutive_delete = [
            'DELETE FROM usr_sess_istorage WHERE session_id = 123456',
            'DELETE FROM usr_session WHERE session_id = e10adc3949ba59abbe56e057f20f883e',
            'DELETE FROM usr_session WHERE user_id = e10adc3949ba59abbe56e057f20f883e'
        ];
        $ilDB
            ->expects($this->exactly(count($consecutive_delete)))
            ->method('manipulate')->with(
                $this->callback(function ($value) use (&$consecutive_delete) {
                    $this->assertSame(array_shift($consecutive_delete), $value);
                    return true;
                })
            )->willReturnOnConsecutiveCalls(
                1,
                1,
                1
            );
 
        $cron_manager = $this->createMock(\ILIAS\Cron\Job\JobManager::class);
        $cron_manager
            ->expects($this->atLeastOnce())
            ->method('isJobActive')
            ->with($this->isString())
            ->willReturn(true);
        $this->setGlobalVariable(
            'cron.manager',
            $cron_manager
        );
 
        $result = '';
        ilSession::writeData('123456', 'Testdata');
        if (ilSession::exists('123456')) {
            $result .= 'exists-';
        }
        if (ilSession::getData('123456') === 'Testdata') {
            $result .= 'write-get-';
        }
        $duplicate = ilSession::duplicate('123456');
        if (ilSession::getData($duplicate) === 'Testdata') {
            $result .= 'duplicate-';
        }
        ilSession::destroy('123456');
        if (!ilSession::exists('123456')) {
            $result .= 'destroy-';
        }
        ilSession::destroyExpiredSessions();
        if (ilSession::exists($duplicate)) {
            $result .= 'destroyExp-';
        }
 
        ilSession::destroyByUserId(17);
        if (!ilSession::exists($duplicate)) {
            $result .= 'destroyByUser-';
        }
 
        $this->assertEquals('exists-write-get-duplicate-destroy-destroyExp-destroyByUser-', $result);
    }
 
    public function testPasswordAssisstanceSession(): void
    {
        $actual = '';
        $usr_id = 4711;
 
        try {
            $sqlite = new PDO('sqlite::memory:');
            $create_table = <<<SQL
create table usr_pwassist
(
    pwassist_id char(180) default '' not null primary key,
    expires     int       default 0  not null,
    ctime       int       default 0  not null,
    user_id     int       default 0  not null,
    constraint c1_idx
        unique (user_id)
);
SQL;
 
            $sqlite->query($create_table);
        } catch (Exception $e) {
            $this->markTestIncomplete(
                'Cannot test the password assistance session storage because of missing sqlite: ' . $e->getMessage()
            );
        }
 
        $db = $this->createMock(ilDBInterface::class);
        $db->method('quote')->willReturnCallback(static function ($value, ?string $type = null) use ($sqlite): string {
            if ($value === null) {
                return 'NULL';
            }
 
            $pdo_type = PDO::PARAM_STR;
            switch ($type) {
                case ilDBConstants::T_TIMESTAMP:
                case ilDBConstants::T_DATETIME:
                case ilDBConstants::T_DATE:
                    if ($value === '') {
                        return 'NULL';
                    }
                    if ($value === 'NOW()') {
                        return $value;
                    }
                    $value = (string) $value;
                    break;
                case ilDBConstants::T_INTEGER:
                    return (string) (int) $value;
                case ilDBConstants::T_FLOAT:
                    $pdo_type = PDO::PARAM_INT;
                    $value = (string) $value;
                    break;
                case ilDBConstants::T_TEXT:
                default:
                    $value = (string) $value;
                    $pdo_type = PDO::PARAM_STR;
                    break;
            }
 
            return $sqlite->quote((string) $value, $pdo_type);
        });
        $db->method('query')->willReturnCallback(static function (string $query) use ($sqlite): ilDBStatement {
            return new ilPDOStatement($sqlite->query($query));
        });
        $db->method('manipulate')->willReturnCallback(static function (string $query) use ($sqlite): int {
            return (int) $sqlite->exec($query);
        });
        $db->method('manipulateF')->willReturnCallback(static function (...$args) use ($db): int {
            $query = $args[0];
 
            $quoted_values = [];
            foreach ($args[1] as $k => $t) {
                $quoted_values[] = $db->quote($args[2][$k], $t);
            }
            $query = vsprintf($query, $quoted_values);
 
            return $db->manipulate($query);
        });
        $db->method('fetchAssoc')->willReturnCallback(static function (ilDBStatement $statement): ?array {
            $res = $statement->fetch(PDO::FETCH_ASSOC);
            if ($res === null || $res === false) {
                $statement->closeCursor();
 
                return null;
            }
 
            return $res;
        });
 
        $pwa_repository = new \ILIAS\Init\PasswordAssitance\Repository\PasswordAssistanceDbRepository(
            $db,
            (new \ILIAS\Data\Factory())->clock()->system()
        );
 
        $hash = new \ILIAS\Init\PasswordAssitance\ValueObject\PasswordAssistanceHash(
            'ae869e66007cc9812f1752f7a3a59f07d3e28bed8361827d0a05563e5c2f4b11'
        );
        $session = $pwa_repository->createSession(
            $hash,
            (new \ILIAS\Data\Factory())->objId($usr_id)
        );
 
        $result = $pwa_repository->getSessionByUsrId($session->usrId());
        if ($result->value()->hash()->value() === $session->hash()->value()) {
            $actual .= 'find-';
        }
 
        $result = $pwa_repository->getSessionByHash($session->hash());
        if ($result->value()->usrId()->toInt() === $usr_id) {
            $actual .= 'read-';
        }
 
        $pwa_repository->deleteSession($session);
        $result = $pwa_repository->getSessionByHash($session->hash());
        if ($result->isError()) {
            $actual .= 'destroy-';
        }
 
        $this->assertEquals('find-read-destroy-', $actual);
 
        $sqlite = null;
    }
 
    public function testUpdateTimestampTouchesExpiryWithoutRewritingPayload(): void
    {
        $client_ini = $this->getMockBuilder(ilIniFile::class)->disableOriginalConstructor()->getMock();
        $client_ini
            ->expects($this->once())
            ->method('readVariable')
            ->with('session', 'expire')
            ->willReturn('1800');
        $this->setGlobalVariable('ilClientIniFile', $client_ini);
 
        $ilDB = $GLOBALS['DIC']['ilDB'];
 
        $before = time();
        $ilDB
            ->expects($this->once())
            ->method('update')
            ->with(
                'usr_session',
                $this->callback(static function (array $values) use ($before): bool {
                    if (array_key_exists('data', $values) || array_key_exists('user_id', $values)) {
                        return false;
                    }
 
                    $expires = $values['expires'][1] ?? null;
                    $ctime = $values['ctime'][1] ?? null;
 
                    return $values['expires'][0] === ilDBConstants::T_INTEGER
                        && $values['ctime'][0] === ilDBConstants::T_INTEGER
                        && is_int($expires)
                        && $expires >= $before + 1800
                        && $expires <= time() + 1800
                        && is_int($ctime)
                        && $ctime >= $before
                        && $ctime <= time();
                }),
                ['session_id' => [ilDBConstants::T_TEXT, 'known-session-id']]
            )
            ->willReturn(1);
 
        self::assertTrue(ilSession::updateTimestamp('known-session-id'));
    }
 
    public function testUpdateTimestampSkipsEmptySessionId(): void
    {
        $ilDB = $GLOBALS['DIC']['ilDB'];
        $ilDB->expects($this->never())->method('update');
 
        self::assertTrue(ilSession::updateTimestamp(''));
    }
 
    public function testUpdateTimestampSkipsWebAccessWithoutSession(): void
    {
        $ilDB = $GLOBALS['DIC']['ilDB'];
        $ilDB->expects($this->never())->method('update');
 
        ilSession::enableWebAccessWithoutSession(true);
        try {
            self::assertTrue(ilSession::updateTimestamp('wac-session-id'));
        } finally {
            ilSession::enableWebAccessWithoutSession(false);
        }
    }
 
    public function testHandlerKeepsExistingSessionOnTimestampUpdate(): void
    {
        $client_ini = $this->getMockBuilder(ilIniFile::class)->disableOriginalConstructor()->getMock();
        $client_ini
            ->expects($this->once())
            ->method('readVariable')
            ->with('session', 'expire')
            ->willReturn('1800');
        $this->setGlobalVariable('ilClientIniFile', $client_ini);
 
        $ilDB = $GLOBALS['DIC']['ilDB'];
        $ilDB->expects($this->once())->method('update')->willReturn(1);
        $ilDB->expects($this->never())->method('manipulate');
 
        $handler = new ilSessionDBHandler();
 
        self::assertTrue($handler->updateTimestamp('known-session-id', 'unchanged-payload'));
    }
 
    public function testHandlerStoresPayloadWhenTimestampUpdateMatchesNoRow(): void
    {
        ilSession::enableWebAccessWithoutSession(false);
 
        $client_ini = $this->createStub(ilIniFile::class);
        $client_ini->method('readVariable')->willReturnCallback(
            static function (string $group, string $key): string {
                if ($group === 'session' && $key === 'expire') {
                    return '1800';
                }
 
                return '';
            }
        );
        $this->setGlobalVariable('ilClientIniFile', $client_ini);
 
        $cron_manager = $this->createMock(\ILIAS\Cron\Job\JobManager::class);
        $cron_manager
            ->expects($this->once())
            ->method('isJobActive')
            ->with('auth_destroy_expired_sessions')
            ->willReturn(true);
        $this->setGlobalVariable('cron.manager', $cron_manager);
 
        $ilDB = $GLOBALS['DIC']['ilDB'];
        $ilDB->expects($this->once())->method('update')->willReturn(0);
        $ilDB->method('quote')->willReturnCallback(
            static fn(mixed $value, ?string $type = null): string => '[' . (string) $value . ']'
        );
        $ilDB->expects($this->once())->method('query')->willReturn($this->createStub(ilDBStatement::class));
        $ilDB->expects($this->once())->method('numRows')->willReturn(0);
        $ilDB
            ->expects($this->once())
            ->method('manipulate')
            ->with($this->callback(static function (string $sql): bool {
                return str_contains($sql, 'INSERT INTO usr_session')
                    && str_contains($sql, '[expired-session-id]')
                    && str_contains($sql, '[expired-flag-payload]');
            }))
            ->willReturn(1);
 
        $working_directory = getcwd();
        if (is_string($working_directory) && !defined('IL_INITIAL_WD')) {
            define('IL_INITIAL_WD', $working_directory);
        }
 
        try {
            $handler = new ilSessionDBHandler();
 
            self::assertTrue($handler->updateTimestamp('expired-session-id', 'expired-flag-payload'));
        } finally {
            if (is_string($working_directory)) {
                chdir($working_directory);
            }
        }
    }
}