mirror of
https://github.com/moodle/moodle.git
synced 2025-07-26 00:31:35 +02:00
deb0e76eee
These are the only cases 100% safe to apply the renaming of the testcase class names to match the file names. All other cases are not safe, because they are missing namespace and may enter into name conflicts. Adding namespaces is not as simple as imagined because it implies to, also, add a good number of modifications to core. See the issue for more details.
589 lines
21 KiB
PHP
589 lines
21 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/>.
|
|
|
|
/**
|
|
* This file contains unit test related to xAPI library.
|
|
*
|
|
* @package core_xapi
|
|
* @copyright 2020 Ferran Recio
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace core_xapi\local;
|
|
|
|
use core_xapi\local\statement\item;
|
|
use core_xapi\local\statement\item_actor;
|
|
use core_xapi\local\statement\item_object;
|
|
use core_xapi\local\statement\item_activity;
|
|
use core_xapi\local\statement\item_verb;
|
|
use core_xapi\local\statement\item_agent;
|
|
use core_xapi\local\statement\item_group;
|
|
use core_xapi\local\statement\item_result;
|
|
use core_xapi\local\statement\item_attachment;
|
|
use core_xapi\local\statement\item_context;
|
|
use core_xapi\iri;
|
|
use core_xapi\xapi_exception;
|
|
use advanced_testcase;
|
|
use stdClass;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* Contains test cases for testing statement class.
|
|
*
|
|
* @package core_xapi
|
|
* @since Moodle 3.9
|
|
* @copyright 2020 Ferran Recio
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class statement_test extends advanced_testcase {
|
|
|
|
/**
|
|
* Returns a valid item for a specific attribute.
|
|
*
|
|
* @param string $itemname statement item name
|
|
* @return item the resulting item
|
|
*/
|
|
private function get_valid_item(string $itemname): item {
|
|
global $USER, $CFG;
|
|
switch ($itemname) {
|
|
case 'attachments':
|
|
case 'attachment':
|
|
$data = (object) [
|
|
'usageType' => iri::generate('example', 'attachment'),
|
|
'display' => (object) [
|
|
'en-US' => 'Example',
|
|
],
|
|
'description' => (object) [
|
|
'en-US' => 'Description example',
|
|
],
|
|
"contentType" => "image/jpg",
|
|
"length" => 1234,
|
|
"sha2" => "b94c0f1cffb77475c6f1899111a0181efe1d6177"
|
|
];
|
|
return item_attachment::create_from_data($data);
|
|
case 'authority':
|
|
$data = (object) [
|
|
'objectType' => 'Agent',
|
|
'account' => (object) [
|
|
'homePage' => $CFG->wwwroot,
|
|
'name' => $USER->id,
|
|
],
|
|
];
|
|
return item_agent::create_from_data($data);
|
|
}
|
|
// For now, the rest of the optional properties have no validation
|
|
// so we create a standard stdClass for all of them.
|
|
$data = (object)[
|
|
'some' => 'data',
|
|
];
|
|
$classname = 'core_xapi\local\statement\item_'.$itemname;
|
|
if (class_exists($classname)) {
|
|
$item = $classname::create_from_data($data);
|
|
} else {
|
|
$item = item::create_from_data($data);
|
|
}
|
|
return $item;
|
|
}
|
|
|
|
/**
|
|
* Test statement creation.
|
|
*
|
|
* @dataProvider create_provider
|
|
* @param bool $useagent if use agent as actor (or group if false)
|
|
* @param array $extras extra item elements
|
|
* @param array $extravalues extra string values
|
|
*/
|
|
public function test_create(bool $useagent, array $extras, array $extravalues) {
|
|
|
|
$this->resetAfterTest();
|
|
|
|
// Create one course with a group.
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
|
|
$this->getDataGenerator()->create_group_member(array('groupid' => $group->id, 'userid' => $user->id));
|
|
|
|
$this->setUser($user);
|
|
|
|
// Our statement.
|
|
$statement = new statement();
|
|
|
|
// Populate statement.
|
|
if ($useagent) {
|
|
$statement->set_actor(item_agent::create_from_user($user));
|
|
} else {
|
|
$statement->set_actor(item_group::create_from_group($group));
|
|
}
|
|
$statement->set_verb(item_verb::create_from_id('cook'));
|
|
$statement->set_object(item_activity::create_from_id('paella'));
|
|
|
|
foreach ($extras as $extra) {
|
|
$method = 'set_'.$extra;
|
|
$item = $this->get_valid_item($extra);
|
|
$statement->$method($item);
|
|
}
|
|
|
|
// For now extra values have no validation.
|
|
foreach ($extravalues as $extra) {
|
|
$method = 'set_'.$extra;
|
|
$statement->$method('Example');
|
|
}
|
|
|
|
// Check resulting statement.
|
|
if ($useagent) {
|
|
$stuser = $statement->get_user();
|
|
$this->assertEquals($user->id, $stuser->id);
|
|
$stusers = $statement->get_all_users();
|
|
$this->assertCount(1, $stusers);
|
|
} else {
|
|
$stgroup = $statement->get_group();
|
|
$this->assertEquals($group->id, $stgroup->id);
|
|
$stusers = $statement->get_all_users();
|
|
$this->assertCount(1, $stusers);
|
|
$stuser = array_shift($stusers);
|
|
$this->assertEquals($user->id, $stuser->id);
|
|
}
|
|
$this->assertEquals('cook', $statement->get_verb_id());
|
|
$this->assertEquals('paella', $statement->get_activity_id());
|
|
|
|
// Check resulting json (only first node structure, internal structure
|
|
// depends on every item json_encode test).
|
|
$data = json_decode(json_encode($statement));
|
|
$this->assertNotEmpty($data->actor);
|
|
$this->assertNotEmpty($data->verb);
|
|
$this->assertNotEmpty($data->object);
|
|
$allextras = ['context', 'result', 'timestamp', 'stored', 'authority', 'version', 'attachments'];
|
|
$alldefined = array_merge($extras, $extravalues);
|
|
foreach ($allextras as $extra) {
|
|
if (in_array($extra, $alldefined)) {
|
|
$this->assertObjectHasAttribute($extra, $data);
|
|
$this->assertNotEmpty($data->$extra);
|
|
} else {
|
|
$this->assertObjectNotHasAttribute($extra, $data);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Data provider for the test_create and test_create_from_data tests.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function create_provider() : array {
|
|
return [
|
|
'Agent statement with no extras' => [
|
|
true, [], []
|
|
],
|
|
'Agent statement with context' => [
|
|
true, ['context'], []
|
|
],
|
|
'Agent statement with result' => [
|
|
true, ['result'], []
|
|
],
|
|
'Agent statement with timestamp' => [
|
|
true, [], ['timestamp']
|
|
],
|
|
'Agent statement with stored' => [
|
|
true, [], ['stored']
|
|
],
|
|
'Agent statement with authority' => [
|
|
true, ['authority'], []
|
|
],
|
|
'Agent statement with version' => [
|
|
true, [], ['version']
|
|
],
|
|
'Group statement with no extras' => [
|
|
false, [], []
|
|
],
|
|
'Group statement with context' => [
|
|
false, ['context'], []
|
|
],
|
|
'Group statement with result' => [
|
|
false, ['result'], []
|
|
],
|
|
'Group statement with timestamp' => [
|
|
false, [], ['timestamp']
|
|
],
|
|
'Group statement with stored' => [
|
|
false, [], ['stored']
|
|
],
|
|
'Group statement with authority' => [
|
|
false, ['authority'], []
|
|
],
|
|
'Group statement with version' => [
|
|
false, [], ['version']
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Test statement creation from xAPI statement data.
|
|
*
|
|
* @dataProvider create_provider
|
|
* @param bool $useagent if use agent as actor (or group if false)
|
|
* @param array $extras extra item elements
|
|
* @param array $extravalues extra string values
|
|
*/
|
|
public function test_create_from_data(bool $useagent, array $extras, array $extravalues) {
|
|
$this->resetAfterTest();
|
|
|
|
// Create one course with a group.
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
|
|
$this->getDataGenerator()->create_group_member(array('groupid' => $group->id, 'userid' => $user->id));
|
|
|
|
$this->setUser($user);
|
|
|
|
// Populate data.
|
|
if ($useagent) {
|
|
$actor = item_agent::create_from_user($user);
|
|
} else {
|
|
$actor = item_group::create_from_group($group);
|
|
}
|
|
$verb = item_verb::create_from_id('cook');
|
|
$object = item_activity::create_from_id('paella');
|
|
|
|
$data = (object) [
|
|
'actor' => $actor->get_data(),
|
|
'verb' => $verb->get_data(),
|
|
'object' => $object->get_data(),
|
|
];
|
|
|
|
foreach ($extras as $extra) {
|
|
$item = $this->get_valid_item($extra);
|
|
$data->$extra = $item->get_data();
|
|
}
|
|
|
|
// For now extra values have no validation.
|
|
foreach ($extravalues as $extra) {
|
|
$data->$extra = 'Example';
|
|
}
|
|
|
|
$statement = statement::create_from_data($data);
|
|
|
|
// Check resulting statement.
|
|
if ($useagent) {
|
|
$stuser = $statement->get_user();
|
|
$this->assertEquals($user->id, $stuser->id);
|
|
$stusers = $statement->get_all_users();
|
|
$this->assertCount(1, $stusers);
|
|
} else {
|
|
$stgroup = $statement->get_group();
|
|
$this->assertEquals($group->id, $stgroup->id);
|
|
$stusers = $statement->get_all_users();
|
|
$this->assertCount(1, $stusers);
|
|
$stuser = array_shift($stusers);
|
|
$this->assertEquals($user->id, $stuser->id);
|
|
}
|
|
$this->assertEquals('cook', $statement->get_verb_id());
|
|
$this->assertEquals('paella', $statement->get_activity_id());
|
|
|
|
// Check resulting json (only first node structure, internal structure
|
|
// depends on every item json_encode test).
|
|
$data = json_decode(json_encode($statement));
|
|
$this->assertNotEmpty($data->actor);
|
|
$this->assertNotEmpty($data->verb);
|
|
$this->assertNotEmpty($data->object);
|
|
$allextras = ['context', 'result', 'timestamp', 'stored', 'authority', 'version', 'attachments'];
|
|
$alldefined = array_merge($extras, $extravalues);
|
|
foreach ($allextras as $extra) {
|
|
if (in_array($extra, $alldefined)) {
|
|
$this->assertObjectHasAttribute($extra, $data);
|
|
$this->assertNotEmpty($data->object);
|
|
} else {
|
|
$this->assertObjectNotHasAttribute($extra, $data);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test adding attachments to statement.
|
|
*
|
|
*/
|
|
public function test_add_attachment() {
|
|
|
|
// Our statement.
|
|
$statement = new statement();
|
|
|
|
$attachments = $statement->get_attachments();
|
|
$this->assertNull($attachments);
|
|
|
|
$item = $this->get_valid_item('attachment');
|
|
$itemdata = $item->get_data();
|
|
$statement->add_attachment($item);
|
|
|
|
$attachments = $statement->get_attachments();
|
|
$this->assertNotNull($attachments);
|
|
$this->assertCount(1, $attachments);
|
|
|
|
$attachment = current($attachments);
|
|
$attachmentdata = $attachment->get_data();
|
|
$this->assertEquals($itemdata->usageType, $attachmentdata->usageType);
|
|
$this->assertEquals($itemdata->length, $attachmentdata->length);
|
|
|
|
// Check resulting json.
|
|
$statementdata = json_decode(json_encode($statement));
|
|
$this->assertObjectHasAttribute('attachments', $statementdata);
|
|
$this->assertNotEmpty($statementdata->attachments);
|
|
$this->assertCount(1, $statementdata->attachments);
|
|
}
|
|
|
|
/**
|
|
* Test adding attachments to statement.
|
|
*
|
|
*/
|
|
public function test_add_attachment_from_data() {
|
|
|
|
$this->resetAfterTest();
|
|
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$this->setUser($user);
|
|
|
|
$actor = item_agent::create_from_user($user);
|
|
$verb = item_verb::create_from_id('cook');
|
|
$object = item_activity::create_from_id('paella');
|
|
|
|
$data = (object) [
|
|
'actor' => $actor->get_data(),
|
|
'verb' => $verb->get_data(),
|
|
'object' => $object->get_data(),
|
|
];
|
|
|
|
$item = $this->get_valid_item('attachment');
|
|
$itemdata = $item->get_data();
|
|
$data->attachments = [$itemdata];
|
|
|
|
$statement = statement::create_from_data($data);
|
|
|
|
$attachments = $statement->get_attachments();
|
|
$this->assertNotNull($attachments);
|
|
$this->assertCount(1, $attachments);
|
|
|
|
$attachment = current($attachments);
|
|
$attachmentdata = $attachment->get_data();
|
|
$this->assertEquals($itemdata->usageType, $attachmentdata->usageType);
|
|
$this->assertEquals($itemdata->length, $attachmentdata->length);
|
|
|
|
$statementdata = json_decode(json_encode($statement));
|
|
$this->assertObjectHasAttribute('attachments', $statementdata);
|
|
$this->assertNotEmpty($statementdata->attachments);
|
|
$this->assertCount(1, $statementdata->attachments);
|
|
|
|
// Now try to send an invalid attachments.
|
|
$this->expectException(xapi_exception::class);
|
|
$data->attachments = 'Invalid data';
|
|
$statement = statement::create_from_data($data);
|
|
}
|
|
|
|
/**
|
|
* Test all getters into a not set statement.
|
|
*
|
|
* @dataProvider invalid_gets_provider
|
|
* @param string $method the method to test
|
|
* @param bool $exception if an exception is expected
|
|
*/
|
|
public function test_invalid_gets(string $method, bool $exception) {
|
|
$statement = new statement();
|
|
if ($exception) {
|
|
$this->expectException(xapi_exception::class);
|
|
}
|
|
$result = $statement->$method();
|
|
$this->assertNull($result);
|
|
}
|
|
|
|
/**
|
|
* Data provider for the text_invalid_gets.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function invalid_gets_provider() : array {
|
|
return [
|
|
'Method get_user on empty statement' => ['get_user', true],
|
|
'Method get_all_users on empty statement' => ['get_all_users', true],
|
|
'Method get_group on empty statement' => ['get_group', true],
|
|
'Method get_verb_id on empty statement' => ['get_verb_id', true],
|
|
'Method get_activity_id on empty statement' => ['get_activity_id', true],
|
|
'Method get_actor on empty statement' => ['get_actor', false],
|
|
'Method get_verb on empty statement' => ['get_verb', false],
|
|
'Method get_object on empty statement' => ['get_object', false],
|
|
'Method get_context on empty statement' => ['get_context', false],
|
|
'Method get_result on empty statement' => ['get_result', false],
|
|
'Method get_timestamp on empty statement' => ['get_timestamp', false],
|
|
'Method get_stored on empty statement' => ['get_stored', false],
|
|
'Method get_authority on empty statement' => ['get_authority', false],
|
|
'Method get_version on empty statement' => ['get_version', false],
|
|
'Method get_attachments on empty statement' => ['get_attachments', false],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Try to get a user from a group statement.
|
|
*/
|
|
public function test_invalid_get_user() {
|
|
|
|
$this->resetAfterTest();
|
|
|
|
// Create one course with a group.
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$group = $this->getDataGenerator()->create_group(array('courseid' => $course->id));
|
|
$this->getDataGenerator()->create_group_member(array('groupid' => $group->id, 'userid' => $user->id));
|
|
|
|
// Our statement.
|
|
$statement = new statement();
|
|
|
|
// Populate statement.
|
|
$statement->set_actor(item_group::create_from_group($group));
|
|
$statement->set_verb(item_verb::create_from_id('cook'));
|
|
$statement->set_object(item_activity::create_from_id('paella'));
|
|
|
|
$this->expectException(xapi_exception::class);
|
|
$statement->get_user();
|
|
}
|
|
|
|
/**
|
|
* Try to get a group from an agent statement.
|
|
*/
|
|
public function test_invalid_get_group() {
|
|
$this->resetAfterTest();
|
|
|
|
$user = $this->getDataGenerator()->create_user();
|
|
|
|
// Our statement.
|
|
$statement = new statement();
|
|
|
|
// Populate statement.
|
|
$statement->set_actor(item_agent::create_from_user($user));
|
|
$statement->set_verb(item_verb::create_from_id('cook'));
|
|
$statement->set_object(item_activity::create_from_id('paella'));
|
|
|
|
$this->expectException(xapi_exception::class);
|
|
$statement->get_group();
|
|
}
|
|
|
|
/**
|
|
* Try to get activity Id from a statement with agent object.
|
|
*/
|
|
public function test_invalid_get_activity_id() {
|
|
$this->resetAfterTest();
|
|
|
|
$user = $this->getDataGenerator()->create_user();
|
|
|
|
// Our statement.
|
|
$statement = new statement();
|
|
|
|
// Populate statement with and agent object.
|
|
$statement->set_actor(item_agent::create_from_user($user));
|
|
$statement->set_verb(item_verb::create_from_id('cook'));
|
|
$statement->set_object(item_agent::create_from_user($user));
|
|
|
|
$this->expectException(xapi_exception::class);
|
|
$statement->get_activity_id();
|
|
}
|
|
|
|
/**
|
|
* Test for invalid structures.
|
|
*
|
|
* @dataProvider invalid_data_provider
|
|
* @param bool $useuser if use user into statement
|
|
* @param bool $userverb if use verb into statement
|
|
* @param bool $useobject if use object into statement
|
|
*/
|
|
public function test_invalid_data(bool $useuser, bool $userverb, bool $useobject): void {
|
|
|
|
$data = new stdClass();
|
|
|
|
if ($useuser) {
|
|
$this->resetAfterTest();
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$data->actor = item_agent::create_from_user($user);
|
|
}
|
|
if ($userverb) {
|
|
$data->verb = item_verb::create_from_id('cook');
|
|
}
|
|
if ($useobject) {
|
|
$data->object = item_activity::create_from_id('paella');
|
|
}
|
|
|
|
$this->expectException(xapi_exception::class);
|
|
$statement = statement::create_from_data($data);
|
|
}
|
|
|
|
/**
|
|
* Data provider for the test_invalid_data tests.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function invalid_data_provider() : array {
|
|
return [
|
|
'No actor, no verb, no object' => [false, false, false],
|
|
'No actor, verb, no object' => [false, true, false],
|
|
'No actor, no verb, object' => [false, false, true],
|
|
'No actor, verb, object' => [false, true, true],
|
|
'Actor, no verb, no object' => [true, false, false],
|
|
'Actor, verb, no object' => [true, true, false],
|
|
'Actor, no verb, object' => [true, false, true],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Test minify statement.
|
|
*/
|
|
public function test_minify() {
|
|
|
|
$this->resetAfterTest();
|
|
|
|
$user = $this->getDataGenerator()->create_user();
|
|
|
|
$this->setUser($user);
|
|
|
|
// Our statement.
|
|
$statement = new statement();
|
|
|
|
// Populate statement.
|
|
$statement->set_actor(item_agent::create_from_user($user));
|
|
$statement->set_verb(item_verb::create_from_id('cook'));
|
|
$statement->set_object(item_activity::create_from_id('paella'));
|
|
$statement->set_result($this->get_valid_item('result'));
|
|
$statement->set_context($this->get_valid_item('context'));
|
|
$statement->set_authority($this->get_valid_item('authority'));
|
|
$statement->add_attachment($this->get_valid_item('attachment'));
|
|
$statement->set_version('Example');
|
|
$statement->set_timestamp('Example');
|
|
$statement->set_stored('Example');
|
|
|
|
$min = $statement->minify();
|
|
|
|
// Check calculated fields.
|
|
$this->assertCount(6, $min);
|
|
$this->assertArrayNotHasKey('actor', $min);
|
|
$this->assertArrayHasKey('verb', $min);
|
|
$this->assertArrayHasKey('object', $min);
|
|
$this->assertArrayHasKey('context', $min);
|
|
$this->assertArrayHasKey('result', $min);
|
|
$this->assertArrayNotHasKey('timestamp', $min);
|
|
$this->assertArrayNotHasKey('stored', $min);
|
|
$this->assertArrayHasKey('authority', $min);
|
|
$this->assertArrayNotHasKey('version', $min);
|
|
$this->assertArrayHasKey('attachments', $min);
|
|
}
|
|
}
|