mirrors
/
nextcloud
mirror of https://github.com/nextcloud/server.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 1008 Wiki Activity
Browse Source

implement ArrayInterface with Session

tags/v6.0.0alpha2
Robin Appelman 11 years ago
parent
cc0cf93136
commit
57f712f8a9
5 changed files with 548 additions and 8 deletions
Split View Show Diff Stats
  1. 1
    1
      lib/session/memory.php
  2. 38
    7
      lib/session/session.php
  3. 9
    0
      tests/lib/session/session.php
  4. 181
    0
      tests/lib/user/manager.php
  5. 319
    0
      tests/lib/user/user.php

+ 1
- 1
lib/session/memory.php View File

@@ -15,7 +15,7 @@ namespace OC\Session;
*
* @package OC\Session
*/
class Memory implements Session {
class Memory extends Session {
protected $data;

public function __construct($name) {

+ 38
- 7
lib/session/session.php View File

@@ -8,41 +8,72 @@

namespace OC\Session;

interface Session {
abstract class Session implements \ArrayAccess {
/**
* $name serves as a namespace for the session keys
*
* @param string $name
*/
public function __construct($name);
abstract public function __construct($name);

/**
* @param string $key
* @param mixed $value
*/
public function set($key, $value);
abstract public function set($key, $value);

/**
* @param string $key
* @return mixed should return null if $key does not exist
*/
public function get($key);
abstract public function get($key);

/**
* @param string $key
* @return bool
*/
public function exists($key);
abstract public function exists($key);

/**
* should not throw any errors if $key does not exist
*
* @param string $key
*/
public function remove($key);
abstract public function remove($key);

/**
* removes all entries within the cache namespace
*/
public function clear();
abstract public function clear();

/**
* @param mixed $offset
* @return bool
*/
public function offsetExists($offset) {
return $this->exists($offset);
}

/**
* @param mixed $offset
* @return mixed
*/
public function offsetGet($offset) {
return $this->get($offset);
}

/**
* @param mixed $offset
* @param mixed $value
*/
public function offsetSet($offset, $value) {
$this->set($offset, $value);
}

/**
* @param mixed $offset
*/
public function offsetUnset($offset) {
$this->remove($offset);
}
}

+ 9
- 0
tests/lib/session/session.php View File

@@ -52,4 +52,13 @@ abstract class Session extends \PHPUnit_Framework_TestCase {
$this->instance->clear();
$this->assertFalse($this->instance->exists('foo'));
}

public function testArrayInterface() {
$this->assertFalse(isset($this->instance['foo']));
$this->instance['foo'] = 'bar';
$this->assertTrue(isset($this->instance['foo']));
$this->assertEquals('bar', $this->instance['foo']);
unset($this->instance['foo']);
$this->assertFalse(isset($this->instance['foo']));
}
}

+ 181
- 0
tests/lib/user/manager.php View File

@@ -0,0 +1,181 @@
<?php

/**
* Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
* This file is licensed under the Affero General Public License version 3 or
* later.
* See the COPYING-README file.
*/

namespace Test\User;

class Manager extends \PHPUnit_Framework_TestCase {
public function testUserExistsSingleBackendExists() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(true));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend);

$this->assertTrue($manager->userExists('foo'));
}

public function testUserExistsSingleBackendNotExists() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(false));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend);

$this->assertFalse($manager->userExists('foo'));
}

public function testUserExistsNoBackends() {
$manager = new \OC\User\Manager();

$this->assertFalse($manager->userExists('foo'));
}

public function testUserExistsTwoBackendsSecondExists() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
*/
$backend1 = $this->getMock('\OC_User_Dummy');
$backend1->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(false));

/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
*/
$backend2 = $this->getMock('\OC_User_Dummy');
$backend2->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(true));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend1);
$manager->registerBackend($backend2);

$this->assertTrue($manager->userExists('foo'));
}

public function testUserExistsTwoBackendsFirstExists() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
*/
$backend1 = $this->getMock('\OC_User_Dummy');
$backend1->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(true));

