mirror_php/moodle
1
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-03-14 04:30:15 +01:00
Code Issues Projects Releases Wiki Activity

Merge branch 'MDL-38197-master' of git://github.com/sammarshallou/moodle

Browse Source
This commit is contained in:
Dan Poltawski 2013-08-20 14:55:07 +08:00
commit 1dae651584
8 changed files with 1030 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

606
admin/tool/generator/classes/backend.php Normal file
View File

@ -0,0 +1,606 @@
<?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/>.
defined('MOODLE_INTERNAL') || die();
/**
* Backend code for the 'make large course' tool.
*
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class tool_generator_backend {
/**
* @var int Lowest (smallest) size index
*/
const MIN_SIZE = 0;
/**
* @var int Highest (largest) size index
*/
const MAX_SIZE = 5;
/**
* @var int Default size index
*/
const DEFAULT_SIZE = 3;
/**
* @var array Number of sections in course
*/
private static $paramsections = array(1, 10, 100, 500, 1000, 2000);
/**
* @var array Number of Page activities in course
*/
private static $parampages = array(1, 50, 200, 1000, 5000, 10000);
/**
* @var array Number of students enrolled in course
*/
private static $paramusers = array(1, 100, 1000, 10000, 50000, 100000);
/**
* Total size of small files: 1KB, 1MB, 10MB, 100MB, 1GB, 2GB.
*
* @var array Number of small files created in a single file activity
*/
private static $paramsmallfilecount = array(1, 64, 128, 1024, 16384, 32768);
/**
* @var array Size of small files (to make the totals into nice numbers)
*/
private static $paramsmallfilesize = array(1024, 16384, 81920, 102400, 65536, 65536);
/**
* Total size of big files: 8KB, 8MB, 80MB, 800MB, 8GB, 16GB.
*
* @var array Number of big files created as individual file activities
*/
private static $parambigfilecount = array(1, 2, 5, 10, 10, 10);
/**
* @var array Size of each large file
*/
private static $parambigfilesize = array(8192, 4194304, 16777216, 83886080,
858993459, 1717986918);
/**
* @var array Number of forum discussions
*/
private static $paramforumdiscussions = array(1, 10, 100, 500, 1000, 2000);
/**
* @var array Number of forum posts per discussion
*/
private static $paramforumposts = array(2, 2, 5, 10, 10, 10);
/**
* @var string Course shortname
*/
private $shortname;
/**
* @var int Size code (index in the above arrays)
*/
private $size;
/**
* @var bool True if displaying progress
*/
private $progress;
/**
* @var testing_data_generator Data generator
*/
private $generator;
/**
* @var stdClass Course object
*/
private $course;
/**
* @var int Epoch time at which last dot was displayed
*/
private $lastdot;
/**
* @var int Epoch time at which last percentage was displayed
*/
private $lastpercentage;
/**
* @var int Epoch time at which current step (current set of dots) started
*/
private $starttime;
/**
* @var array Array from test user number (1...N) to userid in database
*/
private $userids;
/**
* Constructs object ready to create course.
*
* @param string $shortname Course shortname
* @param int $size Size as numeric index
* @param bool $progress True if progress information should be displayed
* @return int Course id
* @throws coding_exception If parameters are invalid
*/
public function __construct($shortname, $size, $progress = true) {
// Check parameter.
if ($size < self::MIN_SIZE || $size > self::MAX_SIZE) {
throw new coding_exception('Invalid size');
}
// Set parameters.
$this->shortname = $shortname;
$this->size = $size;
$this->progress = $progress;
}
/**
* Gets a list of size choices supported by this backend.
*
* @return array List of size (int) => text description for display
*/
public static function get_size_choices() {
$options = array();
for ($size = self::MIN_SIZE; $size <= self::MAX_SIZE; $size++) {
$options[$size] = get_string('size_' . $size, 'tool_generator');
}
return $options;
}
/**
* Converts a size name into the numeric constant.
*
* @param string $sizename Size name e.g. 'L'
* @return int Numeric version
* @throws coding_exception If the size name is not known
*/
public static function size_for_name($sizename) {
for ($size = self::MIN_SIZE; $size <= self::MAX_SIZE; $size++) {
if ($sizename == get_string('shortsize_' . $size, 'tool_generator')) {
return $size;
}
}
throw new coding_exception("Unknown size name '$sizename'");
}
/**
* Checks that a shortname is available (unused).
*
* @param string $shortname Proposed course shortname
* @return string An error message if the name is unavailable or '' if OK
*/
public static function check_shortname_available($shortname) {
global $DB;
$fullname = $DB->get_field('course', 'fullname',
array('shortname' => $shortname), IGNORE_MISSING);
if ($fullname !== false) {
// I wanted to throw an exception here but it is not possible to
// use strings from moodle.php in exceptions, and I didn't want
// to duplicate the string in tool_generator, so I changed this to
// not use exceptions.
return get_string('shortnametaken', 'moodle', $fullname);
}
return '';
}
/**
* Runs the entire 'make' process.
*
* @return int Course id
*/
public function make() {
global $DB, $CFG;
require_once($CFG->dirroot . '/lib/phpunit/classes/util.php');
raise_memory_limit(MEMORY_EXTRA);
if ($this->progress && !CLI_SCRIPT) {
echo html_writer::start_tag('ul');
}
$entirestart = microtime(true);
// Start transaction.
$transaction = $DB->start_delegated_transaction();
// Get generator.
$this->generator = phpunit_util::get_data_generator();
// Make course.
$this->course = $this->create_course();
$this->create_users();
$this->create_pages();
$this->create_small_files();
$this->create_big_files();
$this->create_forum();
// Log total time.
$this->log('complete', round(microtime(true) - $entirestart, 1));
if ($this->progress && !CLI_SCRIPT) {
echo html_writer::end_tag('ul');
}
// Commit transaction and finish.
$transaction->allow_commit();
return $this->course->id;
}
/**
* Creates the actual course.
*
* @return stdClass Course record
*/
private function create_course() {
$this->log('createcourse', $this->shortname);
$courserecord = array('shortname' => $this->shortname,
'fullname' => get_string('fullname', 'tool_generator',
array('size' => get_string('shortsize_' . $this->size, 'tool_generator'))),
'numsections' => self::$paramsections[$this->size]);
return $this->generator->create_course($courserecord, array('createsections' => true));
}
/**
* Creates a number of user accounts and enrols them on the course.
* Note: Existing user accounts that were created by this system are
* reused if available.
*/
private function create_users() {
global $DB;
// Work out total number of users.
$count = self::$paramusers[$this->size];
// Get existing users in order. We will 'fill up holes' in this up to
// the required number.
$this->log('checkaccounts', $count);
$nextnumber = 1;
$rs = $DB->get_recordset_select('user', 'username LIKE ?',
array('tool_generator_%'), 'username', 'id, username');
foreach ($rs as $rec) {
// Extract number from username.
$matches = array();
if (!preg_match('~^tool_generator_([0-9]{6})$~', $rec->username, $matches)) {
continue;
}
$number = (int)$matches[1];
// Create missing users in range up to this.
if ($number != $nextnumber) {
$this->create_user_accounts($nextnumber, min($number - 1, $count));
} else {
$this->userids[$number] = (int)$rec->id;
}
// Stop if we've got enough users.
$nextnumber = $number + 1;
if ($number >= $count) {
break;
}
}
$rs->close();
// Create users from end of existing range.
if ($nextnumber <= $count) {
$this->create_user_accounts($nextnumber, $count);
}
// Assign all users to course.
$this->log('enrol', $count, true);
$enrolplugin = enrol_get_plugin('manual');
$instances = enrol_get_instances($this->course->id, true);
foreach ($instances as $instance) {
if ($instance->enrol === 'manual') {
break;
}
}
if ($instance->enrol !== 'manual') {
throw new coding_exception('No manual enrol plugin in course');
}
$role = $DB->get_record('role', array('shortname' => 'student'), '*', MUST_EXIST);
for ($number = 1; $number <= $count; $number++) {
// Enrol user.
$enrolplugin->enrol_user($instance, $this->userids[$number], $role->id);
$this->dot($number, $count);
}
$this->end_log();
}
/**
* Creates user accounts with a numeric range.
*
* @param int $first Number of first user
* @param int $last Number of last user
*/
private function create_user_accounts($first, $last) {
$this->log('createaccounts', (object)array('from' => $first, 'to' => $last), true);
$count = $last - $first + 1;
$done = 0;
for ($number = $first; $number <= $last; $number++, $done++) {
// Work out username with 6-digit number.
$textnumber = (string)$number;
while (strlen($textnumber) < 6) {
$textnumber = '0' . $textnumber;
}
$username = 'tool_generator_' . $textnumber;
// Create user account.
$record = array('firstname' => get_string('firstname', 'tool_generator'),
'lastname' => $number, 'username' => $username);
$user = $this->generator->create_user($record);
$this->userids[$number] = (int)$user->id;
$this->dot($done, $count);
}
$this->end_log();
}
/**
* Creates a number of Page activities.
*/
private function create_pages() {
// Set up generator.
$pagegenerator = $this->generator->get_plugin_generator('mod_page');
// Create pages.
$number = self::$parampages[$this->size];
$this->log('createpages', $number, true);
for ($i=0; $i<$number; $i++) {
$record = array('course' => $this->course->id);
$options = array('section' => $this->get_random_section());
$pagegenerator->create_instance($record, $options);
$this->dot($i, $number);
}
$this->end_log();
}
/**
* Creates one resource activity with a lot of small files.
*/
private function create_small_files() {
$count = self::$paramsmallfilecount[$this->size];
$this->log('createsmallfiles', $count, true);
// Create resource with default textfile only.
$resourcegenerator = $this->generator->get_plugin_generator('mod_resource');
$record = array('course' => $this->course->id,
'name' => get_string('smallfiles', 'tool_generator'));
$options = array('section' => 0);
$resource = $resourcegenerator->create_instance($record, $options);
// Add files.
$fs = get_file_storage();
$context = context_module::instance($resource->cmid);
$filerecord = array('component' => 'mod_resource', 'filearea' => 'content',
'contextid' => $context->id, 'itemid' => 0, 'filepath' => '/');
for ($i = 0; $i < $count; $i++) {
$filerecord['filename'] = 'smallfile' . $i . '.dat';
// Generate random binary data (different for each file so it
// doesn't compress unrealistically).
$data = self::get_random_binary(self::$paramsmallfilesize[$this->size]);
$fs->create_file_from_string($filerecord, $data);
$this->dot($i, $count);
}
$this->end_log();
}
/**
* Creates a string of random binary data. The start of the string includes
* the current time, in an attempt to avoid large-scale repetition.
*
* @param int $length Number of bytes
* @return Random data
*/
private static function get_random_binary($length) {
$data = microtime(true);
if (strlen($data) > $length) {
// Use last digits of data.
return substr($data, -$length);
}
$length -= strlen($data);
for ($j=0; $j < $length; $j++) {
$data .= chr(rand(1, 255));
}
return $data;
}
/**
* Creates a number of resource activities with one big file each.
*/
private function create_big_files() {
global $CFG;
// Work out how many files and how many blocks to use (up to 64KB).
$count = self::$parambigfilecount[$this->size];
$blocks = ceil(self::$parambigfilesize[$this->size] / 65536);
$blocksize = floor(self::$parambigfilesize[$this->size] / $blocks);
$this->log('createbigfiles', $count, true);
// Prepare temp area.
$tempfolder = make_temp_directory('tool_generator');
$tempfile = $tempfolder . '/' . rand();
// Create resources and files.
$fs = get_file_storage();
$resourcegenerator = $this->generator->get_plugin_generator('mod_resource');
for ($i = 0; $i < $count; $i++) {
// Create resource.
$record = array('course' => $this->course->id,
'name' => get_string('bigfile', 'tool_generator', $i));
$options = array('section' => $this->get_random_section());
$resource = $resourcegenerator->create_instance($record, $options);
// Write file.
$handle = fopen($tempfile, 'w');
if (!$handle) {
throw new coding_exception('Failed to open temporary file');
}
for ($j = 0; $j < $blocks; $j++) {
$data = self::get_random_binary($blocksize);
fwrite($handle, $data);
$this->dot($i * $blocks + $j, $count * $blocks);
}
fclose($handle);
// Add file.
$context = context_module::instance($resource->cmid);
$filerecord = array('component' => 'mod_resource', 'filearea' => 'content',
'contextid' => $context->id, 'itemid' => 0, 'filepath' => '/',
'filename' => 'bigfile' . $i . '.dat');
$fs->create_file_from_pathname($filerecord, $tempfile);
}
unlink($tempfile);
$this->end_log();
}
/**
* Creates one forum activity with a bunch of posts.
*/
private function create_forum() {
global $DB;
$discussions = self::$paramforumdiscussions[$this->size];
$posts = self::$paramforumposts[$this->size];
$totalposts = $discussions * $posts;
$this->log('createforum', $totalposts, true);
// Create empty forum.
$forumgenerator = $this->generator->get_plugin_generator('mod_forum');
$record = array('course' => $this->course->id,
'name' => get_string('pluginname', 'forum'));
$options = array('section' => 0);
$forum = $forumgenerator->create_instance($record, $options);
// Add discussions and posts.
$sofar = 0;
for ($i=0; $i < $discussions; $i++) {
$record = array('forum' => $forum->id, 'course' => $this->course->id,
'userid' => $this->get_random_user());
$discussion = $forumgenerator->create_discussion($record);
$parentid = $DB->get_field('forum_posts', 'id', array('discussion' => $discussion->id), MUST_EXIST);
$sofar++;
for ($j=0; $j < $posts - 1; $j++, $sofar++) {
$record = array('discussion' => $discussion->id,
'userid' => $this->get_random_user(), 'parent' => $parentid);
$forumgenerator->create_post($record);
$this->dot($sofar, $totalposts);
}
}
$this->end_log();
}
/**
* Gets a random section number.
*
* @return int A section number from 1 to the number of sections
*/
private function get_random_section() {
return rand(1, self::$paramsections[$this->size]);
}
/**
* Gets a random user id.
*
* @return int A user id for a random created user
*/
private function get_random_user() {
return $this->userids[rand(1, self::$paramusers[$this->size])];
}
/**
* Displays information as part of progress.
* @param string $langstring Part of langstring (after progress_)
* @param mixed $a Optional lang string parameters
* @param bool $leaveopen If true, doesn't close LI tag (ready for dots)
*/
private function log($langstring, $a = null, $leaveopen = false) {
if (!$this->progress) {
return;
}
if (CLI_SCRIPT) {
echo '* ';
} else {
echo html_writer::start_tag('li');
}
echo get_string('progress_' . $langstring, 'tool_generator', $a);
if (!$leaveopen) {
if (CLI_SCRIPT) {
echo "\n";
} else {
echo html_writer::end_tag('li');
}
} else {
echo ': ';
$this->lastdot = time();
$this->lastpercentage = $this->lastdot;
$this->starttime = microtime(true);
}
}
/**
* Outputs dots. There is up to one dot per second. Once a minute, it
* displays a percentage.
* @param int $number Number of completed items
* @param int $total Total number of items to complete
*/
private function dot($number, $total) {
if (!$this->progress) {
return;
}
$now = time();
if ($now == $this->lastdot) {
return;
}
$this->lastdot = $now;
if (CLI_SCRIPT) {
echo '.';
} else {
echo ' . ';
}
if ($now - $this->lastpercentage >= 30) {
echo round(100.0 * $number / $total, 1) . '%';
$this->lastpercentage = $now;
}
// Update time limit so PHP doesn't time out.
if (!CLI_SCRIPT) {
set_time_limit(120);
}
}
/**
* Ends a log string that was started using log function with $leaveopen.
*/
private function end_log() {
if (!$this->progress) {
return;
}
echo get_string('done', 'tool_generator', round(microtime(true) - $this->starttime, 1));
if (CLI_SCRIPT) {
echo "\n";
} else {
echo html_writer::end_tag('li');
}
}
}

