Search moodle.org's
Developer Documentation
Developer Documentation
See Release Notes
Long Term Support Release
- Bug fixes for general core bugs in 4.1.x will end 13 November 2023 (12 months).
- Bug fixes for security issues in 4.1.x will end 10 November 2025 (36 months).
- PHP version: minimum PHP 7.4.0 Note: minimum PHP version has increased since Moodle 4.0. PHP 8.0.x is supported too.
/lib/testing/classes/ -> util.php (source)
Differences Between: [Versions 310 and 401] [Versions 39 and 401] [Versions 401 and 402] [Versions 401 and 403]
1 <?php 2 // This file is part of Moodle - http://moodle.org/ 3 // 4 // Moodle is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // Moodle is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU General Public License for more details. 13 // 14 // You should have received a copy of the GNU General Public License 15 // along with Moodle. If not, see <http://www.gnu.org/licenses/>. 16 17 /** 18 * Testing util classes 19 * 20 * @abstract 21 * @package core 22 * @category test 23 * @copyright 2012 Petr Skoda {@link http://skodak.org} 24 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 25 */ 26 27 /** 28 * Utils for test sites creation 29 * 30 * @package core 31 * @category test 32 * @copyright 2012 Petr Skoda {@link http://skodak.org} 33 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 34 */ 35 abstract class testing_util { 36 37 /** 38 * @var string dataroot (likely to be $CFG->dataroot). 39 */ 40 private static $dataroot = null; 41 42 /** 43 * @var testing_data_generator 44 */ 45 protected static $generator = null; 46 47 /** 48 * @var string current version hash from php files 49 */ 50 protected static $versionhash = null; 51 52 /** 53 * @var array original content of all database tables 54 */ 55 protected static $tabledata = null; 56 57 /** 58 * @var array original structure of all database tables 59 */ 60 protected static $tablestructure = null; 61 62 /** 63 * @var array keep list of sequenceid used in a table. 64 */ 65 private static $tablesequences = array(); 66 67 /** 68 * @var array list of updated tables. 69 */ 70 public static $tableupdated = array(); 71 72 /** 73 * @var array original structure of all database tables 74 */ 75 protected static $sequencenames = null; 76 77 /** 78 * @var string name of the json file where we store the list of dataroot files to not reset during reset_dataroot. 79 */ 80 private static $originaldatafilesjson = 'originaldatafiles.json'; 81 82 /** 83 * @var boolean set to true once $originaldatafilesjson file is created. 84 */ 85 private static $originaldatafilesjsonadded = false; 86 87 /** 88 * @var int next sequence value for a single test cycle. 89 */ 90 protected static $sequencenextstartingid = null; 91 92 /** 93 * Return the name of the JSON file containing the init filenames. 94 * 95 * @static 96 * @return string 97 */ 98 public static function get_originaldatafilesjson() { 99 return self::$originaldatafilesjson; 100 } 101 102 /** 103 * Return the dataroot. It's useful when mocking the dataroot when unit testing this class itself. 104 * 105 * @static 106 * @return string the dataroot. 107 */ 108 public static function get_dataroot() { 109 global $CFG; 110 111 // By default it's the test framework dataroot. 112 if (empty(self::$dataroot)) { 113 self::$dataroot = $CFG->dataroot; 114 } 115 116 return self::$dataroot; 117 } 118 119 /** 120 * Set the dataroot. It's useful when mocking the dataroot when unit testing this class itself. 121 * 122 * @param string $dataroot the dataroot of the test framework. 123 * @static 124 */ 125 public static function set_dataroot($dataroot) { 126 self::$dataroot = $dataroot; 127 } 128 129 /** 130 * Returns the testing framework name 131 * @static 132 * @return string 133 */ 134 protected static final function get_framework() { 135 $classname = get_called_class(); 136 return substr($classname, 0, strpos($classname, '_')); 137 } 138 139 /** 140 * Get data generator 141 * @static 142 * @return testing_data_generator 143 */ 144 public static function get_data_generator() { 145 if (is_null(self::$generator)) { 146 require_once (__DIR__.'/../generator/lib.php'); 147 self::$generator = new testing_data_generator(); 148 } 149 return self::$generator; 150 } 151 152 /** 153 * Does this site (db and dataroot) appear to be used for production? 154 * We try very hard to prevent accidental damage done to production servers!! 155 * 156 * @static 157 * @return bool 158 */ 159 public static function is_test_site() { 160 global $DB, $CFG; 161 162 $framework = self::get_framework(); 163 164 if (!file_exists(self::get_dataroot() . '/' . $framework . 'testdir.txt')) { 165 // this is already tested in bootstrap script, 166 // but anyway presence of this file means the dataroot is for testing 167 return false; 168 } 169 170 $tables = $DB->get_tables(false); 171 if ($tables) { 172 if (!$DB->get_manager()->table_exists('config')) { 173 return false; 174 } 175 if (!get_config('core', $framework . 'test')) { 176 return false; 177 } 178 } 179 180 return true; 181 } 182 183 /** 184 * Returns whether test database and dataroot were created using the current version codebase 185 * 186 * @return bool 187 */ 188 public static function is_test_data_updated() { 189 global $DB; 190 191 $framework = self::get_framework(); 192 193 $datarootpath = self::get_dataroot() . '/' . $framework; 194 if (!file_exists($datarootpath . '/tabledata.ser') or !file_exists($datarootpath . '/tablestructure.ser')) { 195 return false; 196 } 197 198 if (!file_exists($datarootpath . '/versionshash.txt')) { 199 return false; 200 } 201 202 $hash = core_component::get_all_versions_hash(); 203 $oldhash = file_get_contents($datarootpath . '/versionshash.txt'); 204 205 if ($hash !== $oldhash) { 206 return false; 207 } 208 209 // A direct database request must be used to avoid any possible caching of an older value. 210 $dbhash = $DB->get_field('config', 'value', array('name' => $framework . 'test')); 211 if ($hash !== $dbhash) { 212 return false; 213 } 214 215 return true; 216 } 217 218 /** 219 * Stores the status of the database 220 * 221 * Serializes the contents and the structure and 222 * stores it in the test framework space in dataroot 223 */ 224 protected static function store_database_state() { 225 global $DB, $CFG; 226 227 $framework = self::get_framework(); 228 229 // store data for all tables 230 $data = array(); 231 $structure = array(); 232 $tables = $DB->get_tables(); 233 foreach ($tables as $table) { 234 $columns = $DB->get_columns($table); 235 $structure[$table] = $columns; 236 if (isset($columns['id']) and $columns['id']->auto_increment) { 237 $data[$table] = $DB->get_records($table, array(), 'id ASC'); 238 } else { 239 // there should not be many of these 240 $data[$table] = $DB->get_records($table, array()); 241 } 242 } 243 $data = serialize($data); 244 $datafile = self::get_dataroot() . '/' . $framework . '/tabledata.ser'; 245 file_put_contents($datafile, $data); 246 testing_fix_file_permissions($datafile); 247 248 $structure = serialize($structure); 249 $structurefile = self::get_dataroot() . '/' . $framework . '/tablestructure.ser'; 250 file_put_contents($structurefile, $structure); 251 testing_fix_file_permissions($structurefile); 252 } 253 254 /** 255 * Stores the version hash in both database and dataroot 256 */ 257 protected static function store_versions_hash() { 258 global $CFG; 259 260 $framework = self::get_framework(); 261 $hash = core_component::get_all_versions_hash(); 262 263 // add test db flag 264 set_config($framework . 'test', $hash); 265 266 // hash all plugin versions - helps with very fast detection of db structure changes 267 $hashfile = self::get_dataroot() . '/' . $framework . '/versionshash.txt'; 268 file_put_contents($hashfile, $hash); 269 testing_fix_file_permissions($hashfile); 270 } 271 272 /** 273 * Returns contents of all tables right after installation. 274 * @static 275 * @return array $table=>$records 276 */ 277 protected static function get_tabledata() { 278 if (!isset(self::$tabledata)) { 279 $framework = self::get_framework(); 280 281 $datafile = self::get_dataroot() . '/' . $framework . '/tabledata.ser'; 282 if (!file_exists($datafile)) { 283 // Not initialised yet. 284 return array(); 285 } 286 287 $data = file_get_contents($datafile); 288 self::$tabledata = unserialize($data); 289 } 290 291 if (!is_array(self::$tabledata)) { 292 testing_error(1, 'Can not read dataroot/' . $framework . '/tabledata.ser or invalid format, reinitialize test database.'); 293 } 294 295 return self::$tabledata; 296 } 297 298 /** 299 * Returns structure of all tables right after installation. 300 * @static 301 * @return array $table=>$records 302 */ 303 public static function get_tablestructure() { 304 if (!isset(self::$tablestructure)) { 305 $framework = self::get_framework(); 306 307 $structurefile = self::get_dataroot() . '/' . $framework . '/tablestructure.ser'; 308 if (!file_exists($structurefile)) { 309 // Not initialised yet. 310 return array(); 311 } 312 313 $data = file_get_contents($structurefile); 314 self::$tablestructure = unserialize($data); 315 } 316 317 if (!is_array(self::$tablestructure)) { 318 testing_error(1, 'Can not read dataroot/' . $framework . '/tablestructure.ser or invalid format, reinitialize test database.'); 319 } 320 321 return self::$tablestructure; 322 } 323 324 /** 325 * Returns the names of sequences for each autoincrementing id field in all standard tables. 326 * @static 327 * @return array $table=>$sequencename 328 */ 329 public static function get_sequencenames() { 330 global $DB; 331 332 if (isset(self::$sequencenames)) { 333 return self::$sequencenames; 334 } 335 336 if (!$structure = self::get_tablestructure()) { 337 return array(); 338 } 339 340 self::$sequencenames = array(); 341 foreach ($structure as $table => $ignored) { 342 $name = $DB->get_manager()->generator->getSequenceFromDB(new xmldb_table($table)); 343 if ($name !== false) { 344 self::$sequencenames[$table] = $name; 345 } 346 } 347 348 return self::$sequencenames; 349 } 350 351 /** 352 * Returns list of tables that are unmodified and empty. 353 * 354 * @static 355 * @return array of table names, empty if unknown 356 */ 357 protected static function guess_unmodified_empty_tables() { 358 global $DB; 359 360 $dbfamily = $DB->get_dbfamily(); 361 362 if ($dbfamily === 'mysql') { 363 $empties = array(); 364 $prefix = $DB->get_prefix(); 365 $rs = $DB->get_recordset_sql("SHOW TABLE STATUS LIKE ?", array($prefix.'%')); 366 foreach ($rs as $info) { 367 $table = strtolower($info->name); 368 if (strpos($table, $prefix) !== 0) { 369 // incorrect table match caused by _ 370 continue; 371 } 372 373 if (!is_null($info->auto_increment) && $info->rows == 0 && ($info->auto_increment == 1)) { 374 $table = preg_replace('/^'.preg_quote($prefix, '/').'/', '', $table); 375 $empties[$table] = $table; 376 } 377 } 378 $rs->close(); 379 return $empties; 380 381 } else if ($dbfamily === 'mssql') { 382 $empties = array(); 383 $prefix = $DB->get_prefix(); 384 $sql = "SELECT t.name 385 FROM sys.identity_columns i 386 JOIN sys.tables t ON t.object_id = i.object_id 387 WHERE t.name LIKE ? 388 AND i.name = 'id' 389 AND i.last_value IS NULL"; 390 $rs = $DB->get_recordset_sql($sql, array($prefix.'%')); 391 foreach ($rs as $info) { 392 $table = strtolower($info->name); 393 if (strpos($table, $prefix) !== 0) { 394 // incorrect table match caused by _ 395 continue; 396 } 397 $table = preg_replace('/^'.preg_quote($prefix, '/').'/', '', $table); 398 $empties[$table] = $table; 399 } 400 $rs->close(); 401 return $empties; 402 403 } else if ($dbfamily === 'oracle') { 404 $sequences = self::get_sequencenames(); 405 $sequences = array_map('strtoupper', $sequences); 406 $lookup = array_flip($sequences); 407 $empties = array(); 408 list($seqs, $params) = $DB->get_in_or_equal($sequences); 409 $sql = "SELECT sequence_name FROM user_sequences WHERE last_number = 1 AND sequence_name $seqs"; 410 $rs = $DB->get_recordset_sql($sql, $params); 411 foreach ($rs as $seq) { 412 $table = $lookup[$seq->sequence_name]; 413 $empties[$table] = $table; 414 } 415 $rs->close(); 416 return $empties; 417 418 } else { 419 return array(); 420 } 421 } 422 423 /** 424 * Determine the next unique starting id sequences. 425 * 426 * @static 427 * @param array $records The records to use to determine the starting value for the table. 428 * @param string $table table name. 429 * @return int The value the sequence should be set to. 430 */ 431 private static function get_next_sequence_starting_value($records, $table) { 432 if (isset(self::$tablesequences[$table])) { 433 return self::$tablesequences[$table]; 434 } 435 436 $id = self::$sequencenextstartingid; 437 438 // If there are records, calculate the minimum id we can use. 439 // It must be bigger than the last record's id. 440 if (!empty($records)) { 441 $lastrecord = end($records); 442 $id = max($id, $lastrecord->id + 1); 443 } 444 445 self::$sequencenextstartingid = $id + 1000; 446 447 self::$tablesequences[$table] = $id; 448 449 return $id; 450 } 451 452 /** 453 * Reset all database sequences to initial values. 454 * 455 * @static 456 * @param array $empties tables that are known to be unmodified and empty 457 * @return void 458 */ 459 public static function reset_all_database_sequences(array $empties = null) { 460 global $DB; 461 462 if (!$data = self::get_tabledata()) { 463 // Not initialised yet. 464 return; 465 } 466 if (!$structure = self::get_tablestructure()) { 467 // Not initialised yet. 468 return; 469 } 470 471 $updatedtables = self::$tableupdated; 472 473 // If all starting Id's are the same, it's difficult to detect coding and testing 474 // errors that use the incorrect id in tests. The classic case is cmid vs instance id. 475 // To reduce the chance of the coding error, we start sequences at different values where possible. 476 // In a attempt to avoid tables with existing id's we start at a high number. 477 // Reset the value each time all database sequences are reset. 478 if (defined('PHPUNIT_SEQUENCE_START') and PHPUNIT_SEQUENCE_START) { 479 self::$sequencenextstartingid = PHPUNIT_SEQUENCE_START; 480 } else { 481 self::$sequencenextstartingid = 100000; 482 } 483 484 $dbfamily = $DB->get_dbfamily(); 485 if ($dbfamily === 'postgres') { 486 $queries = array(); 487 $prefix = $DB->get_prefix(); 488 foreach ($data as $table => $records) { 489 // If table is not modified then no need to do anything. 490 if (!isset($updatedtables[$table])) { 491 continue; 492 } 493 if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) { 494 $nextid = self::get_next_sequence_starting_value($records, $table); 495 $queries[] = "ALTER SEQUENCE {$prefix}{$table}_id_seq RESTART WITH $nextid"; 496 } 497 } 498 if ($queries) { 499 $DB->change_database_structure(implode(';', $queries)); 500 } 501 502 } else if ($dbfamily === 'mysql') { 503 $queries = array(); 504 $sequences = array(); 505 $prefix = $DB->get_prefix(); 506 $rs = $DB->get_recordset_sql("SHOW TABLE STATUS LIKE ?", array($prefix.'%')); 507 foreach ($rs as $info) { 508 $table = strtolower($info->name); 509 if (strpos($table, $prefix) !== 0) { 510 // incorrect table match caused by _ 511 continue; 512 } 513 if (!is_null($info->auto_increment)) { 514 $table = preg_replace('/^'.preg_quote($prefix, '/').'/', '', $table); 515 $sequences[$table] = $info->auto_increment; 516 } 517 } 518 $rs->close(); 519 $prefix = $DB->get_prefix(); 520 foreach ($data as $table => $records) { 521 // If table is not modified then no need to do anything. 522 if (!isset($updatedtables[$table])) { 523 continue; 524 } 525 if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) { 526 if (isset($sequences[$table])) { 527 $nextid = self::get_next_sequence_starting_value($records, $table); 528 if ($sequences[$table] != $nextid) { 529 $queries[] = "ALTER TABLE {$prefix}{$table} AUTO_INCREMENT = $nextid"; 530 } 531 } else { 532 // some problem exists, fallback to standard code 533 $DB->get_manager()->reset_sequence($table); 534 } 535 } 536 } 537 if ($queries) { 538 $DB->change_database_structure(implode(';', $queries)); 539 } 540 541 } else if ($dbfamily === 'oracle') { 542 $sequences = self::get_sequencenames(); 543 $sequences = array_map('strtoupper', $sequences); 544 $lookup = array_flip($sequences); 545 546 $current = array(); 547 list($seqs, $params) = $DB->get_in_or_equal($sequences); 548 $sql = "SELECT sequence_name, last_number FROM user_sequences WHERE sequence_name $seqs"; 549 $rs = $DB->get_recordset_sql($sql, $params); 550 foreach ($rs as $seq) { 551 $table = $lookup[$seq->sequence_name]; 552 $current[$table] = $seq->last_number; 553 } 554 $rs->close(); 555 556 foreach ($data as $table => $records) { 557 // If table is not modified then no need to do anything. 558 if (!isset($updatedtables[$table])) { 559 continue; 560 } 561 if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) { 562 $lastrecord = end($records); 563 if ($lastrecord) { 564 $nextid = $lastrecord->id + 1; 565 } else { 566 $nextid = 1; 567 } 568 if (!isset($current[$table])) { 569 $DB->get_manager()->reset_sequence($table); 570 } else if ($nextid == $current[$table]) { 571 continue; 572 } 573 // reset as fast as possible - alternatively we could use http://stackoverflow.com/questions/51470/how-do-i-reset-a-sequence-in-oracle 574 $seqname = $sequences[$table]; 575 $cachesize = $DB->get_manager()->generator->sequence_cache_size; 576 $DB->change_database_structure("DROP SEQUENCE $seqname"); 577 $DB->change_database_structure("CREATE SEQUENCE $seqname START WITH $nextid INCREMENT BY 1 NOMAXVALUE CACHE $cachesize"); 578 } 579 } 580 581 } else { 582 // note: does mssql support any kind of faster reset? 583 // This also implies mssql will not use unique sequence values. 584 if (is_null($empties) and (empty($updatedtables))) { 585 $empties = self::guess_unmodified_empty_tables(); 586 } 587 foreach ($data as $table => $records) { 588 // If table is not modified then no need to do anything. 589 if (isset($empties[$table]) or (!isset($updatedtables[$table]))) { 590 continue; 591 } 592 if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) { 593 $DB->get_manager()->reset_sequence($table); 594 } 595 } 596 } 597 } 598 599 /** 600 * Reset all database tables to default values. 601 * @static 602 * @return bool true if reset done, false if skipped 603 */ 604 public static function reset_database() { 605 global $DB; 606 607 $tables = $DB->get_tables(false); 608 if (!$tables or empty($tables['config'])) { 609 // not installed yet 610 return false; 611 } 612 613 if (!$data = self::get_tabledata()) { 614 // not initialised yet 615 return false; 616 } 617 if (!$structure = self::get_tablestructure()) { 618 // not initialised yet 619 return false; 620 } 621 622 $empties = array(); 623 // Use local copy of self::$tableupdated, as list gets updated in for loop. 624 $updatedtables = self::$tableupdated; 625 626 // If empty tablesequences list then it's the very first run. 627 if (empty(self::$tablesequences) && (($DB->get_dbfamily() != 'mysql') && ($DB->get_dbfamily() != 'postgres'))) { 628 // Only Mysql and Postgres support random sequence, so don't guess, just reset everything on very first run. 629 $empties = self::guess_unmodified_empty_tables(); 630 } 631 632 // Check if any table has been modified by behat selenium process. 633 if (defined('BEHAT_SITE_RUNNING')) { 634 // Crazy way to reset :(. 635 $tablesupdatedfile = self::get_tables_updated_by_scenario_list_path(); 636 if ($tablesupdated = @json_decode(file_get_contents($tablesupdatedfile), true)) { 637 self::$tableupdated = array_merge(self::$tableupdated, $tablesupdated); 638 unlink($tablesupdatedfile); 639 } 640 $updatedtables = self::$tableupdated; 641 } 642 643 $borkedmysql = false; 644 if ($DB->get_dbfamily() === 'mysql') { 645 $version = $DB->get_server_info(); 646 if (version_compare($version['version'], '5.7.4', '<')) { 647 // Everything that comes from Oracle is evil! 648 // 649 // See http://dev.mysql.com/doc/refman/5.6/en/alter-table.html 650 // You cannot reset the counter to a value less than or equal to to the value that is currently in use. 651 // 652 // From 5.6.16 release notes: 653 // InnoDB: The ALTER TABLE INPLACE algorithm would fail to decrease the auto-increment value. 654 // (Bug #17250787, Bug #69882) 655 // This also impacts MySQL < 5.7.4. 656 $borkedmysql = true; 657 } 658 659 if ($borkedmysql) { 660 $mysqlsequences = array(); 661 $prefix = $DB->get_prefix(); 662 $rs = $DB->get_recordset_sql("SHOW TABLE STATUS LIKE ?", array($prefix.'%')); 663 foreach ($rs as $info) { 664 $table = strtolower($info->name); 665 if (strpos($table, $prefix) !== 0) { 666 // Incorrect table match caused by _ char. 667 continue; 668 } 669 if (!is_null($info->auto_increment)) { 670 $table = preg_replace('/^'.preg_quote($prefix, '/').'/', '', $table); 671 $mysqlsequences[$table] = $info->auto_increment; 672 } 673 } 674 $rs->close(); 675 } 676 } 677 678 foreach ($data as $table => $records) { 679 // If table is not modified then no need to do anything. 680 // $updatedtables tables is set after the first run, so check before checking for specific table update. 681 if (!empty($updatedtables) && !isset($updatedtables[$table])) { 682 continue; 683 } 684 685 if ($borkedmysql) { 686 if (empty($records)) { 687 if (!isset($empties[$table])) { 688 // Table has been modified and is not empty. 689 $DB->delete_records($table, null); 690 } 691 continue; 692 } 693 694 if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) { 695 $current = $DB->get_records($table, array(), 'id ASC'); 696 if ($current == $records) { 697 if (isset($mysqlsequences[$table]) and $mysqlsequences[$table] == $structure[$table]['id']->auto_increment) { 698 continue; 699 } 700 } 701 } 702 703 // Use TRUNCATE as a workaround and reinsert everything. 704 $DB->delete_records($table, null); 705 foreach ($records as $record) { 706 $DB->import_record($table, $record, false, true); 707 } 708 continue; 709 } 710 711 if (empty($records)) { 712 if (!isset($empties[$table])) { 713 // Table has been modified and is not empty. 714 $DB->delete_records($table, array()); 715 } 716 continue; 717 } 718 719 if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) { 720 $currentrecords = $DB->get_records($table, array(), 'id ASC'); 721 $changed = false; 722 foreach ($records as $id => $record) { 723 if (!isset($currentrecords[$id])) { 724 $changed = true; 725 break; 726 } 727 if ((array)$record != (array)$currentrecords[$id]) { 728 $changed = true; 729 break; 730 } 731 unset($currentrecords[$id]); 732 } 733 if (!$changed) { 734 if ($currentrecords) { 735 $lastrecord = end($records); 736 $DB->delete_records_select($table, "id > ?", array($lastrecord->id)); 737 continue; 738 } else { 739 continue; 740 } 741 } 742 } 743 744 $DB->delete_records($table, array()); 745 foreach ($records as $record) { 746 $DB->import_record($table, $record, false, true); 747 } 748 } 749 750 // reset all next record ids - aka sequences 751 self::reset_all_database_sequences($empties); 752 753 // remove extra tables 754 foreach ($tables as $table) { 755 if (!isset($data[$table])) { 756 $DB->get_manager()->drop_table(new xmldb_table($table)); 757 } 758 } 759 760 self::reset_updated_table_list(); 761 762 return true; 763 } 764 765 /** 766 * Purge dataroot directory 767 * @static 768 * @return void 769 */ 770 public static function reset_dataroot() { 771 global $CFG; 772 773 $childclassname = self::get_framework() . '_util'; 774 775 // Do not delete automatically installed files. 776 self::skip_original_data_files($childclassname); 777 778 // Clear file status cache, before checking file_exists. 779 clearstatcache(); 780 781 // Clean up the dataroot folder. 782 $handle = opendir(self::get_dataroot()); 783 while (false !== ($item = readdir($handle))) { 784 if (in_array($item, $childclassname::$datarootskiponreset)) { 785 continue; 786 } 787 if (is_dir(self::get_dataroot()."/$item")) { 788 remove_dir(self::get_dataroot()."/$item", false); 789 } else { 790 unlink(self::get_dataroot()."/$item"); 791 } 792 } 793 closedir($handle); 794 795 // Clean up the dataroot/filedir folder. 796 if (file_exists(self::get_dataroot() . '/filedir')) { 797 $handle = opendir(self::get_dataroot() . '/filedir'); 798 while (false !== ($item = readdir($handle))) { 799 if (in_array('filedir' . DIRECTORY_SEPARATOR . $item, $childclassname::$datarootskiponreset)) { 800 continue; 801 } 802 if (is_dir(self::get_dataroot()."/filedir/$item")) { 803 remove_dir(self::get_dataroot()."/filedir/$item", false); 804 } else { 805 unlink(self::get_dataroot()."/filedir/$item"); 806 } 807 } 808 closedir($handle); 809 } 810 811 make_temp_directory(''); 812 make_backup_temp_directory(''); 813 make_cache_directory(''); 814 make_localcache_directory(''); 815 // Purge all data from the caches. This is required for consistency between tests. 816 // Any file caches that happened to be within the data root will have already been clearer (because we just deleted cache) 817 // and now we will purge any other caches as well. This must be done before the cache_factory::reset() as that 818 // removes all definitions of caches and purge does not have valid caches to operate on. 819 cache_helper::purge_all(); 820 // Reset the cache API so that it recreates it's required directories as well. 821 cache_factory::reset(); 822 } 823 824 /** 825 * Gets a text-based site version description. 826 * 827 * @return string The site info 828 */ 829 public static function get_site_info() { 830 global $CFG; 831 832 $output = ''; 833 834 // All developers have to understand English, do not localise! 835 $env = self::get_environment(); 836 837 $output .= "Moodle ".$env['moodleversion']; 838 if ($hash = self::get_git_hash()) { 839 $output .= ", $hash"; 840 } 841 $output .= "\n"; 842 843 // Add php version. 844 require_once($CFG->libdir.'/environmentlib.php'); 845 $output .= "Php: ". normalize_version($env['phpversion']); 846 847 // Add database type and version. 848 $output .= ", " . $env['dbtype'] . ": " . $env['dbversion']; 849 850 // OS details. 851 $output .= ", OS: " . $env['os'] . "\n"; 852 853 return $output; 854 } 855 856 /** 857 * Try to get current git hash of the Moodle in $CFG->dirroot. 858 * @return string null if unknown, sha1 hash if known 859 */ 860 public static function get_git_hash() { 861 global $CFG; 862 863 // This is a bit naive, but it should mostly work for all platforms. 864 865 if (!file_exists("$CFG->dirroot/.git/HEAD")) { 866 return null; 867 } 868 869 $headcontent = file_get_contents("$CFG->dirroot/.git/HEAD"); 870 if ($headcontent === false) { 871 return null; 872 } 873 874 $headcontent = trim($headcontent); 875 876 // If it is pointing to a hash we return it directly. 877 if (strlen($headcontent) === 40) { 878 return $headcontent; 879 } 880 881 if (strpos($headcontent, 'ref: ') !== 0) { 882 return null; 883 } 884 885 $ref = substr($headcontent, 5); 886 887 if (!file_exists("$CFG->dirroot/.git/$ref")) { 888 return null; 889 } 890 891 $hash = file_get_contents("$CFG->dirroot/.git/$ref"); 892 893 if ($hash === false) { 894 return null; 895 } 896 897 $hash = trim($hash); 898 899 if (strlen($hash) != 40) { 900 return null; 901 } 902 903 return $hash; 904 } 905 906 /** 907 * Set state of modified tables. 908 * 909 * @param string $sql sql which is updating the table. 910 */ 911 public static function set_table_modified_by_sql($sql) { 912 global $DB; 913 914 $prefix = $DB->get_prefix(); 915 916 preg_match('/( ' . $prefix . '\w*)(.*)/', $sql, $matches); 917 // Ignore random sql for testing like "XXUPDATE SET XSSD". 918 if (!empty($matches[1])) { 919 $table = trim($matches[1]); 920 $table = preg_replace('/^' . preg_quote($prefix, '/') . '/', '', $table); 921 self::$tableupdated[$table] = true; 922 923 if (defined('BEHAT_SITE_RUNNING')) { 924 $tablesupdatedfile = self::get_tables_updated_by_scenario_list_path(); 925 $tablesupdated = @json_decode(file_get_contents($tablesupdatedfile), true); 926 if (!isset($tablesupdated[$table])) { 927 $tablesupdated[$table] = true; 928 @file_put_contents($tablesupdatedfile, json_encode($tablesupdated, JSON_PRETTY_PRINT)); 929 } 930 } 931 } 932 } 933 934 /** 935 * Reset updated table list. This should be done after every reset. 936 */ 937 public static function reset_updated_table_list() { 938 self::$tableupdated = array(); 939 } 940 941 /** 942 * Delete tablesupdatedbyscenario file. This should be called before suite, 943 * to ensure full db reset. 944 */ 945 public static function clean_tables_updated_by_scenario_list() { 946 $tablesupdatedfile = self::get_tables_updated_by_scenario_list_path(); 947 if (file_exists($tablesupdatedfile)) { 948 unlink($tablesupdatedfile); 949 } 950 951 // Reset static cache of cli process. 952 self::reset_updated_table_list(); 953 } 954 955 /** 956 * Returns the path to the file which holds list of tables updated in scenario. 957 * @return string 958 */ 959 protected final static function get_tables_updated_by_scenario_list_path() { 960 return self::get_dataroot() . '/tablesupdatedbyscenario.json'; 961 } 962 963 /** 964 * Drop the whole test database 965 * @static 966 * @param bool $displayprogress 967 */ 968 protected static function drop_database($displayprogress = false) { 969 global $DB; 970 971 $tables = $DB->get_tables(false); 972 if (isset($tables['config'])) { 973 // config always last to prevent problems with interrupted drops! 974 unset($tables['config']); 975 $tables['config'] = 'config'; 976 } 977 978 if ($displayprogress) { 979 echo "Dropping tables:\n"; 980 } 981 $dotsonline = 0; 982 foreach ($tables as $tablename) { 983 $table = new xmldb_table($tablename); 984 $DB->get_manager()->drop_table($table); 985 986 if ($dotsonline == 60) { 987 if ($displayprogress) { 988 echo "\n"; 989 } 990 $dotsonline = 0; 991 } 992 if ($displayprogress) { 993 echo '.'; 994 } 995 $dotsonline += 1; 996 } 997 if ($displayprogress) { 998 echo "\n"; 999 } 1000 } 1001 1002 /** 1003 * Drops the test framework dataroot 1004 * @static 1005 */ 1006 protected static function drop_dataroot() { 1007 global $CFG; 1008 1009 $framework = self::get_framework(); 1010 $childclassname = $framework . '_util'; 1011 1012 $files = scandir(self::get_dataroot() . '/' . $framework); 1013 foreach ($files as $file) { 1014 if (in_array($file, $childclassname::$datarootskipondrop)) { 1015 continue; 1016 } 1017 $path = self::get_dataroot() . '/' . $framework . '/' . $file; 1018 if (is_dir($path)) { 1019 remove_dir($path, false); 1020 } else { 1021 unlink($path); 1022 } 1023 } 1024 1025 $jsonfilepath = self::get_dataroot() . '/' . self::$originaldatafilesjson; 1026 if (file_exists($jsonfilepath)) { 1027 // Delete the json file. 1028 unlink($jsonfilepath); 1029 // Delete the dataroot filedir. 1030 remove_dir(self::get_dataroot() . '/filedir', false); 1031 } 1032 } 1033 1034 /** 1035 * Skip the original dataroot files to not been reset. 1036 * 1037 * @static 1038 * @param string $utilclassname the util class name.. 1039 */ 1040 protected static function skip_original_data_files($utilclassname) { 1041 $jsonfilepath = self::get_dataroot() . '/' . self::$originaldatafilesjson; 1042 if (file_exists($jsonfilepath)) { 1043 1044 $listfiles = file_get_contents($jsonfilepath); 1045 1046 // Mark each files as to not be reset. 1047 if (!empty($listfiles) && !self::$originaldatafilesjsonadded) { 1048 $originaldatarootfiles = json_decode($listfiles); 1049 // Keep the json file. Only drop_dataroot() should delete it. 1050 $originaldatarootfiles[] = self::$originaldatafilesjson; 1051 $utilclassname::$datarootskiponreset = array_merge($utilclassname::$datarootskiponreset, 1052 $originaldatarootfiles); 1053 self::$originaldatafilesjsonadded = true; 1054 } 1055 } 1056 } 1057 1058 /** 1059 * Save the list of the original dataroot files into a json file. 1060 */ 1061 protected static function save_original_data_files() { 1062 global $CFG; 1063 1064 $jsonfilepath = self::get_dataroot() . '/' . self::$originaldatafilesjson; 1065 1066 // Save the original dataroot files if not done (only executed the first time). 1067 if (!file_exists($jsonfilepath)) { 1068 1069 $listfiles = array(); 1070 $currentdir = 'filedir' . DIRECTORY_SEPARATOR . '.'; 1071 $parentdir = 'filedir' . DIRECTORY_SEPARATOR . '..'; 1072 $listfiles[$currentdir] = $currentdir; 1073 $listfiles[$parentdir] = $parentdir; 1074 1075 $filedir = self::get_dataroot() . '/filedir'; 1076 if (file_exists($filedir)) { 1077 $directory = new RecursiveDirectoryIterator($filedir); 1078 foreach (new RecursiveIteratorIterator($directory) as $file) { 1079 if ($file->isDir()) { 1080 $key = substr($file->getPath(), strlen(self::get_dataroot() . '/')); 1081 } else { 1082 $key = substr($file->getPathName(), strlen(self::get_dataroot() . '/')); 1083 } 1084 $listfiles[$key] = $key; 1085 } 1086 } 1087 1088 // Save the file list in a JSON file. 1089 $fp = fopen($jsonfilepath, 'w'); 1090 fwrite($fp, json_encode(array_values($listfiles))); 1091 fclose($fp); 1092 } 1093 } 1094 1095 /** 1096 * Return list of environment versions on which tests will run. 1097 * Environment includes: 1098 * - moodleversion 1099 * - phpversion 1100 * - dbtype 1101 * - dbversion 1102 * - os 1103 * 1104 * @return array 1105 */ 1106 public static function get_environment() { 1107 global $CFG, $DB; 1108 1109 $env = array(); 1110 1111 // Add moodle version. 1112 $release = null; 1113 require("$CFG->dirroot/version.php"); 1114 $env['moodleversion'] = $release; 1115 1116 // Add php version. 1117 $phpversion = phpversion(); 1118 $env['phpversion'] = $phpversion; 1119 1120 // Add database type and version. 1121 $dbtype = $CFG->dbtype; 1122 $dbinfo = $DB->get_server_info(); 1123 $dbversion = $dbinfo['version']; 1124 $env['dbtype'] = $dbtype; 1125 $env['dbversion'] = $dbversion; 1126 1127 // OS details. 1128 $osdetails = php_uname('s') . " " . php_uname('r') . " " . php_uname('m'); 1129 $env['os'] = $osdetails; 1130 1131 return $env; 1132 } 1133 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