/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
*/
$backend2 = $this->getMock('\OC_User_Dummy');
$backend2->expects($this->never())
->method('userExists');

$manager = new \OC\User\Manager();
$manager->registerBackend($backend1);
$manager->registerBackend($backend2);

$this->assertTrue($manager->userExists('foo'));
}

public function testGetOneBackendExists() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(true));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend);

$this->assertEquals('foo', $manager->get('foo')->getUID());
}

public function testGetOneBackendNotExists() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('userExists')
->with($this->equalTo('foo'))
->will($this->returnValue(false));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend);

$this->assertEquals(null, $manager->get('foo'));
}

public function testSearchOneBackend() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('getUsers')
->with($this->equalTo('fo'))
->will($this->returnValue(array('foo', 'afoo')));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend);

$result = $manager->search('fo');
$this->assertEquals(2, count($result));
$this->assertEquals('afoo', $result[0]->getUID());
$this->assertEquals('foo', $result[1]->getUID());
}

public function testSearchTwoBackendLimitOffset() {
/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend1
*/
$backend1 = $this->getMock('\OC_User_Dummy');
$backend1->expects($this->once())
->method('getUsers')
->with($this->equalTo('fo'), $this->equalTo(3), $this->equalTo(1))
->will($this->returnValue(array('foo1', 'foo2')));

/**
* @var \OC_User_Dummy | \PHPUnit_Framework_MockObject_MockObject $backend2
*/
$backend2 = $this->getMock('\OC_User_Dummy');
$backend2->expects($this->once())
->method('getUsers')
->with($this->equalTo('fo'), $this->equalTo(1), $this->equalTo(0))
->will($this->returnValue(array('foo3')));

$manager = new \OC\User\Manager();
$manager->registerBackend($backend1);
$manager->registerBackend($backend2);

$result = $manager->search('fo', 3, 1);
$this->assertEquals(3, count($result));
$this->assertEquals('foo1', $result[0]->getUID());
$this->assertEquals('foo2', $result[1]->getUID());
$this->assertEquals('foo3', $result[2]->getUID());
}
}

+ 319
- 0
tests/lib/user/user.php View File

@@ -0,0 +1,319 @@
<?php

/**
* Copyright (c) 2013 Robin Appelman <icewind@owncloud.com>
* This file is licensed under the Affero General Public License version 3 or
* later.
* See the COPYING-README file.
*/

namespace Test\User;

use OC\Hooks\PublicEmitter;

class User extends \PHPUnit_Framework_TestCase {
public function testDisplayName() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Backend');
$backend->expects($this->once())
->method('getDisplayName')
->with($this->equalTo('foo'))
->will($this->returnValue('Foo'));

$backend->expects($this->any())
->method('implementsActions')
->with($this->equalTo(\OC_USER_BACKEND_GET_DISPLAYNAME))
->will($this->returnValue(true));

$user = new \OC\User\User('foo', $backend);
$this->assertEquals('Foo', $user->getDisplayName());
}

public function testDisplayNameNotSupported() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Backend');
$backend->expects($this->never())
->method('getDisplayName');

$backend->expects($this->any())
->method('implementsActions')
->with($this->equalTo(\OC_USER_BACKEND_GET_DISPLAYNAME))
->will($this->returnValue(false));

$user = new \OC\User\User('foo', $backend);
$this->assertEquals('foo', $user->getDisplayName());
}

public function testSetPassword() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('setPassword')
->with($this->equalTo('foo'), $this->equalTo('bar'));

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnCallback(function ($actions) {
if ($actions === \OC_USER_BACKEND_SET_PASSWORD) {
return true;
} else {
return false;
}
}));

$user = new \OC\User\User('foo', $backend);
$this->assertTrue($user->setPassword('bar'));
}

public function testSetPasswordNotSupported() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->never())
->method('setPassword');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnValue(false));

$user = new \OC\User\User('foo', $backend);
$this->assertFalse($user->setPassword('bar'));
}

public function testDelete() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('deleteUser')
->with($this->equalTo('foo'));

$user = new \OC\User\User('foo', $backend);
$this->assertTrue($user->delete());
}

