See Release Notes
Long Term Support Release
<?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 the webservice component. * * @package core_webservice * @category test * @copyright 2016 Jun Pataleta <jun@moodle.com> * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */> namespace core_webservice; defined('MOODLE_INTERNAL') || die(); > > use webservice; global $CFG; >require_once($CFG->dirroot . '/webservice/lib.php'); /** * Unit tests for the webservice component. * * @package core_webservice * @category test * @copyright 2016 Jun Pataleta <jun@moodle.com> * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */< class webservice_test extends advanced_testcase {> class lib_test extends \advanced_testcase {/** * Setup. */< public function setUp() {> public function setUp(): void {// Calling parent is good, always. parent::setUp(); // We always need enabled WS for this testcase. set_config('enablewebservices', '1'); } /** * Test init_service_class(). */ public function test_init_service_class() { global $DB, $USER; $this->resetAfterTest(true); // Set current user. $this->setAdminUser(); // Add a web service.< $webservice = new stdClass();> $webservice = new \stdClass();$webservice->name = 'Test web service'; $webservice->enabled = true; $webservice->restrictedusers = false; $webservice->component = 'moodle'; $webservice->timecreated = time(); $webservice->downloadfiles = true; $webservice->uploadfiles = true; $externalserviceid = $DB->insert_record('external_services', $webservice); // Add token.< $externaltoken = new stdClass();> $externaltoken = new \stdClass();$externaltoken->token = 'testtoken'; $externaltoken->tokentype = 0; $externaltoken->userid = $USER->id; $externaltoken->externalserviceid = $externalserviceid; $externaltoken->contextid = 1; $externaltoken->creatorid = $USER->id; $externaltoken->timecreated = time(); $DB->insert_record('external_tokens', $externaltoken); // Add a function to the service.< $wsmethod = new stdClass();> $wsmethod = new \stdClass();$wsmethod->externalserviceid = $externalserviceid; $wsmethod->functionname = 'core_course_get_contents'; $DB->insert_record('external_services_functions', $wsmethod); // Initialise the dummy web service. $dummy = new webservice_dummy(WEBSERVICE_AUTHMETHOD_PERMANENT_TOKEN); // Set the token. $dummy->set_token($externaltoken->token); // Run the web service. $dummy->run(); // Get service methods and structs. $servicemethods = $dummy->get_service_methods(); $servicestructs = $dummy->get_service_structs(); $this->assertNotEmpty($servicemethods); // The function core_course_get_contents should be only the only web service function in the moment. $this->assertEquals(1, count($servicemethods)); // The function core_course_get_contents doesn't have a struct class, so the list of service structs should be empty. $this->assertEmpty($servicestructs); // Add other functions to the service. // The function core_comment_get_comments has one struct class in its output. $wsmethod->functionname = 'core_comment_get_comments'; $DB->insert_record('external_services_functions', $wsmethod); // The function core_grades_update_grades has one struct class in its input. $wsmethod->functionname = 'core_grades_update_grades'; $DB->insert_record('external_services_functions', $wsmethod); // Run the web service again. $dummy->run(); // Get service methods and structs. $servicemethods = $dummy->get_service_methods(); $servicestructs = $dummy->get_service_structs(); $this->assertEquals(3, count($servicemethods)); $this->assertEquals(2, count($servicestructs)); // Check the contents of service methods. foreach ($servicemethods as $method) { // Get the external function info.< $function = external_api::external_function_info($method->name);> $function = \external_api::external_function_info($method->name);// Check input params. foreach ($function->parameters_desc->keys as $name => $keydesc) { $this->check_params($method->inputparams[$name]['type'], $keydesc, $servicestructs); } // Check output params. $this->check_params($method->outputparams['return']['type'], $function->returns_desc, $servicestructs); // Check description. $this->assertEquals($function->description, $method->description); } } /** * Tests update_token_lastaccess() function. * * @throws dml_exception */ public function test_update_token_lastaccess() { global $DB; $this->resetAfterTest(true); // Set current user. $this->setAdminUser(); // Add a web service.< $webservice = new stdClass();> $webservice = new \stdClass();$webservice->name = 'Test web service'; $webservice->enabled = true; $webservice->restrictedusers = false; $webservice->component = 'moodle'; $webservice->timecreated = time(); $webservice->downloadfiles = true; $webservice->uploadfiles = true; $DB->insert_record('external_services', $webservice); // Add token.< $tokenstr = external_create_service_token($webservice->name, context_system::instance()->id);> $tokenstr = external_create_service_token($webservice->name, \context_system::instance()->id);$token = $DB->get_record('external_tokens', ['token' => $tokenstr]); // Trigger last access once (at current time). webservice::update_token_lastaccess($token); // Check last access. $token = $DB->get_record('external_tokens', ['token' => $tokenstr]); $this->assertLessThan(5, abs(time() - $token->lastaccess)); // Try setting it to +1 second. This should not update yet. $before = (int)$token->lastaccess; webservice::update_token_lastaccess($token, $before + 1); $token = $DB->get_record('external_tokens', ['token' => $tokenstr]); $this->assertEquals($before, $token->lastaccess); // To -1000 seconds. This should not update. webservice::update_token_lastaccess($token, $before - 1000); $token = $DB->get_record('external_tokens', ['token' => $tokenstr]); $this->assertEquals($before, $token->lastaccess); // To +59 seconds. This should also not quite update. webservice::update_token_lastaccess($token, $before + 59); $token = $DB->get_record('external_tokens', ['token' => $tokenstr]); $this->assertEquals($before, $token->lastaccess); // Finally to +60 seconds, where it should update. webservice::update_token_lastaccess($token, $before + 60); $token = $DB->get_record('external_tokens', ['token' => $tokenstr]); $this->assertEquals($before + 60, $token->lastaccess); } /**> * Tests for the {@see webservice::get_missing_capabilities_by_users()} implementation. * Utility method that tests the parameter type of a method info's input/output parameter. > */ * > public function test_get_missing_capabilities_by_users() { * @param string $type The parameter type that is being evaluated. > global $DB; * @param mixed $methoddesc The method description of the WS function. > * @param array $servicestructs The list of generated service struct classes. > $this->resetAfterTest(true); */ > $wsman = new webservice(); private function check_params($type, $methoddesc, $servicestructs) { > if ($methoddesc instanceof external_value) { > $user1 = $this->getDataGenerator()->create_user(); // Test for simple types. > $user2 = $this->getDataGenerator()->create_user(); if (in_array($methoddesc->type, [PARAM_INT, PARAM_FLOAT, PARAM_BOOL])) { > $user3 = $this->getDataGenerator()->create_user(); $this->assertEquals($methoddesc->type, $type); > } else { > // Add a test web service. $this->assertEquals('string', $type); > $serviceid = $wsman->add_external_service((object)[ } > 'name' => 'Test web service', } else if ($methoddesc instanceof external_single_structure) { > 'enabled' => 1, // Test that the class name of the struct class is in the array of service structs. > 'requiredcapability' => '', $structinfo = $this->get_struct_info($servicestructs, $type); > 'restrictedusers' => false, $this->assertNotNull($structinfo); > 'component' => 'moodle', // Test that the properties of the struct info exist in the method description. > 'downloadfiles' => false, foreach ($structinfo->properties as $propname => $proptype) { > 'uploadfiles' => false, $this->assertTrue($this->in_keydesc($methoddesc, $propname)); > ]); } > } else if ($methoddesc instanceof external_multiple_structure) { > // Add a function to the service that does not declare any capability as required. // Test for array types. > $wsman->add_external_function_to_service('core_webservice_get_site_info', $serviceid); $this->assertEquals('array', $type); > } > // Users can be provided as an array of objects, arrays or integers (ids). } > $this->assertEmpty($wsman->get_missing_capabilities_by_users([$user1, array($user2), $user3->id], $serviceid)); > /** > // Add a function to the service that declares some capability as required, but that capability is common for * Gets the struct information from the list of struct classes based on the given struct class name. > // any user. Here we use 'core_message_delete_conversation' which declares 'moodle/site:deleteownmessage' which * > // in turn is granted to the authenticated user archetype by default. * @param array $structarray The list of generated struct classes. > $wsman->add_external_function_to_service('core_message_delete_conversation', $serviceid); * @param string $structclass The name of the struct class. > * @return object|null The struct class info, or null if it's not found. > // So all three users should have this capability implicitly. */ > $this->assertEmpty($wsman->get_missing_capabilities_by_users([$user1, $user2, $user3], $serviceid)); private function get_struct_info($structarray, $structclass) { > foreach ($structarray as $struct) { > // Add a function to the service that declares some non-common capability. Here we use if ($struct->classname === $structclass) { > // 'core_group_add_group_members' that wants 'moodle/course:managegroups'. return $struct; > $wsman->add_external_function_to_service('core_group_add_group_members', $serviceid); } > } > // Make it so that the $user1 has the capability in some course. return null; > $course1 = $this->getDataGenerator()->create_course(); } > $this->getDataGenerator()->enrol_user($user1->id, $course1->id, 'editingteacher'); > /** > // Check that no missing capability is reported for the $user1. We don't care at what actual context the * Searches the keys of the given external_single_structure object if it contains a certain property name. > // external function call will evaluate the permission. We just check that there is a chance that the user has * > // the capability somewhere. * @param external_single_structure $keydesc > $this->assertEmpty($wsman->get_missing_capabilities_by_users([$user1], $serviceid)); * @param string $propertyname The property name to be searched for. > * @return bool True if the property name is found in $keydesc. False, otherwise. > // But there is no place at the site where the capability would be granted to the other two users, so it is */ > // reported as missing. private function in_keydesc(external_single_structure $keydesc, $propertyname) { > $missing = $wsman->get_missing_capabilities_by_users([$user1, $user2, $user3], $serviceid); foreach ($keydesc->keys as $key => $desc) { > $this->assertArrayNotHasKey($user1->id, $missing); if ($key === $propertyname) { > $this->assertContains('moodle/course:managegroups', $missing[$user2->id]); return true; > $this->assertContains('moodle/course:managegroups', $missing[$user3->id]); } > } } > return false; > /** } > * Data provider for {@see test_get_active_tokens} } > * > * @return array /** > */ * Class webservice_dummy. > public function get_active_tokens_provider(): array { * > return [ * Dummy webservice class for testing the webservice_base_server class and enable us to expose variables we want to test. > 'No expiration' => [0, true], * > 'Active' => [time() + DAYSECS, true], * @package core_webservice > 'Expired' => [time() - DAYSECS, false], * @category test > ]; * @copyright 2016 Jun Pataleta <jun@moodle.com> > } * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later > */ > /** class webservice_dummy extends webservice_base_server { > * Test getting active tokens for a user > * /** > * @param int $validuntil * webservice_dummy constructor. > * @param bool $expectedactive * > * * @param int $authmethod The authentication method. > * @dataProvider get_active_tokens_provider */ > */ public function __construct($authmethod) { > public function test_get_active_tokens(int $validuntil, bool $expectedactive): void { parent::__construct($authmethod); > $this->resetAfterTest(); > // Arbitrarily naming this as REST in order not to have to register another WS protocol and set capabilities. > $user = $this->getDataGenerator()->create_user(); $this->wsname = 'rest'; > } > /** @var core_webservice_generator $generator */ > $generator = $this->getDataGenerator()->get_plugin_generator('core_webservice'); /** > * Token setter method. > $service = $generator->create_service(['name' => 'My test service', 'shortname' => 'mytestservice']); * > $generator->create_token(['userid' => $user->id, 'service' => $service->shortname, 'validuntil' => $validuntil]); * @param string $token The web service token. > */ > $tokens = webservice::get_active_tokens($user->id); public function set_token($token) { > if ($expectedactive) { $this->token = $token; > $this->assertCount(1, $tokens); } > $this->assertEquals($service->id, reset($tokens)->externalserviceid); > } else { /** > $this->assertEmpty($tokens); * This method parses the request input, it needs to get: > } * 1/ user authentication - username+password or token > } * 2/ function name > * 3/ function parameters > /**< * Dummy webservice class for testing the webservice_base_server class and enable us to expose variables we want to test.> * Dummy webservice class for testing the \webservice_base_server class and enable us to expose variables we want to test.< class webservice_dummy extends webservice_base_server {> class webservice_dummy extends \webservice_base_server {// Just a method stub. No need to implement at the moment since it's not really being used for this test case for now. } /** * Send the result of function call to the WS client. */ protected function send_response() { // Just a method stub. No need to implement at the moment since it's not really being used for this test case for now. } /** * Send the error information to the WS client. * * @param exception $ex */ protected function send_error($ex = null) { // Just a method stub. No need to implement at the moment since it's not really being used for this test case for now. } /** * run() method implementation. */ public function run() { $this->authenticate_user(); $this->init_service_class(); } /** * Getter method of servicemethods array. * * @return array */ public function get_service_methods() { return $this->servicemethods; } /** * Getter method of servicestructs array. * * @return array */ public function get_service_structs() { return $this->servicestructs; } }