Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
  • Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
<?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/>.

< /** < * Persistent class tests. < * < * @package core < * @copyright 2015 Frédéric Massart - FMCorz.net < * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later < */
> namespace core;
< defined('MOODLE_INTERNAL') || die(); < global $CFG;
> use advanced_testcase; > use coding_exception; > use dml_missing_record_exception; > use lang_string; > use xmldb_table;
/** * Persistent testcase. * * @package core * @copyright 2015 Frédéric Massart - FMCorz.net * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
> * @covers \core\persistent
*/
< class core_persistent_testcase extends advanced_testcase {
> class persistent_test extends advanced_testcase {
public function setUp(): void { $this->make_persistent_table();
> $this->make_second_persistent_table();
$this->resetAfterTest(); } /** * Make the table for the persistent. */ protected function make_persistent_table() { global $DB; $dbman = $DB->get_manager(); $table = new xmldb_table(core_testable_persistent::TABLE); $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null); $table->add_field('shortname', XMLDB_TYPE_CHAR, '100', null, null, null, null); $table->add_field('idnumber', XMLDB_TYPE_CHAR, '100', null, null, null, null); $table->add_field('description', XMLDB_TYPE_TEXT, null, null, null, null, null); $table->add_field('descriptionformat', XMLDB_TYPE_INTEGER, '4', null, XMLDB_NOTNULL, null, '0'); $table->add_field('parentid', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0'); $table->add_field('path', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, null); $table->add_field('sortorder', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null); $table->add_field('scaleid', XMLDB_TYPE_INTEGER, '10', null, null, null, null); $table->add_field('timecreated', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null); $table->add_field('timemodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null); $table->add_field('usermodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0'); $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id')); if ($dbman->table_exists($table)) { $dbman->drop_table($table); } $dbman->create_table($table); }
> /** public function test_properties_definition() { > * Make the second table for the persistent. $expected = array( > */ 'shortname' => array( > protected function make_second_persistent_table() { 'type' => PARAM_TEXT, > global $DB; 'default' => '', > $dbman = $DB->get_manager(); 'null' => NULL_NOT_ALLOWED > ), > $table = new xmldb_table(core_testable_second_persistent::TABLE); 'idnumber' => array( > $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null); 'type' => PARAM_TEXT, > $table->add_field('someint', XMLDB_TYPE_INTEGER, '10', null, null, null, null); 'null' => NULL_NOT_ALLOWED > $table->add_field('intnull', XMLDB_TYPE_INTEGER, '10', null, null, null, null); ), > $table->add_field('somefloat', XMLDB_TYPE_FLOAT, '10,5', null, null, null, null); 'description' => array( > $table->add_field('sometext', XMLDB_TYPE_TEXT, null, null, null, null, null); 'type' => PARAM_TEXT, > $table->add_field('someraw', XMLDB_TYPE_CHAR, '100', null, null, null, null); 'default' => '', > $table->add_field('booltrue', XMLDB_TYPE_INTEGER, '1', null, XMLDB_NOTNULL, null, '0'); 'null' => NULL_NOT_ALLOWED > $table->add_field('boolfalse', XMLDB_TYPE_INTEGER, '1', null, XMLDB_NOTNULL, null, '0'); ), > $table->add_field('timecreated', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null); 'descriptionformat' => array( > $table->add_field('timemodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null); 'choices' => array(FORMAT_HTML, FORMAT_MOODLE, FORMAT_PLAIN, FORMAT_MARKDOWN), > $table->add_field('usermodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0'); 'type' => PARAM_INT, > 'default' => FORMAT_HTML, > $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id')); 'null' => NULL_NOT_ALLOWED > ), > if ($dbman->table_exists($table)) { 'parentid' => array( > $dbman->drop_table($table); 'type' => PARAM_INT, > } 'default' => 0, > 'null' => NULL_NOT_ALLOWED > $dbman->create_table($table); ), > } 'path' => array( >
'type' => PARAM_RAW, 'default' => '', 'null' => NULL_NOT_ALLOWED ), 'sortorder' => array( 'type' => PARAM_INT, 'message' => new lang_string('invalidrequest', 'error'), 'null' => NULL_NOT_ALLOWED ), 'scaleid' => array( 'default' => null, 'type' => PARAM_INT, 'null' => NULL_ALLOWED ), 'id' => array( 'default' => 0, 'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED ), 'timecreated' => array( 'default' => 0, 'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED ), 'timemodified' => array( 'default' => 0, 'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED ), 'usermodified' => array( 'default' => 0, 'type' => PARAM_INT, 'null' => NULL_NOT_ALLOWED ), ); $this->assertEquals($expected, core_testable_persistent::properties_definition()); }
> /** public function test_to_record() { > * Test filtering record properties returns only those defined by the persistent $p = new core_testable_persistent(); > */ $expected = (object) array( > public function test_properties_filter(): void { 'shortname' => '', > $result = core_testable_persistent::properties_filter((object) [ 'idnumber' => null, > 'idnumber' => '123', 'description' => '', > 'sortorder' => 1, 'descriptionformat' => FORMAT_HTML, > 'invalidparam' => 'abc', 'parentid' => 0, > ]); 'path' => '', > 'sortorder' => null, > // We should get back all data except invalid param. 'id' => 0, > $this->assertEquals([ 'timecreated' => 0, > 'idnumber' => '123', 'timemodified' => 0, > 'sortorder' => 1, 'usermodified' => 0, > ], $result); 'scaleid' => null, > } ); > $this->assertEquals($expected, $p->to_record()); > /** } > * Test creating persistent instance by specifying record ID in constructor > */ public function test_from_record() { > public function test_constructor() : void { $p = new core_testable_persistent(); > $persistent = (new core_testable_persistent(0, (object) [ $data = (object) array( > 'idnumber' => '123', 'shortname' => 'ddd', > 'sortorder' => 1, 'idnumber' => 'abc', > ]))->create(); 'description' => 'xyz', > 'descriptionformat' => FORMAT_PLAIN, > // Now create a new instance, passing the original instance ID in the constructor. 'parentid' => 999, > $another = new core_testable_persistent($persistent->get('id')); 'path' => '/a/b/c', > $this->assertEquals($another->to_record(), $persistent->to_record()); 'sortorder' => 12, > } 'id' => 1, > 'timecreated' => 2, > /** 'timemodified' => 3, > * Test creating persistent instance by specifying non-existing record ID in constructor throws appropriate exception 'usermodified' => 4, > */ 'scaleid' => null, > public function test_constructor_invalid(): void { ); > $this->expectException(dml_missing_record_exception::class); $p->from_record($data); > $this->expectExceptionMessage('Can\'t find data record in database table phpunit_persistent.'); $this->assertEquals($data, $p->to_record()); > new core_testable_persistent(42); } > } >
public function test_from_record_invalid_param() { $p = new core_testable_persistent(); $data = (object) array(
> 'shortname' => 'ddd', 'invalidparam' => 'abc' > 'idnumber' => 'abc', ); > 'description' => 'xyz', > 'descriptionformat' => FORMAT_PLAIN, $this->expectException(coding_exception::class); > 'parentid' => 999, $p->from_record($data); > 'path' => '/a/b/c', } > 'sortorder' => 12, > 'id' => 1, public function test_validate() { > 'timecreated' => 2, $data = (object) array( > 'timemodified' => 3, 'idnumber' => 'abc', > 'usermodified' => 4, 'sortorder' => 0 > 'scaleid' => null,
< $this->expectException(coding_exception::class);
$p = new core_testable_persistent(0, $data);
> $this->assertFalse(isset($p->beforevalidate)); > // Previous call should succeed, assert we get back all data except invalid param. $this->assertTrue($p->validate()); > unset($data->invalidparam); $this->assertTrue(isset($p->beforevalidate)); > $this->assertEquals($data, $p->to_record());
$this->assertTrue($p->is_valid()); $this->assertEquals(array(), $p->get_errors()); $p->set('descriptionformat', -100); $expected = array( 'descriptionformat' => new lang_string('invaliddata', 'error'), ); $this->assertEquals($expected, $p->validate()); $this->assertFalse($p->is_valid()); $this->assertEquals($expected, $p->get_errors()); } public function test_validation_required() { $data = (object) array( 'idnumber' => 'abc' ); $p = new core_testable_persistent(0, $data); $expected = array( 'sortorder' => new lang_string('requiredelement', 'form'), ); $this->assertFalse($p->is_valid()); $this->assertEquals($expected, $p->get_errors()); } public function test_validation_custom() { $data = (object) array( 'idnumber' => 'abc', 'sortorder' => 10, ); $p = new core_testable_persistent(0, $data); $expected = array( 'sortorder' => new lang_string('invalidkey', 'error'), ); $this->assertFalse($p->is_valid()); $this->assertEquals($expected, $p->get_errors()); } public function test_validation_custom_message() { $data = (object) array( 'idnumber' => 'abc', 'sortorder' => 'abc', ); $p = new core_testable_persistent(0, $data); $expected = array( 'sortorder' => new lang_string('invalidrequest', 'error'), ); $this->assertFalse($p->is_valid()); $this->assertEquals($expected, $p->get_errors()); } public function test_validation_choices() { $data = (object) array( 'idnumber' => 'abc', 'sortorder' => 0, 'descriptionformat' => -100 ); $p = new core_testable_persistent(0, $data); $expected = array( 'descriptionformat' => new lang_string('invaliddata', 'error'), ); $this->assertFalse($p->is_valid()); $this->assertEquals($expected, $p->get_errors()); } public function test_validation_type() { $data = (object) array( 'idnumber' => 'abc', 'sortorder' => 'NaN' ); $p = new core_testable_persistent(0, $data); $this->assertFalse($p->is_valid()); $this->assertArrayHasKey('sortorder', $p->get_errors()); } public function test_validation_null() { $data = (object) array( 'idnumber' => null, 'sortorder' => 0, 'scaleid' => 'bad!' ); $p = new core_testable_persistent(0, $data); $this->assertFalse($p->is_valid()); $this->assertArrayHasKey('idnumber', $p->get_errors()); $this->assertArrayHasKey('scaleid', $p->get_errors()); $p->set('idnumber', 'abc'); $this->assertFalse($p->is_valid()); $this->assertArrayNotHasKey('idnumber', $p->get_errors()); $this->assertArrayHasKey('scaleid', $p->get_errors()); $p->set('scaleid', null); $this->assertTrue($p->is_valid()); $this->assertArrayNotHasKey('scaleid', $p->get_errors()); } public function test_create() { global $DB; $p = new core_testable_persistent(0, (object) array('sortorder' => 123, 'idnumber' => 'abc')); $this->assertFalse(isset($p->beforecreate)); $this->assertFalse(isset($p->aftercreate)); $p->create(); $record = $DB->get_record(core_testable_persistent::TABLE, array('id' => $p->get('id')), '*', MUST_EXIST); $expected = $p->to_record(); $this->assertTrue(isset($p->beforecreate)); $this->assertTrue(isset($p->aftercreate)); $this->assertEquals($expected->sortorder, $record->sortorder); $this->assertEquals($expected->idnumber, $record->idnumber); $this->assertEquals($expected->id, $record->id); $this->assertTrue($p->is_valid()); // Should always be valid after a create. } public function test_update() { global $DB; $p = new core_testable_persistent(0, (object) array('sortorder' => 123, 'idnumber' => 'abc')); $p->create(); $id = $p->get('id'); $p->set('sortorder', 456); $p->from_record((object) array('idnumber' => 'def')); $this->assertFalse(isset($p->beforeupdate)); $this->assertFalse(isset($p->afterupdate)); $p->update(); $expected = $p->to_record(); $record = $DB->get_record(core_testable_persistent::TABLE, array('id' => $p->get('id')), '*', MUST_EXIST); $this->assertTrue(isset($p->beforeupdate)); $this->assertTrue(isset($p->afterupdate)); $this->assertEquals($id, $record->id); $this->assertEquals(456, $record->sortorder); $this->assertEquals('def', $record->idnumber); $this->assertTrue($p->is_valid()); // Should always be valid after an update. }
> /** public function test_save() { > * Test set_many prior to updating the persistent global $DB; > */ $p = new core_testable_persistent(0, (object) array('sortorder' => 123, 'idnumber' => 'abc')); > public function test_set_many_update(): void { $this->assertFalse(isset($p->beforecreate)); > global $DB; $this->assertFalse(isset($p->aftercreate)); > $this->assertFalse(isset($p->beforeupdate)); > $persistent = (new core_testable_persistent(0, (object) [ $this->assertFalse(isset($p->beforeupdate)); > 'idnumber' => 'test', $p->save(); > 'sortorder' => 2 $record = $DB->get_record(core_testable_persistent::TABLE, array('id' => $p->get('id')), '*', MUST_EXIST); > ]))->create(); $expected = $p->to_record(); > $this->assertTrue(isset($p->beforecreate)); > // Set multiple properties, and update. $this->assertTrue(isset($p->aftercreate)); > $persistent->set_many([ $this->assertFalse(isset($p->beforeupdate)); > 'idnumber' => 'test2', $this->assertFalse(isset($p->beforeupdate)); > 'sortorder' => 1, $this->assertEquals($expected->sortorder, $record->sortorder); > ])->update(); $this->assertEquals($expected->idnumber, $record->idnumber); > $this->assertEquals($expected->id, $record->id); > // Confirm our persistent was updated. $this->assertTrue($p->is_valid()); // Should always be valid after a save/create. > $record = $DB->get_record(core_testable_persistent::TABLE, ['id' => $persistent->get('id')], '*', MUST_EXIST); > $this->assertEquals('test2', $record->idnumber); $p->set('idnumber', 'abcd'); > $this->assertEquals(1, $record->sortorder); $p->save(); > } $record = $DB->get_record(core_testable_persistent::TABLE, array('id' => $p->get('id')), '*', MUST_EXIST); >
$expected = $p->to_record(); $this->assertTrue(isset($p->beforeupdate)); $this->assertTrue(isset($p->beforeupdate)); $this->assertEquals($expected->sortorder, $record->sortorder); $this->assertEquals($expected->idnumber, $record->idnumber); $this->assertEquals($expected->id, $record->id); $this->assertTrue($p->is_valid()); // Should always be valid after a save/update. }
> /** public function test_read() { > * Test set_many prior to saving the persistent $p = new core_testable_persistent(0, (object) array('sortorder' => 123, 'idnumber' => 'abc')); > */ $p->create(); > public function test_set_many_save(): void { unset($p->beforevalidate); > global $DB; unset($p->beforecreate); > unset($p->aftercreate); > $persistent = (new core_testable_persistent(0, (object) [ > 'idnumber' => 'test', $p2 = new core_testable_persistent($p->get('id')); > 'sortorder' => 2 $this->assertEquals($p, $p2); > ])); > $p3 = new core_testable_persistent(); > // Set multiple properties, and save. $p3->set('id', $p->get('id')); > $persistent->set_many([ $p3->read(); > 'idnumber' => 'test2', $this->assertEquals($p, $p3); > 'sortorder' => 1, } > ])->save(); > public function test_delete() { > // Confirm our persistent was saved. global $DB; > $record = $DB->get_record(core_testable_persistent::TABLE, ['id' => $persistent->get('id')], '*', MUST_EXIST); > $this->assertEquals('test2', $record->idnumber); $p = new core_testable_persistent(0, (object) array('sortorder' => 123, 'idnumber' => 'abc')); > $this->assertEquals(1, $record->sortorder); $p->create(); > } $this->assertNotEquals(0, $p->get('id')); > $this->assertTrue($DB->record_exists_select(core_testable_persistent::TABLE, 'id = ?', array($p->get('id')))); > /** $this->assertFalse(isset($p->beforedelete)); > * Test set_many with empty array should not modify the persistent $this->assertFalse(isset($p->afterdelete)); > */ > public function test_set_many_empty(): void { $p->delete(); > global $DB; $this->assertFalse($DB->record_exists_select(core_testable_persistent::TABLE, 'id = ?', array($p->get('id')))); > $this->assertEquals(0, $p->get('id')); > $persistent = (new core_testable_persistent(0, (object) [ $this->assertEquals(true, $p->beforedelete); > 'idnumber' => 'test', $this->assertEquals(true, $p->afterdelete); > 'sortorder' => 2 } > ]))->create(); > public function test_has_property() { > // Set empty properties, and update. $this->assertFalse(core_testable_persistent::has_property('unknown')); > $persistent->set_many([])->update(); $this->assertTrue(core_testable_persistent::has_property('idnumber')); > } > // Confirm our persistent was not updated. > $record = $DB->get_record(core_testable_persistent::TABLE, ['id' => $persistent->get('id')], '*', MUST_EXIST); public function test_custom_setter_getter() { > $this->assertEquals('test', $record->idnumber); global $DB; > $this->assertEquals(2, $record->sortorder); > } $path = array(1, 2, 3); > $json = json_encode($path); > /** > * Test set with invalid property $p = new core_testable_persistent(0, (object) array('sortorder' => 0, 'idnumber' => 'abc')); > */ $p->set('path', $path); > public function test_set_invalid_property(): void { $this->assertEquals($path, $p->get('path')); > $persistent = (new core_testable_persistent(0, (object) [ $this->assertEquals($json, $p->to_record()->path); > 'idnumber' => 'test', > 'sortorder' => 2 $p->create(); > ])); $record = $DB->get_record(core_testable_persistent::TABLE, array('id' => $p->get('id')), 'id, path', MUST_EXIST); > $this->assertEquals($json, $record->path); > $this->expectException(coding_exception::class); } > $this->expectExceptionMessage('Unexpected property \'invalid\' requested'); > $persistent->set('invalid', 'stuff'); public function test_record_exists() { > } global $DB; > $this->assertFalse($DB->record_exists(core_testable_persistent::TABLE, array('idnumber' => 'abc'))); > /** $p = new core_testable_persistent(0, (object) array('sortorder' => 123, 'idnumber' => 'abc')); > * Test set_many with invalid property $p->create(); > */ $id = $p->get('id'); > public function test_set_many_invalid_property(): void { $this->assertTrue(core_testable_persistent::record_exists($id)); > $persistent = (new core_testable_persistent(0, (object) [ $this->assertTrue($DB->record_exists(core_testable_persistent::TABLE, array('idnumber' => 'abc'))); > 'idnumber' => 'test', $p->delete(); > 'sortorder' => 2 $this->assertFalse(core_testable_persistent::record_exists($id)); > ])); } > > $this->expectException(coding_exception::class); public function test_get_sql_fields() { > $this->expectExceptionMessage('Unexpected property \'invalid\' requested'); $expected = '' . > $persistent->set_many(['invalid' => 'stuff']); 'c.id AS prefix_id, ' . > } 'c.shortname AS prefix_shortname, ' . >
'c.idnumber AS prefix_idnumber, ' .
> /** 'c.description AS prefix_description, ' . > * Test get_record method for creating persistent instance 'c.descriptionformat AS prefix_descriptionformat, ' . > */ 'c.parentid AS prefix_parentid, ' . > public function test_get_record(): void { 'c.path AS prefix_path, ' . > $persistent = (new core_testable_persistent(0, (object) [ 'c.sortorder AS prefix_sortorder, ' . > 'idnumber' => '123', 'c.scaleid AS prefix_scaleid, ' . > 'sortorder' => 1, 'c.timecreated AS prefix_timecreated, ' . > ]))->create(); 'c.timemodified AS prefix_timemodified, ' . > 'c.usermodified AS prefix_usermodified'; > $another = core_testable_persistent::get_record(['id' => $persistent->get('id')]); $this->assertEquals($expected, core_testable_persistent::get_sql_fields('c', 'prefix_')); > } > // Assert we got back a persistent instance, and it matches original. > $this->assertInstanceOf(core_testable_persistent::class, $another); public function test_get_sql_fields_too_long() { > $this->assertEquals($another->to_record(), $persistent->to_record()); $this->expectException(coding_exception::class); > } $this->expectExceptionMessageMatches('/The alias .+ exceeds 30 characters/'); > core_testable_persistent::get_sql_fields('c'); > /** } > * Test get_record method for creating persistent instance, ignoring a non-existing record } > */ > public function test_get_record_ignore_missing(): void { /** > $persistent = core_testable_persistent::get_record(['id' => 42]); * Example persistent class. > $this->assertFalse($persistent); * > } * @package core > * @copyright 2015 Frédéric Massart - FMCorz.net > /** * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later > * Test get_record method for creating persistent instance, throws appropriate exception for non-existing record */ > */ class core_testable_persistent extends \core\persistent { > public function test_get_record_must_exist(): void { > $this->expectException(dml_missing_record_exception::class); const TABLE = 'phpunit_persistent'; > $this->expectExceptionMessage('Can\'t find data record in database table phpunit_persistent.'); > core_testable_persistent::get_record(['id' => 42], MUST_EXIST); protected static function define_properties() { > } return array( >
'shortname' => array(
> 'type' => PARAM_TEXT, > public function test_get(): void { 'default' => '' > $data = [ ), > 'someint' => 123, 'idnumber' => array( > 'intnull' => null, 'type' => PARAM_TEXT, > 'somefloat' => 33.44, ), > 'sometext' => 'Hello', 'description' => array( > 'someraw' => '/dev/hello', 'type' => PARAM_TEXT, > 'booltrue' => true, 'default' => '' > 'boolfalse' => false, ), > ]; 'descriptionformat' => array( > $p = new core_testable_second_persistent(0, (object)$data); 'choices' => array(FORMAT_HTML, FORMAT_MOODLE, FORMAT_PLAIN, FORMAT_MARKDOWN), > $p->create(); 'type' => PARAM_INT, > 'default' => FORMAT_HTML > $this->assertSame($data['intnull'], $p->get('intnull')); ), > $this->assertSame($data['someint'], $p->get('someint')); 'parentid' => array( > $this->assertIsFloat($p->get('somefloat')); // Avoid === comparisons on floats, verify type and value separated. 'type' => PARAM_INT, > $this->assertEqualsWithDelta($data['somefloat'], $p->get('somefloat'), 0.00001); 'default' => 0 > $this->assertSame($data['sometext'], $p->get('sometext')); ), > $this->assertSame($data['someraw'], $p->get('someraw')); 'path' => array( > $this->assertSame($data['booltrue'], $p->get('booltrue')); 'type' => PARAM_RAW, > $this->assertSame($data['boolfalse'], $p->get('boolfalse')); 'default' => '' > ), > // Ensure that types are correct after reloading data from database. 'sortorder' => array( > $p->read(); 'type' => PARAM_INT, > 'message' => new lang_string('invalidrequest', 'error') > $this->assertSame($data['someint'], $p->get('someint')); ), > $this->assertSame($data['intnull'], $p->get('intnull')); 'scaleid' => array( > $this->assertIsFloat($p->get('somefloat')); // Avoid === comparisons on floats, verify type and value separated. 'type' => PARAM_INT, > $this->assertEqualsWithDelta($data['somefloat'], $p->get('somefloat'), 0.00001); 'default' => null, > $this->assertSame($data['sometext'], $p->get('sometext')); 'null' => NULL_ALLOWED > $this->assertSame($data['someraw'], $p->get('someraw')); ) > $this->assertSame($data['booltrue'], $p->get('booltrue')); ); > $this->assertSame($data['boolfalse'], $p->get('boolfalse')); } > }
< class core_testable_persistent extends \core\persistent {
> class core_testable_persistent extends persistent {
protected function before_validate() {
> /** @var bool before validate status. */ $this->beforevalidate = true; > public ?bool $beforevalidate; } > > /** @var bool before create status. */ protected function before_create() { > public ?bool $beforecreate; $this->beforecreate = true; > } > /** @var bool before update status. */ > public ?bool $beforeupdate; protected function before_update() { > $this->beforeupdate = true; > /** @var bool before delete status. */ } > public ?bool $beforedelete; > protected function before_delete() { > /** @var bool after create status. */ $this->beforedelete = true; > public ?bool $aftercreate; } > > /** @var bool after update status. */ protected function after_create() { > public ?bool $afterupdate; $this->aftercreate = true; > } > /** @var bool after delete status. */ > public ?bool $afterdelete; protected function after_update($result) { >
$this->afterupdate = true; } protected function after_delete($result) { $this->afterdelete = true; } protected function get_path() { $value = $this->raw_get('path'); if (!empty($value)) { $value = json_decode($value); } return $value; } protected function set_path($value) { if (!empty($value)) { $value = json_encode($value); } $this->raw_set('path', $value); } protected function validate_sortorder($value) { if ($value == 10) { return new lang_string('invalidkey', 'error'); } return true; }
> } } > > /** > * Example persistent class to test types. > * > * @package core > * @copyright 2021 David Matamoros <davidmc@moodle.com> > * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later > */ > class core_testable_second_persistent extends persistent { > > /** Table name for the persistent. */ > const TABLE = 'phpunit_second_persistent'; > > /** > * Return the list of properties. > * > * @return array > */ > protected static function define_properties(): array { > return [ > 'someint' => [ > 'type' => PARAM_INT, > ], > 'intnull' => [ > 'type' => PARAM_INT, > 'null' => NULL_ALLOWED, > 'default' => null, > ], > 'somefloat' => [ > 'type' => PARAM_FLOAT, > ], > 'sometext' => [ > 'type' => PARAM_TEXT, > 'default' => '' > ], > 'someraw' => [ > 'type' => PARAM_RAW, > 'default' => '' > ], > 'booltrue' => [ > 'type' => PARAM_BOOL, > ], > 'boolfalse' => [ > 'type' => PARAM_BOOL, > ] > ]; > }