implement ArrayInterface with Session

diff --git a/lib/session/memory.php b/lib/session/memory.php
index 4202ddfd2fc3f27ecb8b0caffc8c1e0f6eaaae16..c148ff4b9b9928af848b7895e9132ce02ea73bd0 100644 (file)
--- a/lib/session/memory.php
+++ b/lib/session/memory.php
@@ -15,7 +15,7 @@ namespace OC\Session;
  *
  * @package OC\Session
  */
-class Memory implements Session {
+class Memory extends Session {
        protected $data;
 
        public function __construct($name) {

diff --git a/lib/session/session.php b/lib/session/session.php
index 3dce3b7f5b3e689f8084fe1bda7699fa346cf64a..55515f57a87d186adb11c407655b50f943350eda 100644 (file)
--- a/lib/session/session.php
+++ b/lib/session/session.php
@@ -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);
+       }
 }

diff --git a/tests/lib/session/session.php b/tests/lib/session/session.php
index be28251608a8eb3bb54dcfbfff5474c38da39e96..72dee44e7cb14e4b35f096fba62428c612d52766 100644 (file)
--- a/tests/lib/session/session.php
+++ b/tests/lib/session/session.php
@@ -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']));
+       }
 }

diff --git a/tests/lib/user/manager.php b/tests/lib/user/manager.php
new file mode 100644 (file)
index 0000000..401ff70
--- /dev/null
+++ b/tests/lib/user/manager.php
@@ -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());
+       }
+}

diff --git a/tests/lib/user/user.php b/tests/lib/user/user.php
new file mode 100644 (file)
index 0000000..ad03bd5
--- /dev/null
+++ b/tests/lib/user/user.php
@@ -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);
+       }
+}