59
admin/tool/generator/classes/make_form.php Normal file
View File

@ -0,0 +1,59 @@
<?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/>.
defined('MOODLE_INTERNAL') || die();
require_once($CFG->libdir . '/formslib.php');
/**
* Form with options for creating large course.
*
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class tool_generator_make_form extends moodleform {
public function definition() {
$mform = $this->_form;
$mform->addElement('select', 'size', get_string('size', 'tool_generator'),
tool_generator_backend::get_size_choices());
$mform->setDefault('size', tool_generator_backend::DEFAULT_SIZE);
$mform->addElement('text', 'shortname', get_string('shortnamecourse'));
$mform->addRule('shortname', get_string('missingshortname'), 'required', null, 'client');
$mform->setType('shortname', PARAM_TEXT);
$mform->addElement('submit', 'submit', get_string('createcourse', 'tool_generator'));
}
public function validation($data, $files) {
global $DB;
$errors = array();
// Check course doesn't already exist.
if (!empty($data['shortname'])) {
// Check shortname.
$error = tool_generator_backend::check_shortname_available($data['shortname']);
if ($error) {
$errors['shortname'] = $error;
}
}
return $errors;
}
}

94
admin/tool/generator/cli/maketestcourse.php Normal file
View File

@ -0,0 +1,94 @@
<?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/>.
/**
* CLI interface for creating a test course.
*
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
define('CLI_SCRIPT', true);
define('NO_OUTPUT_BUFFERING', true);
require(dirname(__FILE__) . '/../../../../config.php');
require_once($CFG->libdir. '/clilib.php');
// CLI options.
list($options, $unrecognized) = cli_get_params(
array(
'help' => false,
'shortname' => false,
'size' => false,
'bypasscheck' => false,
'quiet' => false
),
array(
'h' => 'help'
)
);
// Display help.
if (!empty($options['help']) || empty($options['shortname']) || empty($options['size'])) {
echo "
Utility to create standard test course. (Also available in GUI interface.)
Not for use on live sites; only normally works if debugging is set to DEVELOPER
level.
Options:
--shortname Shortname of course to create (required)
--size Size of course to create XS, S, M, L, XL, or XXL (required)
--bypasscheck Bypasses the developer-mode check (be careful!)
--quiet Do not show any output
-h, --help Print out this help
Example from Moodle root directory:
\$ php admin/tool/generator/cli/maketestcourse.php --shortname=SIZE_S --size=S
";
// Exit with error unless we're showing this because they asked for it.
exit(empty($options['help']) ? 1 : 0);
}
// Check debugging is set to developer level.
if (empty($options['bypasscheck']) && !debugging('', DEBUG_DEVELOPER)) {
cli_error(get_string('error_notdebugging', 'tool_generator'));
}
// Get options.
$shortname = $options['shortname'];
$sizename = $options['size'];
// Check size.
try {
$size = tool_generator_backend::size_for_name($sizename);
} catch (coding_exception $e) {
cli_error("Invalid size ($sizename). Use --help for help.");
}
// Check shortname.
if ($error = tool_generator_backend::check_shortname_available($shortname)) {
cli_error($error);
}
// Switch to admin user account.
session_set_user(get_admin());
// Do backend code to generate course.
$backend = new tool_generator_backend($shortname, $size, empty($options['quiet']));
$id = $backend->make();

58
admin/tool/generator/lang/en/tool_generator.php
View File

@ -15,12 +15,60 @@
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Strings for component 'tool_generator', language 'en', branch 'MOODLE_22_STABLE'
* Language strings.
*
* @package tool
* @subpackage generator
* @copyright 2011 Petr Skoda
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
$string['bigfile'] = 'Big file {$a}';
$string['createcourse'] = 'Create course';
$string['creating'] = 'Creating course';
$string['done'] = 'done ({$a}s)';
$string['explanation'] = 'This tool creates standard test courses that include many
sections, activities, and files.
This is intended to provide a standardised measure for checking the reliability
and performance of various system components (such as backup and restore).
This test is important because there have been many cases previously where,
faced with real-life use cases (e.g. a course with 1,000 activities), the system
does not work.
Courses created using this feature can occupy a large amount of database and
filesystem space (tens of gigabytes). You will need to delete the courses
(and wait for various cleanup runs) to release this space again.
**Do not use this feature on a live system**. Use only on a developer server.
(To avoid accidental use, this feature is disabled unless you have also selected
DEVELOPER debugging level.)';
$string['error_notdebugging'] = 'Not available on this server because debugging is not set to DEVELOPER';
$string['firstname'] = 'Test course user';
$string['fullname'] = 'Test course: {$a->size}';
$string['maketestcourse'] = 'Make test course';
$string['pluginname'] = 'Random course generator';
$string['progress_createcourse'] = 'Creating course {$a}';
$string['progress_checkaccounts'] = 'Checking user accounts ({$a})';
$string['progress_createaccounts'] = 'Creating user accounts ({$a->from} - {$a->to})';
$string['progress_createbigfiles'] = 'Creating big files ({$a})';
$string['progress_createforum'] = 'Creating forum ({$a} posts)';
$string['progress_createpages'] = 'Creating pages ({$a})';
$string['progress_createsmallfiles'] = 'Creating small files ({$a})';
$string['progress_enrol'] = 'Enrolling users into course ({$a})';
$string['progress_complete'] = 'Complete ({$a}s)';
$string['shortsize_0'] = 'XS';
$string['shortsize_1'] = 'S';
$string['shortsize_2'] = 'M';
$string['shortsize_3'] = 'L';
$string['shortsize_4'] = 'XL';
$string['shortsize_5'] = 'XXL';
$string['size'] = 'Size of course';
$string['size_0'] = 'XS (~10KB; create in ~1 second)';
$string['size_1'] = 'S (~10MB; create in ~30 seconds)';
$string['size_2'] = 'M (~100MB; create in ~5 minutes)';
$string['size_3'] = 'L (~1GB; create in ~1 hour)';
$string['size_4'] = 'XL (~10GB; create in ~4 hours)';
$string['size_5'] = 'XXL (~20GB; create in ~8 hours)';
$string['smallfiles'] = 'Small files';

70
admin/tool/generator/maketestcourse.php Normal file
View File

@ -0,0 +1,70 @@
<?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/>.
/**
* Script creates a standardised large course for testing reliability and
* performance.
*
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
// Disable buffering so that the progress output displays gradually without
// needing to call flush().
define('NO_OUTPUT_BUFFERING', true);
require('../../../config.php');
require_once($CFG->libdir . '/adminlib.php');
// Initialise page and check permissions.
admin_externalpage_setup('toolgenerator');
// Start page.
echo $OUTPUT->header();
echo $OUTPUT->heading(get_string('maketestcourse', 'tool_generator'));
// Information message.
$context = context_system::instance();
echo $OUTPUT->box(format_text(get_string('explanation', 'tool_generator'),
FORMAT_MARKDOWN, array('context' => $context)));
// Check debugging is set to DEVELOPER.
if (!debugging('', DEBUG_DEVELOPER)) {
echo $OUTPUT->notification(get_string('error_notdebugging', 'tool_generator'));
echo $OUTPUT->footer();
exit;
}
// Set up the form.
$mform = new tool_generator_make_form('maketestcourse.php');
if ($data = $mform->get_data()) {
// Do actual work.
echo $OUTPUT->heading(get_string('creating', 'tool_generator'));
$backend = new tool_generator_backend($data->shortname, $data->size);
$id = $backend->make();
echo html_writer::div(
html_writer::link(new moodle_url('/course/view.php', array('id' => $id)),
get_string('continue')));
} else {
// Display form.
$mform->display();
}
// Finish page.
echo $OUTPUT->footer();

32
admin/tool/generator/settings.php Normal file
View File

@ -0,0 +1,32 @@
<?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/>.
/**
* Admin settings.
*
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die;
if ($hassiteconfig) {
$ADMIN->add('development', new admin_externalpage('toolgenerator',
get_string('maketestcourse', 'tool_generator'),
$CFG->wwwroot . '/' . $CFG->admin . '/tool/generator/maketestcourse.php'));
}

110
admin/tool/generator/tests/maketestcourse_test.php Normal file
View File

@ -0,0 +1,110 @@
<?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/>.
defined('MOODLE_INTERNAL') || die();
/**
* Automated unit testing. This tests the 'make large course' backend,
* using the 'XS' option so that it completes quickly.
*
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class tool_generator_maketestcourse_testcase extends advanced_testcase {
/**
* Creates a small test course and checks all the components have been put in place.
*/
public function test_make_xs_course() {
global $DB;
$this->resetAfterTest();
$this->setAdminUser();
// Create the XS course.
$backend = new tool_generator_backend('TOOL_MAKELARGECOURSE_XS', 0, false);
$courseid = $backend->make();
// Get course details.
$course = get_course($courseid);
$context = context_course::instance($courseid);
$modinfo = get_fast_modinfo($course);
// Check sections (just section 0 plus one other).
$this->assertEquals(2, count($modinfo->get_section_info_all()));
// Check user is enrolled.
$users = get_enrolled_users($context);
$this->assertEquals(1, count($users));
$this->assertEquals('tool_generator_000001', reset($users)->username);
// Check there's a page on the course.
$pages = $modinfo->get_instances_of('page');
$this->assertEquals(1, count($pages));
// Check there are small files.
$resources = $modinfo->get_instances_of('resource');
$ok = false;
foreach ($resources as $resource) {
if ($resource->sectionnum == 0) {
// The one in section 0 is the 'small files' resource.
$ok = true;
break;
}
}
$this->assertTrue($ok);
// Check it contains 2 files (the default txt and a dat file).
$fs = get_file_storage();
$resourcecontext = context_module::instance($resource->id);
$files = $fs->get_area_files($resourcecontext->id, 'mod_resource', 'content', false, 'filename', false);
$files = array_values($files);
$this->assertEquals(2, count($files));
$this->assertEquals('resource1.txt', $files[0]->get_filename());
$this->assertEquals('smallfile0.dat', $files[1]->get_filename());
// Check there's a single 'big' file (it's actually only 8KB).
$ok = false;
foreach ($resources as $resource) {
if ($resource->sectionnum == 1) {
$ok = true;
break;
}
}
$this->assertTrue($ok);
// Check it contains 2 files.
$resourcecontext = context_module::instance($resource->id);
$files = $fs->get_area_files($resourcecontext->id, 'mod_resource', 'content', false, 'filename', false);
$files = array_values($files);
$this->assertEquals(2, count($files));
$this->assertEquals('bigfile0.dat', $files[0]->get_filename());
$this->assertEquals('resource2.txt', $files[1]->get_filename());
// Get forum and count the number of posts on it.
$forums = $modinfo->get_instances_of('forum');
$forum = reset($forums);
$posts = $DB->count_records_sql("
SELECT
COUNT(1)
FROM
{forum_posts} fp
JOIN {forum_discussions} fd ON fd.id = fp.discussion
WHERE
fd.forum = ?", array($forum->instance));
$this->assertEquals(2, $posts);
}
}

15
admin/tool/generator/version.php
View File

@ -17,16 +17,13 @@
/**
* Version details.
*
* @package tool
* @subpackage generator
* @copyright 2009 Nicolas Connault
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @package tool_generator
* @copyright 2013 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
$plugin->version = 2013050100; // The current plugin version (Date: YYYYMMDDXX)
$plugin->requires = 2013050100; // Requires this Moodle version
$plugin->component = 'tool_generator'; // Full name of the plugin (used for diagnostics)
$plugin->maturity = MATURITY_ALPHA; // this version's maturity level
$plugin->version = 2013080700;
$plugin->requires = 2013080200;
$plugin->component = 'tool_generator';