mirror of
https://github.com/moodle/moodle.git
synced 2025-02-26 13:03:53 +01:00
01148a0816
While this change is not 100% required now, it's good habit and we are checking for it since Moodle 4.4. All the changes in this commit have been applied automatically using the moodle.PHPUnit.TestReturnType sniff and are, exclusively adding the ": void" return types when missing.
381 lines
13 KiB
PHP
381 lines
13 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 phpunit_util;
|
|
|
|
/**
|
|
* Test basic_testcase extra features and PHPUnit Moodle integration.
|
|
*
|
|
* @package core
|
|
* @category test
|
|
* @copyright 2012 Petr Skoda {@link http://skodak.org}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class basic_test extends \basic_testcase {
|
|
protected $testassertexecuted = false;
|
|
|
|
protected function setUp(): void {
|
|
parent::setUp();
|
|
if ($this->getName() === 'test_setup_assert') {
|
|
$this->assertTrue(true);
|
|
$this->testassertexecuted = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests that bootstrapping has occurred correctly
|
|
* @return void
|
|
*/
|
|
public function test_bootstrap(): void {
|
|
global $CFG;
|
|
|
|
// The httpswwwroot has been deprecated, we keep it as an alias for backwards compatibility with plugins only.
|
|
$this->assertTrue(isset($CFG->httpswwwroot));
|
|
$this->assertEquals($CFG->httpswwwroot, $CFG->wwwroot);
|
|
$this->assertEquals($CFG->prefix, $CFG->phpunit_prefix);
|
|
}
|
|
|
|
/**
|
|
* This is just a verification if I understand the PHPUnit assert docs right --skodak
|
|
* @return void
|
|
*/
|
|
public function test_assert_behaviour(): void {
|
|
// Arrays.
|
|
$a = array('a', 'b', 'c');
|
|
$b = array('a', 'c', 'b');
|
|
$c = array('a', 'b', 'c');
|
|
$d = array('a', 'b', 'C');
|
|
$this->assertNotEquals($a, $b);
|
|
$this->assertNotEquals($a, $d);
|
|
$this->assertEquals($a, $c);
|
|
$this->assertEqualsCanonicalizing($a, $b);
|
|
|
|
// Objects.
|
|
$a = new \stdClass();
|
|
$a->x = 'x';
|
|
$a->y = 'y';
|
|
$b = new \stdClass(); // Switched order.
|
|
$b->y = 'y';
|
|
$b->x = 'x';
|
|
$c = $a;
|
|
$d = new \stdClass();
|
|
$d->x = 'x';
|
|
$d->y = 'y';
|
|
$d->z = 'z';
|
|
$this->assertEquals($a, $b);
|
|
$this->assertNotSame($a, $b);
|
|
$this->assertEquals($a, $c);
|
|
$this->assertSame($a, $c);
|
|
$this->assertNotEquals($a, $d);
|
|
|
|
// String comparison.
|
|
$this->assertEquals(1, '1');
|
|
$this->assertEquals(null, '');
|
|
|
|
$this->assertNotEquals(0, '');
|
|
$this->assertNotEquals(null, '0');
|
|
$this->assertNotEquals(array(), '');
|
|
|
|
// Other comparison.
|
|
$this->assertEquals(null, null);
|
|
$this->assertEquals(false, null);
|
|
$this->assertEquals(0, null);
|
|
|
|
// Emptiness.
|
|
$this->assertEmpty(0);
|
|
$this->assertEmpty(0.0);
|
|
$this->assertEmpty('');
|
|
$this->assertEmpty('0');
|
|
$this->assertEmpty(false);
|
|
$this->assertEmpty(null);
|
|
$this->assertEmpty(array());
|
|
|
|
$this->assertNotEmpty(1);
|
|
$this->assertNotEmpty(0.1);
|
|
$this->assertNotEmpty(-1);
|
|
$this->assertNotEmpty(' ');
|
|
$this->assertNotEmpty('0 ');
|
|
$this->assertNotEmpty(true);
|
|
$this->assertNotEmpty(array(null));
|
|
$this->assertNotEmpty(new \stdClass());
|
|
}
|
|
|
|
/**
|
|
* Make sure there are no sloppy Windows line endings
|
|
* that would break our tests.
|
|
*/
|
|
public function test_lineendings(): void {
|
|
$string = <<<STRING
|
|
a
|
|
b
|
|
STRING;
|
|
$this->assertSame("a\nb", $string, 'Make sure all project files are checked out with unix line endings.');
|
|
|
|
}
|
|
|
|
/**
|
|
* Make sure asserts in setUp() do not create problems.
|
|
*/
|
|
public function test_setup_assert(): void {
|
|
$this->assertTrue($this->testassertexecuted);
|
|
$this->testassertexecuted = false;
|
|
}
|
|
|
|
/**
|
|
* Test assert Tag
|
|
*/
|
|
public function test_assert_tag(): void {
|
|
// This should succeed.
|
|
self::assertTag(['id' => 'testid'], "<div><span id='testid'></span></div>");
|
|
$this->expectException(\PHPUnit\Framework\ExpectationFailedException::class);
|
|
self::assertTag(['id' => 'testid'], "<div><div>");
|
|
}
|
|
|
|
/**
|
|
* Tests for assertEqualsIgnoringWhitespace.
|
|
*
|
|
* @param string $expected
|
|
* @param string $actual
|
|
* @param bool $expectationvalid
|
|
* @dataProvider equals_ignoring_whitespace_provider
|
|
*/
|
|
public function test_assertEqualsIgnoringWhitespace( // phpcs:ignore
|
|
string $expected,
|
|
string $actual,
|
|
bool $expectationvalid,
|
|
): void {
|
|
if (!$expectationvalid) {
|
|
$this->expectException(\PHPUnit\Framework\ExpectationFailedException::class);
|
|
}
|
|
self::assertEqualsIgnoringWhitespace($expected, $actual);
|
|
}
|
|
|
|
/**
|
|
* Data provider for assertEqualsIgnoringWhitespace tests
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function equals_ignoring_whitespace_provider(): array {
|
|
return [
|
|
'equal' => ['a b c', 'a b c', true],
|
|
'equal with whitespace' => ["a b c", "a\nb c", true],
|
|
'equal with extra whitespace' => ["a b c", "a\nb c", true],
|
|
'whitespace missing' => ["ab c", "a\nb c", false],
|
|
'not equal' => ['a b c', 'a b d', false],
|
|
'various space types' => [
|
|
implode(' ', [
|
|
'20', // Regular space.
|
|
"a0", // No-Break Space (NBSP).
|
|
"80", // Ogham Space Mark.
|
|
"0", // En Quad.
|
|
"1", // Em Quad.
|
|
"2", // En Space.
|
|
"3", // Em Space.
|
|
"4", // Three-Per-Em Space.
|
|
"5", // Four-Per-Em Space.
|
|
"6", // Six-Per-Em Space.
|
|
"7", // Figure Space.
|
|
"8", // Punctuation Space.
|
|
"9", // Thin Space.
|
|
"0a", // Hair Space.
|
|
"2f", // Narrow No-Break Space (NNBSP).
|
|
"5f", // Medium Mathematical Space.
|
|
"3000", // Ideographic Space.
|
|
".",
|
|
]),
|
|
implode('', [
|
|
// All space chars taken from https://www.compart.com/en/unicode/category/Zs.
|
|
"20\u{0020}", // Regular space.
|
|
"a0\u{00a0}", // No-Break Space (NBSP).
|
|
"80\u{1680}", // Ogham Space Mark.
|
|
"0\u{2000}", // En Quad.
|
|
"1\u{2001}", // Em Quad.
|
|
"2\u{2002}", // En Space.
|
|
"3\u{2003}", // Em Space.
|
|
"4\u{2004}", // Three-Per-Em Space.
|
|
"5\u{2005}", // Four-Per-Em Space.
|
|
"6\u{2006}", // Six-Per-Em Space.
|
|
"7\u{2007}", // Figure Space.
|
|
"8\u{2008}", // Punctuation Space.
|
|
"9\u{2009}", // Thin Space.
|
|
"0a\u{200a}", // Hair Space.
|
|
"2f\u{202f}", // Narrow No-Break Space (NNBSP).
|
|
"5f\u{205f}", // Medium Mathematical Space.
|
|
"3000\u{3000}", // Ideographic Space.
|
|
".",
|
|
]),
|
|
true,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Test that a database modification is detected.
|
|
*
|
|
* @runInSeparateProcess
|
|
* @covers \phpunit_util
|
|
*/
|
|
public function test_db_modification(): void {
|
|
global $DB;
|
|
$DB->set_field('user', 'confirmed', 1, ['id' => -1]);
|
|
|
|
// Let's convert the user warnings into an assert-able exception.
|
|
set_error_handler(
|
|
static function ($errno, $errstr) {
|
|
restore_error_handler();
|
|
throw new \Exception($errstr, $errno);
|
|
},
|
|
E_USER_WARNING // Or any other specific E_ that we want to assert.
|
|
);
|
|
|
|
$this->expectException(\Exception::class);
|
|
$this->expectExceptionMessage('Warning: unexpected database modification');
|
|
phpunit_util::reset_all_data(true);
|
|
}
|
|
|
|
/**
|
|
* Test that a $CFG modification is detected.
|
|
*
|
|
* @runInSeparateProcess
|
|
* @covers \phpunit_util
|
|
*/
|
|
public function test_cfg_modification(): void {
|
|
global $CFG;
|
|
$CFG->xx = 'yy';
|
|
unset($CFG->admin);
|
|
$CFG->rolesactive = 0;
|
|
|
|
// Let's convert the user warnings into an assert-able exception.
|
|
set_error_handler(
|
|
static function ($errno, $errstr) {
|
|
restore_error_handler();
|
|
throw new \Exception($errstr, $errno);
|
|
},
|
|
E_USER_WARNING // Or any other specific E_ that we want to assert.
|
|
);
|
|
|
|
$this->expectException(\Exception::class);
|
|
$this->expectExceptionMessageMatches('/rolesactive.*xx value.*removal.*admin/ms'); // 3 messages matched.
|
|
phpunit_util::reset_all_data(true);
|
|
}
|
|
|
|
/**
|
|
* Test that a $USER modification is detected.
|
|
*
|
|
* @runInSeparateProcess
|
|
* @covers \phpunit_util
|
|
*/
|
|
public function test_user_modification(): void {
|
|
global $USER;
|
|
$USER->id = 10;
|
|
|
|
// Let's convert the user warnings into an assert-able exception.
|
|
set_error_handler(
|
|
static function ($errno, $errstr) {
|
|
restore_error_handler();
|
|
throw new \Exception($errstr, $errno);
|
|
},
|
|
E_USER_WARNING // Or any other specific E_ that we want to assert.
|
|
);
|
|
|
|
$this->expectException(\Exception::class);
|
|
$this->expectExceptionMessage('Warning: unexpected change of $USER');
|
|
phpunit_util::reset_all_data(true);
|
|
}
|
|
|
|
/**
|
|
* Test that a $COURSE modification is detected.
|
|
*
|
|
* @runInSeparateProcess
|
|
* @covers \phpunit_util
|
|
*/
|
|
public function test_course_modification(): void {
|
|
global $COURSE;
|
|
$COURSE->id = 10;
|
|
|
|
// Let's convert the user warnings into an assert-able exception.
|
|
set_error_handler(
|
|
static function ($errno, $errstr) {
|
|
restore_error_handler();
|
|
throw new \Exception($errstr, $errno);
|
|
},
|
|
E_USER_WARNING // Or any other specific E_ that we want to assert.
|
|
);
|
|
|
|
$this->expectException(\Exception::class);
|
|
$this->expectExceptionMessage('Warning: unexpected change of $COURSE');
|
|
phpunit_util::reset_all_data(true);
|
|
}
|
|
|
|
/**
|
|
* Test that all modifications are detected together.
|
|
*
|
|
* @runInSeparateProcess
|
|
* @covers \phpunit_util
|
|
*/
|
|
public function test_all_modifications(): void {
|
|
global $DB, $CFG, $USER, $COURSE;
|
|
$DB->set_field('user', 'confirmed', 1, ['id' => -1]);
|
|
$CFG->xx = 'yy';
|
|
unset($CFG->admin);
|
|
$CFG->rolesactive = 0;
|
|
$USER->id = 10;
|
|
$COURSE->id = 10;
|
|
|
|
// Let's convert the user warnings into an assert-able exception.
|
|
set_error_handler(
|
|
static function ($errno, $errstr) {
|
|
restore_error_handler();
|
|
throw new \Exception($errstr, $errno);
|
|
},
|
|
E_USER_WARNING // Or any other specific E_ that we want to assert.
|
|
);
|
|
|
|
$this->expectException(\Exception::class);
|
|
$this->expectExceptionMessageMatches('/resetting.*rolesactive.*new.*removal.*USER.*COURSE/ms'); // 6 messages matched.
|
|
phpunit_util::reset_all_data(true);
|
|
}
|
|
|
|
/**
|
|
* Test that an open transaction are managed ok by the reset code (silently rolled back).
|
|
*
|
|
* @runInSeparateProcess
|
|
* @covers \phpunit_util
|
|
*/
|
|
public function test_transaction_problem(): void {
|
|
global $DB, $COURSE;
|
|
$originalname = $DB->get_field('course', 'fullname', ['id' => $COURSE->id]); // Normally "PHPUnit test site".
|
|
$changedname = 'Ongoing transaction test site';
|
|
|
|
// Start a transaction and make some database changes.
|
|
$DB->start_delegated_transaction();
|
|
$DB->set_field('course', 'fullname', $changedname, ['id' => $COURSE->id]);
|
|
|
|
// Assert that the transaction is open and the changes were made.
|
|
$this->assertTrue($DB->is_transaction_started());
|
|
$this->assertEquals($changedname, $DB->get_field('course', 'fullname', ['id' => $COURSE->id]));
|
|
|
|
phpunit_util::reset_all_data(false); // We don't want to detect/warn on database changes for this test.
|
|
|
|
// Assert that the transaction is now closed and the changes were rolled back.
|
|
$this->assertFalse($DB->is_transaction_started());
|
|
$this->assertEquals($originalname, $DB->get_field('course', 'fullname', ['id' => $COURSE->id]));
|
|
}
|
|
}
|