/**
* Test validation that class duplicate with autocreate creates and links to a moodle course
*/
public function test_autocreatemoodlecourse_createsandlinksmoodlecourse()
{
global $DB;
$class = new pmclass(1);
$classmoodle = new classmoodlecourse(array('moodlecourseid' => 2, 'classid' => 1));
$classmoodle->save();
$userset = new stdClass();
$userset->name = 'test';
$options = array();
$options['targetcluster'] = $userset;
$options['classes'] = 1;
$options['moodlecourses'] = 'copyalways';
$options['classmap'] = array();
$return = $class->duplicate($options);
// Make sure that a we get a class returned.
$this->assertTrue(is_array($return['classes']));
// Get the new returned id.
$id = $return['classes'][1];
$recordexists = $DB->record_exists('local_elisprogram_cls_mdl', array('classid' => $id));
// We want to validate that a link to the new moodle course was created.
$this->assertTrue($recordexists);
// Get the new course id.
$record = $DB->get_record('local_elisprogram_cls_mdl', array('classid' => $id));
$courseexists = $DB->record_exists('course', array('id' => $record->moodlecourseid));
// We want to validate that new moodle course was created.
$this->assertTrue($recordexists);
ini_set('max_execution_time', '0');
}
/**
* Performs class deletion
* @throws moodle_exception If there was an error in passed parameters.
* @throws data_object_exception If there was an error deleting the entity.
* @param array $data The incoming data parameter.
* @return array An array of parameters, if successful.
*/
public static function class_delete(array $data)
{
global $USER, $DB;
if (static::require_elis_dependencies() !== true) {
throw new moodle_exception('ws_function_requires_elis', 'local_datahub');
}
// Parameter validation.
$params = self::validate_parameters(self::class_delete_parameters(), array('data' => $data));
// Context validation.
$context = context_user::instance($USER->id);
self::validate_context($context);
// Initialize version1elis importplugin for utility functions.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
// Get the class.
$clsid = $DB->get_field(pmclass::TABLE, 'id', array('idnumber' => $data['idnumber']));
if (empty($clsid)) {
throw new data_object_exception('ws_class_delete_fail_invalid_idnumber', 'local_datahub', '', $data);
}
// Capability checking.
require_capability('local/elisprogram:class_delete', \local_elisprogram\context\pmclass::instance($clsid));
// Delete the class.
$pmclass = new pmclass($clsid);
$pmclass->delete();
// Verify class deleted & respond.
if (!$DB->record_exists(pmclass::TABLE, array('id' => $clsid))) {
return array('messagecode' => get_string('ws_class_delete_success_code', 'local_datahub'), 'message' => get_string('ws_class_delete_success_msg', 'local_datahub'));
} else {
throw new data_object_exception('ws_class_delete_fail', 'local_datahub');
}
}
/**
* Test student save works when $USER object not set
*/
public function test_student_save_nouserobject()
{
global $DB, $USER;
// Create Moodle course category.
$crscat = create_course_category((object) array('name' => 'Test Course category', 'idnumber' => 'MCC-1'));
// Create Moodle course.
$crsdata = array('category' => $crscat->id, 'fullname' => 'MC-TEST-ELIS-8484', 'shortname' => 'MC-TEST-ELIS-8484', 'idnumber' => 'MC-TEST-ELIS-8484');
$mdlcrs = new stdClass();
$mdlcrs->id = $DB->insert_record('course', (object) $crsdata);
$cddata = array('name' => 'CD-ELIS-8484', 'code' => 'CD-ELIS-8484', 'idnumber' => 'CD-ELIS-8484', 'syllabus' => 'syllabus');
$cd = new course($cddata);
$cd->save();
$ci = new pmclass(array('idnumber' => 'CI-ELIS-8484', 'courseid' => $cd->id, 'moodlecourseid' => $mdlcrs->id, 'autocreate' => 0));
$ci->save();
$testuser = new user(array('idnumber' => 'testuserelis8484', 'username' => 'testuserelis8484', 'firstname' => 'Test', 'lastname' => 'User-ELIS8484', 'email' => '*****@*****.**', 'city' => 'Waterloo', 'country' => 'CA'));
$testuser->save();
$USER = null;
$sturec = new stdClass();
$sturec->userid = $testuser->id;
$sturec->classid = $ci->id;
$sturec->grade = 0;
$sturec->enrolmenttime = time();
$student = new student($sturec);
$student->save();
$this->assertFalse(empty($student));
if (!empty($student)) {
$this->assertFalse(empty($student->id));
}
}
/**
* Test block_elisadmin_load_menu_children_course function.
*/
public function test_block_elisadmin_load_menu_children_course()
{
global $DB, $USER;
accesslib_clear_all_caches(true);
// Create test user - ensure the returned user is NOT a site admin. if they are, our capability restrictions won't work.
$testuser = new user();
$testuser->username = '******';
$testuser->idnumber = 'testELIS4093';
$testuser->firstname = 'testELIS4093';
$testuser->lastname = 'testELIS4093';
$testuser->email = '*****@*****.**';
$testuser->country = 'CA';
$testuser->save();
$testmuser = $testuser->get_moodleuser();
// Create role with cap: 'local/elisprogram:class_view'.
$testrole = new stdClass();
$testrole->name = 'ELIS Class View';
$testrole->shortname = '_test_ELIS_4093';
$testrole->description = 'ELIS Class View';
$testrole->archetype = '';
$testrole->id = create_role($testrole->name, $testrole->shortname, $testrole->description, $testrole->archetype);
// Ensure our new role is assignable to ELIS class contexts.
set_role_contextlevels($testrole->id, array(CONTEXT_ELIS_CLASS));
// Ensure the role has our required capability assigned.
$sitecontext = context_system::instance();
assign_capability('local/elisprogram:class_view', CAP_ALLOW, $testrole->id, $sitecontext->id, true);
$sitecontext->mark_dirty();
// Create ELIS Course Description.
$testcrs = new course(array('name' => 'CD-ELIS-4093', 'idnumber' => 'CDELIS4093', 'syllabus' => ''));
$testcrs->save();
$testcrs->load();
// Create three(3) Class Instances for Course Descrption.
$testcls1 = new pmclass(array('courseid' => $testcrs->id, 'idnumber' => 'CI_ELIS_4093.1'));
$testcls1->save();
$testcls1->load();
$testcls2 = new pmclass(array('courseid' => $testcrs->id, 'idnumber' => 'CI_ELIS_4093.2'));
$testcls2->save();
$testcls2->load();
$testcls3 = new pmclass(array('courseid' => $testcrs->id, 'idnumber' => 'CI_ELIS_4093.3'));
$testcls3->save();
$testcls3->load();
// Assign testuser new role in one Class Instance.
$context = \local_elisprogram\context\pmclass::instance($testcls2->id);
role_assign($testrole->id, $testmuser->id, $context->id);
// Switch to testuser.
$USER = $testmuser;
$this->setUser($testmuser);
$items = block_elisadmin_load_menu_children_course($testcrs->id, 0, 0, 5, '');
$this->assertEquals(1, count($items));
$this->assertTrue($items[0]->name == 'pmclass_2');
}
/**
* Validate that appropriate fields are synched over to Moodle when PM user is enrolled in a class instance during an import.
*/
public function test_user_sync_on_pm_user_create()
{
global $CFG, $DB;
require_once $CFG->dirroot . '/course/lib.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/classmoodlecourse.class.php');
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/user.class.php');
// Configure the elis enrolment plugin.
$roleid = $DB->get_field('role', 'id', array(), IGNORE_MULTIPLE);
set_config('roleid', $roleid, 'enrol_elis');
$user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
$user->save();
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$class = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$class->save();
$category = new stdClass();
$category->name = 'testcategoryname';
$category->id = $DB->insert_record('course_categories', $category);
// Create the associated context.
context_coursecat::instance($category->id);
$mdlcourse = new stdClass();
$mdlcourse->category = $category->id;
$mdlcourse->fullname = 'testcoursefullname';
$mdlcourse = create_course($mdlcourse);
// Associate class instance to Moodle course.
$classmoodlecourse = new classmoodlecourse(array('classid' => $class->id, 'moodlecourseid' => $mdlcourse->id));
$classmoodlecourse->save();
// Run the enrolment create action.
$record = new stdClass();
$record->context = 'class_testclassidnumber';
$record->user_username = '******';
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->class_enrolment_create($record, 'bogus', 'testclassidnumber');
// Validate the enrolment.
$enrolid = $DB->get_field('enrol', 'id', array('enrol' => 'elis', 'courseid' => $mdlcourse->id));
$this->assertNotEquals(false, $enrolid);
$mdluserid = $DB->get_field('user', 'id', array('username' => 'testuserusername'));
$this->assertNotEquals(false, $mdluserid);
$this->assertTrue($DB->record_exists('user_enrolments', array('enrolid' => $enrolid, 'userid' => $mdluserid)));
// Validate the role assignment.
$mdlcoursecontext = context_course::instance($mdlcourse->id);
$this->assertTrue($DB->record_exists('role_assignments', array('roleid' => $roleid, 'contextid' => $mdlcoursecontext->id, 'userid' => $mdluserid)));
}
/**
* Get an array of allowed clusters for a class that can be passed to get_filter_sql_permissions_elementuser()
* @param int $classid The classid to get clusters for.
* @return array An array of objects
*/
public static function getclustersforclass($classid)
{
$clusters = pmclass::get_allowed_clusters($classid);
$return = array();
foreach ($clusters as $i => $cluster) {
if (is_numeric($cluster)) {
$return[] = (object) array('clusterid' => $cluster);
} else {
if ($cluster instanceof userset) {
$return[] = (object) array('clusterid' => $cluster->id);
}
}
}
return $return;
}
/**
* Clone a track
* @param array $options options for cloning. Valid options are:
* - 'targetcurriculum': the curriculum id to associate the clones with
* (default: same as original track)
* - 'classmap': a mapping of class IDs to use from the original track to
* the cloned track. If a class from the original track is not mapped, a
* new class will be created
* - 'moodlecourse': whether or not to clone Moodle courses (if they were
* autocreated). Values can be (default: "copyalways"):
* - "copyalways": always copy course
* - "copyautocreated": only copy autocreated courses
* - "autocreatenew": autocreate new courses from course template
* - "link": link to existing course
* @return array array of array of object IDs created. Key in outer array
* is type of object (plural). Key in inner array is original object ID,
* value is new object ID. Outer array also has an entry called 'errors',
* which is an array of any errors encountered when duplicating the
* object.
*/
function duplicate(array $options = array())
{
$objs = array('errors' => array());
if (isset($options['targetcluster'])) {
$userset = $options['targetcluster'];
if (!is_object($userset) || !is_a($userset, 'userset')) {
$options['targetcluster'] = $userset = new userset($userset);
}
}
// Due to lazy loading, we need to pre-load this object
$this->load();
// clone main track object
$clone = new track($this);
unset($clone->id);
if (isset($options['targetcurriculum'])) {
$clone->curid = $options['targetcurriculum'];
}
$idnumber = $clone->idnumber;
$name = $clone->name;
if (isset($userset)) {
$to_append = ' - ' . $userset->name;
// if cluster specified, append cluster's name to course
$idnumber = append_once($idnumber, $to_append, array('maxlength' => 95));
$name = append_once($name, $to_append, array('maxlength' => 250));
}
//get a unique idnumber
$clone->idnumber = generate_unique_identifier(track::TABLE, 'idnumber', $idnumber, array('idnumber' => $idnumber));
if ($clone->idnumber != $idnumber) {
//get the suffix appended and add it to the name
$parts = explode('.', $clone->idnumber);
$suffix = end($parts);
$clone->name = $name . '.' . $suffix;
} else {
$clone->name = $name;
}
$clone->autocreate = false;
// avoid warnings
$clone->save();
$objs['tracks'] = array($this->id => $clone->id);
// associate with target cluster (if any)
if (isset($userset)) {
clustertrack::associate($userset->id, $clone->id);
}
// copy classes
$clstrks = track_assignment_get_listing($this->id);
if ($clstrks->valid() === true) {
$objs['classes'] = array();
if (!isset($options['classmap'])) {
$options['classmap'] = array();
}
foreach ($clstrks as $clstrkdata) {
$newclstrk = new trackassignment($clstrkdata);
$newclstrk->trackid = $clone->id;
unset($newclstrk->id);
if (isset($options['classmap'][$clstrkdata->clsid])) {
// use existing duplicate class
$class = new pmclass($options['classmap'][$clstrkdata->clsid]);
} else {
// no existing duplicate -> duplicate class
$class = new pmclass($clstrkdata->clsid);
$rv = $class->duplicate($options);
if (isset($rv['errors']) && !empty($rv['errors'])) {
$objs['errors'] = array_merge($objs['errors'], $rv['errors']);
}
if (isset($rv['classes'])) {
$objs['classes'] = $objs['classes'] + $rv['classes'];
}
}
$newclstrk->classid = $class->id;
$newclstrk->courseid = $class->courseid;
$newclstrk->save();
}
}
unset($clstrks);
return $objs;
}
/**
* Validate that mappings are applied during the instructor enrolment delete action
*/
public function test_mapping_applied_during_instructor_enrolment_delete()
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/data/course.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/instructor.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/pmclass.class.php';
$this->init_mapping();
$userid = $this->create_test_user();
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$pmclass = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$pmclass->save();
$instructor = new instructor(array('classid' => $pmclass->id, 'userid' => $userid));
$instructor->save();
// Run the instructor enrolment delete action.
$record = new stdClass();
$record->customaction = 'delete';
$record->customcontext = 'class_testclassidnumber';
$record->customuser_username = '******';
$record->customuser_email = '*****@*****.**';
$record->customuser_idnumber = 'testuseridnumber';
$record->customrole = 'instructor';
$this->run_enrolment_import((array) $record);
// Validation.
$this->assertEquals(0, $DB->count_records(instructor::TABLE));
}
/**
* Performs class creation
* @throws moodle_exception If there was an error in passed parameters.
* @throws data_object_exception If there was an error creating the entity.
* @param array $data The incoming data parameter.
* @return array An array of parameters, if successful.
*/
public static function class_create(array $data)
{
global $USER, $DB;
if (static::require_elis_dependencies() !== true) {
throw new moodle_exception('ws_function_requires_elis', 'local_datahub');
}
// Parameter validation.
$params = self::validate_parameters(self::class_create_parameters(), array('data' => $data));
// Context validation.
$context = context_user::instance($USER->id);
self::validate_context($context);
// Capability checking.
require_capability('local/elisprogram:class_create', context_system::instance());
// Initialize version1elis importplugin for utility functions.
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
// Create the class.
$data = (object) $data;
$data = $importplugin->add_custom_field_prefixes($data);
// Parse startdate and enddate.
foreach (array('startdate', 'enddate') as $date) {
if (isset($data->{$date})) {
$data->{$date} = $importplugin->parse_date($data->{$date});
}
}
// Check for duplicate idnumbers.
if ($DB->record_exists(pmclass::TABLE, array('idnumber' => $data->idnumber))) {
throw new moodle_exception('ws_class_create_fail_duplicateidnumber', 'local_datahub');
}
// Do course assignment.
$crsid = $DB->get_field(course::TABLE, 'id', array('idnumber' => $data->assignment));
if (empty($crsid)) {
throw new moodle_exception('ws_class_create_fail_invalidcourseassignment', 'local_datahub');
}
$data->courseid = $crsid;
$class = new pmclass();
$class->set_from_data($data);
$class->save();
// Associate this class instance to a track, if necessary.
$importplugin->associate_class_to_track($data, $class->id);
// Associate this class instance to a Moodle course, if necessary.
$importplugin->associate_class_to_moodle_course($data, $class->id);
// Respond.
if (!empty($class->id)) {
$classrec = (array) $DB->get_record(pmclass::TABLE, array('id' => $class->id));
$classobj = $class->to_array();
// Convert multi-valued custom field arrays to comma-separated listing.
$fields = static::get_class_custom_fields();
foreach ($fields as $field) {
// Generate name using custom field prefix.
$fullfieldname = data_object_with_custom_fields::CUSTOM_FIELD_PREFIX . $field->shortname;
if ($field->multivalued && !empty($classobj[$fullfieldname]) && is_array($classobj[$fullfieldname])) {
$classobj[$fullfieldname] = implode(',', $classobj[$fullfieldname]);
}
}
return array('messagecode' => get_string('ws_class_create_success_code', 'local_datahub'), 'message' => get_string('ws_class_create_success_msg', 'local_datahub'), 'record' => array_merge($classrec, $classobj));
} else {
throw new data_object_exception('ws_class_create_fail', 'local_datahub');
}
}
/**
* Test sync_completionelements method.
*
* @dataProvider dataprovider_sync_completionelements
* @param array $gradeitem Array of parameters to create grade_item.
* @param array $gradegrade Array of parameters to create grade_grade.
* @param array $coursecompletion Array of parameters to create coursecompletion.
* @param array $studentgrade Array of parameters to create student_grade.
* @param int $timenow Current timestamp to enable testing with time.
* @param array $expectedstudentgrade Array of parameters we expect to be set in the student_grade.
*/
public function test_sync_completionelements($gradeitem, $gradegrade, $coursecompletion, $studentgrade, $timenow, $expectedstudentgrade)
{
global $DB;
$sync = new \local_elisprogram\moodle\synchronize();
// Test data setup.
$crs = new \course(array('idnumber' => 'CRS1', 'name' => 'Course 1', 'syllabus' => ''));
$crs->save();
$cls = new \pmclass(array('courseid' => $crs->id, 'idnumber' => 'CLS1'));
$cls->save();
$usr = new \user(array('username' => 'test1', 'idnumber' => 'test2', 'firstname' => 'test', 'lastname' => 'user', 'email' => '*****@*****.**', 'country' => 'CA'));
$usr->save();
$musr = $this->getDataGenerator()->create_user();
$gradeitem = new \grade_item($gradeitem, false);
$gradeitem->insert();
$gradegrade['itemid'] = $gradeitem->id;
$gradegrade['userid'] = $musr->id;
$gradegrade = new \grade_grade($gradegrade, false);
$gradegrade->insert();
$coursecompletion['courseid'] = $crs->id;
$coursecompletion = new \coursecompletion($coursecompletion);
$coursecompletion->save();
if ($studentgrade !== false) {
$studentgrade['classid'] = $cls->id;
$studentgrade['userid'] = $usr->id;
$studentgrade['completionid'] = $coursecompletion->id;
$studentgrade = new \student_grade($studentgrade);
$studentgrade->save();
$studentgrade = new \student_grade($studentgrade->id);
$studentgrade->load();
}
// Method parameter setup.
$causer = (object) array('cmid' => $usr->id, 'pmclassid' => $cls->id);
$gis = array($gradeitem->id => (object) array('id' => $gradeitem->id, 'grademax' => $gradeitem->grademax));
$compelements = array($gradeitem->id => (object) array('id' => $coursecompletion->id, 'completion_grade' => $coursecompletion->completion_grade));
$moodlegrades = array($gradeitem->id => $gradegrade);
if ($studentgrade !== false) {
$cmgrades = array($coursecompletion->id => $studentgrade->to_object());
} else {
$cmgrades = array();
}
$sync->sync_completionelements($causer, $gis, $compelements, $moodlegrades, $cmgrades, $timenow);
$actualstudentgrade = false;
if ($studentgrade !== false) {
$actualstudentgrade = $DB->get_record(\student_grade::TABLE, array('id' => $studentgrade->id));
} else {
$actualstudentgrades = $DB->get_records(\student_grade::TABLE, array(), 'id DESC');
if (!empty($actualstudentgrades)) {
$actualstudentgrade = array_shift($actualstudentgrades);
}
}
if ($actualstudentgrade !== false) {
if ($expectedstudentgrade !== false) {
$expectedstudentgrade['id'] = $actualstudentgrade->id;
$expectedstudentgrade['classid'] = $cls->id;
$expectedstudentgrade['userid'] = $usr->id;
$expectedstudentgrade['completionid'] = $coursecompletion->id;
// This is here for tests where we can't reliably predetermine timemodified (i.e. no-sync cases).
if (!isset($expectedstudentgrade['timemodified'])) {
$expectedstudentgrade['timemodified'] = $actualstudentgrade->timemodified;
}
$expectedstudentgrade = (object) $expectedstudentgrade;
$this->assertEquals($expectedstudentgrade, $actualstudentgrade);
} else {
$this->assertTrue(false, 'A student_grade was created when one was not expected.');
}
} else {
// If $expectedstudentgrade is false we were expected no grade to be created. If not, we have a problem.
if ($expectedstudentgrade !== false) {
$this->assertTrue(false, 'No student_grade created when one was expected');
} else {
$this->assertTrue(true);
}
}
}
/**
* Test coursecatalogpage->display_savenew() for setting of class enrolment time (ELIS-8518)
* @uses $DB
* @uses $USER
*/
public function test_display_savenew_classenrolmenttime()
{
global $DB, $USER;
$this->load_csv_data_for_enrolment_test();
$USER = $DB->get_record('user', array('id' => 100));
// Set user to the test user.
$_GET['clsid'] = 100;
// Class GET parameter is expected by coursecatalogpage function.
$now = time();
// Set the startdate on the ELIS class to a day in the future.
$pmclass = new pmclass(100);
$pmclass->startdate = $now + 60 * 60 * 24;
$pmclass->save();
// Set the startdate on the associated Moodle course to a day in the past.
$course = new stdClass();
$course->id = 100;
$course->startdate = $now - 60 * 60 * 24;
$DB->update_record('course', $course);
$coursecatalogpage = new coursecatalogpage();
try {
$coursecatalogpage->display_savenew();
} catch (Exception $e) {
// Ignore the redirect error message because we are not testing that here.
}
$enrolmenttime = $DB->get_field('local_elisprogram_cls_enrol', 'enrolmenttime', array('classid' => 100, 'userid' => 103));
$difference = abs($now - $enrolmenttime);
$this->assertLessThanOrEqual(1, $difference);
// Allow for 1 second variance, just in case.
}
/**
* Tests contexts in pmclass data object.
*
* Covers:
* local/elisprogram/lib/data/pmclass.class.php:259
*/
public function test_classcontexts()
{
$this->setup_curriculum();
$this->setup_curriculumcourse();
$this->setup_courses();
$this->setup_classes();
$pmclass = new pmclass(101);
$pmclass->delete();
}
/**
* Test the autoenrol after course completion function.
*/
public function test_check_autoenrol_after_course_completion()
{
$dataset = $this->createCsvDataSet(array(course::TABLE => elispm::file('tests/fixtures/pmcourse.csv'), pmclass::TABLE => elispm::file('tests/fixtures/pmclass.csv'), user::TABLE => elispm::file('tests/fixtures/pmuser.csv'), student::TABLE => elispm::file('tests/fixtures/student.csv'), waitlist::TABLE => elispm::file('tests/fixtures/waitlist2.csv')));
$this->loadDataSet($dataset);
$class = new pmclass(100);
$class->load();
$class->maxstudents = 2;
$class->enrol_from_waitlist = 1;
$class->save();
$student = new student(array('userid' => 103, 'classid' => 100));
$student->completestatusid = STUSTATUS_PASSED;
$student->save();
$return = waitlist::check_autoenrol_after_course_completion($student);
$this->assertTrue($return);
}
/**
* Validate that the check_for_moodle_courses method deletes the correct set of orphaned associations for a specific user.
* @param array $associations The list of associations and information regarding whether they should be cleaned up or not.
* @dataProvider dataprovider_checkformoodlecourses
*/
public function test_checkformoodlecoursesrespectsuseridparameter($associations)
{
global $DB;
// Set up our classes.
$this->load_csv_data();
$student = new student(array('userid' => 103, 'classid' => 103));
$sink = $this->redirectMessages();
$student->save();
// Track which associations should remain.
$remainingassociations = array();
foreach ($associations as $association) {
// Persist the record.
$record = new classmoodlecourse($association);
$record->save();
// Test user is enrolled in class 103, so this one should be deleted.
if ($association['classid'] != 103) {
// It should persist after the method is called.
$remainingassociations[] = $association;
}
}
// Delete orphaned records.
pmclass::check_for_moodle_courses(103);
// Validate count.
$this->assertEquals(count($remainingassociations), $DB->count_records(classmoodlecourse::TABLE));
// Validate records specifically.
foreach ($remainingassociations as $remainingassociation) {
$params = array('classid' => $remainingassociation['classid'], 'moodlecourseid' => $remainingassociation['moodlecourseid']);
$exists = $DB->record_exists(classmoodlecourse::TABLE, $params);
$this->assertTrue($exists);
}
}
/**
* Override print_num_items to display the max number of students allowed in this class
*
* @param int $numitems max number of students
*/
public function print_num_items($classid, $max)
{
$pmclass = new pmclass($classid);
$students = $pmclass->get_completion_counts($classid);
$langfailed = get_string('num_students_failed', static::LANG_FILE);
$langpassed = get_string('num_students_passed', static::LANG_FILE);
$langnotcomplete = get_string('num_students_not_complete', static::LANG_FILE);
$langmaxstudents = get_string('num_max_students', static::LANG_FILE);
if (!empty($students[STUSTATUS_FAILED])) {
// echo '<div style="float:right;">'.$langfailed.': '.$students[STUSTATUS_FAILED].'</div><br />';
}
if (!empty($students[STUSTATUS_PASSED])) {
// echo '<div style="float:right;">'.$langpassed.': '.$students[STUSTATUS_PASSED].'</div><br />';
}
if (!empty($students[STUSTATUS_NOTCOMPLETE])) {
// echo '<div style="float:right;">'.$langnotcomplete.': '.$students[STUSTATUS_NOTCOMPLETE].'</div><br />';
}
if (!empty($max)) {
echo '<div style="float:right;">' . $langmaxstudents . ': ' . $max . '</div><br />';
}
}
function get_item_display_options($column, $class)
{
$classobj = new pmclass($class);
if (!$classobj->is_enrollable()) {
return get_string('notenrollable', 'enrol');
}
if (student::count_enroled($class->id) < $class->maxstudents || empty($class->maxstudents)) {
$action = 'savenew';
} else {
$action = 'confirmwaitlist';
}
return '<a href="index.php?s=crscat&section=curr&clsid=' . "{$class->id}&action={$action}\">" . get_string('choose') . '</a>';
}
/**
* Test creating a new class entity with a default role assignment defined.
*/
public function test_createclasswithdefaultroleassignment()
{
global $USER, $DB;
list($rcid, $reid) = $this->create_roles('class');
// Setup the editor role to be the default role for the class context.
elis::$config->local_elisprogram->default_class_role_id = $reid;
$sysctx = context_system::instance();
// Assign the test user the creator role.
role_assign($rcid, $USER->id, $sysctx->id);
// Create a new class entity.
$data = array('courseid' => 100, 'idnumber' => 'program100', 'name' => 'program100', 'description' => 'program100');
$obj = new pmclass($data);
$obj->save();
// Initialize a new class management page and invoke the code that handles default role assignments.
$page = new pmclasspage();
$sink = $this->redirectMessages();
$page->after_cm_entity_add($obj);
$classctx = \local_elisprogram\context\pmclass::instance($obj->id);
$params = array('roleid' => $reid, 'userid' => $USER->id, 'contextid' => $classctx->id);
$this->assertTrue($DB->record_exists('role_assignments', $params));
}
/**
* Validate that mappings are applied during the class instance delete action
*/
public function test_mapping_applied_during_class_delete()
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/data/course.class.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/pmclass.class.php';
$this->init_mapping();
$pmcourse = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$pmcourse->save();
$pmclass = new pmclass(array('courseid' => $pmcourse->id, 'idnumber' => 'testclassidnumber'));
$pmclass->save();
// Run the course delete action.
$record = new stdClass();
$record->customaction = 'delete';
$record->customcontext = 'class';
$record->customidnumber = 'testclassidnumber';
$this->run_pmentity_import((array) $record);
// Validation.
$this->assertEquals(0, $DB->count_records(pmclass::TABLE));
}
/**
* Determines whether the current user is allowed to create, edit, and delete associations
* between a user and a class
*
* @param int $userid The id of the user being associated to the class
* @param int $classid The id of the class we are associating the user to
* @uses $DB
* @uses $USER;
* @return boolean True if the current user has the required permissions, otherwise false
*/
public static function can_manage_assoc($userid, $classid)
{
global $DB, $USER;
// TODO: Ugly, this needs to be overhauled
$cpage = new pmclasspage();
if (!pmclasspage::can_enrol_into_class($classid)) {
//the users who satisfty this condition are a superset of those who can manage associations
return false;
} else {
if ($cpage->_has_capability('local/elisprogram:class_enrol', $classid)) {
//current user has the direct capability
return true;
}
}
//get the context for the "indirect" capability
$context = pm_context_set::for_user_with_capability('cluster', 'local/elisprogram:class_enrol_userset_user', $USER->id);
$allowed_clusters = array();
$allowed_clusters = pmclass::get_allowed_clusters($classid);
//query to get users associated to at least one enabling cluster
$cluster_select = '';
if (empty($allowed_clusters)) {
$cluster_select = '0=1';
} else {
$cluster_select = 'clusterid IN (' . implode(',', $allowed_clusters) . ')';
}
$select = "userid = ? AND {$cluster_select}";
//user just needs to be in one of the possible clusters
if ($DB->record_exists_select(clusterassignment::TABLE, $select, array($userid))) {
return true;
}
return false;
}
/**
* Validate that the provided custom field type and value produce the
* specified error message on class instance update
*
* @param string $uitype The input control / UI type
* @param string $value The value to use for the custom field
* @param string $message The expected error message
* @param array $otherparams Other parameters to give to the field owner
* @dataProvider type_error_provider
*/
public function test_class_update_customfield_message($uitype, $value, $message, $otherparams)
{
global $CFG;
require_once $CFG->dirroot . '/local/elisprogram/accesslib.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/data/pmclass.class.php';
$this->create_custom_field(CONTEXT_ELIS_CLASS, $uitype, $otherparams);
// Create mapping record.
$this->create_mapping_record('course', 'testfieldshortname', 'customtestfieldshortname');
$courseid = $this->create_test_course();
$class = new pmclass(array('courseid' => $courseid, 'idnumber' => 'testclassidnumber'));
$class->save();
$data = array('action' => 'update', 'context' => 'class', 'idnumber' => 'testclassidnumber', 'customtestfieldshortname' => $value);
$message = '[course.csv line 2] Class instance with idnumber "testclassidnumber" could not be updated. ' . $message . "\n";
$this->assert_data_produces_error($data, $message, 'course');
}
/**
* Test failure conditions.
* @dataProvider dataprovider_failure
* @expectedException moodle_exception
* @param array $params The incoming parameters.
*/
public function test_failure(array $params, $giveperms = true)
{
global $DB;
if ($giveperms === true) {
$this->give_permissions(array('local/elisprogram:class_delete'));
}
$course = new course(array('idnumber' => 'testcourse', 'name' => 'Test Course', 'syllabus' => ''));
$course->save();
$pmclass = new pmclass(array('idnumber' => 'testclass', 'courseid' => $course->id));
$pmclass->save();
$response = local_datahub_elis_class_delete::class_delete($params);
}
/**
* Check for nags...
*
*/
function pm_check_for_nags()
{
$status = true;
mtrace("Checking notifications<br />\n");
$status = pmclass::check_for_nags() && $status;
$status = pmclass::check_for_moodle_courses() && $status;
$status = course::check_for_nags() && $status;
$status = curriculum::check_for_nags() && $status;
return $status;
}
/**
* Initialize a new class object
* @param int $courseid A course record ID
*/
protected function initclass($courseid)
{
$data = array('idnumber' => '__fcH__TESTID001__', 'courseid' => $courseid);
$newclass = new pmclass($data);
$newclass->save();
$this->tclassid = $newclass->id;
}
/**
*
* @global object $CFG
* @uses $CFG
* @uses $OUTPUT
*/
public function enrol()
{
global $CFG;
$class = new pmclass($this->classid);
// enrol directly in the course
$student = new student();
// TBD: new student($this); didn't work!!!
$student->userid = $this->userid;
$student->classid = $this->classid;
$student->enrolmenttime = max(time(), $class->startdate);
// Disable validation rules for prerequisites and enrolment_limits
$student->validation_overrides[] = 'prerequisites';
$student->validation_overrides[] = 'enrolment_limit';
$courseid = $class->get_moodle_course_id();
if ($courseid) {
$course = $this->_db->get_record('course', array('id' => $courseid));
// check that the elis plugin allows for enrolments from the course
// catalog -- if not, see if there are other plugins that allow
// self-enrolment.
$plugin = enrol_get_plugin('elis');
$enrol = $plugin->get_or_create_instance($course);
if (!$enrol->{enrol_elis_plugin::ENROL_FROM_COURSE_CATALOG_DB}) {
// get course enrolment plugins, and see if any of them allow self-enrolment
$enrols = enrol_get_plugins(true);
$enrolinstances = enrol_get_instances($course->id, true);
foreach ($enrolinstances as $instance) {
if (!isset($enrols[$instance->enrol])) {
continue;
}
$form = $enrols[$instance->enrol]->enrol_page_hook($instance);
if ($form) {
// at least one plugin allows self-enrolment -- send
// the user to the course enrolment page, and prevent
// automatic enrolment
$a = new stdClass();
$a->id = $course->id;
$a->idnumber = $class->idnumber;
$a->wwwroot = $CFG->wwwroot;
$subject = get_string('moodleenrol_subj', self::LANG_FILE, $a);
$message = get_string('moodleenrol', self::LANG_FILE, $a);
$student->no_moodle_enrol = true;
break;
}
}
}
}
$student->save();
// Send notification, if enabled.
$sendnotification = !empty(elis::$config->local_elisprogram->notify_enroledfromwaitlist_user) ? true : false;
if ($sendnotification === true) {
if (!isset($message)) {
$a = new stdClass();
$a->idnum = $class->idnumber;
$subject = get_string('nowenroled', self::LANG_FILE, $a);
$message = get_string('nowenroled', self::LANG_FILE, $a);
}
$cuser = new user($this->userid);
$cuser->load();
$from = get_admin();
notification::notify($message, $cuser, $from);
}
$this->delete();
}
/**
* Test failure conditions.
* @dataProvider dataprovider_failure
* @expectedException moodle_exception
* @param array $user The incoming user data.
*/
public function test_failure(array $user, $giveperms = true)
{
global $DB;
if ($giveperms === true) {
$this->give_permissions(array('local/elisprogram:class_create'));
}
$course = new course();
$course->idnumber = 'testcourse1';
$course->name = 'Test Course 1';
$course->syllabus = 'Test';
$course->save();
// Create a class (used for duplicate test).
$class = new pmclass();
$class->idnumber = 'testclass1';
$class->courseid = $course->id;
$class->save();
$response = local_datahub_elis_class_create::class_create($user);
}
/**
* Validate that credits are correctly transferred from course to enrolment
* for a specific user
*
* @param array $enrolments Enrolment records to create
* @param array $expectedenrolments Records to validate
* @param array $classids The ids of the classes we should run the method for
* @dataProvider dataprovider_credits
*/
public function test_enrolmentupdatesetscreditsforspecificuserid($enrolments, $expectedenrolments, $classids)
{
global $DB;
$this->load_csv_data(true);
// Set up a second course and class.
$course = new course(array('name' => 'secondcourse', 'idnumber' => 'secondcourse', 'syllabus' => '', 'credits' => 1));
$course->save();
$pmclass = new pmclass(array('courseid' => $course->id, 'idnumber' => 'secondclass'));
$pmclass->save();
$this->save_enrolments($enrolments);
$pmuserid = 103;
foreach ($classids as $classid) {
$pmclass = new pmclass($classid);
$sink = $this->redirectMessages();
$pmclass->update_enrolment_status($pmuserid);
}
$expectedenrolments = $this->filter_by_userid($expectedenrolments, $pmuserid);
$this->validate_expected_enrolments($expectedenrolments, $pmuserid);
}
/**
* Validate that track-class associations can be created during a class instance
* update action
*
* @param mixed $autoenrol The appropriate autoenrol value specified
* @param int $dbautoenrol The value expected to be set in the db for autoenrol
* @dataProvider autoenrol_provider
*/
public function test_associate_track_during_class_update($autoenrol, $dbautoenrol)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/curriculum.class.php');
require_once elispm::lib('data/curriculumcourse.class.php');
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/track.class.php');
// Create the course description.
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
// Create the class instance.
$pmclass = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$pmclass->save();
// Create the curriculum / program.
$curriculum = new curriculum(array('idnumber' => 'testcurriculumidnumber'));
$curriculum->save();
// Associate the course description to the program.
$curriculumcourse = new curriculumcourse(array('curriculumid' => $curriculum->id, 'courseid' => $course->id));
$curriculumcourse->save();
// Create the track.
$track = new track(array('curid' => $curriculum->id, 'idnumber' => 'testtrackidnumber'));
$track->save();
// Run the class instance update action.
$record = new stdClass();
$record->assignment = 'testcourseidnumber';
$record->idnumber = 'testclassidnumber';
$record->track = 'testtrackidnumber';
if ($autoenrol !== null) {
$record->autoenrol = $autoenrol;
}
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->class_update($record, 'bogus');
// Validation.
$classid = $DB->get_field(pmclass::TABLE, 'id', array('idnumber' => 'testclassidnumber'));
$this->assertTrue($DB->record_exists(trackassignment::TABLE, array('trackid' => $track->id, 'classid' => $classid, 'autoenrol' => $dbautoenrol)));
}
/**
* Validate that the role field is handled as needed during unassignment
*
* @param string $role The input value for the role field
* @dataProvider role_provider
*/
public function test_elis_user_instructor_unenrolment_handles_role($role)
{
global $CFG, $DB;
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/instructor.class.php');
require_once elispm::lib('data/pmclass.class.php');
require_once elispm::lib('data/user.class.php');
set_config('coursecontact', 'teacher,editingteacher');
set_config('default_instructor_role', 'teacher', 'local_elisprogram');
$user = new user(array('idnumber' => 'testuseridnumber', 'username' => 'testuserusername', 'firstname' => 'testuserfirstname', 'lastname' => 'testuserlastname', 'email' => '*****@*****.**', 'country' => 'CA'));
$user->save();
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$class = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$class->save();
$instructor = new instructor(array('userid' => $user->id, 'classid' => $class->id));
$instructor->save();
// Validate setup.
$this->assertTrue($DB->record_exists(instructor::TABLE, array('userid' => $user->id, 'classid' => $class->id)));
// Run the instructor assignment delete action.
$record = new stdClass();
$record->context = 'class_testclassidnumber';
$record->user_username = '******';
$record->role = $role;
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->class_enrolment_delete($record, 'bogus', 'testclassidnumber');
// Validation.
$this->assertEquals(0, $DB->count_records(instructor::TABLE));
}
/**
* Validate that class instance-moodle course associations can be created during a class instance update action.
*
* @param string $link The link attribute to use in the import, or 'auto' to auto-create from template.
* @dataProvider link_course_provider
*/
public function test_associate_moodle_course_during_class_update($link)
{
global $CFG, $DB, $USER;
require_once $CFG->dirroot . '/course/lib.php';
require_once $CFG->dirroot . '/local/elisprogram/lib/setup.php';
require_once elispm::lib('data/classmoodlecourse.class.php');
require_once elispm::lib('data/coursetemplate.class.php');
require_once elispm::lib('data/course.class.php');
require_once elispm::lib('data/pmclass.class.php');
// Make sure $USER is set up for backup/restore.
$USER->id = $DB->get_field_select('user', 'id', "username != 'guest' AND deleted = 0", array(), IGNORE_MULTIPLE);
// Need the moodle/backup:backupcourse capability.
$guestroleid = create_role('guestrole', 'guestrole', 'guestrole');
set_config('guestroleid', $guestroleid);
set_config('siteguest', '');
$systemcontext = context_system::instance();
$roleid = create_role('testrole', 'testrole', 'testrole');
assign_capability('moodle/backup:backupcourse', CAP_ALLOW, $roleid, $systemcontext->id);
role_assign($roleid, $USER->id, $systemcontext->id);
$coursecategory = new stdClass();
$coursecategory->name = 'testcoursecategoryname';
$coursecategory->id = $DB->insert_record('course_categories', $coursecategory);
$moodlecourse = new stdClass();
$moodlecourse->category = $coursecategory->id;
$moodlecourse->shortname = 'testcourseshortname';
$moodlecourse->fullname = 'testcoursefullname';
$moodlecourse = create_course($moodlecourse);
$course = new course(array('name' => 'testcoursename', 'idnumber' => 'testcourseidnumber', 'syllabus' => ''));
$course->save();
$class = new pmclass(array('courseid' => $course->id, 'idnumber' => 'testclassidnumber'));
$class->save();
// Need this for the 'auto' case, at the very least.
$coursetemplate = new coursetemplate(array('courseid' => $course->id, 'location' => $moodlecourse->id, 'templateclass' => 'moodlecourseurl'));
$coursetemplate->save();
// Run the class instance create action.
$record = new stdClass();
$record->idnumber = 'testclassidnumber';
$record->assignment = 'testcourseidnumber';
$record->link = $link;
$importplugin = rlip_dataplugin_factory::factory('dhimport_version1elis');
$importplugin->fslogger = new silent_fslogger(null);
$importplugin->class_update($record, 'bogus');
// Validation.
if ($record->link == 'auto') {
$moodlecourseid = $moodlecourse->id + 1;
} else {
$moodlecourseid = $moodlecourse->id;
}
$dbautocreated = $record->link == 'auto' ? 1 : 0;
$this->assertTrue($DB->record_exists(classmoodlecourse::TABLE, array('classid' => $class->id, 'moodlecourseid' => $moodlecourseid, 'enroltype' => 0, 'enrolplugin' => 'crlm', 'autocreated' => $dbautocreated)));
ini_set('max_execution_time', '0');
}
/**
* Test main newenrolmentemail() function.
*/
public function test_version1importnewenrolmentemail()
{
global $CFG, $DB;
// This is needed by the required files.
require_once dirname(__FILE__) . '/other/rlip_importplugin_version1elis_fakeemail.php';
$importplugin = new rlip_importplugin_version1elis_fakeemail();
// Create Moodle course.
$course = $this->getDataGenerator()->create_course();
// Enrol some students into Moodle course.
$user2 = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($user2->id, $course->id);
$user3 = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($user3->id, $course->id);
// Enrol teachers into Moodle course.
$teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
$teacher = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($teacher->id, $course->id, $teacherrole->id);
$teacher2 = $this->getDataGenerator()->create_user();
$this->getDataGenerator()->enrol_user($teacher2->id, $course->id, $teacherrole->id);
// Create ELIS class and ELIS user.
$ecourse = new course(array('name' => 'Test Course', 'idnumber' => 'CRS100', 'syllabus' => ''));
$ecourse->save();
$eclass = new pmclass(array('idnumber' => 'CLS100', 'courseid' => $ecourse->id));
$eclass->save();
$euser = new user(array('username' => 'testuser', 'idnumber' => 'testuser', 'firstname' => 'Test', 'lastname' => 'User', 'email' => '*****@*****.**', 'city' => 'Waterloo', 'country' => 'CA'));
$euser->save();
$muser = $euser->get_moodleuser();
// Create student object for elis user/elis class.
$student = new student(array('userid' => $euser->id, 'classid' => $eclass->id));
// Test false return when student "no_moodle_enrol" is set.
$student->no_moodle_enrol = true;
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
$student->no_moodle_enrol = false;
// Test false return when ELIS class is not linked to Moodle course.
$DB->delete_records(classmoodlecourse::TABLE, array('classid' => $eclass->id, 'moodlecourseid' => $course->id));
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
// Test false return when ELIS class is linked to a Moodle course, but Moodle course does not exist.
$cmcid = $DB->insert_record(classmoodlecourse::TABLE, array('classid' => $eclass->id, 'moodlecourseid' => 999999999));
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
$DB->update_record(classmoodlecourse::TABLE, array('id' => $cmcid, 'moodlecourseid' => $course->id));
// Test false return when ELIS user is not linked to Moodle user.
$DB->delete_records(usermoodle::TABLE, array('cuserid' => $euser->id, 'muserid' => $muser->id));
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
// Test false return when ELIS user is linked to Moodle user, but Moodle user does not exist.
$usermoodleid = $DB->insert_record(usermoodle::TABLE, array('cuserid' => $euser->id, 'muserid' => 99999999));
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
$DB->update_record(usermoodle::TABLE, array('id' => $usermoodleid, 'muserid' => $muser->id));
// Test false return when not enabled.
set_config('newenrolmentemailenabled', '0', 'dhimport_version1elis');
set_config('newenrolmentemailsubject', 'Test Subject', 'dhimport_version1elis');
set_config('newenrolmentemailtemplate', 'Test Body', 'dhimport_version1elis');
set_config('newenrolmentemailfrom', 'teacher', 'dhimport_version1elis');
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
// Test false return when enabled but empty template.
set_config('newenrolmentemailenabled', '1', 'dhimport_version1elis');
set_config('newenrolmentemailsubject', 'Test Subject', 'dhimport_version1elis');
set_config('newenrolmentemailtemplate', '', 'dhimport_version1elis');
set_config('newenrolmentemailfrom', 'teacher', 'dhimport_version1elis');
$result = $importplugin->newenrolmentemail($student);
$this->assertFalse($result);
// Test success when enabled, has template text, and user has email.
$testsubject = 'Test Subject';
$testbody = 'Test Body';
set_config('newenrolmentemailenabled', '1', 'dhimport_version1elis');
set_config('newenrolmentemailsubject', $testsubject, 'dhimport_version1elis');
set_config('newenrolmentemailtemplate', $testbody, 'dhimport_version1elis');
set_config('newenrolmentemailfrom', 'admin', 'dhimport_version1elis');
$result = $importplugin->newenrolmentemail($student);
$this->assertNotEmpty($result);
$this->assertInternalType('array', $result);
$this->assertArrayHasKey('user', $result);
$this->assertEquals($muser, $result['user']);
$this->assertArrayHasKey('from', $result);
$this->assertEquals(get_admin(), $result['from']);
$this->assertArrayHasKey('subject', $result);
$this->assertEquals($testsubject, $result['subject']);
$this->assertArrayHasKey('body', $result);
$this->assertEquals($testbody, $result['body']);
// Test success and from is set to teacher when selected.
$testsubject = 'Test Subject';
$testbody = 'Test Body';
set_config('newenrolmentemailenabled', '1', 'dhimport_version1elis');
set_config('newenrolmentemailsubject', $testsubject, 'dhimport_version1elis');
set_config('newenrolmentemailtemplate', $testbody, 'dhimport_version1elis');
set_config('newenrolmentemailfrom', 'teacher', 'dhimport_version1elis');
$result = $importplugin->newenrolmentemail($student);
$this->assertNotEmpty($result);
$this->assertInternalType('array', $result);
$this->assertArrayHasKey('user', $result);
$this->assertEquals($muser, $result['user']);
$this->assertArrayHasKey('from', $result);
$this->assertEquals($teacher, $result['from']);
$this->assertArrayHasKey('subject', $result);
$this->assertEquals($testsubject, $result['subject']);
$this->assertArrayHasKey('body', $result);
$this->assertEquals($testbody, $result['body']);
// Test that subject is replaced by empty string when not present.
$testsubject = null;
$testbody = 'Test Body';
set_config('newenrolmentemailenabled', '1', 'dhimport_version1elis');
set_config('newenrolmentemailsubject', $testsubject, 'dhimport_version1elis');
set_config('newenrolmentemailtemplate', $testbody, 'dhimport_version1elis');
set_config('newenrolmentemailfrom', 'admin', 'dhimport_version1elis');
$result = $importplugin->newenrolmentemail($student);
$this->assertNotEmpty($result);
$this->assertInternalType('array', $result);
$this->assertArrayHasKey('user', $result);
$this->assertEquals($muser, $result['user']);
$this->assertArrayHasKey('from', $result);
$this->assertEquals(get_admin(), $result['from']);
$this->assertArrayHasKey('subject', $result);
$this->assertEquals('', $result['subject']);
$this->assertArrayHasKey('body', $result);
$this->assertEquals($testbody, $result['body']);
// Full testing of replacement is done below, but just test that it's being done at all from the main function.
$testsubject = 'Test Subject';
$testbody = 'Test Body %%user_username%%';
$expectedtestbody = 'Test Body ' . $muser->username;
set_config('newenrolmentemailenabled', '1', 'dhimport_version1elis');
set_config('newenrolmentemailsubject', $testsubject, 'dhimport_version1elis');
set_config('newenrolmentemailtemplate', $testbody, 'dhimport_version1elis');
set_config('newenrolmentemailfrom', 'admin', 'dhimport_version1elis');
$result = $importplugin->newenrolmentemail($student);
$this->assertNotEmpty($result);
$this->assertInternalType('array', $result);
$this->assertArrayHasKey('user', $result);
$this->assertEquals($muser, $result['user']);
$this->assertArrayHasKey('from', $result);
$this->assertEquals(get_admin(), $result['from']);
$this->assertArrayHasKey('subject', $result);
$this->assertEquals($testsubject, $result['subject']);
$this->assertArrayHasKey('body', $result);
$this->assertEquals($expectedtestbody, $result['body']);
}
