1
0
mirror of https://github.com/moodle/moodle.git synced 2025-03-28 19:42:56 +01:00
moodle/lib/tests/session_redis_test.php
Eloy Lafuente (stronk7) 83b490a594 MDL-75111 phpunit: Move tests to use correct names and ns (take#4)
Applied the following changes to various testcase classes:

- Namespaced with component[\level2-API]
- Moved to level2-API subdirectory when required.
- Fixed incorrect use statements with leading backslash.
- Remove file phpdoc block
- Remove MOODLE_INTERNAL if not needed.
- Changed code to point to global scope when needed.
- Fix some relative paths and comments here and there.
- All them passing individually.
- Complete runs passing too.

Special mention to:

- The following task tests have been moved within the level2 directory:
  - \core\adhoc_task_test => \core\task\adhoc_task_test
  - \core\scheduled_task_test => \core\task\scheduled_task_test
  - \core\calendar_cron_task_test => \core\task\calendar_cron_task_test
  - \core\h5p_get_content_types_task_test => \core\task\h5p_get_content_types_task_test
  - \core\task_database_logger_test => \core\task\database_logger_test
  - \core\task_logging_test => \core\task\logging_test

- The following event tests have been moved within level2 directory:
  - \core\event_context_locked_test => \core\event\context_locked_test
  - \core\event_deprecated_test => \core\event\deprecated_test
  - \core\event_grade_deleted_test => \core\event\grade_deleted_test
  - \core\event_profile_field_test => \core\event\profile_field_test
  - \core\event_unknown_logged_test => \core\event\unknown_logged_test
  - \core\event_user_graded_test => \core\event\user_graded_test
  - \core\event_user_password_updated_test => \core\event\user_password_updated_test

- The following output tests have been moved within level2 directory:
  - \core\mustache_template_finder_test => \core\output\mustache_template_finder_test
  - \core\mustache_template_source_loader_test => \core\output\mustache_template_source_loader_test
  - \core\output_mustache_helper_collection_test => \core\output\mustache_helper_collection_test

- The following tests have been moved to their correct tests directories:
  - lib/tests/time_splittings_test.php => analytics/tests/time_splittings_test.php

- All the classes and tests under lib/filebrowser and lib/filestorage
  belong to core, not to core_files. Some day we should move
  them to their correct subsystem.
- All the classes and tests under lib/grade belong to core, not
  to core_grades. Some day we should move them to their correct
  subsystem.
- The core_grades_external class and its \core\grades_external_test
  unit test should belong to the grades subsystem or, alternatively,
  to \core\external, they both should be moved together.
- The core_grading_external class and its \core\grading_external_test
  unit test should belong to the grading subsystem or, alternatively,
  to \core\external, they both should be moved together.
- The \core\message\message and \core\message\inbound (may be others)
  classes, and their associated tests should go to the core_message
  subsystem.
- The core_user class, and its associated tests should go to the
  core_user subsystem.
- The \core\update namespace is plain wrong (update is not valid API)
  and needs action 1) create it or 2) move elsewhere.
2022-08-26 16:34:20 +02:00

