diff --git a/lib/session/memory.php b/lib/session/memory.php
index 4202ddfd2fc3f27ecb8b0caffc8c1e0f6eaaae16..c148ff4b9b9928af848b7895e9132ce02ea73bd0 100644
--- 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
--- 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
--- 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
index 0000000000000000000000000000000000000000..401ff70297e4522a962e4e512dde87b1fde968b6
--- /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
index 0000000000000000000000000000000000000000..ad03bd5748306d2dcf0e18beb3a4fe4a4f156d07
--- /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);
+	}
+}