upstream/nextcloud
1
0
Fork 0
mirror of https://github.com/nextcloud/server.git synced 2026-06-10 09:13:19 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 54

Merge pull request #53150 from nextcloud/tests/noid/ldap

Browse source
This commit is contained in:
Kate 2025-05-28 11:10:13 +02:00 committed by GitHub
commit 85c141e107
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
32 changed files with 606 additions and 662 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

111
apps/user_ldap/tests/AccessTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -41,36 +43,25 @@ use Test\TestCase;
* @package OCA\User_LDAP\Tests
*/
class AccessTest extends TestCase {
/** @var UserMapping|MockObject */
protected $userMapper;
/** @var IManager|MockObject */
protected $shareManager;
/** @var GroupMapping|MockObject */
protected $groupMapper;
/** @var Connection|MockObject */
private $connection;
/** @var LDAP|MockObject */
private $ldap;
/** @var Manager|MockObject */
private $userManager;
/** @var Helper|MockObject */
private $helper;
/** @var IConfig|MockObject */
private $config;
/** @var IUserManager|MockObject */
private $ncUserManager;
protected UserMapping&MockObject $userMapper;
protected IManager&MockObject $shareManager;
protected GroupMapping&MockObject $groupMapper;
private Connection&MockObject $connection;
private LDAP&MockObject $ldap;
private Manager&MockObject $userManager;
private Helper&MockObject $helper;
private IConfig&MockObject $config;
private IUserManager&MockObject $ncUserManager;
private LoggerInterface&MockObject $logger;
private IAppConfig&MockObject $appConfig;
/** @var IEventDispatcher|MockObject */
private $dispatcher;
private IEventDispatcher&MockObject $dispatcher;
private Access $access;
protected function setUp(): void {
$this->connection = $this->createMock(Connection::class);
$this->ldap = $this->createMock(LDAP::class);
$this->connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->ldap])
->getMock();
$this->userManager = $this->createMock(Manager::class);
$this->helper = $this->createMock(Helper::class);
$this->config = $this->createMock(IConfig::class);
@ -126,19 +117,19 @@ class AccessTest extends TestCase {
public function testEscapeFilterPartValidChars(): void {
$input = 'okay';
$this->assertTrue($input === $this->access->escapeFilterPart($input));
$this->assertSame($input, $this->access->escapeFilterPart($input));
}
public function testEscapeFilterPartEscapeWildcard(): void {
$input = '*';
$expected = '\\2a';
$this->assertTrue($expected === $this->access->escapeFilterPart($input));
$this->assertSame($expected, $this->access->escapeFilterPart($input));
}
public function testEscapeFilterPartEscapeWildcard2(): void {
$input = 'foo*bar';
$expected = 'foo\\2abar';
$this->assertTrue($expected === $this->access->escapeFilterPart($input));
$this->assertSame($expected, $this->access->escapeFilterPart($input));
}
/**
@ -151,7 +142,7 @@ class AccessTest extends TestCase {
$this->assertSame($sidExpected, $this->access->convertSID2Str($sidBinary));
}
public function convertSID2StrSuccessData() {
public static function convertSID2StrSuccessData(): array {
return [
[
[
@ -209,55 +200,53 @@ class AccessTest extends TestCase {
$this->assertSame($expected, $this->access->getDomainDNFromDN($inputDN));
}
public function dnInputDataProvider() {
return [[
public static function dnInputDataProvider(): array {
return [
[
'input' => 'foo=bar,bar=foo,dc=foobar',
'interResult' => [
'foo=bar,bar=foo,dc=foobar',
[
'count' => 3,
0 => 'foo=bar',
1 => 'bar=foo',
2 => 'dc=foobar'
],
'expectedResult' => true
true
],
[
'input' => 'foobarbarfoodcfoobar',
'interResult' => false,
'expectedResult' => false
'foobarbarfoodcfoobar',
false,
false
]
]];
];
}
/**
* @dataProvider dnInputDataProvider
* @param array $case
*/
public function testStringResemblesDN($case): void {
public function testStringResemblesDN(string $input, array|bool $interResult, bool $expectedResult): void {
[$lw, $con, $um, $helper] = $this->getConnectorAndLdapMock();
/** @var IConfig|MockObject $config */
/** @var IConfig&MockObject $config */
$config = $this->createMock(IConfig::class);
$access = new Access($lw, $con, $um, $helper, $config, $this->ncUserManager, $this->logger, $this->appConfig, $this->dispatcher);
$lw->expects($this->exactly(1))
->method('explodeDN')
->willReturnCallback(function ($dn) use ($case) {
if ($dn === $case['input']) {
return $case['interResult'];
->willReturnCallback(function ($dn) use ($input, $interResult) {
if ($dn === $input) {
return $interResult;
}
return null;
});
$this->assertSame($case['expectedResult'], $access->stringResemblesDN($case['input']));
$this->assertSame($expectedResult, $access->stringResemblesDN($input));
}
/**
* @dataProvider dnInputDataProvider
* @param $case
*/
public function testStringResemblesDNLDAPmod($case): void {
public function testStringResemblesDNLDAPmod(string $input, array|bool $interResult, bool $expectedResult): void {
[, $con, $um, $helper] = $this->getConnectorAndLdapMock();
/** @var IConfig|MockObject $config */
/** @var IConfig&MockObject $config */
$config = $this->createMock(IConfig::class);
$lw = new LDAP();
$access = new Access($lw, $con, $um, $helper, $config, $this->ncUserManager, $this->logger, $this->appConfig, $this->dispatcher);
@ -266,7 +255,7 @@ class AccessTest extends TestCase {
$this->markTestSkipped('LDAP Module not available');
}
$this->assertSame($case['expectedResult'], $access->stringResemblesDN($case['input']));
$this->assertSame($expectedResult, $access->stringResemblesDN($input));
}
public function testCacheUserHome(): void {
@ -290,7 +279,7 @@ class AccessTest extends TestCase {
->method('getAttributes')
->willReturn(['displayname' => ['bar', 'count' => 1]]);
/** @var UserMapping|MockObject $mapperMock */
/** @var UserMapping&MockObject $mapperMock */
$mapperMock = $this->createMock(UserMapping::class);
$mapperMock->expects($this->any())
->method('getNameByDN')
@ -335,7 +324,7 @@ class AccessTest extends TestCase {
}
public function testBatchApplyUserAttributesSkipped(): void {
/** @var UserMapping|MockObject $mapperMock */
/** @var UserMapping&MockObject $mapperMock */
$mapperMock = $this->createMock(UserMapping::class);
$mapperMock->expects($this->any())
->method('getNameByDN')
@ -376,7 +365,7 @@ class AccessTest extends TestCase {
}
public function testBatchApplyUserAttributesDontSkip(): void {
/** @var UserMapping|MockObject $mapperMock */
/** @var UserMapping&MockObject $mapperMock */
$mapperMock = $this->createMock(UserMapping::class);
$mapperMock->expects($this->any())
->method('getNameByDN')
@ -416,7 +405,7 @@ class AccessTest extends TestCase {
$this->access->batchApplyUserAttributes($data);
}
public function dNAttributeProvider() {
public static function dNAttributeProvider(): array {
// corresponds to Access::resemblesDN()
return [
'dn' => ['dn'],
@ -428,11 +417,10 @@ class AccessTest extends TestCase {
/**
* @dataProvider dNAttributeProvider
* @param $attribute
*/
public function testSanitizeDN($attribute): void {
public function testSanitizeDN(string $attribute): void {
[$lw, $con, $um, $helper] = $this->getConnectorAndLdapMock();
/** @var IConfig|MockObject $config */
/** @var IConfig&MockObject $config */
$config = $this->createMock(IConfig::class);
$dnFromServer = 'cn=Mixed Cases,ou=Are Sufficient To,ou=Test,dc=example,dc=org';
@ -628,7 +616,7 @@ class AccessTest extends TestCase {
$this->userMapper->expects($this->exactly($fakeLdapEntries['count']))
->method('getNameByDN')
->willReturnCallback(function ($fdn) {
$parts = ldap_explode_dn($fdn, false);
$parts = ldap_explode_dn($fdn, 0);
return $parts[0];
});
@ -676,7 +664,7 @@ class AccessTest extends TestCase {
$this->assertSame('Another Good Team', $groups[1]['cn'][0]);
}
public function intUsernameProvider() {
public static function intUsernameProvider(): array {
return [
['alice', 'alice'],
['b/ob', 'bob'],
@ -694,7 +682,7 @@ class AccessTest extends TestCase {
];
}
public function groupIDCandidateProvider() {
public static function groupIDCandidateProvider(): array {
return [
['alice', 'alice'],
['b/ob', 'b/ob'],
@ -713,11 +701,8 @@ class AccessTest extends TestCase {
/**
* @dataProvider intUsernameProvider
*
* @param $name
* @param $expected
*/
public function testSanitizeUsername($name, $expected): void {
public function testSanitizeUsername(string $name, ?string $expected): void {
if ($expected === null) {
$this->expectException(\InvalidArgumentException::class);
}
@ -752,7 +737,7 @@ class AccessTest extends TestCase {
->with('detta')
->willReturnOnConsecutiveCalls($offlineUserMock, $regularUserMock);
/** @var UserMapping|MockObject $mapperMock */
/** @var UserMapping&MockObject $mapperMock */
$mapperMock = $this->createMock(UserMapping::class);
$mapperMock->expects($this->any())
->method('getNameByDN')

14
apps/user_ldap/tests/ConfigurationTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2018-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -10,15 +11,14 @@ namespace OCA\User_LDAP\Tests;
use OCA\User_LDAP\Configuration;
class ConfigurationTest extends \Test\TestCase {
/** @var Configuration */
protected $configuration;
protected Configuration $configuration;
protected function setUp(): void {
parent::setUp();
$this->configuration = new Configuration('t01', false);
}
public function configurationDataProvider() {
public static function configurationDataProvider(): array {
$inputWithDN = [
'cn=someUsers,dc=example,dc=org',
' ',
@ -89,12 +89,12 @@ class ConfigurationTest extends \Test\TestCase {
/**
* @dataProvider configurationDataProvider
*/
public function testSetValue($key, $input, $expected): void {
public function testSetValue(string $key, string|array $input, string|array $expected): void {
$this->configuration->setConfiguration([$key => $input]);
$this->assertSame($this->configuration->$key, $expected);
}
public function avatarRuleValueProvider() {
public static function avatarRuleValueProvider(): array {
return [
['none', []],
['data:selfie', ['selfie']],
@ -108,7 +108,7 @@ class ConfigurationTest extends \Test\TestCase {
/**
* @dataProvider avatarRuleValueProvider
*/
public function testGetAvatarAttributes($setting, $expected): void {
public function testGetAvatarAttributes(string $setting, array $expected): void {
$this->configuration->setConfiguration(['ldapUserAvatarRule' => $setting]);
$this->assertSame($expected, $this->configuration->getAvatarAttributes());
}
@ -116,7 +116,7 @@ class ConfigurationTest extends \Test\TestCase {
/**
* @dataProvider avatarRuleValueProvider
*/
public function testResolveRule($setting, $expected): void {
public function testResolveRule(string $setting, array $expected): void {
$this->configuration->setConfiguration(['ldapUserAvatarRule' => $setting]);
// so far the only thing that can get resolved :)
$this->assertSame($expected, $this->configuration->resolveRule('avatar'));

13
apps/user_ldap/tests/ConnectionTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -10,6 +11,7 @@ namespace OCA\User_LDAP\Tests;
use OC\ServerNotAvailableException;
use OCA\User_LDAP\Connection;
use OCA\User_LDAP\ILDAPWrapper;
use PHPUnit\Framework\MockObject\MockObject;
/**
* Class Test_Connection
@ -19,19 +21,16 @@ use OCA\User_LDAP\ILDAPWrapper;
* @package OCA\User_LDAP\Tests
*/
class ConnectionTest extends \Test\TestCase {
/** @var ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject */
protected $ldap;
/** @var Connection */
protected $connection;
protected ILDAPWrapper&MockObject $ldap;
protected Connection $connection;
protected function setUp(): void {
parent::setUp();
$this->ldap = $this->createMock(ILDAPWrapper::class);
// we use a mock here to replace the cache mechanism, due to missing DI in LDAP backend.
$this->connection = $this->getMockBuilder('OCA\User_LDAP\Connection')
->setMethods(['getFromCache', 'writeToCache'])
$this->connection = $this->getMockBuilder(Connection::class)
->onlyMethods(['getFromCache', 'writeToCache'])
->setConstructorArgs([$this->ldap, '', null])
->getMock();

40
apps/user_ldap/tests/GroupLDAPPluginTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -9,27 +11,23 @@ use OCA\User_LDAP\GroupPluginManager;
use OCP\GroupInterface;
class GroupLDAPPluginTest extends \Test\TestCase {
/**
* @return GroupPluginManager
*/
private function getGroupPluginManager() {
private function getGroupPluginManager(): GroupPluginManager {
return new GroupPluginManager();
}
public function testImplementsActions(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions'])
->getMock();
$plugin->expects($this->any())
->method('respondToActions')
->willReturn(GroupInterface::CREATE_GROUP);
$plugin2 = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions'])
$plugin2 = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions'])
->getMock();
$plugin2->expects($this->any())
@ -47,8 +45,8 @@ class GroupLDAPPluginTest extends \Test\TestCase {
public function testCreateGroup(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions', 'createGroup'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions', 'createGroup'])
->getMock();
$plugin->expects($this->any())
@ -77,8 +75,8 @@ class GroupLDAPPluginTest extends \Test\TestCase {
public function testDeleteGroup(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions', 'deleteGroup'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions', 'deleteGroup'])
->getMock();
$plugin->expects($this->any())
@ -107,8 +105,8 @@ class GroupLDAPPluginTest extends \Test\TestCase {
public function testAddToGroup(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions', 'addToGroup'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions', 'addToGroup'])
->getMock();
$plugin->expects($this->any())
@ -138,8 +136,8 @@ class GroupLDAPPluginTest extends \Test\TestCase {
public function testRemoveFromGroup(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions', 'removeFromGroup'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions', 'removeFromGroup'])
->getMock();
$plugin->expects($this->any())
@ -169,8 +167,8 @@ class GroupLDAPPluginTest extends \Test\TestCase {
public function testCountUsersInGroup(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions', 'countUsersInGroup'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions', 'countUsersInGroup'])
->getMock();
$plugin->expects($this->any())
@ -200,8 +198,8 @@ class GroupLDAPPluginTest extends \Test\TestCase {
public function testgetGroupDetails(): void {
$pluginManager = $this->getGroupPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPGroupPluginDummy')
->setMethods(['respondToActions', 'getGroupDetails'])
$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
->onlyMethods(['respondToActions', 'getGroupDetails'])
->getMock();
$plugin->expects($this->any())

85
apps/user_ldap/tests/Group_LDAPTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -34,10 +35,10 @@ use Test\TestCase;
* @package OCA\User_LDAP\Tests
*/
class Group_LDAPTest extends TestCase {
private MockObject|Access $access;
private MockObject|GroupPluginManager $pluginManager;
private MockObject|IConfig $config;
private MockObject|IUserManager $ncUserManager;
private Access&MockObject $access;
private GroupPluginManager&MockObject $pluginManager;
private IConfig&MockObject $config;
private IUserManager&MockObject $ncUserManager;
private GroupLDAP $groupBackend;
public function setUp(): void {
@ -96,30 +97,19 @@ class Group_LDAPTest extends TestCase {
* @return MockObject|Access
*/
private function getAccessMock() {
static $conMethods;
static $accMethods;
if (is_null($conMethods) || is_null($accMethods)) {
$conMethods = get_class_methods(Connection::class);
$accMethods = get_class_methods(Access::class);
}
$lw = $this->createMock(ILDAPWrapper::class);
$connector = $this->getMockBuilder(Connection::class)
->setMethods($conMethods)
->setConstructorArgs([$lw, '', null])
->getMock();
$this->access = $this->createMock(Access::class);
$this->access->connection = $connector;
$this->access->userManager = $this->createMock(Manager::class);
return $this->access;
}
private function enableGroups() {
private function enableGroups(): void {
$this->access->connection->expects($this->any())
->method('__get')
->willReturnCallback(function ($name) {
@ -179,7 +169,7 @@ class Group_LDAPTest extends TestCase {
public function testCountUsersWithPlugin(): void {
/** @var GroupPluginManager|MockObject $pluginManager */
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'countUsersInGroup'])
->onlyMethods(['implementsActions', 'countUsersInGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -470,7 +460,7 @@ class Group_LDAPTest extends TestCase {
$this->groupBackend->inGroup($uid, $gid);
}
public function groupWithMembersProvider() {
public static function groupWithMembersProvider(): array {
return [
[
'someGroup',
@ -574,7 +564,7 @@ class Group_LDAPTest extends TestCase {
$memberUids = [];
$userRecords = [];
foreach ($memberDNs as $dn) {
$memberUids[] = ldap_explode_dn($dn, false)[0];
$memberUids[] = ldap_explode_dn($dn, 0)[0];
$userRecords[] = ['dn' => [$dn]];
}
@ -876,8 +866,8 @@ class Group_LDAPTest extends TestCase {
$this->initBackend();
$returnedGroups = $this->groupBackend->getUserGroups('userX');
$this->assertCount(2, $returnedGroups);
$this->assertTrue(in_array('groupB', $returnedGroups));
$this->assertTrue(in_array('groupF', $returnedGroups));
$this->assertContains('groupB', $returnedGroups);
$this->assertContains('groupF', $returnedGroups);
}
/**
@ -903,8 +893,8 @@ class Group_LDAPTest extends TestCase {
$this->initBackend();
$returnedGroups = $this->groupBackend->getUserGroups('userX');
$this->assertCount(2, $returnedGroups);
$this->assertTrue(in_array('groupB', $returnedGroups));
$this->assertTrue(in_array('groupF', $returnedGroups));
$this->assertContains('groupB', $returnedGroups);
$this->assertContains('groupF', $returnedGroups);
}
public function testGetUserGroupsUnrecognizedOfflineUser(): void {
@ -946,11 +936,11 @@ class Group_LDAPTest extends TestCase {
$this->initBackend();
$returnedGroups = $this->groupBackend->getUserGroups('userX');
$this->assertCount(2, $returnedGroups);
$this->assertTrue(in_array('groupB', $returnedGroups));
$this->assertTrue(in_array('groupF', $returnedGroups));
$this->assertContains('groupB', $returnedGroups);
$this->assertContains('groupF', $returnedGroups);
}
public function nestedGroupsProvider(): array {
public static function nestedGroupsProvider(): array {
return [
[true],
[false],
@ -1076,7 +1066,7 @@ class Group_LDAPTest extends TestCase {
public function testCreateGroupWithPlugin(): void {
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'createGroup'])
->onlyMethods(['implementsActions', 'createGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1090,7 +1080,7 @@ class Group_LDAPTest extends TestCase {
->willReturn('result');
$this->initBackend();
$this->assertEquals($this->groupBackend->createGroup('gid'), true);
$this->assertTrue($this->groupBackend->createGroup('gid'));
}
@ -1098,7 +1088,7 @@ class Group_LDAPTest extends TestCase {
$this->expectException(\Exception::class);
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'createGroup'])
->onlyMethods(['implementsActions', 'createGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1112,7 +1102,7 @@ class Group_LDAPTest extends TestCase {
public function testDeleteGroupWithPlugin(): void {
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'deleteGroup'])
->onlyMethods(['implementsActions', 'deleteGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1126,7 +1116,7 @@ class Group_LDAPTest extends TestCase {
->willReturn(true);
$mapper = $this->getMockBuilder(GroupMapping::class)
->setMethods(['unmap'])
->onlyMethods(['unmap'])
->disableOriginalConstructor()
->getMock();
@ -1143,7 +1133,7 @@ class Group_LDAPTest extends TestCase {
$this->expectException(\Exception::class);
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'deleteGroup'])
->onlyMethods(['implementsActions', 'deleteGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1157,7 +1147,7 @@ class Group_LDAPTest extends TestCase {
public function testAddToGroupWithPlugin(): void {
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'addToGroup'])
->onlyMethods(['implementsActions', 'addToGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1171,7 +1161,7 @@ class Group_LDAPTest extends TestCase {
->willReturn('result');
$this->initBackend();
$this->assertEquals($this->groupBackend->addToGroup('uid', 'gid'), 'result');
$this->assertEquals('result', $this->groupBackend->addToGroup('uid', 'gid'));
}
@ -1179,7 +1169,7 @@ class Group_LDAPTest extends TestCase {
$this->expectException(\Exception::class);
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'addToGroup'])
->onlyMethods(['implementsActions', 'addToGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1193,7 +1183,7 @@ class Group_LDAPTest extends TestCase {
public function testRemoveFromGroupWithPlugin(): void {
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'removeFromGroup'])
->onlyMethods(['implementsActions', 'removeFromGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1207,7 +1197,7 @@ class Group_LDAPTest extends TestCase {
->willReturn('result');
$this->initBackend();
$this->assertEquals($this->groupBackend->removeFromGroup('uid', 'gid'), 'result');
$this->assertEquals('result', $this->groupBackend->removeFromGroup('uid', 'gid'));
}
@ -1215,7 +1205,7 @@ class Group_LDAPTest extends TestCase {
$this->expectException(\Exception::class);
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'removeFromGroup'])
->onlyMethods(['implementsActions', 'removeFromGroup'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1230,7 +1220,7 @@ class Group_LDAPTest extends TestCase {
public function testGetGroupDetailsWithPlugin(): void {
/** @var GroupPluginManager|MockObject $pluginManager */
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'getGroupDetails'])
->onlyMethods(['implementsActions', 'getGroupDetails'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1244,14 +1234,14 @@ class Group_LDAPTest extends TestCase {
->willReturn('result');
$this->initBackend();
$this->assertEquals($this->groupBackend->getGroupDetails('gid'), 'result');
$this->assertEquals('result', $this->groupBackend->getGroupDetails('gid'));
}
public function testGetGroupDetailsFailing(): void {
$this->expectException(\Exception::class);
$this->pluginManager = $this->getMockBuilder(GroupPluginManager::class)
->setMethods(['implementsActions', 'getGroupDetails'])
->onlyMethods(['implementsActions', 'getGroupDetails'])
->getMock();
$this->pluginManager->expects($this->once())
@ -1263,7 +1253,7 @@ class Group_LDAPTest extends TestCase {
$this->groupBackend->getGroupDetails('gid');
}
public function groupMemberProvider() {
public static function groupMemberProvider(): array {
$base = 'dc=species,dc=earth';
$birdsDn = [
@ -1332,10 +1322,9 @@ class Group_LDAPTest extends TestCase {
}
/**
* @param string[] $expectedMembers
* @dataProvider groupMemberProvider
*/
public function testGroupMembers(array $expectedResult, ?array $groupsInfo = null): void {
public function testGroupMembers(array $expectedResult, array $groupsInfo): void {
$this->access->expects($this->any())
->method('readAttribute')
->willReturnCallback(function ($group) use ($groupsInfo) {
@ -1360,11 +1349,13 @@ class Group_LDAPTest extends TestCase {
foreach ($expectedResult as $groupDN => $expectedMembers) {
$resultingMembers = $this->invokePrivate($this->groupBackend, '_groupMembers', [$groupDN]);
$this->assertEqualsCanonicalizing($expectedMembers, $resultingMembers);
sort($expectedMembers);
sort($resultingMembers);
$this->assertEquals($expectedMembers, $resultingMembers);
}
}
public function displayNameProvider() {
public static function displayNameProvider(): array {
return [
['Graphic Novelists', ['Graphic Novelists']],
['', false],
@ -1374,7 +1365,7 @@ class Group_LDAPTest extends TestCase {
/**
* @dataProvider displayNameProvider
*/
public function testGetDisplayName(string $expected, $ldapResult): void {
public function testGetDisplayName(string $expected, bool|array $ldapResult): void {
$gid = 'graphic_novelists';
$this->access->expects($this->atLeastOnce())

10
apps/user_ldap/tests/HelperTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -9,17 +11,15 @@ use OCA\User_LDAP\Helper;
use OCP\IConfig;
use OCP\IDBConnection;
use OCP\Server;
use PHPUnit\Framework\MockObject\MockObject;
/**
* @group DB
*/
class HelperTest extends \Test\TestCase {
private IConfig&MockObject $config;
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
private $config;
/** @var Helper */
private $helper;
private Helper $helper;
protected function setUp(): void {
parent::setUp();

2
apps/user_ldap/tests/Integration/Lib/IntegrationTestAttributeDetection.php
View file

@ -3,7 +3,7 @@
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
namespace OCA\user_ldap\tests\Integration\Lib;
namespace OCA\User_LDAP\Tests\Integration\Lib;
use OCA\User_LDAP\Group_LDAP;
use OCA\User_LDAP\GroupPluginManager;

9
apps/user_ldap/tests/Jobs/CleanUpTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -18,13 +19,11 @@ use OCP\IDBConnection;
use Test\TestCase;
class CleanUpTest extends TestCase {
/** @var CleanUp */
protected $bgJob;
/** @var array */
protected $mocks;
protected CleanUp $bgJob;
protected array $mocks;
public function setUp(): void {
parent::setUp();
$this->createMocks();
$this->bgJob = new CleanUp($this->mocks['timeFactory'], $this->mocks['userBackend'], $this->mocks['deletedUsersIndex']);
$this->bgJob->setArguments($this->mocks);

101
apps/user_ldap/tests/Jobs/SyncTest.php
View file

@ -1,4 +1,5 @@
<?php
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -26,32 +27,23 @@ use PHPUnit\Framework\MockObject\MockObject;
use Psr\Log\LoggerInterface;
use Test\TestCase;
/**
* @group DB
*/
class SyncTest extends TestCase {
/** @var array */
protected $arguments;
/** @var Helper|MockObject */
protected $helper;
/** @var LDAP|MockObject */
protected $ldapWrapper;
/** @var Manager|MockObject */
protected $userManager;
/** @var UserMapping|MockObject */
protected $mapper;
protected Helper&MockObject $helper;
protected LDAP&MockObject $ldapWrapper;
protected Manager&MockObject $userManager;
protected UserMapping&MockObject $mapper;
protected IConfig&MockObject $config;
protected IAvatarManager&MockObject $avatarManager;
protected IDBConnection&MockObject $dbc;
protected IUserManager&MockObject $ncUserManager;
protected IManager&MockObject $notificationManager;
protected ConnectionFactory&MockObject $connectionFactory;
protected AccessFactory&MockObject $accessFactory;
protected array $arguments = [];
protected Sync $sync;
/** @var IConfig|MockObject */
protected $config;
/** @var IAvatarManager|MockObject */
protected $avatarManager;
/** @var IDBConnection|MockObject */
protected $dbc;
/** @var IUserManager|MockObject */
protected $ncUserManager;
/** @var IManager|MockObject */
protected $notificationManager;
/** @var ConnectionFactory|MockObject */
protected $connectionFactory;
/** @var AccessFactory|MockObject */
protected $accessFactory;
protected function setUp(): void {
parent::setUp();
@ -65,7 +57,11 @@ class SyncTest extends TestCase {
$this->dbc = $this->createMock(IDBConnection::class);
$this->ncUserManager = $this->createMock(IUserManager::class);
$this->notificationManager = $this->createMock(IManager::class);
$this->connectionFactory = $this->createMock(ConnectionFactory::class);
$this->connectionFactory = $this->getMockBuilder(ConnectionFactory::class)
->setConstructorArgs([
$this->ldapWrapper,
])
->getMock();
$this->accessFactory = $this->createMock(AccessFactory::class);
$this->sync = new Sync(
@ -86,7 +82,7 @@ class SyncTest extends TestCase {
$this->sync->overwritePropertiesForTest($this->ldapWrapper);
}
public function intervalDataProvider(): array {
public static function intervalDataProvider(): array {
return [
[
0, 1000, 750
@ -139,7 +135,7 @@ class SyncTest extends TestCase {
$this->sync->updateInterval();
}
public function moreResultsProvider() {
public static function moreResultsProvider(): array {
return [
[ 3, 3, true ],
[ 3, 5, true ],
@ -153,7 +149,11 @@ class SyncTest extends TestCase {
* @dataProvider moreResultsProvider
*/
public function testMoreResults($pagingSize, $results, $expected): void {
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([
$this->ldapWrapper,
])
->getMock();
$this->connectionFactory->expects($this->any())
->method('get')
->willReturn($connection);
@ -166,7 +166,7 @@ class SyncTest extends TestCase {
return null;
});
/** @var Access|MockObject $access */
/** @var Access&MockObject $access */
$access = $this->createMock(Access::class);
$this->accessFactory->expects($this->any())
->method('get')
@ -191,7 +191,7 @@ class SyncTest extends TestCase {
$this->assertSame($expected, $hasMoreResults);
}
public function cycleDataProvider() {
public static function cycleDataProvider(): array {
$lastCycle = ['prefix' => 's01', 'offset' => 1000];
$lastCycle2 = ['prefix' => '', 'offset' => 1000];
return [
@ -207,19 +207,23 @@ class SyncTest extends TestCase {
/**
* @dataProvider cycleDataProvider
*/
public function testDetermineNextCycle($cycleData, $prefixes, $expectedCycle): void {
public function testDetermineNextCycle(?array $cycleData, array $prefixes, ?array $expectedCycle): void {
$this->helper->expects($this->any())
->method('getServerConfigurationPrefixes')
->with(true)
->willReturn($prefixes);
if (is_array($expectedCycle)) {
$calls = [
['user_ldap', 'background_sync_prefix', $expectedCycle['prefix']],
['user_ldap', 'background_sync_offset', $expectedCycle['offset']],
];
$this->config->expects($this->exactly(2))
->method('setAppValue')
->withConsecutive(
['user_ldap', 'background_sync_prefix', $expectedCycle['prefix']],
['user_ldap', 'background_sync_offset', $expectedCycle['offset']]
);
->willReturnCallback(function () use (&$calls) {
$expected = array_shift($calls);
$this->assertEquals($expected, func_get_args());
});
} else {
$this->config->expects($this->never())
->method('setAppValue');
@ -248,7 +252,7 @@ class SyncTest extends TestCase {
$this->assertFalse($this->sync->qualifiesToRun($cycleData));
}
public function runDataProvider(): array {
public static function runDataProvider(): array {
return [
#0 - one LDAP server, reset
[[
@ -283,7 +287,7 @@ class SyncTest extends TestCase {
/**
* @dataProvider runDataProvider
*/
public function testRun($runData): void {
public function testRun(array $runData): void {
$this->config->expects($this->any())
->method('getAppValue')
->willReturnCallback(function ($app, $key, $default) use ($runData) {
@ -310,13 +314,18 @@ class SyncTest extends TestCase {
return $default;
});
$calls = [
['user_ldap', 'background_sync_prefix', $runData['expectedNextCycle']['prefix']],
['user_ldap', 'background_sync_offset', $runData['expectedNextCycle']['offset']],
['user_ldap', 'background_sync_interval', '43200'],
];
$this->config->expects($this->exactly(3))
->method('setAppValue')
->withConsecutive(
['user_ldap', 'background_sync_prefix', $runData['expectedNextCycle']['prefix']],
['user_ldap', 'background_sync_offset', $runData['expectedNextCycle']['offset']],
['user_ldap', 'background_sync_interval', $this->anything()]
);
->willReturnCallback(function () use (&$calls) {
$expected = array_shift($calls);
$this->assertEquals($expected, func_get_args());
});
$this->config->expects($this->any())
->method('getAppKeys')
->with('user_ldap')
@ -327,7 +336,11 @@ class SyncTest extends TestCase {
->with(true)
->willReturn($runData['prefixes']);
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([
$this->ldapWrapper,
])
->getMock();
$this->connectionFactory->expects($this->any())
->method('get')
->willReturn($connection);
@ -340,7 +353,7 @@ class SyncTest extends TestCase {
return null;
});
/** @var Access|MockObject $access */
/** @var Access&MockObject $access */
$access = $this->createMock(Access::class);
$this->accessFactory->expects($this->any())
->method('get')

2
apps/user_ldap/tests/LDAPGroupPluginDummy.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later

308
apps/user_ldap/tests/LDAPProviderTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -12,6 +14,7 @@ use OCA\User_LDAP\Connection;
use OCA\User_LDAP\Group_LDAP;
use OCA\User_LDAP\Helper;
use OCA\User_LDAP\IGroupLDAP;
use OCA\User_LDAP\ILDAPWrapper;
use OCA\User_LDAP\IUserLDAP;
use OCA\User_LDAP\LDAPProviderFactory;
use OCA\User_LDAP\User_LDAP;
@ -31,13 +34,9 @@ use Psr\Log\LoggerInterface;
* @package OCA\User_LDAP\Tests
*/
class LDAPProviderTest extends \Test\TestCase {
protected function setUp(): void {
parent::setUp();
}
private function getServerMock(IUserLDAP $userBackend, IGroupLDAP $groupBackend) {
$server = $this->getMockBuilder('OC\Server')
->setMethods(['getUserManager', 'getBackends', 'getGroupManager'])
->onlyMethods(['getUserManager', 'getGroupManager'])
->setConstructorArgs(['', new Config(\OC::$configDir)])
->getMock();
$server->expects($this->any())
@ -46,16 +45,13 @@ class LDAPProviderTest extends \Test\TestCase {
$server->expects($this->any())
->method('getGroupManager')
->willReturn($this->getGroupManagerMock($groupBackend));
$server->expects($this->any())
->method($this->anything())
->willReturnSelf();
return $server;
}
private function getUserManagerMock(IUserLDAP $userBackend) {
$userManager = $this->getMockBuilder(Manager::class)
->setMethods(['getBackends'])
->onlyMethods(['getBackends'])
->setConstructorArgs([
$this->createMock(IConfig::class),
$this->createMock(ICacheFactory::class),
@ -71,7 +67,7 @@ class LDAPProviderTest extends \Test\TestCase {
private function getGroupManagerMock(IGroupLDAP $groupBackend) {
$groupManager = $this->getMockBuilder('OC\Group\Manager')
->setMethods(['getBackends'])
->onlyMethods(['getBackends'])
->disableOriginalConstructor()
->getMock();
$groupManager->expects($this->any())
@ -98,8 +94,8 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
@ -110,20 +106,25 @@ class LDAPProviderTest extends \Test\TestCase {
$ldapProvider->getUserDN('nonexisting_user');
}
public function testGetUserDN(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'username2dn'])
$userAccess = $this->getMockBuilder(Access::class)
->onlyMethods(['username2dn'])
->disableOriginalConstructor()
->getMock();
$userAccess->expects($this->once())
->method('username2dn')
->willReturn('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->once())
->method('userExists')
->willReturn(true);
$userBackend->expects($this->once())
->method('username2dn')
->willReturn('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
$userBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($userAccess);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -137,12 +138,9 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('Group id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->disableOriginalConstructor()
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists'])
$userBackend = $this->createMock(User_LDAP::class);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists'])
->disableOriginalConstructor()
->getMock();
@ -155,25 +153,23 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetGroupDN(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'username2dn'])
->disableOriginalConstructor()
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists', 'getLDAPAccess', 'groupname2dn'])
$userBackend = $this->createMock(User_LDAP::class);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$groupAccess = $this->createMock(Access::class);
$groupAccess->expects($this->once())
->method('groupname2dn')
->willReturn('cn=existing_group,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
$groupBackend->expects($this->once())
->method('groupExists')
->willReturn(true);
$groupBackend->expects($this->once())
->method('groupname2dn')
->willReturn('cn=existing_group,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
$groupBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($groupAccess);
$server = $this->getServerMock($userBackend, $groupBackend);
@ -183,8 +179,8 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetUserName(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['dn2UserName'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['dn2UserName'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())
@ -199,10 +195,7 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testDNasBaseParameter(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods([])
->disableOriginalConstructor()
->getMock();
$userBackend = $this->createMock(User_LDAP::class);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -215,10 +208,7 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testSanitizeDN(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods([])
->disableOriginalConstructor()
->getMock();
$userBackend = $this->createMock(User_LDAP::class);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -235,10 +225,7 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend = $this->createMock(User_LDAP::class);
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -248,8 +235,8 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetLDAPConnection(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getNewLDAPConnection'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getNewLDAPConnection'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())
@ -271,12 +258,9 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('Group id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->disableOriginalConstructor()
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists'])
$userBackend = $this->createMock(User_LDAP::class);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists'])
->disableOriginalConstructor()
->getMock();
@ -289,12 +273,9 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetGroupLDAPConnection(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->disableOriginalConstructor()
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists','getNewLDAPConnection'])
$userBackend = $this->createMock(User_LDAP::class);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists','getNewLDAPConnection'])
->disableOriginalConstructor()
->getMock();
@ -318,8 +299,8 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
@ -337,7 +318,9 @@ class LDAPProviderTest extends \Test\TestCase {
];
$dn = 'uid=malik,' . $bases[1];
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects($this->any())
->method('__get')
->willReturnCallback(function ($key) use ($bases) {
@ -359,8 +342,8 @@ class LDAPProviderTest extends \Test\TestCase {
->method('username2dn')
->willReturn($dn);
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'getConnection', 'getConfiguration'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->atLeastOnce())
@ -381,8 +364,8 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
@ -399,7 +382,9 @@ class LDAPProviderTest extends \Test\TestCase {
'ou=groups,ou=barfoo,dc=example,dc=org',
];
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects($this->any())
->method('__get')
->willReturnCallback(function ($key) use ($bases) {
@ -415,8 +400,8 @@ class LDAPProviderTest extends \Test\TestCase {
->method('getConnection')
->willReturn($connection);
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'getConnection', 'getConfiguration'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())
@ -437,8 +422,8 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
@ -450,19 +435,25 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testClearCache(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'getConnection', 'clearCache'])
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects($this->once())
->method('clearCache')
->willReturn(true);
$access = $this->createMock(Access::class);
$access->method('getConnection')
->willReturn($connection);
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->once())
->method('userExists')
->willReturn(true);
$userBackend->expects($this->once())
->method('clearCache')
->willReturn(true);
$userBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($access);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -476,11 +467,11 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('Group id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
$userBackend = $this->getMockBuilder(User_LDAP::class)
->disableOriginalConstructor()
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists'])
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists'])
->disableOriginalConstructor()
->getMock();
$groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
@ -492,22 +483,26 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testClearGroupCache(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->disableOriginalConstructor()
$userBackend = $this->createMock(User_LDAP::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists', 'getLDAPAccess', 'getConnection', 'clearCache'])
$connection->expects($this->once())
->method('clearCache')
->willReturn(true);
$access = $this->createMock(Access::class);
$access->method('getConnection')
->willReturn($connection);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$groupBackend->expects($this->once())
->method('groupExists')
->willReturn(true);
$groupBackend->expects($this->once())
->method('clearCache')
->willReturn(true);
$groupBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($access);
$server = $this->getServerMock($userBackend, $groupBackend);
@ -517,8 +512,8 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testDnExists(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['dn2UserName'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['dn2UserName'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())
@ -532,11 +527,7 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testFlagRecord(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods([])
->disableOriginalConstructor()
->getMock();
$userBackend = $this->createMock(User_LDAP::class);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
$ldapProvider = $this->getLDAPProvider($server);
@ -545,11 +536,7 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testUnflagRecord(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods([])
->disableOriginalConstructor()
->getMock();
$userBackend = $this->createMock(User_LDAP::class);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
$ldapProvider = $this->getLDAPProvider($server);
@ -562,8 +549,8 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
@ -575,19 +562,25 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetLDAPDisplayNameField(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'getConnection', 'getConfiguration'])
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects($this->once())
->method('getConfiguration')
->willReturn(['ldap_display_name' => 'displayName']);
$access = $this->createMock(Access::class);
$access->method('getConnection')
->willReturn($connection);
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->once())
->method('userExists')
->willReturn(true);
$userBackend->expects($this->once())
->method('getConfiguration')
->willReturn(['ldap_display_name' => 'displayName']);
$userBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($access);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -600,8 +593,8 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('User id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists'])
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->any())->method('userExists')->willReturn(false);
@ -613,19 +606,25 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetLDAPEmailField(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->setMethods(['userExists', 'getLDAPAccess', 'getConnection', 'getConfiguration'])
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects($this->once())
->method('getConfiguration')
->willReturn(['ldap_email_attr' => 'mail']);
$access = $this->createMock(Access::class);
$access->method('getConnection')
->willReturn($connection);
$userBackend = $this->getMockBuilder(User_LDAP::class)
->onlyMethods(['userExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
$userBackend->expects($this->once())
->method('userExists')
->willReturn(true);
$userBackend->expects($this->once())
->method('getConfiguration')
->willReturn(['ldap_email_attr' => 'mail']);
$userBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($access);
$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
@ -638,16 +637,15 @@ class LDAPProviderTest extends \Test\TestCase {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('Group id not found in LDAP');
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
$userBackend = $this->createMock(User_LDAP::class);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists'])
->disableOriginalConstructor()
->getMock();
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists'])
->disableOriginalConstructor()
->getMock();
$groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
$groupBackend->expects($this->any())
->method('groupExists')
->willReturn(false);
$server = $this->getServerMock($userBackend, $groupBackend);
@ -656,12 +654,19 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testgetLDAPGroupMemberAssoc(): void {
$userBackend = $this->getMockBuilder('OCA\User_LDAP\User_LDAP')
->disableOriginalConstructor()
->getMock();
$userBackend = $this->createMock(User_LDAP::class);
$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
->setMethods(['groupExists', 'getLDAPAccess', 'getConnection', 'getConfiguration'])
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects($this->once())
->method('getConfiguration')
->willReturn(['ldap_group_member_assoc_attribute' => 'assoc_type']);
$access = $this->createMock(Access::class);
$access->method('getConnection')
->willReturn($connection);
$groupBackend = $this->getMockBuilder(Group_LDAP::class)
->onlyMethods(['groupExists', 'getLDAPAccess'])
->disableOriginalConstructor()
->getMock();
@ -669,11 +674,8 @@ class LDAPProviderTest extends \Test\TestCase {
->method('groupExists')
->willReturn(true);
$groupBackend->expects($this->any())
->method('getConfiguration')
->willReturn(['ldap_group_member_assoc_attribute' => 'assoc_type']);
$groupBackend->expects($this->any())
->method($this->anything())
->willReturnSelf();
->method('getLDAPAccess')
->willReturn($access);
$server = $this->getServerMock($userBackend, $groupBackend);
@ -698,7 +700,9 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetMultiValueUserAttributeCacheHit(): void {
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects(self::once())
->method('getFromCache')
->with('admin-mailAlias')
@ -723,7 +727,9 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetMultiValueUserAttributeLdapError(): void {
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects(self::once())
->method('getFromCache')
->with('admin-mailAlias')
@ -760,7 +766,9 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetMultiValueUserAttribute(): void {
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects(self::once())
->method('getFromCache')
->with('admin-mailAlias')
@ -797,7 +805,9 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetUserAttributeLdapError(): void {
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects(self::once())
->method('getFromCache')
->with('admin-mailAlias')
@ -834,7 +844,9 @@ class LDAPProviderTest extends \Test\TestCase {
}
public function testGetUserAttribute(): void {
$connection = $this->createMock(Connection::class);
$connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$connection->expects(self::once())
->method('getFromCache')
->with('admin-mailAlias')

12
apps/user_ldap/tests/LDAPTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -6,20 +8,20 @@
namespace OCA\User_LDAP\Tests;
use OCA\User_LDAP\LDAP;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
class LDAPTest extends TestCase {
/** @var LDAP|\PHPUnit\Framework\MockObject\MockObject */
private $ldap;
private LDAP&MockObject $ldap;
protected function setUp(): void {
parent::setUp();
$this->ldap = $this->getMockBuilder(LDAP::class)
->setMethods(['invokeLDAPMethod'])
->onlyMethods(['invokeLDAPMethod'])
->getMock();
}
public function errorProvider() {
public static function errorProvider(): array {
return [
[
'ldap_search(): Partial search results returned: Sizelimit exceeded at /srv/http/nextcloud/master/apps/user_ldap/lib/LDAP.php#292',
@ -32,8 +34,6 @@ class LDAPTest extends TestCase {
}
/**
* @param string $errorMessage
* @param bool $passThrough
* @dataProvider errorProvider
*/
public function testSearchWithErrorHandler(string $errorMessage, bool $passThrough): void {

10
apps/user_ldap/tests/LDAPUserPluginDummy.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -39,4 +41,12 @@ class LDAPUserPluginDummy implements ILDAPUserPlugin {
public function countUsers() {
return null;
}
public function canDeleteUser() {
return true;
}
public function deleteUser($uid) {
return null;
}
}

33
apps/user_ldap/tests/Mapping/AbstractMappingTest.php → apps/user_ldap/tests/Mapping/AbstractMappingTestCase.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -11,7 +12,7 @@ use OCA\User_LDAP\Mapping\AbstractMapping;
use OCP\IDBConnection;
use OCP\Server;
abstract class AbstractMappingTest extends \Test\TestCase {
abstract class AbstractMappingTestCase extends \Test\TestCase {
abstract public function getMapper(IDBConnection $dbMock);
/**
@ -29,8 +30,8 @@ abstract class AbstractMappingTest extends \Test\TestCase {
* returns an array of test entries with dn, name and uuid as keys
* @return array
*/
protected function getTestData() {
$data = [
protected static function getTestData(): array {
return [
[
'dn' => 'uid=foobar,dc=example,dc=org',
'name' => 'Foobar',
@ -47,8 +48,6 @@ abstract class AbstractMappingTest extends \Test\TestCase {
'uuid' => '3333-CCCC-1234-CDEF',
]
];
return $data;
}
/**
@ -56,7 +55,7 @@ abstract class AbstractMappingTest extends \Test\TestCase {
* @param AbstractMapping $mapper
* @param array $data
*/
protected function mapEntries($mapper, $data) {
protected function mapEntries(AbstractMapping $mapper, array $data): void {
foreach ($data as $entry) {
$done = $mapper->map($entry['dn'], $entry['name'], $entry['uuid']);
$this->assertTrue($done);
@ -70,7 +69,7 @@ abstract class AbstractMappingTest extends \Test\TestCase {
* @return array 0 = \OCA\User_LDAP\Mapping\AbstractMapping, 1 = array of
* users or groups
*/
private function initTest() {
private function initTest(): array {
$dbc = Server::get(IDBConnection::class);
$mapper = $this->getMapper($dbc);
$data = $this->getTestData();
@ -157,13 +156,13 @@ abstract class AbstractMappingTest extends \Test\TestCase {
[$mapper,] = $this->initTest();
$names = $mapper->getNamesBySearch('oo', '%', '%');
$this->assertTrue(is_array($names));
$this->assertIsArray($names);
$this->assertSame(2, count($names));
$this->assertTrue(in_array('Foobar', $names));
$this->assertTrue(in_array('Barfoo', $names));
$this->assertContains('Foobar', $names);
$this->assertContains('Barfoo', $names);
$names = $mapper->getNamesBySearch('nada');
$this->assertTrue(is_array($names));
$this->assertSame(0, count($names));
$this->assertIsArray($names);
$this->assertCount(0, $names);
}
/**
@ -250,20 +249,20 @@ abstract class AbstractMappingTest extends \Test\TestCase {
// get all entries without specifying offset or limit
$results = $mapper->getList();
$this->assertSame(3, count($results));
$this->assertCount(3, $results);
// get all-1 entries by specifying offset, and an high limit
// specifying only offset without limit will not work by underlying lib
$results = $mapper->getList(1, 999);
$this->assertSame(count($data) - 1, count($results));
$this->assertCount(count($data) - 1, $results);
// get first 2 entries by limit, but not offset
$results = $mapper->getList(0, 2);
$this->assertSame(2, count($results));
$this->assertCount(2, $results);
// get 2nd entry by specifying both offset and limit
$results = $mapper->getList(1, 1);
$this->assertSame(1, count($results));
$this->assertCount(1, $results);
}
public function testGetListOfIdsByDn(): void {
@ -282,6 +281,6 @@ abstract class AbstractMappingTest extends \Test\TestCase {
}
$result = $mapper->getListOfIdsByDn($listOfDNs);
$this->assertSame(66640 / 20, count($result));
$this->assertCount(66640 / 20, $result);
}
}

3
apps/user_ldap/tests/Mapping/GroupMappingTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2019-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -17,7 +18,7 @@ use OCP\IDBConnection;
*
* @package OCA\User_LDAP\Tests\Mapping
*/
class GroupMappingTest extends AbstractMappingTest {
class GroupMappingTest extends AbstractMappingTestCase {
public function getMapper(IDBConnection $dbMock) {
return new GroupMapping($dbMock);
}

3
apps/user_ldap/tests/Mapping/UserMappingTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2019-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -18,7 +19,7 @@ use OCP\Support\Subscription\IAssertion;
*
* @package OCA\User_LDAP\Tests\Mapping
*/
class UserMappingTest extends AbstractMappingTest {
class UserMappingTest extends AbstractMappingTestCase {
public function getMapper(IDBConnection $dbMock) {
return new UserMapping($dbMock, $this->createMock(IAssertion::class));
}

39
apps/user_ldap/tests/Migration/AbstractUUIDFixTest.php → apps/user_ldap/tests/Migration/AbstractUUIDFixTestCase.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -13,17 +15,18 @@ use OCA\User_LDAP\Migration\UUIDFix;
use OCA\User_LDAP\Proxy;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\IConfig;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
abstract class AbstractUUIDFixTest extends TestCase {
protected Helper $helper;
protected IConfig $config;
protected LDAP $ldap;
abstract class AbstractUUIDFixTestCase extends TestCase {
protected Helper&MockObject $helper;
protected IConfig&MockObject $config;
protected LDAP&MockObject $ldap;
protected AbstractMapping $mapper;
protected UUIDFix $job;
protected Proxy $proxy;
protected Access $access;
protected ITimeFactory $time;
protected Access&MockObject $access;
protected ITimeFactory&MockObject $time;
protected bool $isUser = true;
protected function setUp(): void {
@ -141,19 +144,23 @@ abstract class AbstractUUIDFixTest extends TestCase {
$this->access->expects($this->exactly(3))
->method('getUUID')
->withConsecutive(
[$args['records'][0]['dn'], $this->isUser],
[$args['records'][1]['dn'], $this->isUser],
[$args['records'][2]['dn'], $this->isUser]
)
->willReturnOnConsecutiveCalls($correctUUIDs[0], $correctUUIDs[1], $correctUUIDs[2]);
->willReturnMap([
[$args['records'][0]['dn'], $this->isUser, null, $correctUUIDs[0]],
[$args['records'][1]['dn'], $this->isUser, null, $correctUUIDs[1]],
[$args['records'][2]['dn'], $this->isUser, null, $correctUUIDs[2]],
]);
$calls = [
[$correctUUIDs[0], $args['records'][0]['dn']],
[$correctUUIDs[2], $args['records'][2]['dn']],
];
$this->mapper->expects($this->exactly(2))
->method('setUUIDbyDN')
->withConsecutive(
[$correctUUIDs[0], $args['records'][0]['dn']],
[$correctUUIDs[2], $args['records'][2]['dn']]
);
->willReturnCallback(function ($i, $j) use (&$calls) {
$expected = array_shift($calls);
$this->assertEquals($expected, func_get_args());
return true;
});
$this->job->run($args);
}

7
apps/user_ldap/tests/Migration/UUIDFixGroupTest.php
View file

@ -1,14 +1,15 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
namespace OCA\Group_LDAP\Tests\Migration;
namespace OCA\User_LDAP\Tests\Migration;
use OCA\User_LDAP\Group_Proxy;
use OCA\User_LDAP\Mapping\GroupMapping;
use OCA\User_LDAP\Migration\UUIDFixGroup;
use OCA\User_LDAP\Tests\Migration\AbstractUUIDFixTest;
/**
* Class UUIDFixGroupTest
@ -16,7 +17,7 @@ use OCA\User_LDAP\Tests\Migration\AbstractUUIDFixTest;
* @package OCA\Group_LDAP\Tests\Migration
* @group DB
*/
class UUIDFixGroupTest extends AbstractUUIDFixTest {
class UUIDFixGroupTest extends AbstractUUIDFixTestCase {
protected function setUp(): void {
$this->isUser = false;
parent::setUp();

48
apps/user_ldap/tests/Migration/UUIDFixInsertTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -11,23 +13,15 @@ use OCA\User_LDAP\Migration\UUIDFixInsert;
use OCP\BackgroundJob\IJobList;
use OCP\IConfig;
use OCP\Migration\IOutput;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
class UUIDFixInsertTest extends TestCase {
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
protected $config;
/** @var UserMapping|\PHPUnit\Framework\MockObject\MockObject */
protected $userMapper;
/** @var GroupMapping|\PHPUnit\Framework\MockObject\MockObject */
protected $groupMapper;
/** @var IJobList|\PHPUnit\Framework\MockObject\MockObject */
protected $jobList;
/** @var UUIDFixInsert */
protected $job;
protected IConfig&MockObject $config;
protected UserMapping&MockObject $userMapper;
protected GroupMapping&MockObject $groupMapper;
protected IJobList&MockObject $jobList;
protected UUIDFixInsert $job;
protected function setUp(): void {
parent::setUp();
@ -48,13 +42,12 @@ class UUIDFixInsertTest extends TestCase {
$this->assertSame('Insert UUIDFix background job for user and group in batches', $this->job->getName());
}
public function recordProvider() {
public static function recordProvider(): array {
$record = [
'dn' => 'cn=somerecord,dc=somewhere',
'name' => 'Something',
'uuid' => 'AB12-3456-CDEF7-8GH9'
];
array_fill(0, 50, $record);
$userBatches = [
0 => array_fill(0, 50, $record),
@ -71,13 +64,12 @@ class UUIDFixInsertTest extends TestCase {
];
}
public function recordProviderTooLongAndNone() {
public static function recordProviderTooLongAndNone(): array {
$record = [
'dn' => 'cn=somerecord,dc=somewhere',
'name' => 'Something',
'uuid' => 'AB12-3456-CDEF7-8GH9'
];
array_fill(0, 50, $record);
$userBatches = [
0 => array_fill(0, 50, $record),
@ -97,7 +89,7 @@ class UUIDFixInsertTest extends TestCase {
/**
* @dataProvider recordProvider
*/
public function testRun($userBatches, $groupBatches): void {
public function testRun(array $userBatches, array $groupBatches): void {
$this->config->expects($this->once())
->method('getAppValue')
->with('user_ldap', 'installed_version', '1.2.1')
@ -105,8 +97,11 @@ class UUIDFixInsertTest extends TestCase {
$this->userMapper->expects($this->exactly(3))
->method('getList')
->withConsecutive([0, 50], [50, 50], [100, 50])
->willReturnOnConsecutiveCalls($userBatches[0], $userBatches[1], $userBatches[2]);
->willReturnMap([
[0, 50, false, $userBatches[0]],
[50, 50, false, $userBatches[1]],
[100, 50, false, $userBatches[2]],
]);
$this->groupMapper->expects($this->exactly(1))
->method('getList')
@ -124,7 +119,7 @@ class UUIDFixInsertTest extends TestCase {
/**
* @dataProvider recordProviderTooLongAndNone
*/
public function testRunWithManyAndNone($userBatches, $groupBatches): void {
public function testRunWithManyAndNone(array $userBatches, array $groupBatches): void {
$this->config->expects($this->once())
->method('getAppValue')
->with('user_ldap', 'installed_version', '1.2.1')
@ -132,8 +127,13 @@ class UUIDFixInsertTest extends TestCase {
$this->userMapper->expects($this->exactly(5))
->method('getList')
->withConsecutive([0, 50], [0, 40], [0, 32], [32, 32], [64, 32])
->willReturnOnConsecutiveCalls($userBatches[0], $userBatches[1], $userBatches[2], $userBatches[3], $userBatches[4]);
->willReturnMap([
[0, 50, false, $userBatches[0]],
[0, 40, false, $userBatches[1]],
[0, 32, false, $userBatches[2]],
[32, 32, false, $userBatches[3]],
[64, 32, false, $userBatches[4]],
]);
$this->groupMapper->expects($this->once())
->method('getList')

4
apps/user_ldap/tests/Migration/UUIDFixUserTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -15,7 +17,7 @@ use OCA\User_LDAP\User_Proxy;
* @package OCA\User_LDAP\Tests\Migration
* @group DB
*/
class UUIDFixUserTest extends AbstractUUIDFixTest {
class UUIDFixUserTest extends AbstractUUIDFixTestCase {
protected function setUp(): void {
$this->isUser = true;
parent::setUp();

5
apps/user_ldap/tests/Service/BirthdateParserServiceTest.php
View file

@ -1,11 +1,12 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
namespace OCA\user_ldap\tests\Service;
namespace OCA\User_LDAP\Tests\Service;
use DateTimeImmutable;
use OCA\User_LDAP\Service\BirthdateParserService;
@ -20,7 +21,7 @@ class BirthdateParserServiceTest extends TestCase {
$this->service = new BirthdateParserService();
}
public function parseBirthdateDataProvider(): array {
public static function parseBirthdateDataProvider(): array {
return [
['2024-01-01', new DateTimeImmutable('2024-01-01'), false],
['20240101', new DateTimeImmutable('2024-01-01'), false],

31
apps/user_ldap/tests/Service/UpdateGroupsServiceTest.php
View file

@ -6,17 +6,15 @@ declare(strict_types=1);
* SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
namespace OCA\user_ldap\tests\Service;
namespace OCA\User_LDAP\Tests\Service;
use OCA\User_LDAP\Db\GroupMembership;
use OCA\User_LDAP\Db\GroupMembershipMapper;
use OCA\User_LDAP\Group_Proxy;
use OCA\User_LDAP\Service\UpdateGroupsService;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Group\Events\UserAddedEvent;
use OCP\Group\Events\UserRemovedEvent;
use OCP\IConfig;
use OCP\IGroup;
use OCP\IGroupManager;
use OCP\IUser;
@ -26,23 +24,12 @@ use Psr\Log\LoggerInterface;
use Test\TestCase;
class UpdateGroupsServiceTest extends TestCase {
/** @var Group_Proxy|MockObject */
protected $groupBackend;
/** @var IEventDispatcher|MockObject */
protected $dispatcher;
/** @var IGroupManager|MockObject */
protected $groupManager;
/** @var IUserManager|MockObject */
protected $userManager;
/** @var LoggerInterface|MockObject */
protected $logger;
/** @var GroupMembershipMapper|MockObject */
protected $groupMembershipMapper;
/** @var IConfig|MockObject */
protected $config;
/** @var ITimeFactory|MockObject */
protected $timeFactory;
protected Group_Proxy&MockObject $groupBackend;
protected IEventDispatcher&MockObject $dispatcher;
protected IGroupManager&MockObject $groupManager;
protected IUserManager&MockObject $userManager;
protected LoggerInterface&MockObject $logger;
protected GroupMembershipMapper&MockObject $groupMembershipMapper;
protected UpdateGroupsService $updateGroupsService;
public function setUp(): void {
@ -52,8 +39,6 @@ class UpdateGroupsServiceTest extends TestCase {
$this->userManager = $this->createMock(IUserManager::class);
$this->logger = $this->createMock(LoggerInterface::class);
$this->groupMembershipMapper = $this->createMock(GroupMembershipMapper::class);
$this->config = $this->createMock(IConfig::class);
$this->timeFactory = $this->createMock(ITimeFactory::class);
$this->updateGroupsService = new UpdateGroupsService(
$this->groupBackend,
@ -62,8 +47,6 @@ class UpdateGroupsServiceTest extends TestCase {
$this->userManager,
$this->logger,
$this->groupMembershipMapper,
$this->config,
$this->timeFactory
);
}

8
apps/user_ldap/tests/Settings/AdminTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -20,13 +22,12 @@ use Test\TestCase;
*/
class AdminTest extends TestCase {
private IL10N&MockObject $l10n;
private ITemplateManager $templateManager;
private Admin $admin;
protected function setUp(): void {
parent::setUp();
$this->l10n = $this->getMockBuilder(IL10N::class)->getMock();
$this->l10n = $this->createMock(IL10N::class);
$this->templateManager = Server::get(ITemplateManager::class);
$this->admin = new Admin(
@ -35,9 +36,6 @@ class AdminTest extends TestCase {
);
}
/**
* @UseDB
*/
public function testGetForm(): void {
$prefixes = ['s01'];
$hosts = ['s01' => ''];

12
apps/user_ldap/tests/Settings/SectionTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -8,15 +10,13 @@ namespace OCA\User_LDAP\Tests\Settings;
use OCA\User_LDAP\Settings\Section;
use OCP\IL10N;
use OCP\IURLGenerator;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
class SectionTest extends TestCase {
/** @var IURLGenerator|\PHPUnit\Framework\MockObject\MockObject */
private $url;
/** @var IL10N|\PHPUnit\Framework\MockObject\MockObject */
private $l;
/** @var Section */
private $section;
private IURLGenerator&MockObject $url;
private IL10N&MockObject $l;
private Section $section;
protected function setUp(): void {
parent::setUp();

21
apps/user_ldap/tests/User/DeletedUsersIndexTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2018 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -11,6 +13,7 @@ use OCP\IConfig;
use OCP\IDBConnection;
use OCP\Server;
use OCP\Share\IManager;
use PHPUnit\Framework\MockObject\MockObject;
/**
* Class DeletedUsersIndexTest
@ -20,19 +23,11 @@ use OCP\Share\IManager;
* @package OCA\User_LDAP\Tests\User
*/
class DeletedUsersIndexTest extends \Test\TestCase {
/** @var DeletedUsersIndex */
protected $dui;
/** @var IConfig */
protected $config;
/** @var IDBConnection */
protected $db;
/** @var UserMapping|\PHPUnit\Framework\MockObject\MockObject */
protected $mapping;
/** @var IManager|\PHPUnit\Framework\MockObject\MockObject */
protected $shareManager;
protected DeletedUsersIndex $dui;
protected IConfig $config;
protected IDBConnection $db;
protected UserMapping&MockObject $mapping;
protected IManager&MockObject $shareManager;
protected function setUp(): void {
parent::setUp();

60
apps/user_ldap/tests/User/ManagerTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -19,6 +20,7 @@ use OCP\Image;
use OCP\IUserManager;
use OCP\Notification\IManager as INotificationManager;
use OCP\Share\IManager;
use PHPUnit\Framework\MockObject\MockObject;
use Psr\Log\LoggerInterface;
/**
@ -29,40 +31,18 @@ use Psr\Log\LoggerInterface;
* @package OCA\User_LDAP\Tests\User
*/
class ManagerTest extends \Test\TestCase {
/** @var Access|\PHPUnit\Framework\MockObject\MockObject */
protected $access;
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
protected $config;
/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
protected $logger;
/** @var IAvatarManager|\PHPUnit\Framework\MockObject\MockObject */
protected $avatarManager;
/** @var Image|\PHPUnit\Framework\MockObject\MockObject */
protected $image;
/** @var IDBConnection|\PHPUnit\Framework\MockObject\MockObject */
protected $dbc;
/** @var IUserManager|\PHPUnit\Framework\MockObject\MockObject */
protected $ncUserManager;
/** @var INotificationManager|\PHPUnit\Framework\MockObject\MockObject */
protected $notificationManager;
/** @var ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject */
protected $ldapWrapper;
/** @var Connection */
protected $connection;
/** @var Manager */
protected $manager;
/** @var IManager|\PHPUnit\Framework\MockObject\MockObject */
protected $shareManager;
protected Access&MockObject $access;
protected IConfig&MockObject $config;
protected LoggerInterface&MockObject $logger;
protected IAvatarManager&MockObject $avatarManager;
protected Image&MockObject $image;
protected IDBConnection&MockObject $dbc;
protected IUserManager&MockObject $ncUserManager;
protected INotificationManager&MockObject $notificationManager;
protected ILDAPWrapper&MockObject $ldapWrapper;
protected Connection $connection;
protected IManager&MockObject $shareManager;
protected Manager $manager;
protected function setUp(): void {
parent::setUp();
@ -97,7 +77,7 @@ class ManagerTest extends \Test\TestCase {
$this->manager->setLdapAccess($this->access);
}
public function dnProvider() {
public static function dnProvider(): array {
return [
['cn=foo,dc=foobar,dc=bar'],
['uid=foo,o=foobar,c=bar'],
@ -197,7 +177,7 @@ class ManagerTest extends \Test\TestCase {
$this->assertNull($user);
}
public function attributeRequestProvider() {
public static function attributeRequestProvider(): array {
return [
[false],
[true],
@ -217,10 +197,10 @@ class ManagerTest extends \Test\TestCase {
$attributes = $this->manager->getAttributes($minimal);
$this->assertTrue(in_array('dn', $attributes));
$this->assertTrue(in_array(strtolower($this->access->getConnection()->ldapEmailAttribute), $attributes));
$this->assertTrue(!in_array($this->access->getConnection()->ldapEmailAttribute, $attributes)); #cases check
$this->assertFalse(in_array('', $attributes));
$this->assertContains('dn', $attributes);
$this->assertContains(strtolower($this->access->getConnection()->ldapEmailAttribute), $attributes);
$this->assertNotContains($this->access->getConnection()->ldapEmailAttribute, $attributes); #cases check
$this->assertNotContains('', $attributes);
$this->assertSame(!$minimal, in_array('jpegphoto', $attributes));
$this->assertSame(!$minimal, in_array('thumbnailphoto', $attributes));
$valueCounts = array_count_values($attributes);

19
apps/user_ldap/tests/User/OfflineUserTest.php
View file

@ -13,20 +13,15 @@ use OCA\User_LDAP\User\OfflineUser;
use OCP\IConfig;
use OCP\Share\IManager;
use OCP\Share\IShare;
use PHPUnit\Framework\MockObject\MockObject;
use Test\TestCase;
class OfflineUserTest extends TestCase {
/** @var OfflineUser */
protected $offlineUser;
/** @var UserMapping|\PHPUnit\Framework\MockObject\MockObject */
protected $mapping;
/** @var string */
protected $uid;
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
protected $config;
/** @var IManager|\PHPUnit\Framework\MockObject\MockObject */
protected $shareManager;
protected UserMapping&MockObject $mapping;
protected string $uid;
protected IConfig&MockObject $config;
protected IManager&MockObject $shareManager;
protected OfflineUser $offlineUser;
public function setUp(): void {
$this->uid = 'deborah';
@ -42,7 +37,7 @@ class OfflineUserTest extends TestCase {
);
}
public function shareOwnerProvider(): array {
public static function shareOwnerProvider(): array {
return [
[[], false],
[[IShare::TYPE_USER], true],

66
apps/user_ldap/tests/User/UserTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -9,6 +10,7 @@ namespace OCA\User_LDAP\Tests\User;
use OCA\User_LDAP\Access;
use OCA\User_LDAP\Connection;
use OCA\User_LDAP\ILDAPWrapper;
use OCA\User_LDAP\User\User;
use OCP\IAvatar;
use OCP\IAvatarManager;
@ -19,6 +21,7 @@ use OCP\IUserManager;
use OCP\Notification\IManager as INotificationManager;
use OCP\Notification\INotification;
use OCP\Util;
use PHPUnit\Framework\MockObject\MockObject;
use Psr\Log\LoggerInterface;
/**
@ -29,33 +32,24 @@ use Psr\Log\LoggerInterface;
* @package OCA\User_LDAP\Tests\User
*/
class UserTest extends \Test\TestCase {
/** @var Access|\PHPUnit\Framework\MockObject\MockObject */
protected $access;
/** @var Connection|\PHPUnit\Framework\MockObject\MockObject */
protected $connection;
/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
protected $config;
/** @var INotificationManager|\PHPUnit\Framework\MockObject\MockObject */
protected $notificationManager;
/** @var IUserManager|\PHPUnit\Framework\MockObject\MockObject */
protected $userManager;
/** @var Image|\PHPUnit\Framework\MockObject\MockObject */
protected $image;
/** @var IAvatarManager|\PHPUnit\Framework\MockObject\MockObject */
protected $avatarManager;
/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
protected $logger;
/** @var string */
protected $uid = 'alice';
/** @var string */
protected $dn = 'uid=alice,dc=foo,dc=bar';
/** @var User */
protected $user;
protected Access&MockObject $access;
protected Connection&MockObject $connection;
protected IConfig&MockObject $config;
protected INotificationManager&MockObject $notificationManager;
protected IUserManager&MockObject $userManager;
protected Image&MockObject $image;
protected IAvatarManager&MockObject $avatarManager;
protected LoggerInterface&MockObject $logger;
protected string $uid = 'alice';
protected string $dn = 'uid=alice,dc=foo,dc=bar';
protected User $user;
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$this->access = $this->createMock(Access::class);
$this->access->connection = $this->connection;
@ -100,9 +94,7 @@ class UserTest extends \Test\TestCase {
$this->equalTo('email'))
->willReturn(['alice@foo.bar']);
$coreUser = $this->getMockBuilder(IUser::class)
->disableOriginalConstructor()
->getMock();
$coreUser = $this->createMock(IUser::class);
$coreUser->expects($this->once())
->method('setSystemEMailAddress')
->with('alice@foo.bar');
@ -506,7 +498,7 @@ class UserTest extends \Test\TestCase {
$avatar = $this->createMock(IAvatar::class);
$avatar->expects($this->once())
->method('set')
->with($this->isInstanceOf($this->image));
->with($this->image);
$this->avatarManager->expects($this->once())
->method('getAvatar')
@ -617,7 +609,7 @@ class UserTest extends \Test\TestCase {
$avatar = $this->createMock(IAvatar::class);
$avatar->expects($this->once())
->method('set')
->with($this->isInstanceOf($this->image));
->with($this->image);
$this->avatarManager->expects($this->once())
->method('getAvatar')
@ -723,7 +715,7 @@ class UserTest extends \Test\TestCase {
$avatar = $this->createMock(IAvatar::class);
$avatar->expects($this->once())
->method('set')
->with($this->isInstanceOf($this->image))
->with($this->image)
->willThrowException(new \Exception());
$this->avatarManager->expects($this->once())
@ -780,7 +772,7 @@ class UserTest extends \Test\TestCase {
$this->user->updateAvatar();
}
public function extStorageHomeDataProvider() {
public static function extStorageHomeDataProvider(): array {
return [
[ 'myFolder', null ],
[ '', null, false ],
@ -865,7 +857,7 @@ class UserTest extends \Test\TestCase {
$this->assertFalse($this->user->getAvatarImage());
}
public function imageDataProvider() {
public static function imageDataProvider(): array {
return [
[ false, false ],
[ 'corruptData', false ],
@ -884,7 +876,7 @@ class UserTest extends \Test\TestCase {
'updateExtStorageHome',
];
/** @var User|\PHPUnit\Framework\MockObject\MockObject $userMock */
/** @var User&MockObject $userMock */
$userMock = $this->getMockBuilder(User::class)
->setConstructorArgs([
$this->uid,
@ -897,7 +889,7 @@ class UserTest extends \Test\TestCase {
$this->userManager,
$this->notificationManager
])
->setMethods($requiredMethods)
->onlyMethods($requiredMethods)
->getMock();
$this->connection->setConfiguration([
@ -937,7 +929,7 @@ class UserTest extends \Test\TestCase {
\OC_Hook::emit('OC_User', 'post_login', ['uid' => $this->uid]);
}
public function emptyHomeFolderAttributeValueProvider() {
public static function emptyHomeFolderAttributeValueProvider(): array {
return [
'empty' => [''],
'prefixOnly' => ['attr:'],
@ -947,7 +939,7 @@ class UserTest extends \Test\TestCase {
/**
* @dataProvider emptyHomeFolderAttributeValueProvider
*/
public function testGetHomePathNotConfigured($attributeValue): void {
public function testGetHomePathNotConfigured(string $attributeValue): void {
$this->connection->expects($this->any())
->method('__get')
->with($this->equalTo('homeFolderNamingRule'))
@ -1011,7 +1003,7 @@ class UserTest extends \Test\TestCase {
$this->user->getHomePath();
}
public function displayNameProvider() {
public static function displayNameProvider(): array {
return [
['Roland Deschain', '', 'Roland Deschain', false],
['Roland Deschain', '', 'Roland Deschain', true],
@ -1023,7 +1015,7 @@ class UserTest extends \Test\TestCase {
/**
* @dataProvider displayNameProvider
*/
public function testComposeAndStoreDisplayName($part1, $part2, $expected, $expectTriggerChange): void {
public function testComposeAndStoreDisplayName(string $part1, string $part2, string $expected, bool $expectTriggerChange): void {
$this->config->expects($this->once())
->method('setUserValue');
$oldName = $expectTriggerChange ? 'xxGunslingerxx' : null;

64
apps/user_ldap/tests/UserLDAPPluginTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2017 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -9,27 +11,23 @@ use OC\User\Backend;
use OCA\User_LDAP\UserPluginManager;
class UserLDAPPluginTest extends \Test\TestCase {
/**
* @return UserPluginManager
*/
private function getUserPluginManager() {
private function getUserPluginManager(): UserPluginManager {
return new UserPluginManager();
}
public function testImplementsActions(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions'])
->getMock();
$plugin->expects($this->any())
->method('respondToActions')
->willReturn(Backend::CREATE_USER);
$plugin2 = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions'])
$plugin2 = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions'])
->getMock();
$plugin2->expects($this->any())
@ -47,8 +45,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testCreateUser(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'createUser'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'createUser'])
->getMock();
$plugin->expects($this->any())
@ -66,7 +64,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->createUser('user', 'password');
}
public function testCreateUserNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements createUser in this LDAP Backend.');
@ -78,8 +76,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testSetPassword(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'setPassword'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'setPassword'])
->getMock();
$plugin->expects($this->any())
@ -97,7 +95,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->setPassword('user', 'password');
}
public function testSetPasswordNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements setPassword in this LDAP Backend.');
@ -109,8 +107,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testGetHome(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'getHome'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'getHome'])
->getMock();
$plugin->expects($this->any())
@ -127,7 +125,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->getHome('uid');
}
public function testGetHomeNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements getHome in this LDAP Backend.');
@ -139,8 +137,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testGetDisplayName(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'getDisplayName'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'getDisplayName'])
->getMock();
$plugin->expects($this->any())
@ -157,7 +155,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->getDisplayName('uid');
}
public function testGetDisplayNameNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements getDisplayName in this LDAP Backend.');
@ -169,8 +167,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testSetDisplayName(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'setDisplayName'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'setDisplayName'])
->getMock();
$plugin->expects($this->any())
@ -188,7 +186,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->setDisplayName('user', 'password');
}
public function testSetDisplayNameNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements setDisplayName in this LDAP Backend.');
@ -200,8 +198,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testCanChangeAvatar(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'canChangeAvatar'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'canChangeAvatar'])
->getMock();
$plugin->expects($this->any())
@ -218,7 +216,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->canChangeAvatar('uid');
}
public function testCanChangeAvatarNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements canChangeAvatar in this LDAP Backend.');
@ -230,8 +228,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testCountUsers(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'countUsers'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'countUsers'])
->getMock();
$plugin->expects($this->any())
@ -245,7 +243,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->countUsers();
}
public function testCountUsersNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements countUsers in this LDAP Backend.');
@ -257,8 +255,8 @@ class UserLDAPPluginTest extends \Test\TestCase {
public function testDeleteUser(): void {
$pluginManager = $this->getUserPluginManager();
$plugin = $this->getMockBuilder('OCA\User_LDAP\Tests\LDAPUserPluginDummy')
->setMethods(['respondToActions', 'canDeleteUser','deleteUser'])
$plugin = $this->getMockBuilder(LDAPUserPluginDummy::class)
->onlyMethods(['respondToActions', 'canDeleteUser','deleteUser'])
->getMock();
$plugin->expects($this->any())
@ -281,7 +279,7 @@ class UserLDAPPluginTest extends \Test\TestCase {
$pluginManager->deleteUser('uid');
}
public function testDeleteUserNotRegistered(): void {
$this->expectException(\Exception::class);
$this->expectExceptionMessage('No plugin implements deleteUser in this LDAP Backend.');

79
apps/user_ldap/tests/User_LDAPTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -10,6 +11,7 @@ namespace OCA\User_LDAP\Tests;
use OC\User\Backend;
use OCA\User_LDAP\Access;
use OCA\User_LDAP\Connection;
use OCA\User_LDAP\ILDAPWrapper;
use OCA\User_LDAP\Mapping\AbstractMapping;
use OCA\User_LDAP\Mapping\UserMapping;
use OCA\User_LDAP\User\DeletedUsersIndex;
@ -38,24 +40,15 @@ use Test\TestCase;
* @package OCA\User_LDAP\Tests
*/
class User_LDAPTest extends TestCase {
/** @var User_LDAP */
protected $backend;
/** @var Access|MockObject */
protected $access;
/** @var OfflineUser|MockObject */
protected $offlineUser;
/** @var INotificationManager|MockObject */
protected $notificationManager;
/** @var UserPluginManager|MockObject */
protected $pluginManager;
/** @var Connection|MockObject */
protected $connection;
/** @var Manager|MockObject */
protected $userManager;
/** @var LoggerInterface|MockObject */
protected $logger;
/** @var DeletedUsersIndex|MockObject */
protected $deletedUsersIndex;
protected Access&MockObject $access;
protected OfflineUser&MockObject $offlineUser;
protected INotificationManager&MockObject $notificationManager;
protected UserPluginManager&MockObject $pluginManager;
protected Connection&MockObject $connection;
protected Manager&MockObject $userManager;
protected LoggerInterface&MockObject $logger;
protected DeletedUsersIndex&MockObject $deletedUsersIndex;
protected User_LDAP $backend;
protected function setUp(): void {
parent::setUp();
@ -63,7 +56,9 @@ class User_LDAPTest extends TestCase {
Server::get(IUserManager::class)->clearBackends();
Server::get(IGroupManager::class)->clearBackends();
$this->connection = $this->createMock(Connection::class);
$this->connection = $this->getMockBuilder(Connection::class)
->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
->getMock();
$this->userManager = $this->createMock(Manager::class);
$this->access = $this->createMock(Access::class);
@ -86,7 +81,7 @@ class User_LDAPTest extends TestCase {
);
}
private function prepareMockForUserExists() {
private function prepareMockForUserExists(): void {
$this->access->expects($this->any())
->method('username2dn')
->willReturnCallback(function ($uid) {
@ -114,10 +109,8 @@ class User_LDAPTest extends TestCase {
/**
* Prepares the Access mock for checkPassword tests
* @param bool $noDisplayName
* @return void
*/
private function prepareAccessForCheckPassword($noDisplayName = false) {
private function prepareAccessForCheckPassword(bool $noDisplayName = false): void {
$this->connection->expects($this->any())
->method('__get')
->willReturnCallback(function ($name) {
@ -347,7 +340,7 @@ class User_LDAPTest extends TestCase {
->method('invalidate')
->with('uid');
$this->assertEquals(true, $this->backend->deleteUser('uid'));
$this->assertTrue($this->backend->deleteUser('uid'));
}
/**
@ -404,7 +397,7 @@ class User_LDAPTest extends TestCase {
$backend = new UserLDAP($this->access, $this->notificationManager, $this->pluginManager, $this->logger, $this->deletedUsersIndex);
$result = $backend->getUsers();
$this->assertEquals(3, count($result));
$this->assertCount(3, $result);
}
public function testGetUsersLimitOffset(): void {
@ -412,7 +405,7 @@ class User_LDAPTest extends TestCase {
$backend = new UserLDAP($this->access, $this->notificationManager, $this->pluginManager, $this->logger, $this->deletedUsersIndex);
$result = $backend->getUsers('', 1, 2);
$this->assertEquals(1, count($result));
$this->assertCount(1, $result);
}
public function testGetUsersLimitOffset2(): void {
@ -420,7 +413,7 @@ class User_LDAPTest extends TestCase {
$backend = new UserLDAP($this->access, $this->notificationManager, $this->pluginManager, $this->logger, $this->deletedUsersIndex);
$result = $backend->getUsers('', 2, 1);
$this->assertEquals(2, count($result));
$this->assertCount(2, $result);
}
public function testGetUsersSearchWithResult(): void {
@ -428,7 +421,7 @@ class User_LDAPTest extends TestCase {
$backend = new UserLDAP($this->access, $this->notificationManager, $this->pluginManager, $this->logger, $this->deletedUsersIndex);
$result = $backend->getUsers('yo');
$this->assertEquals(2, count($result));
$this->assertCount(2, $result);
}
public function testGetUsersSearchEmptyResult(): void {
@ -436,7 +429,7 @@ class User_LDAPTest extends TestCase {
$backend = new UserLDAP($this->access, $this->notificationManager, $this->pluginManager, $this->logger, $this->deletedUsersIndex);
$result = $backend->getUsers('nix');
$this->assertEquals(0, count($result));
$this->assertCount(0, $result);
}
private function getUsers($search = '', $limit = null, $offset = null) {
@ -453,7 +446,7 @@ class User_LDAPTest extends TestCase {
Server::get(IUserManager::class)->registerBackend($backend);
$result = $this->getUsers();
$this->assertEquals(3, count($result));
$this->assertCount(3, $result);
}
public function testGetUsersViaAPILimitOffset(): void {
@ -462,7 +455,7 @@ class User_LDAPTest extends TestCase {
Server::get(IUserManager::class)->registerBackend($backend);
$result = $this->getUsers('', 1, 2);
$this->assertEquals(1, count($result));
$this->assertCount(1, $result);
}
public function testGetUsersViaAPILimitOffset2(): void {
@ -471,7 +464,7 @@ class User_LDAPTest extends TestCase {
Server::get(IUserManager::class)->registerBackend($backend);
$result = $this->getUsers('', 2, 1);
$this->assertEquals(2, count($result));
$this->assertCount(2, $result);
}
public function testGetUsersViaAPISearchWithResult(): void {
@ -480,7 +473,7 @@ class User_LDAPTest extends TestCase {
Server::get(IUserManager::class)->registerBackend($backend);
$result = $this->getUsers('yo');
$this->assertEquals(2, count($result));
$this->assertCount(2, $result);
}
public function testGetUsersViaAPISearchEmptyResult(): void {
@ -489,15 +482,13 @@ class User_LDAPTest extends TestCase {
Server::get(IUserManager::class)->registerBackend($backend);
$result = $this->getUsers('nix');
$this->assertEquals(0, count($result));
$this->assertCount(0, $result);
}
public function testUserExists(): void {
$backend = new UserLDAP($this->access, $this->notificationManager, $this->pluginManager, $this->logger, $this->deletedUsersIndex);
$this->prepareMockForUserExists();
$user = $this->createMock(User::class);
$this->userManager->expects($this->never())
->method('get');
$this->userManager->expects($this->once())
@ -1182,8 +1173,6 @@ class User_LDAPTest extends TestCase {
/**
* Prepares the Access mock for setPassword tests
*
* @param bool $enablePasswordChange
*/
private function prepareAccessForSetPassword($enablePasswordChange = true) {
$this->connection->expects($this->any())
@ -1328,7 +1317,7 @@ class User_LDAPTest extends TestCase {
$this->assertEquals($this->backend->setPassword('uid', 'password'), 'result');
}
public function avatarDataProvider() {
public static function avatarDataProvider(): array {
return [
[ 'validImageData', false ],
[ 'corruptImageData', true ],
@ -1336,8 +1325,10 @@ class User_LDAPTest extends TestCase {
];
}
/** @dataProvider avatarDataProvider */
public function testCanChangeAvatar($imageData, $expected): void {
/**
* @dataProvider avatarDataProvider
*/
public function testCanChangeAvatar(string|bool $imageData, bool $expected): void {
$isValidImage = str_starts_with((string)$imageData, 'valid');
$user = $this->createMock(User::class);
@ -1451,9 +1442,9 @@ class User_LDAPTest extends TestCase {
$this->assertFalse($this->backend->createUser('uid', 'password'));
}
public function actionProvider() {
public static function actionProvider(): array {
return [
[ 'ldapUserAvatarRule', 'default', Backend::PROVIDE_AVATAR, true] ,
[ 'ldapUserAvatarRule', 'default', Backend::PROVIDE_AVATAR, true],
[ 'ldapUserAvatarRule', 'data:selfiePhoto', Backend::PROVIDE_AVATAR, true],
[ 'ldapUserAvatarRule', 'none', Backend::PROVIDE_AVATAR, false],
[ 'turnOnPasswordChange', 0, Backend::SET_PASSWORD, false],
@ -1464,7 +1455,7 @@ class User_LDAPTest extends TestCase {
/**
* @dataProvider actionProvider
*/
public function testImplementsAction($configurable, $value, $actionCode, $expected): void {
public function testImplementsAction(string $configurable, string|int $value, int $actionCode, bool $expected): void {
$this->pluginManager->expects($this->once())
->method('getImplementedActions')
->willReturn(0);

28
apps/user_ldap/tests/User_ProxyTest.php
View file

@ -1,4 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
@ -17,22 +19,14 @@ use Psr\Log\LoggerInterface;
use Test\TestCase;
class User_ProxyTest extends TestCase {
/** @var Helper|MockObject */
protected $helper;
/** @var ILDAPWrapper|MockObject */
private $ldapWrapper;
/** @var AccessFactory|MockObject */
private $accessFactory;
/** @var INotificationManager|MockObject */
private $notificationManager;
/** @var User_Proxy|MockObject */
private $proxy;
/** @var UserPluginManager|MockObject */
private $userPluginManager;
/** @var LoggerInterface|MockObject */
protected $logger;
/** @var DeletedUsersIndex|MockObject */
protected $deletedUsersIndex;
protected Helper&MockObject $helper;
private ILDAPWrapper&MockObject $ldapWrapper;
private AccessFactory&MockObject $accessFactory;
private INotificationManager&MockObject $notificationManager;
private User_Proxy&MockObject $proxy;
private UserPluginManager&MockObject $userPluginManager;
protected LoggerInterface&MockObject $logger;
protected DeletedUsersIndex&MockObject $deletedUsersIndex;
protected function setUp(): void {
parent::setUp();
@ -54,7 +48,7 @@ class User_ProxyTest extends TestCase {
$this->logger,
$this->deletedUsersIndex,
])
->setMethods(['handleRequest'])
->onlyMethods(['handleRequest'])
->getMock();
}

21
apps/user_ldap/tests/WizardTest.php
View file

@ -1,5 +1,6 @@
<?php
declare(strict_types=1);
/**
* SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
* SPDX-FileCopyrightText: 2016 ownCloud, Inc.
@ -35,32 +36,28 @@ class WizardTest extends TestCase {
}
}
private function getWizardAndMocks() {
private function getWizardAndMocks(): array {
static $confMethods;
static $connMethods;
static $accMethods;
if (is_null($confMethods)) {
$confMethods = get_class_methods('\OCA\User_LDAP\Configuration');
$connMethods = get_class_methods('\OCA\User_LDAP\Connection');
$accMethods = get_class_methods('\OCA\User_LDAP\Access');
}
/** @var ILDAPWrapper|\PHPUnit\Framework\MockObject\MockObject $lw */
/** @var ILDAPWrapper&MockObject $lw */
$lw = $this->createMock(ILDAPWrapper::class);
/** @var Configuration|\PHPUnit\Framework\MockObject\MockObject $conf */
/** @var Configuration&MockObject $conf */
$conf = $this->getMockBuilder(Configuration::class)
->setMethods($confMethods)
->onlyMethods($confMethods)
->setConstructorArgs(['', true])
->getMock();
/** @var Access|\PHPUnit\Framework\MockObject\MockObject $access */
/** @var Access&MockObject $access */
$access = $this->createMock(Access::class);
return [new Wizard($conf, $lw, $access), $conf, $lw, $access];
}
private function prepareLdapWrapperForConnections(MockObject &$ldap) {
private function prepareLdapWrapperForConnections(MockObject $ldap) {
$ldap->expects($this->once())
->method('connect')
//dummy value
@ -346,7 +343,7 @@ class WizardTest extends TestCase {
});
$result = $wizard->detectEmailAttribute();
$this->assertSame(false, $result->hasChanges());
$this->assertFalse($result->hasChanges());
}
public function testCumulativeSearchOnAttributeSkipReadDN(): void {
@ -423,7 +420,7 @@ class WizardTest extends TestCase {
// The following expectations are the real test
$filters = ['f1', 'f2', '*'];
$resultArray = $wizard->cumulativeSearchOnAttribute($filters, 'cn', 0);
$this->assertSame(6, count($resultArray));
$this->assertCount(6, $resultArray);
unset($mark);
}
}