admin/tool/uploadcourse/tests/course_test.php

   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  * File containing tests for the course class.
  19  *
  20  * @package    tool_uploadcourse
  21  * @copyright  2013 Frédéric Massart
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 global $CFG;
  28
  29 /**
  30  * Course test case.
  31  *
  32  * @package    tool_uploadcourse
  33  * @copyright  2013 Frédéric Massart
  34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or late
  35  */
  36 class tool_uploadcourse_course_testcase extends advanced_testcase {
  37
  38     /**
  39      * @expectedException coding_exception
  40      */
  41     public function test_proceed_without_prepare() {
  42         $this->resetAfterTest(true);
  43         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
  44         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
  45         $data = array();
  46         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
  47         $co->proceed();
  48     }
  49
  50     /**
  51      * @expectedException moodle_exception
  52      */
  53     public function test_proceed_when_prepare_failed() {
  54         $this->resetAfterTest(true);
  55         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
  56         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
  57         $data = array();
  58         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
  59         $this->assertFalse($co->prepare());
  60         $co->proceed();
  61     }
  62
  63     public function test_proceed_when_already_started() {
  64         $this->resetAfterTest(true);
  65         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
  66         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
  67         $data = array('shortname' => 'test', 'fullname' => 'New course', 'summary' => 'New', 'category' => 1);
  68         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
  69         $this->assertTrue($co->prepare());
  70         $co->proceed();
  71         $this->expectException('coding_exception');
  72         $co->proceed();
  73     }
  74
  75     public function test_invalid_shortname() {
  76         $this->resetAfterTest(true);
  77         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
  78         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
  79         $data = array('shortname' => '<invalid>', 'fullname' => 'New course', 'summary' => 'New', 'category' => 1);
  80         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
  81         $this->assertFalse($co->prepare());
  82         $this->assertArrayHasKey('invalidshortname', $co->get_errors());
  83     }
  84
  85     public function test_create() {
  86         global $DB;
  87         $this->resetAfterTest(true);
  88
  89         // Existing course.
  90         $c1 = $this->getDataGenerator()->create_course(array('shortname' => 'c1', 'summary' => 'Yay!'));
  91         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c1')));
  92
  93         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
  94
  95         // Try to add a new course.
  96         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
  97         $data = array('shortname' => 'newcourse', 'fullname' => 'New course', 'summary' => 'New', 'category' => 1);
  98         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
  99         $this->assertTrue($co->prepare());
 100         $this->assertFalse($DB->record_exists('course', array('shortname' => 'newcourse')));
 101         $co->proceed();
 102         $this->assertTrue($DB->record_exists('course', array('shortname' => 'newcourse')));
 103
 104         // Try to add a new course, that already exists.
 105         $coursecount = $DB->count_records('course', array());
 106         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 107         $data = array('shortname' => 'c1', 'fullname' => 'C1FN', 'summary' => 'C1', 'category' => 1);
 108         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 109         $this->assertFalse($co->prepare());
 110         $this->assertArrayHasKey('courseexistsanduploadnotallowed', $co->get_errors());
 111         $this->assertEquals($coursecount, $DB->count_records('course', array()));
 112         $this->assertNotEquals('C1', $DB->get_field_select('course', 'summary', 'shortname = :s', array('s' => 'c1')));
 113
 114         // Try to add new with shortname incrementation.
 115         $mode = tool_uploadcourse_processor::MODE_CREATE_ALL;
 116         $data = array('shortname' => 'c1', 'fullname' => 'C1FN', 'summary' => 'C1', 'category' => 1);
 117         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 118         $this->assertTrue($co->prepare());
 119         $co->proceed();
 120         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c2')));
 121     }
 122
 123     public function test_delete() {
 124         global $DB;
 125         $this->resetAfterTest(true);
 126
 127         $c1 = $this->getDataGenerator()->create_course();
 128         $c2 = $this->getDataGenerator()->create_course();
 129
 130         $this->assertTrue($DB->record_exists('course', array('shortname' => $c1->shortname)));
 131         $this->assertFalse($DB->record_exists('course', array('shortname' => 'DoesNotExist')));
 132
 133         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
 134         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 135
 136         // Try delete when option not available.
 137         $importoptions = array('candelete' => false);
 138         $data = array('shortname' => $c1->shortname, 'delete' => 1);
 139         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 140         $this->assertFalse($co->prepare());
 141         $this->assertArrayHasKey('coursedeletionnotallowed', $co->get_errors());
 142         $this->assertTrue($DB->record_exists('course', array('shortname' => $c1->shortname)));
 143
 144         // Try delete when not requested.
 145         $importoptions = array('candelete' => true);
 146         $data = array('shortname' => $c1->shortname, 'delete' => 0);
 147         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 148         $this->assertTrue($co->prepare());
 149         $co->proceed();
 150         $this->assertTrue($DB->record_exists('course', array('shortname' => $c1->shortname)));
 151
 152         // Try delete when requested.
 153         $importoptions = array('candelete' => true);
 154         $data = array('shortname' => $c1->shortname, 'delete' => 1);
 155         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 156         $this->assertTrue($co->prepare());
 157         $co->proceed();
 158         $this->assertFalse($DB->record_exists('course', array('shortname' => $c1->shortname)));
 159         $this->assertTrue($DB->record_exists('course', array('shortname' => $c2->shortname)));
 160
 161         // Try deleting non-existing record, this should not fail.
 162         $data = array('shortname' => 'DoesNotExist', 'delete' => 1);
 163         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 164         $this->assertFalse($co->prepare());
 165         $this->assertArrayHasKey('cannotdeletecoursenotexist', $co->get_errors());
 166     }
 167
 168     public function test_update() {
 169         global $DB;
 170         $this->resetAfterTest(true);
 171
 172         $c1 = $this->getDataGenerator()->create_course(array('shortname' => 'c1'));
 173
 174         // Try to update with existing shortnames, not allowing creation, and updating nothing.
 175         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 176         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 177         $data = array('shortname' => 'c1', 'fullname' => 'New fullname');
 178         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 179         $this->assertFalse($co->prepare());
 180         $this->assertArrayHasKey('updatemodedoessettonothing', $co->get_errors());
 181
 182         // Try to update with non-existing shortnames.
 183         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 184         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 185         $data = array('shortname' => 'DoesNotExist', 'fullname' => 'New fullname');
 186         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 187         $this->assertFalse($co->prepare());
 188         $this->assertArrayHasKey('coursedoesnotexistandcreatenotallowed', $co->get_errors());
 189
 190         // Try a proper update.
 191         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 192         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 193         $data = array('shortname' => 'c1', 'fullname' => 'New fullname');
 194         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 195         $this->assertTrue($co->prepare());
 196         $co->proceed();
 197         $this->assertEquals('New fullname', $DB->get_field_select('course', 'fullname', 'shortname = :s', array('s' => 'c1')));
 198
 199         // Try a proper update with defaults.
 200         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 201         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_OR_DEFAUTLS;
 202         $data = array('shortname' => 'c1', 'fullname' => 'Another fullname');
 203         $defaults = array('fullname' => 'Not this one', 'summary' => 'Awesome summary');
 204         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaults);
 205         $this->assertTrue($co->prepare());
 206         $co->proceed();
 207         $this->assertEquals('Another fullname', $DB->get_field_select('course', 'fullname', 'shortname = :s', array('s' => 'c1')));
 208         $this->assertEquals('Awesome summary', $DB->get_field_select('course', 'summary', 'shortname = :s', array('s' => 'c1')));
 209
 210         // Try a proper update missing only.
 211         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 212         $updatemode = tool_uploadcourse_processor::UPDATE_MISSING_WITH_DATA_OR_DEFAUTLS;
 213         $DB->set_field('course', 'summary', '', array('shortname' => 'c1'));
 214         $this->assertEquals('', $DB->get_field_select('course', 'summary', 'shortname = :s', array('s' => 'c1')));
 215         $data = array('shortname' => 'c1', 'summary' => 'Fill in summary');
 216         $defaults = array('summary' => 'Do not use this summary');
 217         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaults);
 218         $this->assertTrue($co->prepare());
 219         $co->proceed();
 220         $this->assertEquals('Fill in summary', $DB->get_field_select('course', 'summary', 'shortname = :s', array('s' => 'c1')));
 221
 222         // Try a proper update missing only using defaults.
 223         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 224         $updatemode = tool_uploadcourse_processor::UPDATE_MISSING_WITH_DATA_OR_DEFAUTLS;
 225         $DB->set_field('course', 'summary', '', array('shortname' => 'c1'));
 226         $this->assertEquals('', $DB->get_field_select('course', 'summary', 'shortname = :s', array('s' => 'c1')));
 227         $data = array('shortname' => 'c1');
 228         $defaults = array('summary' => 'Use this summary');
 229         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaults);
 230         $this->assertTrue($co->prepare());
 231         $co->proceed();
 232         $this->assertEquals('Use this summary', $DB->get_field_select('course', 'summary', 'shortname = :s', array('s' => 'c1')));
 233     }
 234
 235     public function test_data_saved() {
 236         global $DB;
 237         $this->resetAfterTest(true);
 238
 239         // Create.
 240         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 241         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 242         $data = array(
 243             'shortname' => 'c1',
 244             'fullname' => 'Fullname',
 245             'category' => '1',
 246             'visible' => '0',
 247             'startdate' => '8 June 1990',
 248             'idnumber' => '123abc',
 249             'summary' => 'Summary',
 250             'format' => 'weeks',
 251             'theme' => 'afterburner',
 252             'lang' => 'en',
 253             'newsitems' => '7',
 254             'showgrades' => '0',
 255             'showreports' => '1',
 256             'legacyfiles' => '1',
 257             'maxbytes' => '1234',
 258             'groupmode' => '2',
 259             'groupmodeforce' => '1',
 260             'enablecompletion' => '1',
 261             'tags' => 'Cat, Dog',
 262
 263             'role_teacher' => 'Knight',
 264             'role_manager' => 'Jedi',
 265
 266             'enrolment_1' => 'guest',
 267             'enrolment_2' => 'self',
 268             'enrolment_2_roleid' => '1',
 269             'enrolment_3' => 'manual',
 270             'enrolment_3_disable' => '1',
 271         );
 272
 273         $this->assertFalse($DB->record_exists('course', array('shortname' => 'c1')));
 274         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 275         $this->assertTrue($co->prepare());
 276         $co->proceed();
 277         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c1')));
 278         $course = $DB->get_record('course', array('shortname' => 'c1'));
 279         $ctx = context_course::instance($course->id);
 280
 281         $this->assertEquals($data['fullname'], $course->fullname);
 282         $this->assertEquals($data['category'], $course->category);
 283         $this->assertEquals($data['visible'], $course->visible);
 284         $this->assertEquals(mktime(0, 0, 0, 6, 8, 1990), $course->startdate);
 285         $this->assertEquals($data['idnumber'], $course->idnumber);
 286         $this->assertEquals($data['summary'], $course->summary);
 287         $this->assertEquals($data['format'], $course->format);
 288         $this->assertEquals($data['theme'], $course->theme);
 289         $this->assertEquals($data['lang'], $course->lang);
 290         $this->assertEquals($data['newsitems'], $course->newsitems);
 291         $this->assertEquals($data['showgrades'], $course->showgrades);
 292         $this->assertEquals($data['showreports'], $course->showreports);
 293         $this->assertEquals($data['legacyfiles'], $course->legacyfiles);
 294         $this->assertEquals($data['maxbytes'], $course->maxbytes);
 295         $this->assertEquals($data['groupmode'], $course->groupmode);
 296         $this->assertEquals($data['groupmodeforce'], $course->groupmodeforce);
 297         $this->assertEquals($data['enablecompletion'], $course->enablecompletion);
 298         $this->assertEquals($data['tags'], join(', ', core_tag_tag::get_item_tags_array('core', 'course', $course->id)));
 299
 300         // Roles.
 301         $roleids = array();
 302         $roles = get_all_roles();
 303         foreach ($roles as $role) {
 304             $roleids[$role->shortname] = $role->id;
 305         }
 306         $this->assertEquals('Knight', $DB->get_field_select('role_names', 'name',
 307             'roleid = :roleid AND contextid = :ctxid', array('ctxid' => $ctx->id, 'roleid' => $roleids['teacher'])));
 308         $this->assertEquals('Jedi', $DB->get_field_select('role_names', 'name',
 309             'roleid = :roleid AND contextid = :ctxid', array('ctxid' => $ctx->id, 'roleid' => $roleids['manager'])));
 310
 311         // Enrolment methods.
 312         $enroldata = array();
 313         $instances = enrol_get_instances($course->id, false);
 314         $this->assertCount(3, $instances);
 315         foreach ($instances as $instance) {
 316             $enroldata[$instance->enrol] = $instance;
 317         }
 318
 319         $this->assertNotEmpty($enroldata['guest']);
 320         $this->assertEquals(ENROL_INSTANCE_ENABLED, $enroldata['guest']->status);
 321         $this->assertNotEmpty($enroldata['self']);
 322         $this->assertEquals($data['enrolment_2_roleid'], $enroldata['self']->roleid);
 323         $this->assertEquals(ENROL_INSTANCE_ENABLED, $enroldata['self']->status);
 324         $this->assertNotEmpty($enroldata['manual']);
 325         $this->assertEquals(ENROL_INSTANCE_DISABLED, $enroldata['manual']->status);
 326
 327         // Update existing course.
 328         $cat = $this->getDataGenerator()->create_category();
 329         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 330         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 331         $data = array(
 332             'shortname' => 'c1',
 333             'fullname' => 'Fullname 2',
 334             'category' => $cat->id,
 335             'visible' => '1',
 336             'startdate' => '11 June 1984',
 337             'idnumber' => 'changeidn',
 338             'summary' => 'Summary 2',
 339             'format' => 'topics',
 340             'theme' => 'clean',
 341             'lang' => '',
 342             'newsitems' => '2',
 343             'showgrades' => '1',
 344             'showreports' => '0',
 345             'legacyfiles' => '0',
 346             'maxbytes' => '4321',
 347             'groupmode' => '1',
 348             'groupmodeforce' => '0',
 349             'enablecompletion' => '0',
 350
 351             'role_teacher' => 'Teacher',
 352             'role_manager' => 'Manager',
 353
 354             'enrolment_1' => 'guest',
 355             'enrolment_1_disable' => '1',
 356             'enrolment_2' => 'self',
 357             'enrolment_2_roleid' => '2',
 358             'enrolment_3' => 'manual',
 359             'enrolment_3_delete' => '1',
 360         );
 361
 362         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c1')));
 363         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 364         $this->assertTrue($co->prepare());
 365         $co->proceed();
 366         $course = $DB->get_record('course', array('shortname' => 'c1'));
 367         $ctx = context_course::instance($course->id);
 368
 369         $this->assertEquals($data['fullname'], $course->fullname);
 370         $this->assertEquals($data['category'], $course->category);
 371         $this->assertEquals($data['visible'], $course->visible);
 372         $this->assertEquals(mktime(0, 0, 0, 6, 11, 1984), $course->startdate);
 373         $this->assertEquals($data['idnumber'], $course->idnumber);
 374         $this->assertEquals($data['summary'], $course->summary);
 375         $this->assertEquals($data['format'], $course->format);
 376         $this->assertEquals($data['theme'], $course->theme);
 377         $this->assertEquals($data['lang'], $course->lang);
 378         $this->assertEquals($data['newsitems'], $course->newsitems);
 379         $this->assertEquals($data['showgrades'], $course->showgrades);
 380         $this->assertEquals($data['showreports'], $course->showreports);
 381         $this->assertEquals($data['legacyfiles'], $course->legacyfiles);
 382         $this->assertEquals($data['maxbytes'], $course->maxbytes);
 383         $this->assertEquals($data['groupmode'], $course->groupmode);
 384         $this->assertEquals($data['groupmodeforce'], $course->groupmodeforce);
 385         $this->assertEquals($data['enablecompletion'], $course->enablecompletion);
 386
 387         // Roles.
 388         $roleids = array();
 389         $roles = get_all_roles();
 390         foreach ($roles as $role) {
 391             $roleids[$role->shortname] = $role->id;
 392         }
 393         $this->assertEquals('Teacher', $DB->get_field_select('role_names', 'name',
 394             'roleid = :roleid AND contextid = :ctxid', array('ctxid' => $ctx->id, 'roleid' => $roleids['teacher'])));
 395         $this->assertEquals('Manager', $DB->get_field_select('role_names', 'name',
 396             'roleid = :roleid AND contextid = :ctxid', array('ctxid' => $ctx->id, 'roleid' => $roleids['manager'])));
 397
 398         // Enrolment methods.
 399         $enroldata = array();
 400         $instances = enrol_get_instances($course->id, false);
 401         $this->assertCount(2, $instances);
 402         foreach ($instances as $instance) {
 403             $enroldata[$instance->enrol] = $instance;
 404         }
 405
 406         $this->assertNotEmpty($enroldata['guest']);
 407         $this->assertEquals(ENROL_INSTANCE_DISABLED, $enroldata['guest']->status);
 408         $this->assertNotEmpty($enroldata['self']);
 409         $this->assertEquals($data['enrolment_2_roleid'], $enroldata['self']->roleid);
 410         $this->assertEquals(ENROL_INSTANCE_ENABLED, $enroldata['self']->status);
 411     }
 412
 413     public function test_default_data_saved() {
 414         global $DB;
 415         $this->resetAfterTest(true);
 416
 417         // Create.
 418         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 419         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 420         $data = array(
 421             'shortname' => 'c1',
 422         );
 423         $defaultdata = array(
 424             'fullname' => 'Fullname',
 425             'category' => '1',
 426             'visible' => '0',
 427             'startdate' => '8 June 1990',
 428             'idnumber' => '123abc',
 429             'summary' => 'Summary',
 430             'format' => 'weeks',
 431             'theme' => 'afterburner',
 432             'lang' => 'en',
 433             'newsitems' => '7',
 434             'showgrades' => '0',
 435             'showreports' => '1',
 436             'legacyfiles' => '1',
 437             'maxbytes' => '1234',
 438             'groupmode' => '2',
 439             'groupmodeforce' => '1',
 440             'enablecompletion' => '1',
 441         );
 442
 443         $this->assertFalse($DB->record_exists('course', array('shortname' => 'c1')));
 444         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaultdata);
 445         $this->assertTrue($co->prepare());
 446         $co->proceed();
 447         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c1')));
 448         $course = $DB->get_record('course', array('shortname' => 'c1'));
 449         $ctx = context_course::instance($course->id);
 450
 451         $this->assertEquals($defaultdata['fullname'], $course->fullname);
 452         $this->assertEquals($defaultdata['category'], $course->category);
 453         $this->assertEquals($defaultdata['visible'], $course->visible);
 454         $this->assertEquals(mktime(0, 0, 0, 6, 8, 1990), $course->startdate);
 455         $this->assertEquals($defaultdata['idnumber'], $course->idnumber);
 456         $this->assertEquals($defaultdata['summary'], $course->summary);
 457         $this->assertEquals($defaultdata['format'], $course->format);
 458         $this->assertEquals($defaultdata['theme'], $course->theme);
 459         $this->assertEquals($defaultdata['lang'], $course->lang);
 460         $this->assertEquals($defaultdata['newsitems'], $course->newsitems);
 461         $this->assertEquals($defaultdata['showgrades'], $course->showgrades);
 462         $this->assertEquals($defaultdata['showreports'], $course->showreports);
 463         $this->assertEquals($defaultdata['legacyfiles'], $course->legacyfiles);
 464         $this->assertEquals($defaultdata['maxbytes'], $course->maxbytes);
 465         $this->assertEquals($defaultdata['groupmode'], $course->groupmode);
 466         $this->assertEquals($defaultdata['groupmodeforce'], $course->groupmodeforce);
 467         $this->assertEquals($defaultdata['enablecompletion'], $course->enablecompletion);
 468
 469         // Update.
 470         $cat = $this->getDataGenerator()->create_category();
 471         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 472         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_OR_DEFAUTLS;
 473         $data = array(
 474             'shortname' => 'c1',
 475         );
 476         $defaultdata = array(
 477             'fullname' => 'Fullname 2',
 478             'category' => $cat->id,
 479             'visible' => '1',
 480             'startdate' => '11 June 1984',
 481             'idnumber' => 'changedid',
 482             'summary' => 'Summary 2',
 483             'format' => 'topics',
 484             'theme' => 'clean',
 485             'lang' => '',
 486             'newsitems' => '2',
 487             'showgrades' => '1',
 488             'showreports' => '0',
 489             'legacyfiles' => '0',
 490             'maxbytes' => '1111',
 491             'groupmode' => '1',
 492             'groupmodeforce' => '0',
 493             'enablecompletion' => '0',
 494         );
 495
 496         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c1')));
 497         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaultdata);
 498         $this->assertTrue($co->prepare());
 499         $co->proceed();
 500         $this->assertTrue($DB->record_exists('course', array('shortname' => 'c1')));
 501         $course = $DB->get_record('course', array('shortname' => 'c1'));
 502         $ctx = context_course::instance($course->id);
 503
 504         $this->assertEquals($defaultdata['fullname'], $course->fullname);
 505         $this->assertEquals($defaultdata['category'], $course->category);
 506         $this->assertEquals($defaultdata['visible'], $course->visible);
 507         $this->assertEquals(mktime(0, 0, 0, 6, 11, 1984), $course->startdate);
 508         $this->assertEquals($defaultdata['idnumber'], $course->idnumber);
 509         $this->assertEquals($defaultdata['summary'], $course->summary);
 510         $this->assertEquals($defaultdata['format'], $course->format);
 511         $this->assertEquals($defaultdata['theme'], $course->theme);
 512         $this->assertEquals($defaultdata['lang'], $course->lang);
 513         $this->assertEquals($defaultdata['newsitems'], $course->newsitems);
 514         $this->assertEquals($defaultdata['showgrades'], $course->showgrades);
 515         $this->assertEquals($defaultdata['showreports'], $course->showreports);
 516         $this->assertEquals($defaultdata['legacyfiles'], $course->legacyfiles);
 517         $this->assertEquals($defaultdata['maxbytes'], $course->maxbytes);
 518         $this->assertEquals($defaultdata['groupmode'], $course->groupmode);
 519         $this->assertEquals($defaultdata['groupmodeforce'], $course->groupmodeforce);
 520         $this->assertEquals($defaultdata['enablecompletion'], $course->enablecompletion);
 521     }
 522
 523     public function test_rename() {
 524         global $DB;
 525         $this->resetAfterTest(true);
 526
 527         $c1 = $this->getDataGenerator()->create_course(array('shortname' => 'c1'));
 528         $c2 = $this->getDataGenerator()->create_course(array('shortname' => 'c2'));
 529
 530         // Cannot rename when creating.
 531         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 532         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 533         $importoptions = array('canrename' => true);
 534         $data = array('shortname' => 'c1', 'rename' => 'newshortname');
 535         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 536         $this->assertFalse($co->prepare());
 537         $this->assertArrayHasKey('courseexistsanduploadnotallowed', $co->get_errors());
 538
 539         // Cannot rename when creating.
 540         $mode = tool_uploadcourse_processor::MODE_CREATE_ALL;
 541         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 542         $importoptions = array('canrename' => true);
 543         $data = array('shortname' => 'c1', 'rename' => 'newshortname', 'category' => 1, 'summary' => 'S', 'fullname' => 'F');
 544         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 545         $this->assertFalse($co->prepare());
 546         $this->assertArrayHasKey('canonlyrenameinupdatemode', $co->get_errors());
 547
 548         // Error when not allowed to rename the course.
 549         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 550         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 551         $importoptions = array('canrename' => false);
 552         $data = array('shortname' => 'c1', 'rename' => 'newshortname');
 553         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 554         $this->assertFalse($co->prepare());
 555         $this->assertArrayHasKey('courserenamingnotallowed', $co->get_errors());
 556
 557         // Can rename when updating.
 558         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
 559         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 560         $importoptions = array('canrename' => true);
 561         $data = array('shortname' => 'c1', 'rename' => 'newshortname');
 562         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 563         $this->assertTrue($co->prepare());
 564         $co->proceed();
 565         $this->assertEquals('newshortname', $DB->get_field_select('course', 'shortname', 'id = :id', array('id' => $c1->id)));
 566
 567         // Can rename when updating.
 568         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 569         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 570         $importoptions = array('canrename' => true);
 571         $data = array('shortname' => 'newshortname', 'rename' => 'newshortname2');
 572         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 573         $this->assertTrue($co->prepare());
 574         $co->proceed();
 575         $this->assertEquals('newshortname2', $DB->get_field_select('course', 'shortname', 'id = :id', array('id' => $c1->id)));
 576
 577         // Error when course does not exist.
 578         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
 579         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 580         $importoptions = array('canrename' => true);
 581         $data = array('shortname' => 'DoesNotExist', 'rename' => 'c1', 'category' => 1, 'summary' => 'S', 'fullname' => 'F');
 582         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 583         $this->assertFalse($co->prepare());
 584         $this->assertArrayHasKey('cannotrenamecoursenotexist', $co->get_errors());
 585
 586         // Renaming still updates the other values.
 587         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
 588         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_OR_DEFAUTLS;
 589         $importoptions = array('canrename' => true);
 590         $data = array('shortname' => 'newshortname2', 'rename' => 'c1', 'fullname' => 'Another fullname!');
 591         $defaultdata = array('summary' => 'New summary!');
 592         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaultdata, $importoptions);
 593         $this->assertTrue($co->prepare());
 594         $co->proceed();
 595         $this->assertEquals('c1', $DB->get_field_select('course', 'shortname', 'id = :id', array('id' => $c1->id)));
 596         $this->assertEquals('New summary!', $DB->get_field_select('course', 'summary', 'id = :id', array('id' => $c1->id)));
 597         $this->assertEquals('Another fullname!', $DB->get_field_select('course', 'fullname', 'id = :id', array('id' => $c1->id)));
 598
 599         // Renaming with invalid shortname.
 600         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
 601         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 602         $importoptions = array('canrename' => true);
 603         $data = array('shortname' => 'c1', 'rename' => '<span>invalid</span>');
 604         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 605         $this->assertFalse($co->prepare());
 606         $this->assertArrayHasKey('invalidshortname', $co->get_errors());
 607
 608         // Renaming with invalid shortname.
 609         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
 610         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 611         $importoptions = array('canrename' => true);
 612         $data = array('shortname' => 'c1', 'rename' => 'c2');
 613         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 614         $this->assertFalse($co->prepare());
 615         $this->assertArrayHasKey('cannotrenameshortnamealreadyinuse', $co->get_errors());
 616     }
 617
 618     public function test_restore_course() {
 619         global $DB;
 620         $this->resetAfterTest(true);
 621         $this->setAdminUser();
 622
 623         $c1 = $this->getDataGenerator()->create_course();
 624         $c1f1 = $this->getDataGenerator()->create_module('forum', array('course' => $c1->id));
 625
 626         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 627         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 628         $data = array('shortname' => 'A1', 'templatecourse' => $c1->shortname, 'summary' => 'A', 'category' => 1,
 629             'fullname' => 'A1');
 630         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 631         $this->assertTrue($co->prepare());
 632         $co->proceed();
 633         $course = $DB->get_record('course', array('shortname' => 'A1'));
 634         $modinfo = get_fast_modinfo($course);
 635         $found = false;
 636         foreach ($modinfo->get_cms() as $cmid => $cm) {
 637             if ($cm->modname == 'forum' && $cm->name == $c1f1->name) {
 638                 $found = true;
 639                 break;
 640             }
 641         }
 642         $this->assertTrue($found);
 643
 644         // Restoring twice from the same course should work.
 645         $data = array('shortname' => 'B1', 'templatecourse' => $c1->shortname, 'summary' => 'B', 'category' => 1,
 646             'fullname' => 'B1');
 647         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 648         $this->assertTrue($co->prepare());
 649         $co->proceed();
 650         $course = $DB->get_record('course', array('shortname' => 'B1'));
 651         $modinfo = get_fast_modinfo($course);
 652         $found = false;
 653         foreach ($modinfo->get_cms() as $cmid => $cm) {
 654             if ($cm->modname == 'forum' && $cm->name == $c1f1->name) {
 655                 $found = true;
 656                 break;
 657             }
 658         }
 659         $this->assertTrue($found);
 660     }
 661
 662     public function test_restore_file() {
 663         global $DB;
 664         $this->resetAfterTest(true);
 665         $this->setAdminUser();
 666
 667         $c1 = $this->getDataGenerator()->create_course();
 668         $c1f1 = $this->getDataGenerator()->create_module('forum', array('course' => $c1->id));
 669
 670         // Restore from a file, checking that the file takes priority over the templatecourse.
 671         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 672         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 673         $data = array('shortname' => 'A1', 'backupfile' => __DIR__ . '/fixtures/backup.mbz',
 674             'summary' => 'A', 'category' => 1, 'fullname' => 'A1', 'templatecourse' => $c1->shortname);
 675         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 676         $this->assertTrue($co->prepare());
 677         $co->proceed();
 678         $course = $DB->get_record('course', array('shortname' => 'A1'));
 679         $modinfo = get_fast_modinfo($course);
 680         $found = false;
 681         foreach ($modinfo->get_cms() as $cmid => $cm) {
 682             if ($cm->modname == 'glossary' && $cm->name == 'Imported Glossary') {
 683                 $found = true;
 684             } else if ($cm->modname == 'forum' && $cm->name == $c1f1->name) {
 685                 // We should not find this!
 686                 $this->assertTrue(false);
 687             }
 688         }
 689         $this->assertTrue($found);
 690
 691         // Restoring twice from the same file should work.
 692         $data = array('shortname' => 'B1', 'backupfile' => __DIR__ . '/fixtures/backup.mbz',
 693             'summary' => 'B', 'category' => 1, 'fullname' => 'B1');
 694         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 695         $this->assertTrue($co->prepare());
 696         $co->proceed();
 697         $course = $DB->get_record('course', array('shortname' => 'B1'));
 698         $modinfo = get_fast_modinfo($course);
 699         $found = false;
 700         foreach ($modinfo->get_cms() as $cmid => $cm) {
 701             if ($cm->modname == 'glossary' && $cm->name == 'Imported Glossary') {
 702                 $found = true;
 703             } else if ($cm->modname == 'forum' && $cm->name == $c1f1->name) {
 704                 // We should not find this!
 705                 $this->assertTrue(false);
 706             }
 707         }
 708         $this->assertTrue($found);
 709     }
 710
 711     public function test_restore_invalid_file() {
 712         $this->resetAfterTest();
 713
 714         // Restore from a non-existing file should not be allowed.
 715         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 716         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 717         $data = array('shortname' => 'A1', 'backupfile' => '/lead/no/where',
 718             'category' => 1, 'fullname' => 'A1');
 719         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 720         $this->assertFalse($co->prepare());
 721         $this->assertArrayHasKey('cannotreadbackupfile', $co->get_errors());
 722
 723         // Restore from an invalid file should not be allowed.
 724         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 725         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 726         $data = array('shortname' => 'A1', 'backupfile' => __FILE__,
 727             'category' => 1, 'fullname' => 'A1');
 728         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 729
 730         $this->assertFalse($co->prepare());
 731         $this->assertArrayHasKey('invalidbackupfile', $co->get_errors());
 732
 733         // Zip packer throws a debugging message, this assertion is only here to prevent
 734         // the message from being displayed.
 735         $this->assertDebuggingCalled();
 736     }
 737
 738     public function test_restore_invalid_course() {
 739         $this->resetAfterTest();
 740
 741         // Restore from an invalid file should not be allowed.
 742         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 743         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 744         $data = array('shortname' => 'A1', 'templatecourse' => 'iamnotavalidcourse',
 745             'category' => 1, 'fullname' => 'A1');
 746         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 747         $this->assertFalse($co->prepare());
 748         $this->assertArrayHasKey('coursetorestorefromdoesnotexist', $co->get_errors());
 749     }
 750
 751     /**
 752      * Testing the reset on groups, group members and enrolments.
 753      */
 754     public function test_reset() {
 755         global $DB;
 756         $this->resetAfterTest(true);
 757
 758         $c1 = $this->getDataGenerator()->create_course();
 759         $c1ctx = context_course::instance($c1->id);
 760         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 761         $teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
 762
 763         $u1 = $this->getDataGenerator()->create_user();
 764         $this->getDataGenerator()->enrol_user($u1->id, $c1->id, $studentrole->id);
 765         $this->assertCount(1, get_enrolled_users($c1ctx));
 766
 767         $g1 = $this->getDataGenerator()->create_group(array('courseid' => $c1->id));
 768         $this->getDataGenerator()->create_group_member(array('groupid' => $g1->id, 'userid' => $u1->id));
 769         $this->assertEquals(1, $DB->count_records('groups', array('courseid' => $c1->id)));
 770         $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $g1->id, 'userid' => $u1->id)));
 771
 772         // Wrong mode.
 773         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 774         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 775         $data = array('shortname' => 'DoesNotExist', 'reset' => '1', 'summary' => 'summary', 'fullname' => 'FN', 'category' => 1);
 776         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 777         $this->assertFalse($co->prepare());
 778         $this->assertArrayHasKey('canonlyresetcourseinupdatemode', $co->get_errors());
 779         $this->assertTrue($DB->record_exists('groups', array('id' => $g1->id)));
 780         $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $g1->id, 'userid' => $u1->id)));
 781         $this->assertCount(1, get_enrolled_users($c1ctx));
 782
 783         // Reset not allowed.
 784         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 785         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 786         $data = array('shortname' => $c1->shortname, 'reset' => '1');
 787         $importoptions = array('canreset' => false);
 788         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 789         $this->assertFalse($co->prepare());
 790         $this->assertArrayHasKey('courseresetnotallowed', $co->get_errors());
 791         $this->assertTrue($DB->record_exists('groups', array('id' => $g1->id)));
 792         $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $g1->id, 'userid' => $u1->id)));
 793         $this->assertCount(1, get_enrolled_users($c1ctx));
 794
 795         // Reset allowed but not requested.
 796         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 797         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 798         $data = array('shortname' => $c1->shortname, 'reset' => '0');
 799         $importoptions = array('canreset' => true);
 800         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 801         $this->assertTrue($co->prepare());
 802         $co->proceed();
 803         $this->assertTrue($DB->record_exists('groups', array('id' => $g1->id)));
 804         $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $g1->id, 'userid' => $u1->id)));
 805         $this->assertCount(1, get_enrolled_users($c1ctx));
 806
 807         // Reset passed as a default parameter, should not be taken in account.
 808         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 809         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 810         $data = array('shortname' => $c1->shortname);
 811         $importoptions = array('canreset' => true);
 812         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array('reset' => 1), $importoptions);
 813         $this->assertTrue($co->prepare());
 814         $co->proceed();
 815         $this->assertTrue($DB->record_exists('groups', array('id' => $g1->id)));
 816         $this->assertTrue($DB->record_exists('groups_members', array('groupid' => $g1->id, 'userid' => $u1->id)));
 817         $this->assertCount(1, get_enrolled_users($c1ctx));
 818
 819         // Reset executed from data.
 820         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 821         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 822         $data = array('shortname' => $c1->shortname, 'reset' => 1);
 823         $importoptions = array('canreset' => true);
 824         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 825         $this->assertTrue($co->prepare());
 826         $co->proceed();
 827         $this->assertFalse($DB->record_exists('groups', array('id' => $g1->id)));
 828         $this->assertFalse($DB->record_exists('groups_members', array('groupid' => $g1->id, 'userid' => $u1->id)));
 829         $this->assertCount(0, get_enrolled_users($c1ctx));
 830
 831         // Reset executed from import option.
 832         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 833         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 834         $data = array('shortname' => $c1->shortname, 'reset' => 0);
 835         $importoptions = array('reset' => 1, 'canreset' => true);
 836         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 837
 838         $g1 = $this->getDataGenerator()->create_group(array('courseid' => $c1->id));
 839         $this->getDataGenerator()->create_group_member(array('groupid' => $g1->id, 'userid' => $u1->id));
 840         $this->assertEquals(1, $DB->count_records('groups', array('courseid' => $c1->id)));
 841         $this->assertTrue($co->prepare());
 842         $co->proceed();
 843         $this->assertFalse($DB->record_exists('groups', array('id' => $g1->id)));
 844     }
 845
 846     public function test_create_bad_category() {
 847         global $DB;
 848         $this->resetAfterTest(true);
 849
 850         // Ensure fails when category cannot be resolved upon creation.
 851         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 852         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 853         $data = array('shortname' => 'c1', 'summary' => 'summary', 'fullname' => 'FN', 'category' => 'Wrong cat');
 854         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 855         $this->assertFalse($co->prepare());
 856         $this->assertArrayHasKey('couldnotresolvecatgorybyid', $co->get_errors());
 857
 858         // Ensure fails when category is 0 on create.
 859         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 860         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 861         $data = array('shortname' => 'c1', 'summary' => 'summary', 'fullname' => 'FN', 'category' => '0');
 862         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 863         $this->assertFalse($co->prepare());
 864         $this->assertArrayHasKey('missingmandatoryfields', $co->get_errors());
 865
 866         // Ensure fails when category cannot be resolved upon update.
 867         $c1 = $this->getDataGenerator()->create_course();
 868         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 869         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 870         $data = array('shortname' => $c1->shortname, 'category' => 'Wrong cat');
 871         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 872         $this->assertFalse($co->prepare());
 873         $this->assertArrayHasKey('couldnotresolvecatgorybyid', $co->get_errors());
 874
 875         // Ensure does not update the category when it is 0.
 876         $c1 = $this->getDataGenerator()->create_course();
 877         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 878         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 879         $data = array('shortname' => $c1->shortname, 'category' => '0');
 880         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 881         $this->assertTrue($co->prepare());
 882         $this->assertEmpty($co->get_errors());
 883         $this->assertEmpty($co->get_statuses());
 884         $co->proceed();
 885         $this->assertEquals($c1->category, $DB->get_field('course', 'category', array('id' => $c1->id)));
 886
 887         // Ensure does not update the category when it is set to 0 in the defaults.
 888         $c1 = $this->getDataGenerator()->create_course();
 889         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 890         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_OR_DEFAUTLS;
 891         $data = array('shortname' => $c1->shortname);
 892         $defaults = array('category' => '0');
 893         $co = new tool_uploadcourse_course($mode, $updatemode, $data, $defaults);
 894         $this->assertTrue($co->prepare());
 895         $this->assertEmpty($co->get_errors());
 896         $this->assertEmpty($co->get_statuses());
 897         $co->proceed();
 898         $this->assertEquals($c1->category, $DB->get_field('course', 'category', array('id' => $c1->id)));
 899     }
 900
 901     public function test_enrolment_data() {
 902         $this->resetAfterTest(true);
 903
 904         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 905         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 906         $data = array('shortname' => 'c1', 'summary' => 'S', 'fullname' => 'FN', 'category' => '1');
 907         $data['enrolment_1'] = 'manual';
 908         $data['enrolment_1_role'] = 'teacher';
 909         $data['enrolment_1_startdate'] = '2nd July 2013';
 910         $data['enrolment_1_enddate'] = '2nd August 2013';
 911         $data['enrolment_1_enrolperiod'] = '10 days';
 912         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 913         $this->assertTrue($co->prepare());
 914         $co->proceed();
 915
 916         // Enrolment methods.
 917         $enroldata = array();
 918         $instances = enrol_get_instances($co->get_id(), false);
 919         foreach ($instances as $instance) {
 920             $enroldata[$instance->enrol] = $instance;
 921         }
 922
 923         $this->assertNotEmpty($enroldata['manual']);
 924         $this->assertEquals(ENROL_INSTANCE_ENABLED, $enroldata['manual']->status);
 925         $this->assertEquals(strtotime($data['enrolment_1_startdate']), $enroldata['manual']->enrolstartdate);
 926         $this->assertEquals(strtotime('1970-01-01 GMT + ' . $data['enrolment_1_enrolperiod']), $enroldata['manual']->enrolperiod);
 927         $this->assertEquals(strtotime('12th July 2013'), $enroldata['manual']->enrolenddate);
 928     }
 929
 930     public function test_idnumber_problems() {
 931         $this->resetAfterTest(true);
 932
 933         $c1 = $this->getDataGenerator()->create_course(array('shortname' => 'sntaken', 'idnumber' => 'taken'));
 934         $c2 = $this->getDataGenerator()->create_course();
 935
 936         // Create with existing ID number.
 937         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 938         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 939         $data = array('shortname' => 'c2', 'summary' => 'summary', 'fullname' => 'FN', 'category' => '1',
 940             'idnumber' => $c1->idnumber);
 941         $co = new tool_uploadcourse_course($mode, $updatemode, $data);
 942         $this->assertFalse($co->prepare());
 943         $this->assertArrayHasKey('idnumberalreadyinuse', $co->get_errors());
 944
 945         // Rename to existing ID number.
 946         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
 947         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
 948         $data = array('shortname' => $c2->shortname, 'rename' => 'SN', 'idnumber' => $c1->idnumber);
 949         $importoptions = array('canrename' => true);
 950         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 951         $this->assertFalse($co->prepare());
 952         $this->assertArrayHasKey('cannotrenameidnumberconflict', $co->get_errors());
 953
 954         // Incrementing shortname increments idnumber.
 955         $mode = tool_uploadcourse_processor::MODE_CREATE_ALL;
 956         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 957         $data = array('shortname' => $c1->shortname, 'idnumber' => $c1->idnumber, 'summary' => 'S', 'fullname' => 'F',
 958             'category' => 1);
 959         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), array());
 960         $this->assertTrue($co->prepare());
 961         $this->assertArrayHasKey('courseshortnameincremented', $co->get_statuses());
 962         $this->assertArrayHasKey('courseidnumberincremented', $co->get_statuses());
 963         $data = $co->get_data();
 964         $this->assertEquals('sntaken_2', $data['shortname']);
 965         $this->assertEquals('taken_2', $data['idnumber']);
 966
 967         // Incrementing shortname increments idnumber unless available.
 968         $mode = tool_uploadcourse_processor::MODE_CREATE_ALL;
 969         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 970         $data = array('shortname' => $c1->shortname, 'idnumber' => 'nottaken', 'summary' => 'S', 'fullname' => 'F',
 971             'category' => 1);
 972         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), array());
 973         $this->assertTrue($co->prepare());
 974         $this->assertArrayHasKey('courseshortnameincremented', $co->get_statuses());
 975         $this->assertArrayNotHasKey('courseidnumberincremented', $co->get_statuses());
 976         $data = $co->get_data();
 977         $this->assertEquals('sntaken_2', $data['shortname']);
 978         $this->assertEquals('nottaken', $data['idnumber']);
 979     }
 980
 981     public function test_generate_shortname() {
 982         $this->resetAfterTest(true);
 983
 984         $c1 = $this->getDataGenerator()->create_course(array('shortname' => 'taken'));
 985
 986         // Generate a shortname.
 987         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 988         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 989         $data = array('summary' => 'summary', 'fullname' => 'FN', 'category' => '1', 'idnumber' => 'IDN');
 990         $importoptions = array('shortnametemplate' => '%i');
 991         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
 992         $this->assertTrue($co->prepare());
 993         $this->assertArrayHasKey('courseshortnamegenerated', $co->get_statuses());
 994
 995         // Generate a shortname without a template.
 996         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
 997         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
 998         $data = array('summary' => 'summary', 'fullname' => 'FN', 'category' => '1');
 999         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), array());
