Tests for AuthUser

src/Auth/AuthUserTrait.php

@@ -14,13 +14,6 @@ if (!defined('USER_RIGHT_KEY')) {
 /**
  * Convenience wrapper to access Auth data and check on rights/roles.
  *
- * It can be used anywhere in the application due to static access.
- * So in the view we can use this shortcut to check if a user is logged in:
- *
- *   if (Auth::id()) {
- *     // Display element
- *   }
- *
  * Simply add it at the class file:
  *
  *   trait AuthUserTrait;
@@ -49,10 +42,37 @@ trait AuthUserTrait {
 	 *
 	 * This can be used anywhere to check if a user is logged in.
 	 *
+	 * @param string $field Field name. Defaults to `id`.
 	 * @return mixed User id if existent, null otherwise.
 	 */
-	public function id() {
-		return $this->user('id');
+	public function id($field = 'id') {
+		return $this->user($field);
+	}
+
+	/**
+	 * This check can be used to tell if a record that belongs to some user is the
+	 * current logged in user
+	 *
+	 * @param string|int $userId
+	 * @param string $field Field name. Defaults to `id`.
+	 * @return boolean
+	 */
+	public function isMe($userId, $field = 'id') {
+		return ($userId && (string)$userId === (string)$this->user($field));
+	}
+
+	/**
+	 * Get the user data of the current session.
+	 *
+	 * @param string $key Key in dot syntax.
+	 * @return mixed Data
+	 */
+	public function user($key = null) {
+		$user = $this->_getUser();
+		if ($key === null) {
+			return $user;
+		}
+		return Hash::get($user, $key);
 	}
 
 	/**
@@ -75,36 +95,24 @@ trait AuthUserTrait {
 	}
 
 	/**
-	 * Get the user data of the current session.
-	 *
-	 * @param string $key Key in dot syntax.
-	 * @return mixed Data
-	 */
-	public function user($key = null) {
-		return Hash::get($this->_getUser(), $key);
-	}
-
-	/**
 	 * Check if the current session has this role.
 	 *
 	 * @param mixed $role
 	 * @param mixed $providedRoles
 	 * @return bool Success
 	 */
-	public function hasRole($ownRole, $providedRoles = null) {
+	public function hasRole($expectedRole, $providedRoles = null) {
 		if ($providedRoles !== null) {
-			$roles = $providedRoles;
+			$roles = (array)$providedRoles;
 		} else {
-			$roles = $this->roles();
+			$roles = (array)$this->roles();
 		}
-		if (is_array($roles)) {
-			if (in_array($ownRole, $roles)) {
-				return true;
-			}
-		} elseif (!empty($roles)) {
-			if ($ownRole == $roles) {
-				return true;
-			}
+		if (empty($roles)) {
+			return false;
+		}
+
+		if (in_array($expectedRole, $roles)) {
+			return true;
 		}
 		return false;
 	}
@@ -115,24 +123,24 @@ trait AuthUserTrait {
 	 * You can either require one of the roles (default), or you can require all
 	 * roles to match.
 	 *
-	 * @param mixed $roles
+	 * @param mixed $expectedRoles
 	 * @param bool $oneRoleIsEnough (if all $roles have to match instead of just one)
 	 * @param mixed $providedRoles
 	 * @return bool Success
 	 */
-	public function hasRoles($ownRoles, $oneRoleIsEnough = true, $providedRoles = null) {
+	public function hasRoles($expectedRoles, $oneRoleIsEnough = true, $providedRoles = null) {
 		if ($providedRoles !== null) {
 			$roles = $providedRoles;
 		} else {
 			$roles = $this->roles();
 		}
-		$ownRoles = (array)$ownRoles;
-		if (empty($ownRoles)) {
+		$expectedRoles = (array)$expectedRoles;
+		if (empty($expectedRoles)) {
 			return false;
 		}
 		$count = 0;
-		foreach ($ownRoles as $role) {
-			if ($this->hasRole($role, $roles)) {
+		foreach ($expectedRoles as $expectedRole) {
+			if ($this->hasRole($expectedRole, $roles)) {
 				if ($oneRoleIsEnough) {
 					return true;
 				}
@@ -144,7 +152,7 @@ trait AuthUserTrait {
 			}
 		}
 
-		if ($count === count($ownRoles)) {
+		if ($count === count($expectedRoles)) {
 			return true;
 		}
 		return false;
@@ -162,14 +170,14 @@ trait AuthUserTrait {
 	 * @param mixed $providedRights
 	 * @return bool Success
 	 */
-	public function hasRight($ownRight, $providedRights = null) {
+	public function hasRight($expectedRight, $providedRights = null) {
 		if ($providedRights !== null) {
 			$rights = $providedRights;
 		} else {
 			$rights = $this->user(USER_RIGHT_KEY);
 		}
 		$rights = (array)$rights;
-		if (array_key_exists($ownRight, $rights) && !empty($rights[$ownRight])) {
+		if (array_key_exists($expectedRight, $rights) && !empty($rights[$expectedRight])) {
 			return true;
 		}
 		return false;

src/Controller/Component/AuthUserComponent.php

@@ -13,7 +13,7 @@ class AuthUserComponent extends Component {
 
 	use AuthUserTrait;
 
-	public $components = ['Auth', 'Tools.Session'];
+	public $components = ['Auth'];
 
 	/**
 	 * AuthUserComponent::beforeRender()
@@ -27,6 +27,11 @@ class AuthUserComponent extends Component {
 		$controller->set(compact('authUser'));
 	}
 
+	/**
+	 * AuthUserComponent::_getUser()
+	 *
+	 * @return array
+	 */
 	protected function _getUser() {
 		return (array)$this->Auth->user();
 	}

tests/TestCase/Controller/Component/AuthUserComponentTest.php

@@ -0,0 +1,183 @@
+<?php
+namespace Tools\Test\TestCase\Controller\Component;
+
+use Cake\Controller\ComponentRegistry;
+use Tools\Controller\Component\AuthUserComponent;
+use Cake\Controller\Controller;
+use Cake\Core\Configure;
+use Cake\Network\Session;
+use Cake\TestSuite\TestCase;
+use Cake\Network\Request;
+
+/**
+ * AuthUserComponent class
+ *
+ */
+class AuthUserComponentTest extends TestCase {
+
+	/**
+	 * fixtures
+	 *
+	 * @var string
+	 */
+	public $fixtures = array('core.sessions');
+
+	public $AuthUser;
+
+	/**
+	 * setUp method
+	 *
+	 * @return void
+	 */
+	public function setUp() {
+		parent::setUp();
+
+		$controller = new Controller(new Request());
+		$this->ComponentRegistry = new ComponentRegistry($controller);
+		$this->AuthUser = new AuthUserComponent($this->ComponentRegistry);
+		$this->AuthUser->Auth = $this->getMock('Cake\Controller\Component\AuthComponent', ['user'], [$this->ComponentRegistry]);
+	}
+
+	/**
+	 * tearDown method
+	 *
+	 * @return void
+	 */
+	public function tearDown() {
+		parent::tearDown();
+	}
+
+	/**
+	 * testSessionReadWrite method
+	 *
+	 * @return void
+	 */
+	public function testEmptyAuthSession() {
+		$this->assertNull($this->AuthUser->id());
+
+		$this->assertFalse($this->AuthUser->isMe(null));
+		$this->assertFalse($this->AuthUser->isMe(''));
+		$this->assertFalse($this->AuthUser->isMe(0));
+		$this->assertFalse($this->AuthUser->isMe(1));
+	}
+
+	/**
+	 * AuthUserComponentTest::testId()
+	 *
+	 * @return void
+	 */
+	public function testId() {
+		$this->AuthUser->Auth->expects($this->once())
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1']));
+
+		$this->assertSame('1', $this->AuthUser->id());
+	}
+
+	/**
+	 * AuthUserComponentTest::testId()
+	 *
+	 * @return void
+	 */
+	public function testIsMe() {
+		$this->AuthUser->Auth->expects($this->any())
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1']));
+
+		$this->assertFalse($this->AuthUser->isMe(null));
+		$this->assertFalse($this->AuthUser->isMe(''));
+		$this->assertFalse($this->AuthUser->isMe(0));
+
+		$this->assertTrue($this->AuthUser->isMe('1'));
+		$this->assertTrue($this->AuthUser->isMe(1));
+	}
+
+	/**
+	 * AuthUserComponentTest::testUser()
+	 *
+	 * @return void
+	 */
+	public function testUser() {
+		$this->AuthUser->Auth->expects($this->any())
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1', 'username' => 'foo']));
+
+		$this->assertSame(['id' => '1', 'username' => 'foo'], $this->AuthUser->user());
+		$this->assertSame('foo', $this->AuthUser->user('username'));
+		$this->assertNull($this->AuthUser->user('foofoo'));
+	}
+
+	/**
+	 * AuthUserComponentTest::testRoles()
+	 *
+	 * @return void
+	 */
+	public function testRoles() {
+		$this->AuthUser->Auth->expects($this->once())
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1', 'Roles' => ['1', '2']]));
+
+		$this->assertSame(['1', '2'], $this->AuthUser->roles());
+	}
+
+	/**
+	 * AuthUserComponentTest::testRolesDeep()
+	 *
+	 * @return void
+	 */
+	public function testRolesDeep() {
+		$this->AuthUser->Auth->expects($this->once())
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1', 'Roles' => [['id' => '1'], ['id' => '2']]]));
+
+		$this->assertSame(['1', '2'], $this->AuthUser->roles());
+	}
+
+	/**
+	 * AuthUserComponentTest::testHasRole()
+	 *
+	 * @return void
+	 */
+	public function testHasRole() {
+		$this->AuthUser->Auth->expects($this->exactly(3))
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1', 'Roles' => [['id' => '1'], ['id' => '2']]]));
+
+		$this->assertTrue($this->AuthUser->hasRole(2));
+		$this->assertTrue($this->AuthUser->hasRole('2'));
+		$this->assertFalse($this->AuthUser->hasRole(3));
+
+		$this->assertTrue($this->AuthUser->hasRole(3, [1, 3]));
+		$this->assertFalse($this->AuthUser->hasRole(3, [2, 4]));
+	}
+
+	/**
+	 * AuthUserComponentTest::testHasRoles()
+	 *
+	 * @return void
+	 */
+	public function testHasRoles() {
+		$this->AuthUser->Auth->expects($this->exactly(6))
+			->method('user')
+			->with(null)
+			->will($this->returnValue(['id' => '1', 'Roles' => [['id' => '1'], ['id' => '2']]]));
+
+		$this->assertTrue($this->AuthUser->hasRoles([2]));
+		$this->assertTrue($this->AuthUser->hasRoles('2'));
+		$this->assertFalse($this->AuthUser->hasRoles([3, 4]));
+		$this->assertTrue($this->AuthUser->hasRoles([1, 2], false));
+
+		$this->assertTrue($this->AuthUser->hasRoles([1, 6], [1, 3, 5]));
+		$this->assertFalse($this->AuthUser->hasRoles([3, 4], [2, 4]));
+
+		$this->assertFalse($this->AuthUser->hasRoles([1, 3, 5], false, [1, 3]));
+		$this->assertTrue($this->AuthUser->hasRoles([1, 3, 5], false, [1, 3, 5]));
+	}
+
+}

tests/TestCase/View/Helper/AuthUserHelperTest.php

@@ -0,0 +1,170 @@
+<?php
+namespace Tools\Test\TestCase\View\Helper;
+
+use Tools\View\Helper\AuthUserHelper;
+use Cake\Core\Configure;
+use Cake\TestSuite\TestCase;
+use Cake\View\View;
+
+/**
+ * AuthUserHelper class
+ *
+ */
+class AuthUserHelperTest extends TestCase {
+
+	/**
+	 * fixtures
+	 *
+	 * @var string
+	 */
+	public $fixtures = array('core.sessions');
+
+	public $AuthUser;
+
+	/**
+	 * setUp method
+	 *
+	 * @return void
+	 */
+	public function setUp() {
+		parent::setUp();
+
+		$this->request = $this->getMock('Cake\Network\Request', ['cookie']);
+		$this->view = new View($this->request);
+		$this->AuthUser = new AuthUserHelper($this->view);
+	}
+
+	/**
+	 * tearDown method
+	 *
+	 * @return void
+	 */
+	public function tearDown() {
+		parent::tearDown();
+	}
+
+	/**
+	 * testSessionReadWrite method
+	 *
+	 * @return void
+	 * @expectedException RuntimeException
+	 */
+	public function testEmptyAuthSessionDueToMissing() {
+		$this->AuthUser->id();
+	}
+
+	/**
+	 * AuthUserHelperTest::testEmptyAuthSession()
+	 *
+	 * @return void
+	 */
+	public function testEmptyAuthSession() {
+		$this->view->viewVars['authUser'] = [];
+		$this->assertNull($this->AuthUser->id());
+
+		$this->assertFalse($this->AuthUser->isMe(null));
+		$this->assertFalse($this->AuthUser->isMe(''));
+		$this->assertFalse($this->AuthUser->isMe(0));
+		$this->assertFalse($this->AuthUser->isMe(1));
+	}
+
+	/**
+	 * AuthUserHelperTest::testId()
+	 *
+	 * @return void
+	 */
+	public function testId() {
+		$this->view->viewVars['authUser'] = ['id' => '1'];
+
+		$this->assertSame('1', $this->AuthUser->id());
+	}
+
+
+	/**
+	 * AuthUserHelperTest::testId()
+	 *
+	 * @return void
+	 */
+	public function testIsMe() {
+		$this->view->viewVars['authUser'] = ['id' => '1'];
+
+		$this->assertFalse($this->AuthUser->isMe(null));
+		$this->assertFalse($this->AuthUser->isMe(''));
+		$this->assertFalse($this->AuthUser->isMe(0));
+
+		$this->assertTrue($this->AuthUser->isMe('1'));
+		$this->assertTrue($this->AuthUser->isMe(1));
+	}
+
+	/**
+	 * AuthUserHelperTest::testUser()
+	 *
+	 * @return void
+	 */
+	public function testUser() {
+		$this->view->viewVars['authUser'] = ['id' => '1', 'username' => 'foo'];
+
+		$this->assertSame(['id' => '1', 'username' => 'foo'], $this->AuthUser->user());
+		$this->assertSame('foo', $this->AuthUser->user('username'));
+		$this->assertNull($this->AuthUser->user('foofoo'));
+	}
+
+	/**
+	 * AuthUserHelperTest::testRoles()
+	 *
+	 * @return void
+	 */
+	public function testRoles() {
+		$this->view->viewVars['authUser'] = ['id' => '1', 'Roles' => ['1', '2']];
+
+		$this->assertSame(['1', '2'], $this->AuthUser->roles());
+	}
+
+	/**
+	 * AuthUserHelperTest::testRolesDeep()
+	 *
+	 * @return void
+	 */
+	public function testRolesDeep() {
+		$this->view->viewVars['authUser'] = ['id' => '1', 'Roles' => [['id' => '1'], ['id' => '2']]];
+
+		$this->assertSame(['1', '2'], $this->AuthUser->roles());
+	}
+
+	/**
+	 * AuthUserHelperTest::testHasRole()
+	 *
+	 * @return void
+	 */
+	public function testHasRole() {
+		$this->view->viewVars['authUser'] = ['id' => '1', 'Roles' => [['id' => '1'], ['id' => '2']]];
+
+		$this->assertTrue($this->AuthUser->hasRole(2));
+		$this->assertTrue($this->AuthUser->hasRole('2'));
+		$this->assertFalse($this->AuthUser->hasRole(3));
+
+		$this->assertTrue($this->AuthUser->hasRole(3, [1, 3]));
+		$this->assertFalse($this->AuthUser->hasRole(3, [2, 4]));
+	}
+
+	/**
+	 * AuthUserHelperTest::testHasRoles()
+	 *
+	 * @return void
+	 */
+	public function testHasRoles() {
+		$this->view->viewVars['authUser'] = ['id' => '1', 'Roles' => [['id' => '1'], ['id' => '2']]];
+
+		$this->assertTrue($this->AuthUser->hasRoles([2]));
+		$this->assertTrue($this->AuthUser->hasRoles('2'));
+		$this->assertFalse($this->AuthUser->hasRoles([3, 4]));
+		$this->assertTrue($this->AuthUser->hasRoles([1, 2], false));
+
+		$this->assertTrue($this->AuthUser->hasRoles([1, 6], [1, 3, 5]));
+		$this->assertFalse($this->AuthUser->hasRoles([3, 4], [2, 4]));
+
+		$this->assertFalse($this->AuthUser->hasRoles([1, 3, 5], false, [1, 3]));
+		$this->assertTrue($this->AuthUser->hasRoles([1, 3, 5], false, [1, 3, 5]));
+	}
+
+}