340 lines
14 KiB
PHP

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
namespace core;
use Redis;
use RedisException;
/**
* Unit tests for classes/session/redis.php.
*
* NOTE: in order to execute this test you need to set up
* Redis server and add configuration a constant
* to config.php or phpunit.xml configuration file:
*
* define('TEST_SESSION_REDIS_HOST', '127.0.0.1');
*
* @package core
* @author Russell Smith <mr-russ@smith2001.net>
* @copyright 2016 Russell Smith
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @runClassInSeparateProcess
*/
class session_redis_test extends \advanced_testcase {
/** @var $keyprefix This key prefix used when testing Redis */
protected $keyprefix = null;
/** @var $redis The current testing redis connection */
protected $redis = null;
/** @var int $acquiretimeout how long we wait for session lock in seconds when testing Redis */
protected $acquiretimeout = 1;
/** @var int $lockexpire how long to wait in seconds before expiring the lock when testing Redis */
protected $lockexpire = 70;
public function setUp(): void {
global $CFG;
if (!extension_loaded('redis')) {
$this->markTestSkipped('Redis extension not loaded.');
}
if (!defined('TEST_SESSION_REDIS_HOST')) {
$this->markTestSkipped('Session test server not set. define: TEST_SESSION_REDIS_HOST');
}
$version = phpversion('Redis');
if (!$version) {
$this->markTestSkipped('Redis extension version missing');
} else if (version_compare($version, '2.0') <= 0) {
$this->markTestSkipped('Redis extension version must be at least 2.0: now running "' . $version . '"');
}
$this->resetAfterTest();
$this->keyprefix = 'phpunit'.rand(1, 100000);
$CFG->session_redis_host = TEST_SESSION_REDIS_HOST;
$CFG->session_redis_prefix = $this->keyprefix;
// Set a very short lock timeout to ensure tests run quickly. We are running single threaded,
// so unless we lock and expect it to be there, we will always see a lock.
$CFG->session_redis_acquire_lock_timeout = $this->acquiretimeout;
$CFG->session_redis_lock_expire = $this->lockexpire;
$this->redis = new Redis();
$this->redis->connect(TEST_SESSION_REDIS_HOST);
}
public function tearDown(): void {
if (!extension_loaded('redis') || !defined('TEST_SESSION_REDIS_HOST')) {
return;
}
$list = $this->redis->keys($this->keyprefix.'*');
foreach ($list as $keyname) {
$this->redis->del($keyname);
}
$this->redis->close();
}
public function test_normal_session_read_only() {
$sess = new \core\session\redis();
$sess->set_requires_write_lock(false);
$sess->init();
$this->assertSame('', $sess->handler_read('sess1'));
$this->assertTrue($sess->handler_close());
}
public function test_normal_session_start_stop_works() {
$sess = new \core\session\redis();
$sess->init();
$sess->set_requires_write_lock(true);
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess->handler_read('sess1'));
$this->assertTrue($sess->handler_write('sess1', 'DATA'));
$this->assertTrue($sess->handler_close());
// Read the session again to ensure locking did what it should.
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('DATA', $sess->handler_read('sess1'));
$this->assertTrue($sess->handler_write('sess1', 'DATA-new'));
$this->assertTrue($sess->handler_close());
$this->assertSessionNoLocks();
}
public function test_compression_read_and_write_works() {
global $CFG;
$CFG->session_redis_compressor = \core\session\redis::COMPRESSION_GZIP;
$sess = new \core\session\redis();
$sess->init();
$this->assertTrue($sess->handler_write('sess1', 'DATA'));
$this->assertSame('DATA', $sess->handler_read('sess1'));
$this->assertTrue($sess->handler_close());
if (extension_loaded('zstd')) {
$CFG->session_redis_compressor = \core\session\redis::COMPRESSION_ZSTD;
$sess = new \core\session\redis();
$sess->init();
$this->assertTrue($sess->handler_write('sess2', 'DATA'));
$this->assertSame('DATA', $sess->handler_read('sess2'));
$this->assertTrue($sess->handler_close());
}
$CFG->session_redis_compressor = \core\session\redis::COMPRESSION_NONE;
}
public function test_session_blocks_with_existing_session() {
$sess = new \core\session\redis();
$sess->init();
$sess->set_requires_write_lock(true);
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess->handler_read('sess1'));
$this->assertTrue($sess->handler_write('sess1', 'DATA'));
$this->assertTrue($sess->handler_close());
// Sessions are not locked until they have been saved once.
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('DATA', $sess->handler_read('sess1'));
$sessblocked = new \core\session\redis();
$sessblocked->init();
$sessblocked->set_requires_write_lock(true);
$this->assertTrue($sessblocked->handler_open('Not used', 'Not used'));
// Trap the error log and send it to stdOut so we can expect output at the right times.
$errorlog = tempnam(sys_get_temp_dir(), "rediserrorlog");
$this->iniSet('error_log', $errorlog);
try {
$sessblocked->handler_read('sess1');
$this->fail('Session lock must fail to be obtained.');
} catch (\core\session\exception $e) {
$this->assertStringContainsString("Unable to obtain lock for session id sess1", $e->getMessage());
$this->assertStringContainsString('within 1 sec.', $e->getMessage());
$this->assertStringContainsString('session lock timeout (1 min 10 secs) ', $e->getMessage());
$this->assertStringContainsString('Cannot obtain session lock for sid: sess1', file_get_contents($errorlog));
}
$this->assertTrue($sessblocked->handler_close());
$this->assertTrue($sess->handler_write('sess1', 'DATA-new'));
$this->assertTrue($sess->handler_close());
$this->assertSessionNoLocks();
}
public function test_session_is_destroyed_when_it_does_not_exist() {
$sess = new \core\session\redis();
$sess->init();
$sess->set_requires_write_lock(true);
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertTrue($sess->handler_destroy('sess-destroy'));
$this->assertSessionNoLocks();
}
public function test_session_is_destroyed_when_we_have_it_open() {
$sess = new \core\session\redis();
$sess->init();
$sess->set_requires_write_lock(true);
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess->handler_read('sess-destroy'));
$this->assertTrue($sess->handler_destroy('sess-destroy'));
$this->assertTrue($sess->handler_close());
$this->assertSessionNoLocks();
}
public function test_multiple_sessions_do_not_interfere_with_each_other() {
$sess1 = new \core\session\redis();
$sess1->set_requires_write_lock(true);
$sess1->init();
$sess2 = new \core\session\redis();
$sess2->set_requires_write_lock(true);
$sess2->init();
// Initialize session 1.
$this->assertTrue($sess1->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess1->handler_read('sess1'));
$this->assertTrue($sess1->handler_write('sess1', 'DATA'));
$this->assertTrue($sess1->handler_close());
// Initialize session 2.
$this->assertTrue($sess2->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess2->handler_read('sess2'));
$this->assertTrue($sess2->handler_write('sess2', 'DATA2'));
$this->assertTrue($sess2->handler_close());
// Open and read session 1 and 2.
$this->assertTrue($sess1->handler_open('Not used', 'Not used'));
$this->assertSame('DATA', $sess1->handler_read('sess1'));
$this->assertTrue($sess2->handler_open('Not used', 'Not used'));
$this->assertSame('DATA2', $sess2->handler_read('sess2'));
// Write both sessions.
$this->assertTrue($sess1->handler_write('sess1', 'DATAX'));
$this->assertTrue($sess2->handler_write('sess2', 'DATA2X'));
// Read both sessions.
$this->assertTrue($sess1->handler_open('Not used', 'Not used'));
$this->assertTrue($sess2->handler_open('Not used', 'Not used'));
$this->assertEquals('DATAX', $sess1->handler_read('sess1'));
$this->assertEquals('DATA2X', $sess2->handler_read('sess2'));
// Close both sessions
$this->assertTrue($sess1->handler_close());
$this->assertTrue($sess2->handler_close());
// Read the session again to ensure locking did what it should.
$this->assertSessionNoLocks();
}
public function test_multiple_sessions_work_with_a_single_instance() {
$sess = new \core\session\redis();
$sess->init();
$sess->set_requires_write_lock(true);
// Initialize session 1.
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess->handler_read('sess1'));
$this->assertTrue($sess->handler_write('sess1', 'DATA'));
$this->assertSame('', $sess->handler_read('sess2'));
$this->assertTrue($sess->handler_write('sess2', 'DATA2'));
$this->assertSame('DATA', $sess->handler_read('sess1'));
$this->assertSame('DATA2', $sess->handler_read('sess2'));
$this->assertTrue($sess->handler_destroy('sess2'));
$this->assertTrue($sess->handler_close());
$this->assertSessionNoLocks();
$this->assertTrue($sess->handler_close());
}
public function test_session_exists_returns_valid_values() {
$sess = new \core\session\redis();
$sess->init();
$sess->set_requires_write_lock(true);
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertSame('', $sess->handler_read('sess1'));
$this->assertFalse($sess->session_exists('sess1'), 'Session must not exist yet, it has not been saved');
$this->assertTrue($sess->handler_write('sess1', 'DATA'));
$this->assertTrue($sess->session_exists('sess1'), 'Session must exist now.');
$this->assertTrue($sess->handler_destroy('sess1'));
$this->assertFalse($sess->session_exists('sess1'), 'Session should be destroyed.');
}
public function test_kill_sessions_removes_the_session_from_redis() {
global $DB;
$sess = new \core\session\redis();
$sess->init();
$this->assertTrue($sess->handler_open('Not used', 'Not used'));
$this->assertTrue($sess->handler_write('sess1', 'DATA'));
$this->assertTrue($sess->handler_write('sess2', 'DATA'));
$this->assertTrue($sess->handler_write('sess3', 'DATA'));
$sessiondata = new \stdClass();
$sessiondata->userid = 2;
$sessiondata->timecreated = time();
$sessiondata->timemodified = time();
$sessiondata->sid = 'sess1';
$DB->insert_record('sessions', $sessiondata);
$sessiondata->sid = 'sess2';
$DB->insert_record('sessions', $sessiondata);
$sessiondata->sid = 'sess3';
$DB->insert_record('sessions', $sessiondata);
$this->assertNotEquals('', $sess->handler_read('sess1'));
$sess->kill_session('sess1');
$this->assertEquals('', $sess->handler_read('sess1'));
$this->assertEmpty($this->redis->keys($this->keyprefix.'sess1.lock'));
$sess->kill_all_sessions();
$this->assertEquals(3, $DB->count_records('sessions'), 'Moodle handles session database, plugin must not change it.');
$this->assertSessionNoLocks();
$this->assertEmpty($this->redis->keys($this->keyprefix.'*'), 'There should be no session data left.');
}
public function test_exception_when_connection_attempts_exceeded() {
global $CFG;
$CFG->session_redis_port = 111111;
$actual = '';
$sess = new \core\session\redis();
try {
$sess->init();
} catch (RedisException $e) {
$actual = $e->getMessage();
}
$expected = 'Failed to connect (try 5 out of 5) to redis at ' . TEST_SESSION_REDIS_HOST . ':111111';
$this->assertDebuggingCalledCount(5);
$this->assertStringContainsString($expected, $actual);
}
/**
* Assert that we don't have any session locks in Redis.
*/
protected function assertSessionNoLocks() {
$this->assertEmpty($this->redis->keys($this->keyprefix.'*.lock'));
}
}