public function testCheckPassword() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('checkPassword')
->with($this->equalTo('foo'), $this->equalTo('bar'))
->will($this->returnValue(true));

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnCallback(function ($actions) {
if ($actions === \OC_USER_BACKEND_CHECK_PASSWORD) {
return true;
} else {
return false;
}
}));

$user = new \OC\User\User('foo', $backend);
$this->assertTrue($user->checkPassword('bar'));
}

public function testCheckPasswordNotSupported() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->never())
->method('checkPassword');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnValue(false));

$user = new \OC\User\User('foo', $backend);
$this->assertFalse($user->checkPassword('bar'));
}

public function testGetHome() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('getHome')
->with($this->equalTo('foo'))
->will($this->returnValue('/home/foo'));

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnCallback(function ($actions) {
if ($actions === \OC_USER_BACKEND_GET_HOME) {
return true;
} else {
return false;
}
}));

$user = new \OC\User\User('foo', $backend);
$this->assertEquals('/home/foo', $user->getHome());
}

public function testGetHomeNotSupported() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->never())
->method('getHome');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnValue(false));

$user = new \OC\User\User('foo', $backend);
$this->assertEquals(\OC_Config::getValue("datadirectory", \OC::$SERVERROOT . "/data") . '/foo', $user->getHome());
}

public function testCanChangePassword() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnCallback(function ($actions) {
if ($actions === \OC_USER_BACKEND_SET_PASSWORD) {
return true;
} else {
return false;
}
}));

$user = new \OC\User\User('foo', $backend);
$this->assertTrue($user->canChangePassword());
}

public function testCanChangePasswordNotSupported() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnValue(false));

$user = new \OC\User\User('foo', $backend);
$this->assertFalse($user->canChangePassword());
}

public function testCanChangeDisplayName() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnCallback(function ($actions) {
if ($actions === \OC_USER_BACKEND_SET_DISPLAYNAME) {
return true;
} else {
return false;
}
}));

$user = new \OC\User\User('foo', $backend);
$this->assertTrue($user->canChangeDisplayName());
}

public function testCanChangeDisplayNameNotSupported() {
/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnValue(false));

$user = new \OC\User\User('foo', $backend);
$this->assertFalse($user->canChangeDisplayName());
}

public function testSetPasswordHooks() {
$hooksCalled = 0;
$test = $this;

/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('setPassword');

/**
* @param \OC\User\User $user
* @param string $password
*/
$hook = function ($user, $password) use ($test, &$hooksCalled) {
$hooksCalled++;
$test->assertEquals('foo', $user->getUID());
$test->assertEquals('bar', $password);
};

$emitter = new PublicEmitter();
$emitter->listen('\OC\User', 'preSetPassword', $hook);
$emitter->listen('\OC\User', 'postSetPassword', $hook);

$backend->expects($this->any())
->method('implementsActions')
->will($this->returnCallback(function ($actions) {
if ($actions === \OC_USER_BACKEND_SET_PASSWORD) {
return true;
} else {
return false;
}
}));

$user = new \OC\User\User('foo', $backend, $emitter);

$user->setPassword('bar');
$this->assertEquals(2, $hooksCalled);
}

public function testDeleteHooks() {
$hooksCalled = 0;
$test = $this;

/**
* @var \OC_User_Backend | \PHPUnit_Framework_MockObject_MockObject $backend
*/
$backend = $this->getMock('\OC_User_Dummy');
$backend->expects($this->once())
->method('deleteUser');

/**
* @param \OC\User\User $user
*/
$hook = function ($user) use ($test, &$hooksCalled) {
$hooksCalled++;
$test->assertEquals('foo', $user->getUID());
};

$emitter = new PublicEmitter();
$emitter->listen('\OC\User', 'preDelete', $hook);
$emitter->listen('\OC\User', 'postDelete', $hook);

$user = new \OC\User\User('foo', $backend, $emitter);
$this->assertTrue($user->delete());
$this->assertEquals(2, $hooksCalled);
}
}

Write Preview
Loading…
Cancel
Save