1000         $this->assertFalse($co->prepare());
1001         $this->assertArrayHasKey('missingshortnamenotemplate', $co->get_errors());
1002
1003         // Generate a shortname in update mode.
1004         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
1005         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
1006         $data = array('summary' => 'summary', 'fullname' => 'FN', 'category' => '1');
1007         $importoptions = array('shortnametemplate' => '%f');
1008         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1009         $this->assertFalse($co->prepare());
1010         // Commented because we never get here as the course without shortname does not exist.
1011         // $this->assertArrayHasKey('cannotgenerateshortnameupdatemode', $co->get_errors());
1012
1013         // Generate a shortname to a course that already exists.
1014         $mode = tool_uploadcourse_processor::MODE_CREATE_NEW;
1015         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
1016         $data = array('summary' => 'summary', 'fullname' => 'taken', 'category' => '1');
1017         $importoptions = array('shortnametemplate' => '%f');
1018         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1019         $this->assertFalse($co->prepare());
1020         $this->assertArrayHasKey('generatedshortnamealreadyinuse', $co->get_errors());
1021
1022         // Generate a shortname to a course that already exists will be incremented.
1023         $mode = tool_uploadcourse_processor::MODE_CREATE_ALL;
1024         $updatemode = tool_uploadcourse_processor::UPDATE_NOTHING;
1025         $data = array('summary' => 'summary', 'fullname' => 'taken', 'category' => '1');
1026         $importoptions = array('shortnametemplate' => '%f');
1027         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1028         $this->assertTrue($co->prepare());
1029         $this->assertArrayHasKey('courseshortnamegenerated', $co->get_statuses());
1030         $this->assertArrayHasKey('courseshortnameincremented', $co->get_statuses());
1031     }
1032
1033     public function test_mess_with_frontpage() {
1034         global $SITE;
1035         $this->resetAfterTest(true);
1036
1037         // Updating the front page.
1038         $mode = tool_uploadcourse_processor::MODE_UPDATE_ONLY;
1039         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
1040         $data = array('shortname' => $SITE->shortname, 'idnumber' => 'NewIDN');
1041         $importoptions = array();
1042         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1043         $this->assertFalse($co->prepare());
1044         $this->assertArrayHasKey('cannotupdatefrontpage', $co->get_errors());
1045
1046         // Updating the front page.
1047         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
1048         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
1049         $data = array('shortname' => $SITE->shortname, 'idnumber' => 'NewIDN');
1050         $importoptions = array();
1051         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1052         $this->assertFalse($co->prepare());
1053         $this->assertArrayHasKey('cannotupdatefrontpage', $co->get_errors());
1054
1055         // Generating a shortname should not be allowed in update mode, and so we cannot update the front page.
1056         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
1057         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
1058         $data = array('idnumber' => 'NewIDN', 'fullname' => 'FN', 'category' => 1);
1059         $importoptions = array('shortnametemplate' => $SITE->shortname);
1060         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1061         $this->assertFalse($co->prepare());
1062         $this->assertArrayHasKey('cannotgenerateshortnameupdatemode', $co->get_errors());
1063
1064         // Renaming to the front page should not be allowed.
1065         $c1 = $this->getDataGenerator()->create_course();
1066         $mode = tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE;
1067         $updatemode = tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY;
1068         $data = array('shortname' => $c1->shortname, 'fullname' => 'FN', 'idnumber' => 'NewIDN', 'rename' => $SITE->shortname);
1069         $importoptions = array('canrename' => true);
1070         $co = new tool_uploadcourse_course($mode, $updatemode, $data, array(), $importoptions);
1071         $this->assertFalse($co->prepare());
1072         $this->assertArrayHasKey('cannotrenameshortnamealreadyinuse', $co->get_errors());
1073
1074     }
1075
1076 }