Andrew Nicols
4e2e54eed0
Some templates can legitimately contain invalid HTML (e.g. mismatched tags) because the templates operate in pairs. In these instances we should not use an editor because the nature of the editor (content editable) means that the browser automatically corrects all HTML supplied to it, thus breaking the template entirely. Therefore we need to disable HTML editors for some templates, and do so in a way tied to the instance of the activity, rather than to a specific user. This patch adds a new 'config' field, with matching setters and getters, to allow such per-instance values to be stored.
883 lines
32 KiB
PHP
883 lines
32 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Unit tests for lib.php
|
|
*
|
|
* @package mod_data
|
|
* @category phpunit
|
|
* @copyright 2013 Adrian Greeve
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/mod/data/lib.php');
|
|
|
|
/**
|
|
* Unit tests for lib.php
|
|
*
|
|
* @package mod_data
|
|
* @copyright 2013 Adrian Greeve
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class mod_data_lib_testcase extends advanced_testcase {
|
|
|
|
/**
|
|
* @var moodle_database
|
|
*/
|
|
protected $DB = null;
|
|
|
|
/**
|
|
* Tear Down to reset DB.
|
|
*/
|
|
public function tearDown() {
|
|
global $DB;
|
|
|
|
if (isset($this->DB)) {
|
|
$DB = $this->DB;
|
|
$this->DB = null;
|
|
}
|
|
}
|
|
|
|
public function test_data_delete_record() {
|
|
global $DB;
|
|
|
|
$this->resetAfterTest();
|
|
|
|
// Create a record for deleting.
|
|
$this->setAdminUser();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$record = new stdClass();
|
|
$record->course = $course->id;
|
|
$record->name = "Mod data delete test";
|
|
$record->intro = "Some intro of some sort";
|
|
|
|
$module = $this->getDataGenerator()->create_module('data', $record);
|
|
|
|
$field = data_get_field_new('text', $module);
|
|
|
|
$fielddetail = new stdClass();
|
|
$fielddetail->d = $module->id;
|
|
$fielddetail->mode = 'add';
|
|
$fielddetail->type = 'text';
|
|
$fielddetail->sesskey = sesskey();
|
|
$fielddetail->name = 'Name';
|
|
$fielddetail->description = 'Some name';
|
|
|
|
$field->define_field($fielddetail);
|
|
$field->insert_field();
|
|
$recordid = data_add_record($module);
|
|
|
|
$datacontent = array();
|
|
$datacontent['fieldid'] = $field->field->id;
|
|
$datacontent['recordid'] = $recordid;
|
|
$datacontent['content'] = 'Asterix';
|
|
|
|
$contentid = $DB->insert_record('data_content', $datacontent);
|
|
$cm = get_coursemodule_from_instance('data', $module->id, $course->id);
|
|
|
|
// Check to make sure that we have a database record.
|
|
$data = $DB->get_records('data', array('id' => $module->id));
|
|
$this->assertEquals(1, count($data));
|
|
|
|
$datacontent = $DB->get_records('data_content', array('id' => $contentid));
|
|
$this->assertEquals(1, count($datacontent));
|
|
|
|
$datafields = $DB->get_records('data_fields', array('id' => $field->field->id));
|
|
$this->assertEquals(1, count($datafields));
|
|
|
|
$datarecords = $DB->get_records('data_records', array('id' => $recordid));
|
|
$this->assertEquals(1, count($datarecords));
|
|
|
|
// Test to see if a failed delete returns false.
|
|
$result = data_delete_record(8798, $module, $course->id, $cm->id);
|
|
$this->assertFalse($result);
|
|
|
|
// Delete the record.
|
|
$result = data_delete_record($recordid, $module, $course->id, $cm->id);
|
|
|
|
// Check that all of the record is gone.
|
|
$datacontent = $DB->get_records('data_content', array('id' => $contentid));
|
|
$this->assertEquals(0, count($datacontent));
|
|
|
|
$datarecords = $DB->get_records('data_records', array('id' => $recordid));
|
|
$this->assertEquals(0, count($datarecords));
|
|
|
|
// Make sure the function returns true on a successful deletion.
|
|
$this->assertTrue($result);
|
|
}
|
|
|
|
/**
|
|
* Test comment_created event.
|
|
*/
|
|
public function test_data_comment_created_event() {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . '/comment/lib.php');
|
|
|
|
$this->resetAfterTest();
|
|
|
|
// Create a record for deleting.
|
|
$this->setAdminUser();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$record = new stdClass();
|
|
$record->course = $course->id;
|
|
$record->name = "Mod data delete test";
|
|
$record->intro = "Some intro of some sort";
|
|
$record->comments = 1;
|
|
|
|
$module = $this->getDataGenerator()->create_module('data', $record);
|
|
$field = data_get_field_new('text', $module);
|
|
|
|
$fielddetail = new stdClass();
|
|
$fielddetail->name = 'Name';
|
|
$fielddetail->description = 'Some name';
|
|
|
|
$field->define_field($fielddetail);
|
|
$field->insert_field();
|
|
$recordid = data_add_record($module);
|
|
|
|
$datacontent = array();
|
|
$datacontent['fieldid'] = $field->field->id;
|
|
$datacontent['recordid'] = $recordid;
|
|
$datacontent['content'] = 'Asterix';
|
|
|
|
$contentid = $DB->insert_record('data_content', $datacontent);
|
|
$cm = get_coursemodule_from_instance('data', $module->id, $course->id);
|
|
|
|
$context = context_module::instance($module->cmid);
|
|
$cmt = new stdClass();
|
|
$cmt->context = $context;
|
|
$cmt->course = $course;
|
|
$cmt->cm = $cm;
|
|
$cmt->area = 'database_entry';
|
|
$cmt->itemid = $recordid;
|
|
$cmt->showcount = true;
|
|
$cmt->component = 'mod_data';
|
|
$comment = new comment($cmt);
|
|
|
|
// Triggering and capturing the event.
|
|
$sink = $this->redirectEvents();
|
|
$comment->add('New comment');
|
|
$events = $sink->get_events();
|
|
$this->assertCount(1, $events);
|
|
$event = reset($events);
|
|
|
|
// Checking that the event contains the expected values.
|
|
$this->assertInstanceOf('\mod_data\event\comment_created', $event);
|
|
$this->assertEquals($context, $event->get_context());
|
|
$url = new moodle_url('/mod/data/view.php', array('id' => $cm->id));
|
|
$this->assertEquals($url, $event->get_url());
|
|
$this->assertEventContextNotUsed($event);
|
|
}
|
|
|
|
/**
|
|
* Test comment_deleted event.
|
|
*/
|
|
public function test_data_comment_deleted_event() {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . '/comment/lib.php');
|
|
|
|
$this->resetAfterTest();
|
|
|
|
// Create a record for deleting.
|
|
$this->setAdminUser();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$record = new stdClass();
|
|
$record->course = $course->id;
|
|
$record->name = "Mod data delete test";
|
|
$record->intro = "Some intro of some sort";
|
|
$record->comments = 1;
|
|
|
|
$module = $this->getDataGenerator()->create_module('data', $record);
|
|
$field = data_get_field_new('text', $module);
|
|
|
|
$fielddetail = new stdClass();
|
|
$fielddetail->name = 'Name';
|
|
$fielddetail->description = 'Some name';
|
|
|
|
$field->define_field($fielddetail);
|
|
$field->insert_field();
|
|
$recordid = data_add_record($module);
|
|
|
|
$datacontent = array();
|
|
$datacontent['fieldid'] = $field->field->id;
|
|
$datacontent['recordid'] = $recordid;
|
|
$datacontent['content'] = 'Asterix';
|
|
|
|
$contentid = $DB->insert_record('data_content', $datacontent);
|
|
$cm = get_coursemodule_from_instance('data', $module->id, $course->id);
|
|
|
|
$context = context_module::instance($module->cmid);
|
|
$cmt = new stdClass();
|
|
$cmt->context = $context;
|
|
$cmt->course = $course;
|
|
$cmt->cm = $cm;
|
|
$cmt->area = 'database_entry';
|
|
$cmt->itemid = $recordid;
|
|
$cmt->showcount = true;
|
|
$cmt->component = 'mod_data';
|
|
$comment = new comment($cmt);
|
|
$newcomment = $comment->add('New comment 1');
|
|
|
|
// Triggering and capturing the event.
|
|
$sink = $this->redirectEvents();
|
|
$comment->delete($newcomment->id);
|
|
$events = $sink->get_events();
|
|
$this->assertCount(1, $events);
|
|
$event = reset($events);
|
|
|
|
// Checking that the event contains the expected values.
|
|
$this->assertInstanceOf('\mod_data\event\comment_deleted', $event);
|
|
$this->assertEquals($context, $event->get_context());
|
|
$url = new moodle_url('/mod/data/view.php', array('id' => $module->cmid));
|
|
$this->assertEquals($url, $event->get_url());
|
|
$this->assertEventContextNotUsed($event);
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return true if the user
|
|
* has the mod/data:manageentries capability.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_true_with_capability() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
$data = new stdClass();
|
|
|
|
$this->setUser($user);
|
|
|
|
assign_capability('mod/data:manageentries', CAP_ALLOW, $roleid, $context);
|
|
|
|
$this->assertTrue(data_user_can_manage_entry($record, $data, $context),
|
|
'data_user_can_manage_entry() returns true if the user has mod/data:manageentries capability');
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return false if the data
|
|
* is set to readonly.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_false_readonly() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
|
|
$this->setUser($user);
|
|
|
|
// Need to make sure they don't have this capability in order to fall back to
|
|
// the other checks.
|
|
assign_capability('mod/data:manageentries', CAP_PROHIBIT, $roleid, $context);
|
|
|
|
// Causes readonly mode to be enabled.
|
|
$data = new stdClass();
|
|
$now = time();
|
|
// Add a small margin around the periods to prevent errors with slow tests.
|
|
$data->timeviewfrom = $now - 1;
|
|
$data->timeviewto = $now + 5;
|
|
|
|
$this->assertFalse(data_user_can_manage_entry($record, $data, $context),
|
|
'data_user_can_manage_entry() returns false if the data is read only');
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return false if the record
|
|
* can't be found in the database.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_false_no_record() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
$data = new stdClass();
|
|
// Causes readonly mode to be disabled.
|
|
$now = time();
|
|
$data->timeviewfrom = $now + 100;
|
|
$data->timeviewto = $now - 100;
|
|
|
|
$this->setUser($user);
|
|
|
|
// Need to make sure they don't have this capability in order to fall back to
|
|
// the other checks.
|
|
assign_capability('mod/data:manageentries', CAP_PROHIBIT, $roleid, $context);
|
|
|
|
// Pass record id instead of object to force DB lookup.
|
|
$this->assertFalse(data_user_can_manage_entry(1, $data, $context),
|
|
'data_user_can_manage_entry() returns false if the record cannot be found');
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return false if the record
|
|
* isn't owned by the user.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_false_not_owned_record() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
$data = new stdClass();
|
|
// Causes readonly mode to be disabled.
|
|
$now = time();
|
|
$data->timeviewfrom = $now + 100;
|
|
$data->timeviewto = $now - 100;
|
|
// Make sure the record isn't owned by this user.
|
|
$record->userid = $user->id + 1;
|
|
|
|
$this->setUser($user);
|
|
|
|
// Need to make sure they don't have this capability in order to fall back to
|
|
// the other checks.
|
|
assign_capability('mod/data:manageentries', CAP_PROHIBIT, $roleid, $context);
|
|
|
|
$this->assertFalse(data_user_can_manage_entry($record, $data, $context),
|
|
'data_user_can_manage_entry() returns false if the record isnt owned by the user');
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return true if the data
|
|
* doesn't require approval.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_true_data_no_approval() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
$data = new stdClass();
|
|
// Causes readonly mode to be disabled.
|
|
$now = time();
|
|
$data->timeviewfrom = $now + 100;
|
|
$data->timeviewto = $now - 100;
|
|
// The record doesn't need approval.
|
|
$data->approval = false;
|
|
// Make sure the record is owned by this user.
|
|
$record->userid = $user->id;
|
|
|
|
$this->setUser($user);
|
|
|
|
// Need to make sure they don't have this capability in order to fall back to
|
|
// the other checks.
|
|
assign_capability('mod/data:manageentries', CAP_PROHIBIT, $roleid, $context);
|
|
|
|
$this->assertTrue(data_user_can_manage_entry($record, $data, $context),
|
|
'data_user_can_manage_entry() returns true if the record doesnt require approval');
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return true if the record
|
|
* isn't yet approved.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_true_record_unapproved() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
$data = new stdClass();
|
|
// Causes readonly mode to be disabled.
|
|
$now = time();
|
|
$data->timeviewfrom = $now + 100;
|
|
$data->timeviewto = $now - 100;
|
|
// The record needs approval.
|
|
$data->approval = true;
|
|
// Make sure the record is owned by this user.
|
|
$record->userid = $user->id;
|
|
// The record hasn't yet been approved.
|
|
$record->approved = false;
|
|
|
|
$this->setUser($user);
|
|
|
|
// Need to make sure they don't have this capability in order to fall back to
|
|
// the other checks.
|
|
assign_capability('mod/data:manageentries', CAP_PROHIBIT, $roleid, $context);
|
|
|
|
$this->assertTrue(data_user_can_manage_entry($record, $data, $context),
|
|
'data_user_can_manage_entry() returns true if the record is not yet approved');
|
|
}
|
|
|
|
/**
|
|
* Checks that data_user_can_manage_entry will return the 'manageapproved'
|
|
* value if the record has already been approved.
|
|
*/
|
|
public function test_data_user_can_manage_entry_return_manageapproved() {
|
|
|
|
$this->resetAfterTest();
|
|
$testdata = $this->create_user_test_data();
|
|
|
|
$user = $testdata['user'];
|
|
$course = $testdata['course'];
|
|
$roleid = $testdata['roleid'];
|
|
$context = $testdata['context'];
|
|
$record = $testdata['record'];
|
|
$data = new stdClass();
|
|
// Causes readonly mode to be disabled.
|
|
$now = time();
|
|
$data->timeviewfrom = $now + 100;
|
|
$data->timeviewto = $now - 100;
|
|
// The record needs approval.
|
|
$data->approval = true;
|
|
// Can the user managed approved records?
|
|
$data->manageapproved = false;
|
|
// Make sure the record is owned by this user.
|
|
$record->userid = $user->id;
|
|
// The record has been approved.
|
|
$record->approved = true;
|
|
|
|
$this->setUser($user);
|
|
|
|
// Need to make sure they don't have this capability in order to fall back to
|
|
// the other checks.
|
|
assign_capability('mod/data:manageentries', CAP_PROHIBIT, $roleid, $context);
|
|
|
|
$canmanageentry = data_user_can_manage_entry($record, $data, $context);
|
|
|
|
// Make sure the result of the check is what ever the manageapproved setting
|
|
// is set to.
|
|
$this->assertEquals($data->manageapproved, $canmanageentry,
|
|
'data_user_can_manage_entry() returns the manageapproved setting on approved records');
|
|
}
|
|
|
|
/**
|
|
* Helper method to create a set of test data for data_user_can_manage tests
|
|
*
|
|
* @return array contains user, course, roleid, module, context and record
|
|
*/
|
|
private function create_user_test_data() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$roleid = $this->getDataGenerator()->create_role();
|
|
$record = new stdClass();
|
|
$record->name = "test name";
|
|
$record->intro = "test intro";
|
|
$record->comments = 1;
|
|
$record->course = $course->id;
|
|
$record->userid = $user->id;
|
|
|
|
$module = $this->getDataGenerator()->create_module('data', $record);
|
|
$cm = get_coursemodule_from_instance('data', $module->id, $course->id);
|
|
$context = context_module::instance($module->cmid);
|
|
|
|
$this->getDataGenerator()->role_assign($roleid, $user->id, $context->id);
|
|
|
|
return array(
|
|
'user' => $user,
|
|
'course' => $course,
|
|
'roleid' => $roleid,
|
|
'module' => $module,
|
|
'context' => $context,
|
|
'record' => $record
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tests for mod_data_rating_can_see_item_ratings().
|
|
*
|
|
* @throws coding_exception
|
|
* @throws rating_exception
|
|
*/
|
|
public function test_mod_data_rating_can_see_item_ratings() {
|
|
global $DB;
|
|
|
|
$this->resetAfterTest();
|
|
|
|
// Setup test data.
|
|
$course = new stdClass();
|
|
$course->groupmode = SEPARATEGROUPS;
|
|
$course->groupmodeforce = true;
|
|
$course = $this->getDataGenerator()->create_course($course);
|
|
$data = $this->getDataGenerator()->create_module('data', array('course' => $course->id));
|
|
$cm = get_coursemodule_from_instance('data', $data->id);
|
|
$context = context_module::instance($cm->id);
|
|
|
|
// Create users.
|
|
$user1 = $this->getDataGenerator()->create_user();
|
|
$user2 = $this->getDataGenerator()->create_user();
|
|
$user3 = $this->getDataGenerator()->create_user();
|
|
$user4 = $this->getDataGenerator()->create_user();
|
|
|
|
// Groups and stuff.
|
|
$role = $DB->get_record('role', array('shortname' => 'teacher'), '*', MUST_EXIST);
|
|
$this->getDataGenerator()->enrol_user($user1->id, $course->id, $role->id);
|
|
$this->getDataGenerator()->enrol_user($user2->id, $course->id, $role->id);
|
|
$this->getDataGenerator()->enrol_user($user3->id, $course->id, $role->id);
|
|
$this->getDataGenerator()->enrol_user($user4->id, $course->id, $role->id);
|
|
|
|
$group1 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
|
|
$group2 = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
|
|
groups_add_member($group1, $user1);
|
|
groups_add_member($group1, $user2);
|
|
groups_add_member($group2, $user3);
|
|
groups_add_member($group2, $user4);
|
|
|
|
// Add data.
|
|
$field = data_get_field_new('text', $data);
|
|
|
|
$fielddetail = new stdClass();
|
|
$fielddetail->name = 'Name';
|
|
$fielddetail->description = 'Some name';
|
|
|
|
$field->define_field($fielddetail);
|
|
$field->insert_field();
|
|
|
|
// Add a record with a group id of zero (all participants).
|
|
$recordid1 = data_add_record($data, 0);
|
|
|
|
$datacontent = array();
|
|
$datacontent['fieldid'] = $field->field->id;
|
|
$datacontent['recordid'] = $recordid1;
|
|
$datacontent['content'] = 'Obelix';
|
|
$DB->insert_record('data_content', $datacontent);
|
|
|
|
$recordid = data_add_record($data, $group1->id);
|
|
|
|
$datacontent = array();
|
|
$datacontent['fieldid'] = $field->field->id;
|
|
$datacontent['recordid'] = $recordid;
|
|
$datacontent['content'] = 'Asterix';
|
|
$DB->insert_record('data_content', $datacontent);
|
|
|
|
// Now try to access it as various users.
|
|
unassign_capability('moodle/site:accessallgroups', $role->id);
|
|
// Eveyone should have access to the record with the group id of zero.
|
|
$params1 = array('contextid' => 2,
|
|
'component' => 'mod_data',
|
|
'ratingarea' => 'entry',
|
|
'itemid' => $recordid1,
|
|
'scaleid' => 2);
|
|
|
|
$params = array('contextid' => 2,
|
|
'component' => 'mod_data',
|
|
'ratingarea' => 'entry',
|
|
'itemid' => $recordid,
|
|
'scaleid' => 2);
|
|
|
|
$this->setUser($user1);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user2);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user3);
|
|
$this->assertFalse(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user4);
|
|
$this->assertFalse(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
|
|
// Now try with accessallgroups cap and make sure everything is visible.
|
|
assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $role->id, $context->id);
|
|
$this->setUser($user1);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user2);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user3);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user4);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
|
|
// Change group mode and verify visibility.
|
|
$course->groupmode = VISIBLEGROUPS;
|
|
$DB->update_record('course', $course);
|
|
unassign_capability('moodle/site:accessallgroups', $role->id);
|
|
$this->setUser($user1);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user2);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user3);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
$this->setUser($user4);
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params));
|
|
$this->assertTrue(mod_data_rating_can_see_item_ratings($params1));
|
|
|
|
}
|
|
|
|
/**
|
|
* Tests for mod_data_refresh_events.
|
|
*/
|
|
public function test_data_refresh_events() {
|
|
global $DB;
|
|
$this->resetAfterTest();
|
|
$this->setAdminUser();
|
|
|
|
$timeopen = time();
|
|
$timeclose = time() + 86400;
|
|
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_data');
|
|
$params['course'] = $course->id;
|
|
$params['timeavailablefrom'] = $timeopen;
|
|
$params['timeavailableto'] = $timeclose;
|
|
$data = $generator->create_instance($params);
|
|
|
|
// Normal case, with existing course.
|
|
$this->assertTrue(data_refresh_events($course->id));
|
|
$eventparams = array('modulename' => 'data', 'instance' => $data->id, 'eventtype' => 'open');
|
|
$openevent = $DB->get_record('event', $eventparams, '*', MUST_EXIST);
|
|
$this->assertEquals($openevent->timestart, $timeopen);
|
|
|
|
$eventparams = array('modulename' => 'data', 'instance' => $data->id, 'eventtype' => 'close');
|
|
$closeevent = $DB->get_record('event', $eventparams, '*', MUST_EXIST);
|
|
$this->assertEquals($closeevent->timestart, $timeclose);
|
|
// In case the course ID is passed as a numeric string.
|
|
$this->assertTrue(data_refresh_events('' . $course->id));
|
|
// Course ID not provided.
|
|
$this->assertTrue(data_refresh_events());
|
|
$eventparams = array('modulename' => 'data');
|
|
$events = $DB->get_records('event', $eventparams);
|
|
foreach ($events as $event) {
|
|
if ($event->modulename === 'data' && $event->instance === $data->id && $event->eventtype === 'open') {
|
|
$this->assertEquals($event->timestart, $timeopen);
|
|
}
|
|
if ($event->modulename === 'data' && $event->instance === $data->id && $event->eventtype === 'close') {
|
|
$this->assertEquals($event->timestart, $timeclose);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Data provider for tests of data_get_config.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function data_get_config_provider() {
|
|
$initialdata = (object) [
|
|
'template_foo' => true,
|
|
'template_bar' => false,
|
|
'template_baz' => null,
|
|
];
|
|
|
|
$database = (object) [
|
|
'config' => json_encode($initialdata),
|
|
];
|
|
|
|
return [
|
|
'Return full dataset (no key/default)' => [
|
|
[$database],
|
|
$initialdata,
|
|
],
|
|
'Return full dataset (no default)' => [
|
|
[$database, null],
|
|
$initialdata,
|
|
],
|
|
'Return full dataset' => [
|
|
[$database, null, null],
|
|
$initialdata,
|
|
],
|
|
'Return requested key only, value true, no default' => [
|
|
[$database, 'template_foo'],
|
|
true,
|
|
],
|
|
'Return requested key only, value false, no default' => [
|
|
[$database, 'template_bar'],
|
|
false,
|
|
],
|
|
'Return requested key only, value null, no default' => [
|
|
[$database, 'template_baz'],
|
|
null,
|
|
],
|
|
'Return unknown key, value null, no default' => [
|
|
[$database, 'template_bum'],
|
|
null,
|
|
],
|
|
'Return requested key only, value true, default null' => [
|
|
[$database, 'template_foo', null],
|
|
true,
|
|
],
|
|
'Return requested key only, value false, default null' => [
|
|
[$database, 'template_bar', null],
|
|
false,
|
|
],
|
|
'Return requested key only, value null, default null' => [
|
|
[$database, 'template_baz', null],
|
|
null,
|
|
],
|
|
'Return unknown key, value null, default null' => [
|
|
[$database, 'template_bum', null],
|
|
null,
|
|
],
|
|
'Return requested key only, value true, default 42' => [
|
|
[$database, 'template_foo', 42],
|
|
true,
|
|
],
|
|
'Return requested key only, value false, default 42' => [
|
|
[$database, 'template_bar', 42],
|
|
false,
|
|
],
|
|
'Return requested key only, value null, default 42' => [
|
|
[$database, 'template_baz', 42],
|
|
null,
|
|
],
|
|
'Return unknown key, value null, default 42' => [
|
|
[$database, 'template_bum', 42],
|
|
42,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Tests for data_get_config.
|
|
*
|
|
* @dataProvider data_get_config_provider
|
|
* @param array $funcargs The args to pass to data_get_config
|
|
* @param mixed $expectation The expected value
|
|
*/
|
|
public function test_data_get_config($funcargs, $expectation) {
|
|
$this->assertEquals($expectation, call_user_func_array('data_get_config', $funcargs));
|
|
}
|
|
|
|
/**
|
|
* Data provider for tests of data_set_config.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function data_set_config_provider() {
|
|
$basevalue = (object) ['id' => rand(1, 1000)];
|
|
$config = [
|
|
'template_foo' => true,
|
|
'template_bar' => false,
|
|
];
|
|
|
|
$withvalues = clone $basevalue;
|
|
$withvalues->config = json_encode((object) $config);
|
|
|
|
return [
|
|
'Empty config, New value' => [
|
|
$basevalue,
|
|
'etc',
|
|
'newvalue',
|
|
true,
|
|
json_encode((object) ['etc' => 'newvalue'])
|
|
],
|
|
'Has config, New value' => [
|
|
clone $withvalues,
|
|
'etc',
|
|
'newvalue',
|
|
true,
|
|
json_encode((object) array_merge($config, ['etc' => 'newvalue']))
|
|
],
|
|
'Has config, Update value, string' => [
|
|
clone $withvalues,
|
|
'template_foo',
|
|
'newvalue',
|
|
true,
|
|
json_encode((object) array_merge($config, ['template_foo' => 'newvalue']))
|
|
],
|
|
'Has config, Update value, true' => [
|
|
clone $withvalues,
|
|
'template_bar',
|
|
true,
|
|
true,
|
|
json_encode((object) array_merge($config, ['template_bar' => true]))
|
|
],
|
|
'Has config, Update value, false' => [
|
|
clone $withvalues,
|
|
'template_foo',
|
|
false,
|
|
true,
|
|
json_encode((object) array_merge($config, ['template_foo' => false]))
|
|
],
|
|
'Has config, Update value, null' => [
|
|
clone $withvalues,
|
|
'template_foo',
|
|
null,
|
|
true,
|
|
json_encode((object) array_merge($config, ['template_foo' => null]))
|
|
],
|
|
'Has config, No update, value true' => [
|
|
clone $withvalues,
|
|
'template_foo',
|
|
true,
|
|
false,
|
|
$withvalues->config,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Tests for data_set_config.
|
|
*
|
|
* @dataProvider data_set_config_provider
|
|
* @param object $database The example row for the entry
|
|
* @param string $key The config key to set
|
|
* @param mixed $value The value of the key
|
|
* @param bool $expectupdate Whether we expected an update
|
|
* @param mixed $newconfigvalue The expected value
|
|
*/
|
|
public function test_data_set_config($database, $key, $value, $expectupdate, $newconfigvalue) {
|
|
global $DB;
|
|
|
|
// Mock the database.
|
|
// Note: Use the actual test class here rather than the abstract because are testing concrete methods.
|
|
$this->DB = $DB;
|
|
$DB = $this->getMockBuilder(get_class($DB))
|
|
->setMethods(['set_field'])
|
|
->getMock();
|
|
|
|
$DB->expects($this->exactly((int) $expectupdate))
|
|
->method('set_field')
|
|
->with(
|
|
'data',
|
|
'config',
|
|
$newconfigvalue,
|
|
['id' => $database->id]
|
|
);
|
|
|
|
// Perform the update.
|
|
data_set_config($database, $key, $value);
|
|
|
|
// Ensure that the value was updated by reference in $database.
|
|
$config = json_decode($database->config);
|
|
$this->assertEquals($value, $config->$key);
|
|
}
|
|
}
|