You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
464 lines
21 KiB
464 lines
21 KiB
2 years ago
|
<?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/>.
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Testing the service layer within core_favourites.
|
||
|
|
*
|
||
|
|
* @package core_favourites
|
||
|
|
* @category test
|
||
|
|
* @copyright 2018 Jake Dallimore <jrhdallimore@gmail.com>
|
||
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
||
|
|
*/
|
||
|
|
use \core_favourites\local\entity\favourite;
|
||
|
|
defined('MOODLE_INTERNAL') || die();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test class covering the user_favourite_service within the service layer of favourites.
|
||
|
|
*
|
||
|
|
* @copyright 2018 Jake Dallimore <jrhdallimore@gmail.com>
|
||
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
||
|
|
*/
|
||
|
|
class user_favourite_service_testcase extends advanced_testcase {
|
||
|
|
|
||
|
|
public function setUp() {
|
||
|
|
$this->resetAfterTest();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Basic setup stuff to be reused in most tests.
|
||
|
|
protected function setup_users_and_courses() {
|
||
|
|
$user1 = self::getDataGenerator()->create_user();
|
||
|
|
$user1context = \context_user::instance($user1->id);
|
||
|
|
$user2 = self::getDataGenerator()->create_user();
|
||
|
|
$user2context = \context_user::instance($user2->id);
|
||
|
|
$course1 = self::getDataGenerator()->create_course();
|
||
|
|
$course2 = self::getDataGenerator()->create_course();
|
||
|
|
$course1context = context_course::instance($course1->id);
|
||
|
|
$course2context = context_course::instance($course2->id);
|
||
|
|
return [$user1context, $user2context, $course1context, $course2context];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Generates an in-memory repository for testing, using an array store for CRUD stuff.
|
||
|
|
*
|
||
|
|
* @param array $mockstore
|
||
|
|
* @return \PHPUnit\Framework\MockObject\MockObject
|
||
|
|
*/
|
||
|
|
protected function get_mock_repository(array $mockstore) {
|
||
|
|
// This mock will just store data in an array.
|
||
|
|
$mockrepo = $this->getMockBuilder(\core_favourites\local\repository\favourite_repository_interface::class)
|
||
|
|
->setMethods([])
|
||
|
|
->getMock();
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('add')
|
||
|
|
->will($this->returnCallback(function(favourite $favourite) use (&$mockstore) {
|
||
|
|
// Mock implementation of repository->add(), where an array is used instead of the DB.
|
||
|
|
// Duplicates are confirmed via the unique key, and exceptions thrown just like a real repo.
|
||
|
|
$key = $favourite->userid . $favourite->component . $favourite->itemtype . $favourite->itemid
|
||
|
|
. $favourite->contextid;
|
||
|
|
|
||
|
|
// Check the objects for the unique key.
|
||
|
|
foreach ($mockstore as $item) {
|
||
|
|
if ($item->uniquekey == $key) {
|
||
|
|
throw new \moodle_exception('Favourite already exists');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$index = count($mockstore); // Integer index.
|
||
|
|
$favourite->uniquekey = $key; // Simulate the unique key constraint.
|
||
|
|
$favourite->id = $index;
|
||
|
|
$mockstore[$index] = $favourite;
|
||
|
|
return $mockstore[$index];
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('find_by')
|
||
|
|
->will($this->returnCallback(function(array $criteria, int $limitfrom = 0, int $limitnum = 0) use (&$mockstore) {
|
||
|
|
// Check the mockstore for all objects with properties matching the key => val pairs in $criteria.
|
||
|
|
foreach ($mockstore as $index => $mockrow) {
|
||
|
|
$mockrowarr = (array)$mockrow;
|
||
|
|
if (array_diff($criteria, $mockrowarr) == []) {
|
||
|
|
$returns[$index] = $mockrow;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Return a subset of the records, according to the paging options, if set.
|
||
|
|
if ($limitnum != 0) {
|
||
|
|
return array_slice($returns, $limitfrom, $limitnum);
|
||
|
|
}
|
||
|
|
// Otherwise, just return the full set.
|
||
|
|
return $returns;
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('find_favourite')
|
||
|
|
->will($this->returnCallback(function(int $userid, string $comp, string $type, int $id, int $ctxid) use (&$mockstore) {
|
||
|
|
// Check the mockstore for all objects with properties matching the key => val pairs in $criteria.
|
||
|
|
$crit = ['userid' => $userid, 'component' => $comp, 'itemtype' => $type, 'itemid' => $id, 'contextid' => $ctxid];
|
||
|
|
foreach ($mockstore as $fakerow) {
|
||
|
|
$fakerowarr = (array)$fakerow;
|
||
|
|
if (array_diff($crit, $fakerowarr) == []) {
|
||
|
|
return $fakerow;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw new \dml_missing_record_exception("Item not found");
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('find')
|
||
|
|
->will($this->returnCallback(function(int $id) use (&$mockstore) {
|
||
|
|
return $mockstore[$id];
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('exists')
|
||
|
|
->will($this->returnCallback(function(int $id) use (&$mockstore) {
|
||
|
|
return array_key_exists($id, $mockstore);
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('count_by')
|
||
|
|
->will($this->returnCallback(function(array $criteria) use (&$mockstore) {
|
||
|
|
$count = 0;
|
||
|
|
// Check the mockstore for all objects with properties matching the key => val pairs in $criteria.
|
||
|
|
foreach ($mockstore as $index => $mockrow) {
|
||
|
|
$mockrowarr = (array)$mockrow;
|
||
|
|
if (array_diff($criteria, $mockrowarr) == []) {
|
||
|
|
$count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return $count;
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('delete')
|
||
|
|
->will($this->returnCallback(function(int $id) use (&$mockstore) {
|
||
|
|
foreach ($mockstore as $mockrow) {
|
||
|
|
if ($mockrow->id == $id) {
|
||
|
|
unset($mockstore[$id]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
);
|
||
|
|
$mockrepo->expects($this->any())
|
||
|
|
->method('exists_by')
|
||
|
|
->will($this->returnCallback(function(array $criteria) use (&$mockstore) {
|
||
|
|
// Check the mockstore for all objects with properties matching the key => val pairs in $criteria.
|
||
|
|
foreach ($mockstore as $index => $mockrow) {
|
||
|
|
$mockrowarr = (array)$mockrow;
|
||
|
|
if (array_diff($criteria, $mockrowarr) == []) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
})
|
||
|
|
);
|
||
|
|
return $mockrepo;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test getting a user_favourite_service from the static locator.
|
||
|
|
*/
|
||
|
|
public function test_get_service_for_user_context() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
$userservice = \core_favourites\service_factory::get_service_for_user_context($user1context);
|
||
|
|
$this->assertInstanceOf(\core_favourites\local\service\user_favourite_service::class, $userservice);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming an item can be favourited only once.
|
||
|
|
*/
|
||
|
|
public function test_create_favourite_basic() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for a user.
|
||
|
|
$repo = $this->get_mock_repository([]); // Mock repository, using the array as a mock DB.
|
||
|
|
$user1service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite a course.
|
||
|
|
$favourite1 = $user1service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
$this->assertObjectHasAttribute('id', $favourite1);
|
||
|
|
|
||
|
|
// Try to favourite the same course again.
|
||
|
|
$this->expectException('moodle_exception');
|
||
|
|
$user1service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming that an exception is thrown if trying to favourite an item for a non-existent component.
|
||
|
|
*/
|
||
|
|
public function test_create_favourite_nonexistent_component() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]); // Mock repository, using the array as a mock DB.
|
||
|
|
$user1service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Try to favourite something in a non-existent component.
|
||
|
|
$this->expectException('moodle_exception');
|
||
|
|
$user1service->create_favourite('core_cccourse', 'my_area', $course1context->instanceid, $course1context);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test fetching favourites for single user, by area.
|
||
|
|
*/
|
||
|
|
public function test_find_favourites_by_type_single_user() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]); // Mock repository, using the array as a mock DB.
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite 2 courses, in separate areas.
|
||
|
|
$fav1 = $service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
$fav2 = $service->create_favourite('core_course', 'anothertype', $course2context->instanceid, $course2context);
|
||
|
|
|
||
|
|
// Verify we can get favourites by area.
|
||
|
|
$favourites = $service->find_favourites_by_type('core_course', 'course');
|
||
|
|
$this->assertInternalType('array', $favourites);
|
||
|
|
$this->assertCount(1, $favourites); // We only get favourites for the 'core_course/course' area.
|
||
|
|
$this->assertAttributeEquals($fav1->id, 'id', $favourites[$fav1->id]);
|
||
|
|
|
||
|
|
$favourites = $service->find_favourites_by_type('core_course', 'anothertype');
|
||
|
|
$this->assertInternalType('array', $favourites);
|
||
|
|
$this->assertCount(1, $favourites); // We only get favourites for the 'core_course/course' area.
|
||
|
|
$this->assertAttributeEquals($fav2->id, 'id', $favourites[$fav2->id]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Make sure the find_favourites_by_type() method only returns favourites for the scoped user.
|
||
|
|
*/
|
||
|
|
public function test_find_favourites_by_type_multiple_users() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for 2 users.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$user1service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
$user2service = new \core_favourites\local\service\user_favourite_service($user2context, $repo);
|
||
|
|
|
||
|
|
// Now, as each user, favourite the same course.
|
||
|
|
$fav1 = $user1service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
$fav2 = $user2service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
|
||
|
|
// Verify find_favourites_by_type only returns results for the user to which the service is scoped.
|
||
|
|
$user1favourites = $user1service->find_favourites_by_type('core_course', 'course');
|
||
|
|
$this->assertInternalType('array', $user1favourites);
|
||
|
|
$this->assertCount(1, $user1favourites); // We only get favourites for the 'core_course/course' area for $user1.
|
||
|
|
$this->assertAttributeEquals($fav1->id, 'id', $user1favourites[$fav1->id]);
|
||
|
|
|
||
|
|
$user2favourites = $user2service->find_favourites_by_type('core_course', 'course');
|
||
|
|
$this->assertInternalType('array', $user2favourites);
|
||
|
|
$this->assertCount(1, $user2favourites); // We only get favourites for the 'core_course/course' area for $user2.
|
||
|
|
$this->assertAttributeEquals($fav2->id, 'id', $user2favourites[$fav2->id]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming that an exception is thrown if trying to get favourites for a non-existent component.
|
||
|
|
*/
|
||
|
|
public function test_find_favourites_by_type_nonexistent_component() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Verify we get an exception if we try to search for favourites in an invalid component.
|
||
|
|
$this->expectException('moodle_exception');
|
||
|
|
$service->find_favourites_by_type('cccore_notreal', 'something');
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming the pagination support for the find_favourites_by_type() method.
|
||
|
|
*/
|
||
|
|
public function test_find_favourites_by_type_pagination() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite 10 arbitrary items.
|
||
|
|
foreach (range(1, 10) as $i) {
|
||
|
|
$service->create_favourite('core_course', 'course', $i, $course1context);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify we have 10 favourites.
|
||
|
|
$this->assertCount(10, $service->find_favourites_by_type('core_course', 'course'));
|
||
|
|
|
||
|
|
// Verify we get back 5 favourites for page 1.
|
||
|
|
$favourites = $service->find_favourites_by_type('core_course', 'course', 0, 5);
|
||
|
|
$this->assertCount(5, $favourites);
|
||
|
|
|
||
|
|
// Verify we get back 5 favourites for page 2.
|
||
|
|
$favourites = $service->find_favourites_by_type('core_course', 'course', 5, 5);
|
||
|
|
$this->assertCount(5, $favourites);
|
||
|
|
|
||
|
|
// Verify we get back an empty array if querying page 3.
|
||
|
|
$favourites = $service->find_favourites_by_type('core_course', 'course', 10, 5);
|
||
|
|
$this->assertCount(0, $favourites);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming the basic deletion behaviour.
|
||
|
|
*/
|
||
|
|
public function test_delete_favourite_basic() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite a course.
|
||
|
|
$fav1 = $service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
$this->assertTrue($repo->exists($fav1->id));
|
||
|
|
|
||
|
|
// Delete the favourite.
|
||
|
|
$service->delete_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
|
||
|
|
// Verify the favourite doesn't exist.
|
||
|
|
$this->assertFalse($repo->exists($fav1->id));
|
||
|
|
|
||
|
|
// Try to delete a favourite which we know doesn't exist.
|
||
|
|
$this->expectException(\moodle_exception::class);
|
||
|
|
$service->delete_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming the behaviour of the favourite_exists() method.
|
||
|
|
*/
|
||
|
|
public function test_favourite_exists() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite a course.
|
||
|
|
$fav1 = $service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
|
||
|
|
// Verify we can check existence of the favourite.
|
||
|
|
$this->assertTrue(
|
||
|
|
$service->favourite_exists(
|
||
|
|
'core_course',
|
||
|
|
'course',
|
||
|
|
$course1context->instanceid,
|
||
|
|
$course1context
|
||
|
|
)
|
||
|
|
);
|
||
|
|
|
||
|
|
// And one that we know doesn't exist.
|
||
|
|
$this->assertFalse(
|
||
|
|
$service->favourite_exists(
|
||
|
|
'core_course',
|
||
|
|
'someothertype',
|
||
|
|
$course1context->instanceid,
|
||
|
|
$course1context
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming the behaviour of the get_favourite() method.
|
||
|
|
*/
|
||
|
|
public function test_get_favourite() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite a course.
|
||
|
|
$fav1 = $service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
|
||
|
|
$result = $service->get_favourite(
|
||
|
|
'core_course',
|
||
|
|
'course',
|
||
|
|
$course1context->instanceid,
|
||
|
|
$course1context
|
||
|
|
);
|
||
|
|
// Verify we can get the favourite.
|
||
|
|
$this->assertEquals($fav1->id, $result->id);
|
||
|
|
|
||
|
|
// And one that we know doesn't exist.
|
||
|
|
$this->assertNull(
|
||
|
|
$service->get_favourite(
|
||
|
|
'core_course',
|
||
|
|
'someothertype',
|
||
|
|
$course1context->instanceid,
|
||
|
|
$course1context
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test confirming the behaviour of the count_favourites_by_type() method.
|
||
|
|
*/
|
||
|
|
public function test_count_favourites_by_type() {
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
$repo = $this->get_mock_repository([]);
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
$this->assertEquals(0, $service->count_favourites_by_type('core_course', 'course', $course1context));
|
||
|
|
// Favourite a course.
|
||
|
|
$service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
|
||
|
|
$this->assertEquals(1, $service->count_favourites_by_type('core_course', 'course', $course1context));
|
||
|
|
|
||
|
|
// Favourite another course.
|
||
|
|
$service->create_favourite('core_course', 'course', $course2context->instanceid, $course1context);
|
||
|
|
|
||
|
|
$this->assertEquals(2, $service->count_favourites_by_type('core_course', 'course', $course1context));
|
||
|
|
|
||
|
|
// Favourite a course in another context.
|
||
|
|
$service->create_favourite('core_course', 'course', $course2context->instanceid, $course2context);
|
||
|
|
|
||
|
|
// Doesn't affect original context.
|
||
|
|
$this->assertEquals(2, $service->count_favourites_by_type('core_course', 'course', $course1context));
|
||
|
|
// Gets counted if we include all contexts.
|
||
|
|
$this->assertEquals(3, $service->count_favourites_by_type('core_course', 'course'));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Verify that the join sql generated by get_join_sql_by_type is valid and can be used to include favourite information.
|
||
|
|
*/
|
||
|
|
public function test_get_join_sql_by_type() {
|
||
|
|
global $DB;
|
||
|
|
list($user1context, $user2context, $course1context, $course2context) = $this->setup_users_and_courses();
|
||
|
|
|
||
|
|
// Get a user_favourite_service for the user.
|
||
|
|
// We need to use a real (DB) repository, as we want to run the SQL.
|
||
|
|
$repo = new \core_favourites\local\repository\favourite_repository();
|
||
|
|
$service = new \core_favourites\local\service\user_favourite_service($user1context, $repo);
|
||
|
|
|
||
|
|
// Favourite the first course only.
|
||
|
|
$service->create_favourite('core_course', 'course', $course1context->instanceid, $course1context);
|
||
|
|
|
||
|
|
// Generate the join snippet.
|
||
|
|
list($favsql, $favparams) = $service->get_join_sql_by_type('core_course', 'course', 'favalias', 'c.id');
|
||
|
|
|
||
|
|
// Join against a simple select, including the 2 courses only.
|
||
|
|
$params = ['courseid1' => $course1context->instanceid, 'courseid2' => $course2context->instanceid];
|
||
|
|
$params = $params + $favparams;
|
||
|
|
$records = $DB->get_records_sql("SELECT c.id, favalias.component
|
||
|
|
FROM {course} c $favsql
|
||
|
|
WHERE c.id = :courseid1 OR c.id = :courseid2", $params);
|
||
|
|
|
||
|
|
// Verify the favourite information is returned, but only for the favourited course.
|
||
|
|
$this->assertCount(2, $records);
|
||
|
|
$this->assertEquals('core_course', $records[$course1context->instanceid]->component);
|
||
|
|
$this->assertEmpty($records[$course2context->instanceid]->component);
|
||
|
|
}
|
||
|
|
}
|