578 lines
16 KiB
PHP
578 lines
16 KiB
PHP
<?php
|
||
/**
|
||
* ownCloud
|
||
*
|
||
* @author Arthur Schiwon
|
||
* @copyright 2013 Arthur Schiwon blizzz@owncloud.com
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
|
||
* License as published by the Free Software Foundation; either
|
||
* version 3 of the License, or any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
|
||
*
|
||
* You should have received a copy of the GNU Affero General Public
|
||
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
*/
|
||
|
||
namespace OCA\user_ldap\tests;
|
||
|
||
use \OCA\user_ldap\USER_LDAP as UserLDAP;
|
||
use \OCA\user_ldap\lib\Access;
|
||
use \OCA\user_ldap\lib\Connection;
|
||
use \OCA\user_ldap\lib\ILDAPWrapper;
|
||
|
||
class Test_User_Ldap_Direct extends \PHPUnit_Framework_TestCase {
|
||
protected $backend;
|
||
protected $access;
|
||
|
||
public function setUp() {
|
||
\OC_User::clearBackends();
|
||
\OC_Group::clearBackends();
|
||
}
|
||
|
||
private function getAccessMock() {
|
||
static $conMethods;
|
||
static $accMethods;
|
||
static $uMethods;
|
||
|
||
if(is_null($conMethods) || is_null($accMethods)) {
|
||
$conMethods = get_class_methods('\OCA\user_ldap\lib\Connection');
|
||
$accMethods = get_class_methods('\OCA\user_ldap\lib\Access');
|
||
unset($accMethods[array_search('getConnection', $accMethods)]);
|
||
$uMethods = get_class_methods('\OCA\user_ldap\lib\user\User');
|
||
unset($uMethods[array_search('getUsername', $uMethods)]);
|
||
unset($uMethods[array_search('getDN', $uMethods)]);
|
||
unset($uMethods[array_search('__construct', $uMethods)]);
|
||
}
|
||
$lw = $this->getMock('\OCA\user_ldap\lib\ILDAPWrapper');
|
||
$connector = $this->getMock('\OCA\user_ldap\lib\Connection',
|
||
$conMethods,
|
||
array($lw, null, null));
|
||
|
||
$um = new \OCA\user_ldap\lib\user\Manager(
|
||
$this->getMock('\OCP\IConfig'),
|
||
$this->getMock('\OCA\user_ldap\lib\FilesystemHelper'),
|
||
$this->getMock('\OCA\user_ldap\lib\LogWrapper'),
|
||
$this->getMock('\OCP\IAvatarManager'),
|
||
$this->getMock('\OCP\Image')
|
||
);
|
||
|
||
$access = $this->getMock('\OCA\user_ldap\lib\Access',
|
||
$accMethods,
|
||
array($connector, $lw, $um));
|
||
|
||
$um->setLdapAccess($access);
|
||
|
||
return $access;
|
||
}
|
||
|
||
private function prepareMockForUserExists(&$access) {
|
||
$access->expects($this->any())
|
||
->method('username2dn')
|
||
->will($this->returnCallback(function($uid) {
|
||
switch ($uid) {
|
||
case 'gunslinger':
|
||
return 'dnOfRoland,dc=test';
|
||
break;
|
||
case 'formerUser':
|
||
return 'dnOfFormerUser,dc=test';
|
||
break;
|
||
case 'newyorker':
|
||
return 'dnOfNewYorker,dc=test';
|
||
break;
|
||
case 'ladyofshadows':
|
||
return 'dnOfLadyOfShadows,dc=test';
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* Prepares the Access mock for checkPassword tests
|
||
* @param \OCA\user_ldap\lib\Access $access mock
|
||
* @return void
|
||
*/
|
||
private function prepareAccessForCheckPassword(&$access) {
|
||
$access->expects($this->once())
|
||
->method('escapeFilterPart')
|
||
->will($this->returnCallback(function($uid) {
|
||
return $uid;
|
||
}));
|
||
|
||
$access->connection->expects($this->any())
|
||
->method('__get')
|
||
->will($this->returnCallback(function($name) {
|
||
if($name === 'ldapLoginFilter') {
|
||
return '%uid';
|
||
}
|
||
return null;
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('fetchListOfUsers')
|
||
->will($this->returnCallback(function($filter) {
|
||
if($filter === 'roland') {
|
||
return array('dnOfRoland,dc=test');
|
||
}
|
||
return array();
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('dn2username')
|
||
->with($this->equalTo('dnOfRoland,dc=test'))
|
||
->will($this->returnValue('gunslinger'));
|
||
|
||
$access->expects($this->any())
|
||
->method('areCredentialsValid')
|
||
->will($this->returnCallback(function($dn, $pwd) {
|
||
if($pwd === 'dt19') {
|
||
return true;
|
||
}
|
||
return false;
|
||
}));
|
||
}
|
||
|
||
public function testCheckPasswordUidReturn() {
|
||
$access = $this->getAccessMock();
|
||
|
||
$this->prepareAccessForCheckPassword($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = $backend->checkPassword('roland', 'dt19');
|
||
$this->assertEquals('gunslinger', $result);
|
||
}
|
||
|
||
public function testCheckPasswordWrongPassword() {
|
||
$access = $this->getAccessMock();
|
||
|
||
$this->prepareAccessForCheckPassword($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = $backend->checkPassword('roland', 'wrong');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
public function testCheckPasswordWrongUser() {
|
||
$access = $this->getAccessMock();
|
||
|
||
$this->prepareAccessForCheckPassword($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = $backend->checkPassword('mallory', 'evil');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
public function testCheckPasswordPublicAPI() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForCheckPassword($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::checkPassword('roland', 'dt19');
|
||
$this->assertEquals('gunslinger', $result);
|
||
}
|
||
|
||
public function testCheckPasswordPublicAPIWrongPassword() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForCheckPassword($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::checkPassword('roland', 'wrong');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
public function testCheckPasswordPublicAPIWrongUser() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForCheckPassword($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::checkPassword('mallory', 'evil');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
/**
|
||
* Prepares the Access mock for getUsers tests
|
||
* @param \OCA\user_ldap\lib\Access $access mock
|
||
* @return void
|
||
*/
|
||
private function prepareAccessForGetUsers(&$access) {
|
||
$access->expects($this->once())
|
||
->method('escapeFilterPart')
|
||
->will($this->returnCallback(function($search) {
|
||
return $search;
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('getFilterPartForUserSearch')
|
||
->will($this->returnCallback(function($search) {
|
||
return $search;
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('combineFilterWithAnd')
|
||
->will($this->returnCallback(function($param) {
|
||
return $param[1];
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('fetchListOfUsers')
|
||
->will($this->returnCallback(function($search, $a, $l, $o) {
|
||
$users = array('gunslinger', 'newyorker', 'ladyofshadows');
|
||
if(empty($search)) {
|
||
$result = $users;
|
||
} else {
|
||
$result = array();
|
||
foreach($users as $user) {
|
||
if(stripos($user, $search) !== false) {
|
||
$result[] = $user;
|
||
}
|
||
}
|
||
}
|
||
if(!is_null($l) || !is_null($o)) {
|
||
$result = array_slice($result, $o, $l);
|
||
}
|
||
return $result;
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('ownCloudUserNames')
|
||
->will($this->returnArgument(0));
|
||
}
|
||
|
||
public function testGetUsersNoParam() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->getUsers();
|
||
$this->assertEquals(3, count($result));
|
||
}
|
||
|
||
public function testGetUsersLimitOffset() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->getUsers('', 1, 2);
|
||
$this->assertEquals(1, count($result));
|
||
}
|
||
|
||
public function testGetUsersLimitOffset2() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->getUsers('', 2, 1);
|
||
$this->assertEquals(2, count($result));
|
||
}
|
||
|
||
public function testGetUsersSearchWithResult() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->getUsers('yo');
|
||
$this->assertEquals(2, count($result));
|
||
}
|
||
|
||
public function testGetUsersSearchEmptyResult() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->getUsers('nix');
|
||
$this->assertEquals(0, count($result));
|
||
}
|
||
|
||
public function testGetUsersViaAPINoParam() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::getUsers();
|
||
$this->assertEquals(3, count($result));
|
||
}
|
||
|
||
public function testGetUsersViaAPILimitOffset() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::getUsers('', 1, 2);
|
||
$this->assertEquals(1, count($result));
|
||
}
|
||
|
||
public function testGetUsersViaAPILimitOffset2() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::getUsers('', 2, 1);
|
||
$this->assertEquals(2, count($result));
|
||
}
|
||
|
||
public function testGetUsersViaAPISearchWithResult() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::getUsers('yo');
|
||
$this->assertEquals(2, count($result));
|
||
}
|
||
|
||
public function testGetUsersViaAPISearchEmptyResult() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetUsers($access);
|
||
$backend = new UserLDAP($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$result = \OCP\User::getUsers('nix');
|
||
$this->assertEquals(0, count($result));
|
||
}
|
||
|
||
public function testUserExists() {
|
||
$access = $this->getAccessMock();
|
||
$backend = new UserLDAP($access);
|
||
$this->prepareMockForUserExists($access);
|
||
|
||
$access->expects($this->any())
|
||
->method('readAttribute')
|
||
->will($this->returnCallback(function($dn) {
|
||
if($dn === 'dnOfRoland,dc=test') {
|
||
return array();
|
||
}
|
||
return false;
|
||
}));
|
||
|
||
//test for existing user
|
||
$result = $backend->userExists('gunslinger');
|
||
$this->assertTrue($result);
|
||
|
||
//test for deleted user
|
||
$result = $backend->userExists('formerUser');
|
||
$this->assertFalse($result);
|
||
|
||
//test for never-existing user
|
||
$result = $backend->userExists('mallory');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
public function testUserExistsPublicAPI() {
|
||
$access = $this->getAccessMock();
|
||
$backend = new UserLDAP($access);
|
||
$this->prepareMockForUserExists($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
$access->expects($this->any())
|
||
->method('readAttribute')
|
||
->will($this->returnCallback(function($dn) {
|
||
if($dn === 'dnOfRoland,dc=test') {
|
||
return array();
|
||
}
|
||
return false;
|
||
}));
|
||
|
||
//test for existing user
|
||
$result = \OCP\User::userExists('gunslinger');
|
||
$this->assertTrue($result);
|
||
|
||
//test for deleted user
|
||
$result = \OCP\User::userExists('formerUser');
|
||
$this->assertFalse($result);
|
||
|
||
//test for never-existing user
|
||
$result = \OCP\User::userExists('mallory');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
public function testDeleteUser() {
|
||
$access = $this->getAccessMock();
|
||
$backend = new UserLDAP($access);
|
||
|
||
//we do not support deleting users at all
|
||
$result = $backend->deleteUser('gunslinger');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
public function testGetHome() {
|
||
$access = $this->getAccessMock();
|
||
$backend = new UserLDAP($access);
|
||
$this->prepareMockForUserExists($access);
|
||
|
||
$access->connection->expects($this->any())
|
||
->method('__get')
|
||
->will($this->returnCallback(function($name) {
|
||
if($name === 'homeFolderNamingRule') {
|
||
return 'attr:testAttribute';
|
||
}
|
||
return null;
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('readAttribute')
|
||
->will($this->returnCallback(function($dn, $attr) {
|
||
switch ($dn) {
|
||
case 'dnOfRoland,dc=test':
|
||
if($attr === 'testAttribute') {
|
||
return array('/tmp/rolandshome/');
|
||
}
|
||
return array();
|
||
break;
|
||
case 'dnOfLadyOfShadows,dc=test':
|
||
if($attr === 'testAttribute') {
|
||
return array('susannah/');
|
||
}
|
||
return array();
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
}));
|
||
|
||
//absolut path
|
||
$result = $backend->getHome('gunslinger');
|
||
$this->assertEquals('/tmp/rolandshome/', $result);
|
||
|
||
//datadir-relativ path
|
||
$result = $backend->getHome('ladyofshadows');
|
||
$datadir = \OCP\Config::getSystemValue('datadirectory',
|
||
\OC::$SERVERROOT.'/data');
|
||
$this->assertEquals($datadir.'/susannah/', $result);
|
||
|
||
//no path at all – triggers OC default behaviour
|
||
$result = $backend->getHome('newyorker');
|
||
$this->assertFalse($result);
|
||
}
|
||
|
||
private function prepareAccessForGetDisplayName(&$access) {
|
||
$access->connection->expects($this->any())
|
||
->method('__get')
|
||
->will($this->returnCallback(function($name) {
|
||
if($name === 'ldapUserDisplayName') {
|
||
return 'displayname';
|
||
}
|
||
return null;
|
||
}));
|
||
|
||
$access->expects($this->any())
|
||
->method('readAttribute')
|
||
->will($this->returnCallback(function($dn, $attr) {
|
||
switch ($dn) {
|
||
case 'dnOfRoland,dc=test':
|
||
if($attr === 'displayname') {
|
||
return array('Roland Deschain');
|
||
}
|
||
return array();
|
||
break;
|
||
|
||
default:
|
||
return false;
|
||
}
|
||
}));
|
||
}
|
||
|
||
public function testGetDisplayName() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetDisplayName($access);
|
||
$backend = new UserLDAP($access);
|
||
$this->prepareMockForUserExists($access);
|
||
|
||
//with displayName
|
||
$result = $backend->getDisplayName('gunslinger');
|
||
$this->assertEquals('Roland Deschain', $result);
|
||
|
||
//empty displayname retrieved
|
||
$result = $backend->getDisplayName('newyorker');
|
||
$this->assertEquals(null, $result);
|
||
}
|
||
|
||
public function testGetDisplayNamePublicAPI() {
|
||
$access = $this->getAccessMock();
|
||
$this->prepareAccessForGetDisplayName($access);
|
||
$backend = new UserLDAP($access);
|
||
$this->prepareMockForUserExists($access);
|
||
\OC_User::useBackend($backend);
|
||
|
||
//with displayName
|
||
$result = \OCP\User::getDisplayName('gunslinger');
|
||
$this->assertEquals('Roland Deschain', $result);
|
||
|
||
//empty displayname retrieved
|
||
$result = \OCP\User::getDisplayName('newyorker');
|
||
$this->assertEquals('newyorker', $result);
|
||
}
|
||
|
||
//no test for getDisplayNames, because it just invokes getUsers and
|
||
//getDisplayName
|
||
|
||
public function testCountUsers() {
|
||
$access = $this->getAccessMock();
|
||
|
||
$access->connection->expects($this->once())
|
||
->method('__get')
|
||
->will($this->returnCallback(function($name) {
|
||
if($name === 'ldapLoginFilter') {
|
||
return 'uid=%uid';
|
||
}
|
||
return null;
|
||
}));
|
||
|
||
$access->expects($this->once())
|
||
->method('countUsers')
|
||
->will($this->returnCallback(function($filter, $a, $b, $c) {
|
||
if($filter !== 'uid=*') {
|
||
return false;
|
||
}
|
||
return 5;
|
||
}));
|
||
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->countUsers();
|
||
$this->assertEquals(5, $result);
|
||
}
|
||
|
||
public function testCountUsersFailing() {
|
||
$access = $this->getAccessMock();
|
||
|
||
$access->connection->expects($this->once())
|
||
->method('__get')
|
||
->will($this->returnCallback(function($name) {
|
||
if($name === 'ldapLoginFilter') {
|
||
return 'invalidFilter';
|
||
}
|
||
return null;
|
||
}));
|
||
|
||
$access->expects($this->once())
|
||
->method('countUsers')
|
||
->will($this->returnCallback(function($filter, $a, $b, $c) {
|
||
if($filter !== 'uid=*') {
|
||
return false;
|
||
}
|
||
return 5;
|
||
}));
|
||
|
||
$backend = new UserLDAP($access);
|
||
|
||
$result = $backend->countUsers();
|
||
$this->assertFalse($result);
|
||
}
|
||
}
|