mirror of
https://github.com/moodle/moodle.git
synced 2025-05-15 04:36:13 +02:00
0dbeb9748b
There are some unexpected differences between 310 and master, better reconcile them now. Note this is not 100% critical but, as far as nothing exclusively for 4.0 has landed to master yet only branch/version differences should exist.
372 lines
15 KiB
PHP
372 lines
15 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/>.
|
|
|
|
/**
|
|
* Handle simple PHP/CSV/XML datasets to be use with ease by unit tests.
|
|
*
|
|
* This is a very minimal class, able to load data from PHP arrays and
|
|
* CSV/XML files, optionally uploading them to database.
|
|
*
|
|
* This doesn't aim to be a complex or complete solution, but just a
|
|
* utility class to replace old phpunit/dbunit uses, because that package
|
|
* is not longer maintained. Note that, ideally, generators should provide
|
|
* the needed utilities to proceed with this loading of information to
|
|
* database and, if there is any future that should be it.
|
|
*
|
|
* @package core
|
|
* @category test
|
|
* @copyright 2020 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
declare(strict_types=1);
|
|
|
|
/**
|
|
* Lightweight dataset class for phpunit, supports XML, CSV and array datasets.
|
|
*
|
|
* This is a simple replacement class for the old old phpunit/dbunit, now
|
|
* archived. It allows to load CSV, XML and array structures to database.
|
|
*/
|
|
class phpunit_dataset {
|
|
|
|
/** @var array tables being handled by the dataset */
|
|
protected $tables = [];
|
|
/** @var array columns belonging to every table (keys) handled by the dataset */
|
|
protected $columns = [];
|
|
/** @var array rows belonging to every table (keys) handled by the dataset */
|
|
protected $rows = [];
|
|
|
|
/**
|
|
* Load information from multiple files (XML, CSV) to the dataset.
|
|
*
|
|
* This method accepts an array of full paths to CSV or XML files to be loaded
|
|
* into the dataset. For CSV files, the name of the table which the file belongs
|
|
* to needs to be specified. Example:
|
|
*
|
|
* $fullpaths = [
|
|
* '/path/to/users.xml',
|
|
* 'course' => '/path/to/courses.csv',
|
|
* ];
|
|
*
|
|
* @param array $fullpaths full paths to CSV or XML files to load.
|
|
*/
|
|
public function from_files(array $fullpaths): void {
|
|
foreach ($fullpaths as $table => $fullpath) {
|
|
$table = is_int($table) ? null : $table; // Only a table when it's an associative array.
|
|
$this->from_file($fullpath, $table);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load information from one file (XML, CSV) to the dataset.
|
|
*
|
|
* @param string $fullpath full path to CSV or XML file to load.
|
|
* @param string|null $table name of the table which the file belongs to (only for CSV files).
|
|
*/
|
|
public function from_file(string $fullpath, ?string $table = null): void {
|
|
if (!file_exists($fullpath)) {
|
|
throw new coding_exception('from_file, file not found: ' . $fullpath);
|
|
}
|
|
|
|
if (!is_readable($fullpath)) {
|
|
throw new coding_exception('from_file, file not readable: ' . $fullpath);
|
|
}
|
|
|
|
$extension = strtolower(pathinfo($fullpath, PATHINFO_EXTENSION));
|
|
if (!in_array($extension, ['csv', 'xml'])) {
|
|
throw new coding_exception('from_file, cannot handle files with extension: ' . $extension);
|
|
}
|
|
|
|
$this->from_string(file_get_contents($fullpath), $extension, $table);
|
|
}
|
|
|
|
/**
|
|
* Load information from a string (XML, CSV) to the dataset.
|
|
*
|
|
* @param string $content contents (CSV or XML) to load.
|
|
* @param string $type format of the content to be loaded (csv or xml).
|
|
* @param string|null $table name of the table which the file belongs to (only for CSV files).
|
|
*/
|
|
public function from_string(string $content, string $type, ?string $table = null): void {
|
|
switch ($type) {
|
|
case 'xml':
|
|
$this->load_xml($content);
|
|
break;
|
|
case 'csv':
|
|
if (empty($table)) {
|
|
throw new coding_exception('from_string, contents of type "cvs" require a $table to be passed, none found');
|
|
}
|
|
$this->load_csv($content, $table);
|
|
break;
|
|
default:
|
|
throw new coding_exception('from_string, cannot handle contents of type: ' . $type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load information from a PHP array to the dataset.
|
|
*
|
|
* The general structure of the PHP array must be
|
|
* [table name] => [array of rows, each one being an array of values or column => values.
|
|
* The format of the array must be one of the following:
|
|
* - non-associative array, with column names in the first row (pretty much like CSV files are):
|
|
* $structure = [
|
|
* 'table 1' => [
|
|
* ['column name 1', 'column name 2'],
|
|
* ['row 1 column 1 value', 'row 1 column 2 value'*,
|
|
* ['row 2 column 1 value', 'row 2 column 2 value'*,
|
|
* ],
|
|
* 'table 2' => ...
|
|
* ];
|
|
* - associative array, with column names being keys in the array.
|
|
* $structure = [
|
|
* 'table 1' => [
|
|
* ['column name 1' => 'row 1 column 1 value', 'column name 2' => 'row 1 column 2 value'],
|
|
* ['column name 1' => 'row 2 column 1 value', 'column name 2' => 'row 2 column 2 value'],
|
|
* ],
|
|
* 'table 2' => ...
|
|
* ];
|
|
* @param array $structure php array with a valid structure to be loaded to the dataset.
|
|
*/
|
|
public function from_array(array $structure): void {
|
|
foreach ($structure as $tablename => $rows) {
|
|
if (in_array($tablename, $this->tables)) {
|
|
throw new coding_exception('from_array, table already added to dataset: ' . $tablename);
|
|
}
|
|
|
|
$this->tables[] = $tablename;
|
|
$this->columns[$tablename] = [];
|
|
$this->rows[$tablename] = [];
|
|
|
|
$isassociative = false;
|
|
$firstrow = reset($rows);
|
|
|
|
if (array_key_exists(0, $firstrow)) {
|
|
// Columns are the first row (csv-like).
|
|
$this->columns[$tablename] = $firstrow;
|
|
array_shift($rows);
|
|
} else {
|
|
// Columns are the keys on every record, first one must have all.
|
|
$this->columns[$tablename] = array_keys($firstrow);
|
|
$isassociative = true;
|
|
}
|
|
|
|
$countcols = count($this->columns[$tablename]);
|
|
foreach ($rows as $row) {
|
|
$countvalues = count($row);
|
|
if ($countcols != $countvalues) {
|
|
throw new coding_exception('from_array, number of columns must match number of values, found: ' .
|
|
$countcols . ' vs ' . $countvalues);
|
|
}
|
|
if ($isassociative && $this->columns[$tablename] != array_keys($row)) {
|
|
throw new coding_exception('from_array, columns in all elements must match first one, found: ' .
|
|
implode(', ', array_keys($row)));
|
|
}
|
|
$this->rows[$tablename][] = array_combine($this->columns[$tablename], array_values($row));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send all the information to the dataset to the database.
|
|
*
|
|
* This method gets all the information loaded in the dataset, using the from_xxx() methods
|
|
* and sends it to the database; table and column names must match.
|
|
*
|
|
* Note that, if the information to be sent to database contains sequence columns (usually 'id')
|
|
* then those values will be preserved (performing an import and adjusting sequences later). Else
|
|
* normal inserts will happen and sequence (auto-increment) columns will be fed automatically.
|
|
*
|
|
* @param string[] $filter Tables to be sent to database. If not specified, all tables are processed.
|
|
*/
|
|
public function to_database(array $filter = []): void {
|
|
global $DB;
|
|
|
|
// Verify all filter elements are correct.
|
|
foreach ($filter as $table) {
|
|
if (!in_array($table, $this->tables)) {
|
|
throw new coding_exception('dataset_to_database, table is not in the dataset: ' . $table);
|
|
}
|
|
}
|
|
|
|
$structure = phpunit_util::get_tablestructure();
|
|
|
|
foreach ($this->tables as $table) {
|
|
// Apply filter.
|
|
if (!empty($filter) && !in_array($table, $filter)) {
|
|
continue;
|
|
}
|
|
|
|
$doimport = false;
|
|
|
|
if (isset($structure[$table]['id']) and $structure[$table]['id']->auto_increment) {
|
|
$doimport = in_array('id', $this->columns[$table]);
|
|
}
|
|
|
|
foreach ($this->rows[$table] as $row) {
|
|
if ($doimport) {
|
|
$DB->import_record($table, $row);
|
|
} else {
|
|
$DB->insert_record($table, $row);
|
|
}
|
|
}
|
|
|
|
if ($doimport) {
|
|
$DB->get_manager()->reset_sequence(new xmldb_table($table));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the rows, for a given table, that the dataset holds.
|
|
*
|
|
* @param string[] $filter Tables to return rows. If not specified, all tables are processed.
|
|
* @return array tables as keys with rows on each as sub array.
|
|
*/
|
|
public function get_rows(array $filter = []): array {
|
|
// Verify all filter elements are correct.
|
|
foreach ($filter as $table) {
|
|
if (!in_array($table, $this->tables)) {
|
|
throw new coding_exception('dataset_get_rows, table is not in the dataset: ' . $table);
|
|
}
|
|
}
|
|
|
|
$result = [];
|
|
foreach ($this->tables as $table) {
|
|
// Apply filter.
|
|
if (!empty($filter) && !in_array($table, $filter)) {
|
|
continue;
|
|
}
|
|
$result[$table] = $this->rows[$table];
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Given a CSV content, process and load it as a table into the dataset.
|
|
*
|
|
* @param string $content CSV content to be loaded (only one table).
|
|
* @param string $tablename Name of the table the content belongs to.
|
|
*/
|
|
protected function load_csv(string $content, string $tablename): void {
|
|
if (in_array($tablename, $this->tables)) {
|
|
throw new coding_exception('csv_dataset_format, table already added to dataset: ' . $tablename);
|
|
}
|
|
|
|
$this->tables[] = $tablename;
|
|
$this->columns[$tablename] = [];
|
|
$this->rows[$tablename] = [];
|
|
|
|
// Normalise newlines.
|
|
$content = preg_replace('#\r\n?#', '\n', $content);
|
|
|
|
// Function str_getcsv() is not good for new lines within the data, so lets use temp file and fgetcsv() instead.
|
|
$tempfile = tempnam(make_temp_directory('phpunit'), 'csv');
|
|
$fh = fopen($tempfile, 'w+b');
|
|
fwrite($fh, $content);
|
|
|
|
// And let's read it using fgetcsv().
|
|
rewind($fh);
|
|
|
|
// We just accept default, delimiter = comma, enclosure = double quote.
|
|
while ( ($row = fgetcsv($fh) ) !== false ) {
|
|
if (empty($this->columns[$tablename])) {
|
|
$this->columns[$tablename] = $row;
|
|
} else {
|
|
$this->rows[$tablename][] = array_combine($this->columns[$tablename], $row);
|
|
}
|
|
}
|
|
fclose($fh);
|
|
unlink($tempfile);
|
|
}
|
|
|
|
/**
|
|
* Given a XML content, process and load it as tables into the dataset.
|
|
*
|
|
* @param string $content XML content to be loaded (can be multi-table).
|
|
*/
|
|
protected function load_xml(string $content): void {
|
|
$xml = new SimpleXMLElement($content);
|
|
// Main element must be dataset.
|
|
if ($xml->getName() !== 'dataset') {
|
|
throw new coding_exception('xml_dataset_format, main xml element must be "dataset", found: ' . $xml->getName());
|
|
}
|
|
|
|
foreach ($xml->children() as $table) {
|
|
// Only table elements allowed.
|
|
if ($table->getName() !== 'table') {
|
|
throw new coding_exception('xml_dataset_format, only "table" elements allowed, found: ' . $table->getName());
|
|
}
|
|
// Only allowed attribute of table is "name".
|
|
if (!isset($table['name'])) {
|
|
throw new coding_exception('xml_dataset_format, "table" element only allows "name" attribute.');
|
|
}
|
|
|
|
$tablename = (string)$table['name'];
|
|
if (in_array($tablename, $this->tables)) {
|
|
throw new coding_exception('xml_dataset_format, table already added to dataset: ' . $tablename);
|
|
}
|
|
|
|
$this->tables[] = $tablename;
|
|
$this->columns[$tablename] = [];
|
|
$this->rows[$tablename] = [];
|
|
|
|
$countcols = 0;
|
|
foreach ($table->children() as $colrow) {
|
|
// Only column and row allowed.
|
|
if ($colrow->getName() !== 'column' && $colrow->getName() !== 'row') {
|
|
throw new coding_exception('xml_dataset_format, only "column or "row" elements allowed, found: ' .
|
|
$colrow->getName());
|
|
}
|
|
// Column always before row.
|
|
if ($colrow->getName() == 'column' && !empty($this->rows[$tablename])) {
|
|
throw new coding_exception('xml_dataset_format, "column" elements always must be before "row" ones');
|
|
}
|
|
// Row always after column.
|
|
if ($colrow->getName() == 'row' && empty($this->columns[$tablename])) {
|
|
throw new coding_exception('xml_dataset_format, "row" elements always must be after "column" ones');
|
|
}
|
|
|
|
// Process column.
|
|
if ($colrow->getName() == 'column') {
|
|
$this->columns[$tablename][] = (string)$colrow;
|
|
$countcols++;
|
|
}
|
|
|
|
// Process row.
|
|
if ($colrow->getName() == 'row') {
|
|
$countvalues = 0;
|
|
$row = [];
|
|
foreach ($colrow->children() as $value) {
|
|
// Only value allowed under row.
|
|
if ($value->getName() !== 'value') {
|
|
throw new coding_exception('xml_dataset_format, only "value" elements allowed, found: ' .
|
|
$value->getName());
|
|
}
|
|
$row[$this->columns[$tablename][$countvalues]] = (string)$value;
|
|
$countvalues++;
|
|
}
|
|
if ($countcols !== $countvalues) {
|
|
throw new coding_exception('xml_dataset_format, number of columns must match number of values, found: ' .
|
|
$countcols . ' vs ' . $countvalues);
|
|
}
|
|
$this->rows[$tablename][] = $row;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|