AS1024/Kanboard-Prod
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rewrite of the authentication and authorization system

Browse Source
This commit is contained in:
Frederic Guillot
2015-12-05 20:31:27 -05:00
parent 346b8312e5
commit e9fedf3e5c
255 changed files with 14114 additions and 9820 deletions
Download Patch File Download Diff File Expand all files Collapse all files

296
tests/units/Model/AclTest.php
View File

@@ -1,296 +0,0 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\Acl;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\User;
class AclTest extends Base
{
public function testMatchAcl()
{
$acl_rules = array(
'controller1' => array('action1', 'action3'),
'controller3' => '*',
'controller5' => '-',
'controller6' => array(),
'controllera' => '*',
);
$acl = new Acl($this->container);
$this->assertTrue($acl->matchAcl($acl_rules, 'controller1', 'aCtiOn1'));
$this->assertTrue($acl->matchAcl($acl_rules, 'controller1', 'action1'));
$this->assertTrue($acl->matchAcl($acl_rules, 'controller1', 'action3'));
$this->assertFalse($acl->matchAcl($acl_rules, 'controller1', 'action2'));
$this->assertFalse($acl->matchAcl($acl_rules, 'controller2', 'action2'));
$this->assertFalse($acl->matchAcl($acl_rules, 'controller2', 'action3'));
$this->assertTrue($acl->matchAcl($acl_rules, 'controller3', 'anything'));
$this->assertFalse($acl->matchAcl($acl_rules, 'controller4', 'anything'));
$this->assertFalse($acl->matchAcl($acl_rules, 'controller5', 'anything'));
$this->assertFalse($acl->matchAcl($acl_rules, 'controller6', 'anything'));
$this->assertTrue($acl->matchAcl($acl_rules, 'ControllerA', 'anything'));
$this->assertTrue($acl->matchAcl($acl_rules, 'controllera', 'anything'));
}
public function testPublicActions()
{
$acl = new Acl($this->container);
$this->assertTrue($acl->isPublicAction('task', 'readonly'));
$this->assertTrue($acl->isPublicAction('board', 'readonly'));
$this->assertFalse($acl->isPublicAction('board', 'show'));
$this->assertTrue($acl->isPublicAction('feed', 'project'));
$this->assertTrue($acl->isPublicAction('feed', 'user'));
$this->assertTrue($acl->isPublicAction('ical', 'project'));
$this->assertTrue($acl->isPublicAction('ical', 'user'));
$this->assertTrue($acl->isPublicAction('oauth', 'github'));
$this->assertTrue($acl->isPublicAction('oauth', 'google'));
$this->assertTrue($acl->isPublicAction('auth', 'login'));
$this->assertTrue($acl->isPublicAction('auth', 'check'));
$this->assertTrue($acl->isPublicAction('auth', 'captcha'));
}
public function testAdminActions()
{
$acl = new Acl($this->container);
$this->assertFalse($acl->isAdminAction('board', 'show'));
$this->assertFalse($acl->isAdminAction('task', 'show'));
$this->assertTrue($acl->isAdminAction('config', 'api'));
$this->assertTrue($acl->isAdminAction('config', 'anything'));
$this->assertTrue($acl->isAdminAction('config', 'anything'));
$this->assertTrue($acl->isAdminAction('user', 'save'));
}
public function testProjectAdminActions()
{
$acl = new Acl($this->container);
$this->assertFalse($acl->isProjectAdminAction('config', 'save'));
$this->assertFalse($acl->isProjectAdminAction('user', 'index'));
$this->assertTrue($acl->isProjectAdminAction('project', 'remove'));
}
public function testProjectManagerActions()
{
$acl = new Acl($this->container);
$this->assertFalse($acl->isProjectManagerAction('board', 'readonly'));
$this->assertFalse($acl->isProjectManagerAction('project', 'remove'));
$this->assertFalse($acl->isProjectManagerAction('project', 'show'));
$this->assertTrue($acl->isProjectManagerAction('project', 'disable'));
$this->assertTrue($acl->isProjectManagerAction('category', 'index'));
$this->assertTrue($acl->isProjectManagerAction('project', 'users'));
$this->assertFalse($acl->isProjectManagerAction('app', 'index'));
}
public function testPageAccessNoSession()
{
$acl = new Acl($this->container);
$this->assertFalse($acl->isAllowed('board', 'readonly'));
$this->assertFalse($acl->isAllowed('task', 'show'));
$this->assertFalse($acl->isAllowed('config', 'application'));
$this->assertFalse($acl->isAllowed('project', 'users'));
$this->assertFalse($acl->isAllowed('task', 'remove'));
$this->assertTrue($acl->isAllowed('app', 'index'));
}
public function testPageAccessEmptySession()
{
$acl = new Acl($this->container);
$this->container['sessionStorage']->user = array();
$this->assertFalse($acl->isAllowed('board', 'readonly'));
$this->assertFalse($acl->isAllowed('task', 'show'));
$this->assertFalse($acl->isAllowed('config', 'application'));
$this->assertFalse($acl->isAllowed('project', 'users'));
$this->assertFalse($acl->isAllowed('task', 'remove'));
$this->assertTrue($acl->isAllowed('app', 'index'));
}
public function testPageAccessAdminUser()
{
$acl = new Acl($this->container);
$this->container['sessionStorage']->user = array(
'is_admin' => true,
);
$this->assertTrue($acl->isAllowed('board', 'readonly'));
$this->assertTrue($acl->isAllowed('task', 'readonly'));
$this->assertTrue($acl->isAllowed('webhook', 'github'));
$this->assertTrue($acl->isAllowed('task', 'show'));
$this->assertTrue($acl->isAllowed('task', 'update'));
$this->assertTrue($acl->isAllowed('config', 'application'));
$this->assertTrue($acl->isAllowed('project', 'show'));
$this->assertTrue($acl->isAllowed('project', 'users'));
$this->assertTrue($acl->isAllowed('project', 'remove'));
$this->assertTrue($acl->isAllowed('category', 'edit'));
$this->assertTrue($acl->isAllowed('task', 'remove'));
$this->assertTrue($acl->isAllowed('app', 'index'));
}
public function testPageAccessProjectAdmin()
{
$acl = new Acl($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$u = new User($this->container);
// We create our user
$this->assertEquals(2, $u->create(array('username' => 'unittest', 'password' => 'unittest')));
// We create a project and set our user as project manager
$this->assertEquals(1, $p->create(array('name' => 'UnitTest')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->isMember(1, 2));
$this->assertFalse($pp->isManager(1, 2));
// We fake a session for him
$this->container['sessionStorage']->user = array(
'id' => 2,
'is_admin' => false,
'is_project_admin' => true,
);
$this->assertTrue($acl->isAllowed('board', 'readonly', 1));
$this->assertTrue($acl->isAllowed('task', 'readonly', 1));
$this->assertTrue($acl->isAllowed('webhook', 'github', 1));
$this->assertTrue($acl->isAllowed('task', 'show', 1));
$this->assertFalse($acl->isAllowed('task', 'show', 2));
$this->assertTrue($acl->isAllowed('task', 'update', 1));
$this->assertTrue($acl->isAllowed('project', 'show', 1));
$this->assertFalse($acl->isAllowed('config', 'application', 1));
$this->assertTrue($acl->isAllowed('project', 'users', 1));
$this->assertFalse($acl->isAllowed('project', 'users', 2));
$this->assertTrue($acl->isAllowed('project', 'remove', 1));
$this->assertFalse($acl->isAllowed('project', 'remove', 2));
$this->assertTrue($acl->isAllowed('category', 'edit', 1));
$this->assertTrue($acl->isAllowed('task', 'remove', 1));
$this->assertTrue($acl->isAllowed('app', 'index', 1));
}
public function testPageAccessProjectManager()
{
$acl = new Acl($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$u = new User($this->container);
// We create our user
$this->assertEquals(2, $u->create(array('username' => 'unittest', 'password' => 'unittest')));
// We create a project and set our user as project manager
$this->assertEquals(1, $p->create(array('name' => 'UnitTest'), 2, true));
$this->assertTrue($pp->isMember(1, 2));
$this->assertTrue($pp->isManager(1, 2));
// We fake a session for him
$this->container['sessionStorage']->user = array(
'id' => 2,
'is_admin' => false,
);
$this->assertTrue($acl->isAllowed('board', 'readonly', 1));
$this->assertTrue($acl->isAllowed('task', 'readonly', 1));
$this->assertTrue($acl->isAllowed('webhook', 'github', 1));
$this->assertTrue($acl->isAllowed('task', 'show', 1));
$this->assertFalse($acl->isAllowed('task', 'show', 2));
$this->assertTrue($acl->isAllowed('task', 'update', 1));
$this->assertTrue($acl->isAllowed('project', 'show', 1));
$this->assertFalse($acl->isAllowed('config', 'application', 1));
$this->assertTrue($acl->isAllowed('project', 'users', 1));
$this->assertFalse($acl->isAllowed('project', 'users', 2));
$this->assertFalse($acl->isAllowed('project', 'remove', 1));
$this->assertFalse($acl->isAllowed('project', 'remove', 2));
$this->assertTrue($acl->isAllowed('category', 'edit', 1));
$this->assertTrue($acl->isAllowed('task', 'remove', 1));
$this->assertTrue($acl->isAllowed('app', 'index', 1));
}
public function testPageAccessMember()
{
$acl = new Acl($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$u = new User($this->container);
// We create our user
$this->assertEquals(2, $u->create(array('username' => 'unittest', 'password' => 'unittest')));
// We create a project and set our user as member
$this->assertEquals(1, $p->create(array('name' => 'UnitTest1')));
$this->assertEquals(2, $p->create(array('name' => 'UnitTest2')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->isMember(1, 2));
$this->assertFalse($pp->isManager(1, 2));
$this->container['sessionStorage']->user = array(
'id' => 2,
'is_admin' => false,
);
$this->assertTrue($acl->isAllowed('board', 'readonly', 1));
$this->assertTrue($acl->isAllowed('task', 'readonly', 1));
$this->assertTrue($acl->isAllowed('webhook', 'github', 1));
$this->assertFalse($acl->isAllowed('board', 'show', 2));
$this->assertTrue($acl->isAllowed('board', 'show', 1));
$this->assertFalse($acl->isAllowed('task', 'show', 2));
$this->assertTrue($acl->isAllowed('task', 'show', 1));
$this->assertTrue($acl->isAllowed('task', 'update', 1));
$this->assertTrue($acl->isAllowed('project', 'show', 1));
$this->assertFalse($acl->isAllowed('config', 'application', 1));
$this->assertFalse($acl->isAllowed('project', 'users', 1));
$this->assertTrue($acl->isAllowed('task', 'remove', 1));
$this->assertFalse($acl->isAllowed('task', 'remove', 2));
$this->assertTrue($acl->isAllowed('app', 'index', 1));
}
public function testPageAccessNotMember()
{
$acl = new Acl($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$u = new User($this->container);
// We create our user
$this->assertEquals(2, $u->create(array('username' => 'unittest', 'password' => 'unittest')));
// We create a project and set our user as member
$this->assertEquals(1, $p->create(array('name' => 'UnitTest1')));
$this->assertEquals(2, $p->create(array('name' => 'UnitTest2')));
$this->assertFalse($pp->isMember(1, 2));
$this->assertFalse($pp->isManager(1, 2));
$this->container['sessionStorage']->user = array(
'id' => 2,
'is_admin' => false,
);
$this->assertFalse($acl->isAllowed('board', 'show', 2));
$this->assertFalse($acl->isAllowed('board', 'show', 1));
$this->assertFalse($acl->isAllowed('task', 'show', 1));
$this->assertFalse($acl->isAllowed('task', 'update', 1));
$this->assertFalse($acl->isAllowed('project', 'show', 1));
$this->assertFalse($acl->isAllowed('config', 'application', 1));
$this->assertFalse($acl->isAllowed('project', 'users', 1));
$this->assertFalse($acl->isAllowed('task', 'remove', 1));
$this->assertTrue($acl->isAllowed('app', 'index', 1));
}
public function testExtend()
{
$acl = new Acl($this->container);
$this->assertFalse($acl->isProjectManagerAction('plop', 'show'));
$acl->extend('project_manager_acl', array('plop' => '*'));
$this->assertTrue($acl->isProjectManagerAction('plop', 'show'));
$this->assertTrue($acl->isProjectManagerAction('swimlane', 'index'));
}
}

27
tests/units/Model/ActionTest.php
View File

@@ -11,9 +11,10 @@ use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\Category;
use Kanboard\Model\User;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\ProjectUserRole;
use Kanboard\Integration\GithubWebhook;
use Kanboard\Integration\BitbucketWebhook;
use Kanboard\Core\Security\Role;
class ActionTest extends Base
{
@@ -62,7 +63,7 @@ class ActionTest extends Base
public function testResolveDuplicatedParameters()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$a = new Action($this->container);
$c = new Category($this->container);
$u = new User($this->container);
@@ -78,9 +79,9 @@ class ActionTest extends Base
$this->assertEquals(2, $u->create(array('username' => 'unittest1')));
$this->assertEquals(3, $u->create(array('username' => 'unittest2')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(1, 3));
$this->assertTrue($pp->addMember(2, 3));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 3, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(2, 3, Role::PROJECT_MEMBER));
// anything
$this->assertEquals('blah', $a->resolveParameters(array('name' => 'foobar', 'value' => 'blah'), 2));
@@ -113,7 +114,7 @@ class ActionTest extends Base
public function testDuplicateSuccess()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$a = new Action($this->container);
$u = new User($this->container);
@@ -123,9 +124,9 @@ class ActionTest extends Base
$this->assertEquals(2, $u->create(array('username' => 'unittest1')));
$this->assertEquals(3, $u->create(array('username' => 'unittest2')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(1, 3));
$this->assertTrue($pp->addMember(2, 3));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 3, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(2, 3, Role::PROJECT_MEMBER));
$this->assertEquals(1, $a->create(array(
'project_id' => 1,
@@ -159,7 +160,7 @@ class ActionTest extends Base
public function testDuplicateUnableToResolveParams()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$a = new Action($this->container);
$u = new User($this->container);
@@ -168,7 +169,7 @@ class ActionTest extends Base
$this->assertEquals(2, $u->create(array('username' => 'unittest1')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertEquals(1, $a->create(array(
'project_id' => 1,
@@ -196,7 +197,7 @@ class ActionTest extends Base
public function testDuplicateMixedResults()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$a = new Action($this->container);
$u = new User($this->container);
$c = new Category($this->container);
@@ -210,7 +211,7 @@ class ActionTest extends Base
$this->assertEquals(2, $u->create(array('username' => 'unittest1')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertEquals(1, $a->create(array(
'project_id' => 1,

39
tests/units/Model/AuthenticationTest.php
View File

@@ -1,39 +0,0 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\User;
use Kanboard\Model\Authentication;
class AuthenticationTest extends Base
{
public function testHasCaptcha()
{
$u = new User($this->container);
$a = new Authentication($this->container);
$this->assertFalse($a->hasCaptcha('not_found'));
$this->assertFalse($a->hasCaptcha('admin'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertFalse($a->hasCaptcha('not_found'));
$this->assertTrue($a->hasCaptcha('admin'));
}
public function testHandleFailedLogin()
{
$u = new User($this->container);
$a = new Authentication($this->container);
$this->assertFalse($u->isLocked('admin'));
for ($i = 0; $i <= 6; $i++) {
$a->handleFailedLogin('admin');
}
$this->assertTrue($u->isLocked('admin'));
}
}

37
tests/units/Model/ProjectDuplicationTest.php
View File

@@ -5,13 +5,14 @@ require_once __DIR__.'/../Base.php';
use Kanboard\Model\Action;
use Kanboard\Model\Project;
use Kanboard\Model\Category;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\ProjectUserRole;
use Kanboard\Model\ProjectDuplication;
use Kanboard\Model\User;
use Kanboard\Model\Swimlane;
use Kanboard\Model\Task;
use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Core\Security\Role;
class ProjectDuplicationTest extends Base
{
@@ -72,10 +73,10 @@ class ProjectDuplicationTest extends Base
$this->assertEquals(0, $project['is_public']);
$this->assertEmpty($project['token']);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$this->assertEquals(array(1 => 'admin'), $pp->getMembers(1));
$this->assertEquals(array(1 => 'admin'), $pp->getMembers(2));
$this->assertEquals(array(1 => 'admin'), $pp->getAssignableUsers(1));
$this->assertEquals(array(1 => 'admin'), $pp->getAssignableUsers(2));
}
public function testCloneProjectWithCategories()
@@ -114,7 +115,7 @@ class ProjectDuplicationTest extends Base
{
$p = new Project($this->container);
$c = new Category($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$u = new User($this->container);
$pd = new ProjectDuplication($this->container);
@@ -123,15 +124,12 @@ class ProjectDuplicationTest extends Base
$this->assertEquals(4, $u->create(array('username' => 'unittest3', 'password' => 'unittest')));
$this->assertEquals(1, $p->create(array('name' => 'P1')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(1, 4));
$this->assertTrue($pp->addManager(1, 3));
$this->assertTrue($pp->isMember(1, 2));
$this->assertTrue($pp->isMember(1, 3));
$this->assertTrue($pp->isMember(1, 4));
$this->assertFalse($pp->isManager(1, 2));
$this->assertTrue($pp->isManager(1, 3));
$this->assertFalse($pp->isManager(1, 4));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 3, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 4, Role::PROJECT_MANAGER));
$this->assertEquals(Role::PROJECT_MEMBER, $pp->getUserRole(1, 2));
$this->assertEquals(Role::PROJECT_MEMBER, $pp->getUserRole(1, 3));
$this->assertEquals(Role::PROJECT_MANAGER, $pp->getUserRole(1, 4));
$this->assertEquals(2, $pd->duplicate(1));
@@ -139,13 +137,10 @@ class ProjectDuplicationTest extends Base
$this->assertNotEmpty($project);
$this->assertEquals('P1 (Clone)', $project['name']);
$this->assertEquals(3, count($pp->getMembers(2)));
$this->assertTrue($pp->isMember(2, 2));
$this->assertTrue($pp->isMember(2, 3));
$this->assertTrue($pp->isMember(2, 4));
$this->assertFalse($pp->isManager(2, 2));
$this->assertTrue($pp->isManager(2, 3));
$this->assertFalse($pp->isManager(2, 4));
$this->assertEquals(3, count($pp->getUsers(2)));
$this->assertEquals(Role::PROJECT_MEMBER, $pp->getUserRole(2, 2));
$this->assertEquals(Role::PROJECT_MEMBER, $pp->getUserRole(2, 3));
$this->assertEquals(Role::PROJECT_MANAGER, $pp->getUserRole(2, 4));
}
public function testCloneProjectWithActionTaskAssignCurrentUser()

340
tests/units/Model/ProjectGroupRoleTest.php Normal file
View File

@@ -0,0 +1,340 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\Project;
use Kanboard\Model\User;
use Kanboard\Model\Group;
use Kanboard\Model\GroupMember;
use Kanboard\Model\ProjectGroupRole;
use Kanboard\Core\Security\Role;
class ProjectGroupRoleTest extends Base
{
public function testGetUserRole()
{
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$groupMemberModel = new GroupMember($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(1, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 1));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertEquals(Role::PROJECT_VIEWER, $groupRoleModel->getUserRole(1, 1));
$this->assertEquals('', $groupRoleModel->getUserRole(1, 2));
}
public function testAddGroup()
{
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(1, $groupModel->create('Test'));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertFalse($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$groups = $groupRoleModel->getGroups(1);
$this->assertCount(1, $groups);
$this->assertEquals(1, $groups[0]['id']);
$this->assertEquals('Test', $groups[0]['name']);
$this->assertEquals(Role::PROJECT_VIEWER, $groups[0]['role']);
}
public function testRemoveGroup()
{
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(1, $groupModel->create('Test'));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->removeGroup(1, 1));
$this->assertFalse($groupRoleModel->removeGroup(1, 1));
$this->assertEmpty($groupRoleModel->getGroups(1));
}
public function testChangeRole()
{
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(1, $groupModel->create('Test'));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->changeGroupRole(1, 1, Role::PROJECT_MANAGER));
$groups = $groupRoleModel->getGroups(1);
$this->assertCount(1, $groups);
$this->assertEquals(1, $groups[0]['id']);
$this->assertEquals('Test', $groups[0]['name']);
$this->assertEquals(Role::PROJECT_MANAGER, $groups[0]['role']);
}
public function testGetGroups()
{
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$groups = $groupRoleModel->getGroups(1);
$this->assertCount(3, $groups);
$this->assertEquals(3, $groups[0]['id']);
$this->assertEquals('Group A', $groups[0]['name']);
$this->assertEquals(Role::PROJECT_MANAGER, $groups[0]['role']);
$this->assertEquals(2, $groups[1]['id']);
$this->assertEquals('Group B', $groups[1]['name']);
$this->assertEquals(Role::PROJECT_MEMBER, $groups[1]['role']);
$this->assertEquals(1, $groups[2]['id']);
$this->assertEquals('Group C', $groups[2]['name']);
$this->assertEquals(Role::PROJECT_VIEWER, $groups[2]['role']);
}
public function testGetUsers()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1')));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(1, $groupModel->create('Group A'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group C'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$users = $groupRoleModel->getUsers(2);
$this->assertCount(0, $users);
$users = $groupRoleModel->getUsers(1);
$this->assertCount(3, $users);
$this->assertEquals(2, $users[0]['id']);
$this->assertEquals('user 1', $users[0]['username']);
$this->assertEquals('User #1', $users[0]['name']);
$this->assertEquals(Role::PROJECT_MANAGER, $users[0]['role']);
$this->assertEquals(3, $users[1]['id']);
$this->assertEquals('user 2', $users[1]['username']);
$this->assertEquals('', $users[1]['name']);
$this->assertEquals(Role::PROJECT_MEMBER, $users[1]['role']);
$this->assertEquals(4, $users[2]['id']);
$this->assertEquals('user 3', $users[2]['username']);
$this->assertEquals('', $users[2]['name']);
$this->assertEquals(Role::PROJECT_VIEWER, $users[2]['role']);
}
public function testGetAssignableUsers()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1')));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(1, $groupModel->create('Group A'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group C'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$users = $groupRoleModel->getAssignableUsers(2);
$this->assertCount(0, $users);
$users = $groupRoleModel->getAssignableUsers(1);
$this->assertCount(2, $users);
$this->assertEquals(2, $users[0]['id']);
$this->assertEquals('user 1', $users[0]['username']);
$this->assertEquals('User #1', $users[0]['name']);
$this->assertEquals(3, $users[1]['id']);
$this->assertEquals('user 2', $users[1]['username']);
$this->assertEquals('', $users[1]['name']);
}
public function testGetProjectsByUser()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1')));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(2, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$projects = $groupRoleModel->getProjectsByUser(2);
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $groupRoleModel->getProjectsByUser(3);
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $groupRoleModel->getProjectsByUser(4);
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $groupRoleModel->getProjectsByUser(5);
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
}
public function testGetActiveProjectsByUser()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1', 'is_active' => 0)));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(2, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$projects = $groupRoleModel->getProjectsByUser(2, array(Project::ACTIVE));
$this->assertCount(0, $projects);
$projects = $groupRoleModel->getProjectsByUser(3, array(Project::ACTIVE));
$this->assertCount(0, $projects);
$projects = $groupRoleModel->getProjectsByUser(4, array(Project::ACTIVE));
$this->assertCount(0, $projects);
$projects = $groupRoleModel->getProjectsByUser(5, array(Project::ACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
}
public function testGetInactiveProjectsByUser()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1', 'is_active' => 0)));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(2, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$projects = $groupRoleModel->getProjectsByUser(2, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $groupRoleModel->getProjectsByUser(3, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $groupRoleModel->getProjectsByUser(4, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $groupRoleModel->getProjectsByUser(5, array(Project::INACTIVE));
$this->assertCount(0, $projects);
}
}

318
tests/units/Model/ProjectPermissionTest.php
View File

@@ -2,286 +2,54 @@
require_once __DIR__.'/../Base.php';
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\Project;
use Kanboard\Model\User;
use Kanboard\Model\Group;
use Kanboard\Model\GroupMember;
use Kanboard\Model\ProjectGroupRole;
use Kanboard\Model\ProjectUserRole;
use Kanboard\Core\Security\Role;
class ProjectPermissionTest extends Base
{
public function testAllowEverybody()
public function testDuplicate()
{
$user = new User($this->container);
$this->assertNotFalse($user->create(array('username' => 'unittest#1', 'password' => 'unittest')));
$this->assertNotFalse($user->create(array('username' => 'unittest#2', 'password' => 'unittest')));
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$this->assertEquals(1, $p->create(array('name' => 'UnitTest')));
$this->assertFalse($pp->isEverybodyAllowed(1));
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertFalse($pp->isUserAllowed(1, 2));
$this->assertFalse($pp->isUserAllowed(1, 3));
$this->assertEquals(array(), $pp->getMembers(1));
$this->assertEquals(array('Unassigned'), $pp->getMemberList(1));
$this->assertEmpty($pp->getMemberProjects(1));
$this->assertEmpty($pp->getMemberProjects(2));
$this->assertEmpty($pp->getMemberProjects(3));
$this->assertEmpty($pp->getMemberProjectIds(1));
$this->assertEmpty($pp->getMemberProjectIds(2));
$this->assertEmpty($pp->getMemberProjectIds(3));
$this->assertEmpty($pp->getActiveMemberProjectIds(1));
$this->assertEmpty($pp->getActiveMemberProjectIds(2));
$this->assertEmpty($pp->getActiveMemberProjectIds(3));
$this->assertEmpty($pp->getActiveMemberProjects(1));
$this->assertEmpty($pp->getActiveMemberProjects(2));
$this->assertEmpty($pp->getActiveMemberProjects(3));
$this->assertTrue($p->update(array('id' => 1, 'is_everybody_allowed' => 1)));
$this->assertTrue($pp->isEverybodyAllowed(1));
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertTrue($pp->isUserAllowed(1, 2));
$this->assertTrue($pp->isUserAllowed(1, 3));
$this->assertEquals(array('1' => 'admin', '2' => 'unittest#1', '3' => 'unittest#2'), $pp->getMembers(1));
$this->assertEquals(array('Unassigned', '1' => 'admin', '2' => 'unittest#1', '3' => 'unittest#2'), $pp->getMemberList(1));
$this->assertNotEmpty($pp->getMemberProjects(1));
$this->assertNotEmpty($pp->getMemberProjects(2));
$this->assertNotEmpty($pp->getMemberProjects(3));
$this->assertNotEmpty($pp->getMemberProjectIds(1));
$this->assertNotEmpty($pp->getMemberProjectIds(2));
$this->assertNotEmpty($pp->getMemberProjectIds(3));
$this->assertNotEmpty($pp->getActiveMemberProjectIds(1));
$this->assertNotEmpty($pp->getActiveMemberProjectIds(2));
$this->assertNotEmpty($pp->getActiveMemberProjectIds(3));
$this->assertNotEmpty($pp->getActiveMemberProjects(1));
$this->assertNotEmpty($pp->getActiveMemberProjects(2));
$this->assertNotEmpty($pp->getActiveMemberProjects(3));
$this->assertTrue($p->disable(1));
$this->assertEmpty($pp->getActiveMemberProjectIds(1));
$this->assertEmpty($pp->getActiveMemberProjectIds(2));
$this->assertEmpty($pp->getActiveMemberProjectIds(3));
$this->assertEmpty($pp->getActiveMemberProjects(1));
$this->assertEmpty($pp->getActiveMemberProjects(2));
$this->assertEmpty($pp->getActiveMemberProjects(3));
}
public function testDisallowEverybody()
{
// We create a regular user
$user = new User($this->container);
$user->create(array('username' => 'unittest', 'password' => 'unittest'));
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$this->assertEquals(1, $p->create(array('name' => 'UnitTest')));
$this->assertEmpty($pp->getMembers(1)); // Nobody is specified for the given project
$this->assertTrue($pp->isUserAllowed(1, 1)); // Admin should be allowed
$this->assertFalse($pp->isUserAllowed(1, 2)); // Regular user should be denied
}
public function testAllowUser()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$user = new User($this->container);
$this->assertNotFalse($user->create(array('username' => 'unittest', 'password' => 'unittest')));
// We create a project
$this->assertEquals(1, $p->create(array('name' => 'UnitTest')));
$this->assertEmpty($pp->getMemberProjects(1));
$this->assertEmpty($pp->getMemberProjects(2));
$this->assertEmpty($pp->getMemberProjectIds(1));
$this->assertEmpty($pp->getMemberProjectIds(2));
$this->assertEmpty($pp->getActiveMemberProjectIds(1));
$this->assertEmpty($pp->getActiveMemberProjectIds(2));
$this->assertEmpty($pp->getActiveMemberProjects(1));
$this->assertEmpty($pp->getActiveMemberProjects(2));
// We allow the admin user
$this->assertTrue($pp->addMember(1, 1));
$this->assertTrue($pp->addMember(1, 2));
// Non-existant project
$this->assertFalse($pp->addMember(50, 1));
// Non-existant user
$this->assertFalse($pp->addMember(1, 50));
// Both users should be allowed
$this->assertEquals(array('1' => 'admin', '2' => 'unittest'), $pp->getMembers(1));
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertTrue($pp->isUserAllowed(1, 2));
$this->assertNotEmpty($pp->getMemberProjects(1));
$this->assertNotEmpty($pp->getMemberProjects(2));
$this->assertNotEmpty($pp->getMemberProjectIds(1));
$this->assertNotEmpty($pp->getMemberProjectIds(2));
$this->assertNotEmpty($pp->getActiveMemberProjectIds(1));
$this->assertNotEmpty($pp->getActiveMemberProjectIds(2));
$this->assertNotEmpty($pp->getActiveMemberProjects(1));
$this->assertNotEmpty($pp->getActiveMemberProjects(2));
}
public function testRevokeUser()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$user = new User($this->container);
$user->create(array('username' => 'unittest', 'password' => 'unittest'));
// We create a project
$this->assertEquals(1, $p->create(array('name' => 'UnitTest')));
// We revoke our admin user (not existing row)
$this->assertFalse($pp->revokeMember(1, 1));
// We should have nobody in the users list
$this->assertEmpty($pp->getMembers(1));
// Only admin is allowed
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertFalse($pp->isUserAllowed(1, 2));
// We allow only the regular user
$this->assertTrue($pp->addMember(1, 2));
// All users should be allowed (admin and regular)
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertTrue($pp->isUserAllowed(1, 2));
// However, we should have only our regular user in the list
$this->assertEquals(array('2' => 'unittest'), $pp->getMembers(1));
// We allow our admin, we should have both in the list
$this->assertTrue($pp->addMember(1, 1));
$this->assertEquals(array('1' => 'admin', '2' => 'unittest'), $pp->getMembers(1));
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertTrue($pp->isUserAllowed(1, 2));
// We revoke the regular user
$this->assertTrue($pp->revokeMember(1, 2));
// Only admin should be allowed
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertFalse($pp->isUserAllowed(1, 2));
// We should have only admin in the list
$this->assertEquals(array('1' => 'admin'), $pp->getMembers(1));
// We revoke the admin user
$this->assertTrue($pp->revokeMember(1, 1));
$this->assertEmpty($pp->getMembers(1));
// Only admin should be allowed again
$this->assertTrue($pp->isUserAllowed(1, 1));
$this->assertFalse($pp->isUserAllowed(1, 2));
}
public function testManager()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$u = new User($this->container);
$this->assertEquals(2, $u->create(array('username' => 'unittest', 'password' => 'unittest')));
$this->assertEquals(1, $p->create(array('name' => 'UnitTest1')));
$this->assertFalse($pp->isMember(1, 2));
$this->assertFalse($pp->isManager(1, 2));
$this->assertEquals(2, $p->create(array('name' => 'UnitTest2'), 1, true));
$this->assertFalse($pp->isMember(2, 2));
$this->assertFalse($pp->isManager(2, 2));
$this->assertEquals(3, $p->create(array('name' => 'UnitTest3'), 2, true));
$this->assertTrue($pp->isMember(3, 2));
$this->assertTrue($pp->isManager(3, 2));
$this->assertEquals(4, $p->create(array('name' => 'UnitTest4')));
$this->assertTrue($pp->addManager(4, 2));
$this->assertTrue($pp->isMember(4, 2));
$this->assertTrue($pp->isManager(4, 2));
$this->assertEquals(5, $p->create(array('name' => 'UnitTest5')));
$this->assertTrue($pp->addMember(5, 2));
$this->assertTrue($pp->changeRole(5, 2, 1));
$this->assertTrue($pp->isMember(5, 2));
$this->assertTrue($pp->isManager(5, 2));
$this->assertTrue($pp->changeRole(5, 2, 0));
$this->assertTrue($pp->isMember(5, 2));
$this->assertFalse($pp->isManager(5, 2));
}
public function testUsersList()
{
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$user = new User($this->container);
$this->assertNotFalse($user->create(array('username' => 'unittest', 'password' => 'unittest')));
// We create project
$this->assertEquals(1, $p->create(array('name' => 'UnitTest')));
// No restriction, we should have no body
$this->assertEquals(
array('Unassigned'),
$pp->getMemberList(1)
);
// We allow only the regular user
$this->assertTrue($pp->addMember(1, 2));
$this->assertEquals(
array(0 => 'Unassigned', 2 => 'unittest'),
$pp->getMemberList(1)
);
// We allow the admin user
$this->assertTrue($pp->addMember(1, 1));
$this->assertEquals(
array(0 => 'Unassigned', 1 => 'admin', 2 => 'unittest'),
$pp->getMemberList(1)
);
// We revoke only the regular user
$this->assertTrue($pp->revokeMember(1, 2));
$this->assertEquals(
array(0 => 'Unassigned', 1 => 'admin'),
$pp->getMemberList(1)
);
// We revoke only the admin user, we should have everybody
$this->assertTrue($pp->revokeMember(1, 1));
$this->assertEquals(
array(0 => 'Unassigned'),
$pp->getMemberList(1)
);
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$projectPermission = new ProjectPermission($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1')));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(6, $userModel->create(array('username' => 'user 5', 'name' => 'User #5')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 5, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 6, Role::PROJECT_MEMBER));
$this->assertTrue($projectPermission->duplicate(1, 2));
$this->assertCount(2, $userRoleModel->getUsers(2));
$this->assertCount(3, $groupRoleModel->getUsers(2));
}
}

1
tests/units/Model/ProjectTest.php
View File

@@ -5,7 +5,6 @@ require_once __DIR__.'/../Base.php';
use Kanboard\Core\Translator;
use Kanboard\Subscriber\ProjectModificationDateSubscriber;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\User;
use Kanboard\Model\Task;
use Kanboard\Model\TaskCreation;

400
tests/units/Model/ProjectUserRoleTest.php Normal file
View File

@@ -0,0 +1,400 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\Project;
use Kanboard\Model\User;
use Kanboard\Model\Group;
use Kanboard\Model\GroupMember;
use Kanboard\Model\ProjectGroupRole;
use Kanboard\Model\ProjectUserRole;
use Kanboard\Core\Security\Role;
class ProjectUserRoleTest extends Base
{
public function testAddUser()
{
$projectModel = new Project($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_VIEWER));
$this->assertFalse($userRoleModel->addUser(1, 1, Role::PROJECT_VIEWER));
$users = $userRoleModel->getUsers(1);
$this->assertCount(1, $users);
$this->assertEquals(1, $users[0]['id']);
$this->assertEquals('admin', $users[0]['username']);
$this->assertEquals('', $users[0]['name']);
$this->assertEquals(Role::PROJECT_VIEWER, $users[0]['role']);
}
public function testRemoveUser()
{
$projectModel = new Project($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->removeUser(1, 1));
$this->assertFalse($userRoleModel->removeUser(1, 1));
$this->assertEmpty($userRoleModel->getUsers(1));
}
public function testChangeRole()
{
$projectModel = new Project($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($userRoleModel->changeUserRole(1, 1, Role::PROJECT_MANAGER));
$users = $userRoleModel->getUsers(1);
$this->assertCount(1, $users);
$this->assertEquals(1, $users[0]['id']);
$this->assertEquals('admin', $users[0]['username']);
$this->assertEquals('', $users[0]['name']);
$this->assertEquals(Role::PROJECT_MANAGER, $users[0]['role']);
}
public function testGetRole()
{
$projectModel = new Project($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEmpty($userRoleModel->getUserRole(1, 1));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_VIEWER));
$this->assertEquals(Role::PROJECT_VIEWER, $userRoleModel->getUserRole(1, 1));
$this->assertTrue($userRoleModel->changeUserRole(1, 1, Role::PROJECT_MEMBER));
$this->assertEquals(Role::PROJECT_MEMBER, $userRoleModel->getUserRole(1, 1));
$this->assertTrue($userRoleModel->changeUserRole(1, 1, Role::PROJECT_MANAGER));
$this->assertEquals(Role::PROJECT_MANAGER, $userRoleModel->getUserRole(1, 1));
$this->assertEquals('', $userRoleModel->getUserRole(1, 2));
}
public function testGetRoleWithGroups()
{
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$groupMemberModel = new GroupMember($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(1, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 1));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertEquals(Role::PROJECT_VIEWER, $userRoleModel->getUserRole(1, 1));
$this->assertEquals('', $userRoleModel->getUserRole(1, 2));
}
public function testGetAssignableUsersWithoutGroups()
{
$projectModel = new Project($this->container);
$userModel = new User($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(2, $userModel->create(array('username' => 'user1', 'name' => 'User1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user2', 'name' => 'User2')));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(1, 2, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 3, Role::PROJECT_VIEWER));
$users = $userRoleModel->getAssignableUsers(1);
$this->assertCount(2, $users);
$this->assertEquals('admin', $users[1]);
$this->assertEquals('User1', $users[2]);
}
public function testGetAssignableUsersWithGroups()
{
$projectModel = new Project($this->container);
$userModel = new User($this->container);
$groupModel = new Group($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$groupMemberModel = new GroupMember($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test')));
$this->assertEquals(2, $userModel->create(array('username' => 'user1', 'name' => 'User1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user2', 'name' => 'User2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user3', 'name' => 'User3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user4', 'name' => 'User4')));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(1, 2, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 3, Role::PROJECT_VIEWER));
$this->assertEquals(1, $groupModel->create('Group A'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(1, 2, Role::PROJECT_MEMBER));
$users = $userRoleModel->getAssignableUsers(1);
$this->assertCount(3, $users);
$this->assertEquals('admin', $users[1]);
$this->assertEquals('User1', $users[2]);
$this->assertEquals('User4', $users[5]);
}
public function testGetAssignableUsersList()
{
$projectModel = new Project($this->container);
$userModel = new User($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test1')));
$this->assertEquals(2, $projectModel->create(array('name' => 'Test2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user1', 'name' => 'User1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user2', 'name' => 'User2')));
$this->assertTrue($userRoleModel->addUser(2, 1, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(1, 1, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(1, 2, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 3, Role::PROJECT_VIEWER));
$users = $userRoleModel->getAssignableUsersList(1);
$this->assertCount(3, $users);
$this->assertEquals('Unassigned', $users[0]);
$this->assertEquals('admin', $users[1]);
$this->assertEquals('User1', $users[2]);
$users = $userRoleModel->getAssignableUsersList(1, true, true, true);
$this->assertCount(4, $users);
$this->assertEquals('Unassigned', $users[0]);
$this->assertEquals('Everybody', $users[-1]);
$this->assertEquals('admin', $users[1]);
$this->assertEquals('User1', $users[2]);
$users = $userRoleModel->getAssignableUsersList(2, true, true, true);
$this->assertCount(1, $users);
$this->assertEquals('admin', $users[1]);
}
public function testGetAssignableUsersWithEverybodyAllowed()
{
$projectModel = new Project($this->container);
$userModel = new User($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Test', 'is_everybody_allowed' => 1)));
$this->assertEquals(2, $userModel->create(array('username' => 'user1', 'name' => 'User1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user2', 'name' => 'User2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user3', 'name' => 'User3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user4', 'name' => 'User4')));
$users = $userRoleModel->getAssignableUsers(1);
$this->assertCount(5, $users);
$this->assertEquals('admin', $users[1]);
$this->assertEquals('User1', $users[2]);
$this->assertEquals('User2', $users[3]);
$this->assertEquals('User3', $users[4]);
$this->assertEquals('User4', $users[5]);
}
public function testGetProjectsByUser()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1')));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(6, $userModel->create(array('username' => 'user 5', 'name' => 'User #5')));
$this->assertEquals(7, $userModel->create(array('username' => 'user 6')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(2, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 6, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(2, 6, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(2, 7, Role::PROJECT_MEMBER));
$projects = $userRoleModel->getProjectsByUser(2);
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(3);
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(4);
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(5);
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
$projects = $userRoleModel->getProjectsByUser(6);
$this->assertCount(2, $projects);
$this->assertEquals('Project 1', $projects[1]);
$this->assertEquals('Project 2', $projects[2]);
$projects = $userRoleModel->getProjectsByUser(7);
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
}
public function testGetActiveProjectsByUser()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1', 'is_active' => 0)));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(6, $userModel->create(array('username' => 'user 5', 'name' => 'User #5')));
$this->assertEquals(7, $userModel->create(array('username' => 'user 6')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(2, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 6, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(2, 6, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(2, 7, Role::PROJECT_MEMBER));
$projects = $userRoleModel->getProjectsByUser(2, array(Project::ACTIVE));
$this->assertCount(0, $projects);
$projects = $userRoleModel->getProjectsByUser(3, array(Project::ACTIVE));
$this->assertCount(0, $projects);
$projects = $userRoleModel->getProjectsByUser(4, array(Project::ACTIVE));
$this->assertCount(0, $projects);
$projects = $userRoleModel->getProjectsByUser(5, array(Project::ACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
$projects = $userRoleModel->getProjectsByUser(6, array(Project::ACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
$projects = $userRoleModel->getProjectsByUser(7, array(Project::ACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 2', $projects[2]);
}
public function testGetInactiveProjectsByUser()
{
$userModel = new User($this->container);
$projectModel = new Project($this->container);
$groupModel = new Group($this->container);
$groupMemberModel = new GroupMember($this->container);
$groupRoleModel = new ProjectGroupRole($this->container);
$userRoleModel = new ProjectUserRole($this->container);
$this->assertEquals(1, $projectModel->create(array('name' => 'Project 1', 'is_active' => 0)));
$this->assertEquals(2, $projectModel->create(array('name' => 'Project 2')));
$this->assertEquals(2, $userModel->create(array('username' => 'user 1', 'name' => 'User #1')));
$this->assertEquals(3, $userModel->create(array('username' => 'user 2')));
$this->assertEquals(4, $userModel->create(array('username' => 'user 3')));
$this->assertEquals(5, $userModel->create(array('username' => 'user 4')));
$this->assertEquals(6, $userModel->create(array('username' => 'user 5', 'name' => 'User #5')));
$this->assertEquals(7, $userModel->create(array('username' => 'user 6')));
$this->assertEquals(1, $groupModel->create('Group C'));
$this->assertEquals(2, $groupModel->create('Group B'));
$this->assertEquals(3, $groupModel->create('Group A'));
$this->assertTrue($groupMemberModel->addUser(1, 4));
$this->assertTrue($groupMemberModel->addUser(2, 5));
$this->assertTrue($groupMemberModel->addUser(3, 3));
$this->assertTrue($groupMemberModel->addUser(3, 2));
$this->assertTrue($groupRoleModel->addGroup(1, 1, Role::PROJECT_VIEWER));
$this->assertTrue($groupRoleModel->addGroup(2, 2, Role::PROJECT_MEMBER));
$this->assertTrue($groupRoleModel->addGroup(1, 3, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(1, 6, Role::PROJECT_MANAGER));
$this->assertTrue($userRoleModel->addUser(2, 6, Role::PROJECT_MEMBER));
$this->assertTrue($userRoleModel->addUser(2, 7, Role::PROJECT_MEMBER));
$projects = $userRoleModel->getProjectsByUser(2, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(3, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(4, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(5, array(Project::INACTIVE));
$this->assertCount(0, $projects);
$projects = $userRoleModel->getProjectsByUser(6, array(Project::INACTIVE));
$this->assertCount(1, $projects);
$this->assertEquals('Project 1', $projects[1]);
$projects = $userRoleModel->getProjectsByUser(7, array(Project::INACTIVE));
$this->assertCount(0, $projects);
}
}

2
tests/units/Model/SubtaskTest.php
View File

@@ -8,7 +8,7 @@ use Kanboard\Model\Subtask;
use Kanboard\Model\Project;
use Kanboard\Model\Category;
use Kanboard\Model\User;
use Kanboard\Model\UserSession;
use Kanboard\Core\User\UserSession;
class SubtaskTest extends Base
{

1
tests/units/Model/TaskCreationTest.php
View File

@@ -8,7 +8,6 @@ use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\TaskStatus;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
class TaskCreationTest extends Base
{

35
tests/units/Model/TaskDuplicationTest.php
View File

@@ -8,10 +8,11 @@ use Kanboard\Model\TaskDuplication;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\TaskStatus;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\ProjectUserRole;
use Kanboard\Model\Category;
use Kanboard\Model\User;
use Kanboard\Model\Swimlane;
use Kanboard\Core\Security\Role;
class TaskDuplicationTest extends Base
{
@@ -127,7 +128,7 @@ class TaskDuplicationTest extends Base
// Check the values of the duplicated task
$task = $tf->getById(2);
$this->assertNotEmpty($task);
$this->assertEquals(1, $task['owner_id']);
$this->assertEquals(0, $task['owner_id']);
$this->assertEquals(0, $task['category_id']);
$this->assertEquals(0, $task['swimlane_id']);
$this->assertEquals(6, $task['column_id']);
@@ -333,7 +334,7 @@ class TaskDuplicationTest extends Base
$tc = new TaskCreation($this->container);
$tf = new TaskFinder($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
// We create 2 projects
$this->assertEquals(1, $p->create(array('name' => 'test1')));
@@ -357,10 +358,8 @@ class TaskDuplicationTest extends Base
// We create a new user for our project
$user = new User($this->container);
$this->assertNotFalse($user->create(array('username' => 'unittest#1', 'password' => 'unittest')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(2, 2));
$this->assertTrue($pp->isUserAllowed(1, 2));
$this->assertTrue($pp->isUserAllowed(2, 2));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(2, 2, Role::PROJECT_MEMBER));
// We duplicate our task to the 2nd project
$this->assertEquals(3, $td->duplicateToProject(1, 2));
@@ -391,7 +390,7 @@ class TaskDuplicationTest extends Base
$tc = new TaskCreation($this->container);
$tf = new TaskFinder($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pr = new ProjectUserRole($this->container);
// We create 2 projects
$this->assertEquals(1, $p->create(array('name' => 'test1')));
@@ -399,6 +398,7 @@ class TaskDuplicationTest extends Base
// We create a task
$this->assertEquals(1, $tc->create(array('title' => 'test', 'project_id' => 1, 'column_id' => 2, 'owner_id' => 2)));
$this->assertTrue($pr->addUser(2, 1, Role::PROJECT_MEMBER));
// We duplicate our task to the 2nd project
$this->assertEquals(2, $td->duplicateToProject(1, 2, null, null, null, 1));
@@ -425,7 +425,6 @@ class TaskDuplicationTest extends Base
$tc = new TaskCreation($this->container);
$tf = new TaskFinder($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$user = new User($this->container);
// We create 2 projects
@@ -446,7 +445,7 @@ class TaskDuplicationTest extends Base
// Check the values of the moved task
$task = $tf->getById(1);
$this->assertNotEmpty($task);
$this->assertEquals(1, $task['owner_id']);
$this->assertEquals(0, $task['owner_id']);
$this->assertEquals(0, $task['category_id']);
$this->assertEquals(0, $task['swimlane_id']);
$this->assertEquals(2, $task['project_id']);
@@ -496,7 +495,7 @@ class TaskDuplicationTest extends Base
$tc = new TaskCreation($this->container);
$tf = new TaskFinder($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$user = new User($this->container);
// We create 2 projects
@@ -505,10 +504,8 @@ class TaskDuplicationTest extends Base
// We create a new user for our project
$this->assertNotFalse($user->create(array('username' => 'unittest#1', 'password' => 'unittest')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(2, 2));
$this->assertTrue($pp->isUserAllowed(1, 2));
$this->assertTrue($pp->isUserAllowed(2, 2));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(2, 2, Role::PROJECT_MEMBER));
// We create a task
$this->assertEquals(1, $tc->create(array('title' => 'test', 'project_id' => 1, 'column_id' => 2, 'owner_id' => 2)));
@@ -531,7 +528,7 @@ class TaskDuplicationTest extends Base
$tc = new TaskCreation($this->container);
$tf = new TaskFinder($this->container);
$p = new Project($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$user = new User($this->container);
// We create 2 projects
@@ -540,10 +537,8 @@ class TaskDuplicationTest extends Base
// We create a new user for our project
$this->assertNotFalse($user->create(array('username' => 'unittest#1', 'password' => 'unittest')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(2, 2));
$this->assertTrue($pp->isUserAllowed(1, 2));
$this->assertTrue($pp->isUserAllowed(2, 2));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(2, 2, Role::PROJECT_MEMBER));
// We create a task
$this->assertEquals(1, $tc->create(array('title' => 'test', 'project_id' => 1, 'column_id' => 2, 'owner_id' => 3)));

1
tests/units/Model/TaskFinderTest.php
View File

@@ -6,7 +6,6 @@ use Kanboard\Model\Task;
use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\Category;
use Kanboard\Model\User;

1
tests/units/Model/TaskModificationTest.php
View File

@@ -8,7 +8,6 @@ use Kanboard\Model\TaskModification;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\TaskStatus;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
class TaskModificationTest extends Base
{

2
tests/units/Model/TaskPermissionTest.php
View File

@@ -9,7 +9,7 @@ use Kanboard\Model\TaskPermission;
use Kanboard\Model\Project;
use Kanboard\Model\Category;
use Kanboard\Model\User;
use Kanboard\Model\UserSession;
use Kanboard\Core\User\UserSession;
class TaskPermissionTest extends Base
{

1
tests/units/Model/TaskStatusTest.php
View File

@@ -8,7 +8,6 @@ use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\TaskStatus;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
class TaskStatusTest extends Base
{

1
tests/units/Model/TaskTest.php
View File

@@ -7,7 +7,6 @@ use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\TaskStatus;
use Kanboard\Model\Project;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\Category;
use Kanboard\Model\User;

43
tests/units/Model/UserLockingTest.php Normal file
View File

@@ -0,0 +1,43 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\UserLocking;
class UserLockingTest extends Base
{
public function testFailedLogin()
{
$u = new UserLocking($this->container);
$this->assertEquals(0, $u->getFailedLogin('admin'));
$this->assertEquals(0, $u->getFailedLogin('not_found'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertEquals(2, $u->getFailedLogin('admin'));
$this->assertTrue($u->resetFailedLogin('admin'));
$this->assertEquals(0, $u->getFailedLogin('admin'));
}
public function testLocking()
{
$u = new UserLocking($this->container);
$this->assertFalse($u->isLocked('admin'));
$this->assertFalse($u->isLocked('not_found'));
$this->assertTrue($u->lock('admin', 1));
$this->assertTrue($u->isLocked('admin'));
}
public function testCaptcha()
{
$u = new UserLocking($this->container);
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertFalse($u->hasCaptcha('admin', 2));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertTrue($u->hasCaptcha('admin', 2));
}
}

22
tests/units/Model/UserNotificationTest.php
View File

@@ -9,12 +9,14 @@ use Kanboard\Model\Comment;
use Kanboard\Model\User;
use Kanboard\Model\File;
use Kanboard\Model\Project;
use Kanboard\Model\Task;
use Kanboard\Model\ProjectPermission;
use Kanboard\Model\Task;
use Kanboard\Model\ProjectUserRole;
use Kanboard\Model\UserNotification;
use Kanboard\Model\UserNotificationFilter;
use Kanboard\Model\UserNotificationType;
use Kanboard\Subscriber\UserNotificationSubscriber;
use Kanboard\Core\Security\Role;
class UserNotificationTest extends Base
{
@@ -23,11 +25,11 @@ class UserNotificationTest extends Base
$u = new User($this->container);
$p = new Project($this->container);
$n = new UserNotification($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$this->assertEquals(1, $p->create(array('name' => 'UnitTest1')));
$this->assertEquals(2, $u->create(array('username' => 'user1')));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertEmpty($n->getUsersWithNotificationEnabled(1));
$n->enableNotification(2);
@@ -101,7 +103,7 @@ class UserNotificationTest extends Base
$u = new User($this->container);
$p = new Project($this->container);
$n = new UserNotification($this->container);
$pp = new ProjectPermission($this->container);
$pp = new ProjectUserRole($this->container);
$this->assertEquals(1, $p->create(array('name' => 'UnitTest1')));
@@ -118,16 +120,16 @@ class UserNotificationTest extends Base
$this->assertNotFalse($u->create(array('username' => 'user4')));
// Nobody is member of any projects
$this->assertEmpty($pp->getMembers(1));
$this->assertEmpty($pp->getUsers(1));
$this->assertEmpty($n->getUsersWithNotificationEnabled(1));
// We allow all users to be member of our projects
$this->assertTrue($pp->addMember(1, 1));
$this->assertTrue($pp->addMember(1, 2));
$this->assertTrue($pp->addMember(1, 3));
$this->assertTrue($pp->addMember(1, 4));
$this->assertTrue($pp->addUser(1, 1, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 2, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 3, Role::PROJECT_MEMBER));
$this->assertTrue($pp->addUser(1, 4, Role::PROJECT_MEMBER));
$this->assertNotEmpty($pp->getMembers(1));
$this->assertNotEmpty($pp->getUsers(1));
$users = $n->getUsersWithNotificationEnabled(1);
$this->assertNotEmpty($users);

158
tests/units/Model/UserSessionTest.php
View File

@@ -1,158 +0,0 @@
<?php
require_once __DIR__.'/../Base.php';
use Kanboard\Model\UserSession;
class UserSessionTest extends Base
{
public function testInitialize()
{
$us = new UserSession($this->container);
$user = array(
'id' => '123',
'username' => 'john',
'password' => 'something',
'twofactor_secret' => 'something else',
'is_admin' => '1',
'is_project_admin' => '0',
'is_ldap_user' => '0',
'twofactor_activated' => '0',
);
$us->initialize($user);
$session = $this->container['sessionStorage']->getAll();
$this->assertNotEmpty($session);
$this->assertEquals(123, $session['user']['id']);
$this->assertEquals('john', $session['user']['username']);
$this->assertTrue($session['user']['is_admin']);
$this->assertFalse($session['user']['is_project_admin']);
$this->assertFalse($session['user']['is_ldap_user']);
$this->assertFalse($session['user']['twofactor_activated']);
$this->assertArrayNotHasKey('password', $session['user']);
$this->assertArrayNotHasKey('twofactor_secret', $session['user']);
$this->assertEquals('john', $us->getUsername());
}
public function testGetId()
{
$us = new UserSession($this->container);
$this->assertEquals(0, $us->getId());
$this->container['sessionStorage']->user = array('id' => 2);
$this->assertEquals(2, $us->getId());
$this->container['sessionStorage']->user = array('id' => '2');
$this->assertEquals(2, $us->getId());
}
public function testIsLogged()
{
$us = new UserSession($this->container);
$this->assertFalse($us->isLogged());
$this->container['sessionStorage']->user = array();
$this->assertFalse($us->isLogged());
$this->container['sessionStorage']->user = array('id' => 1);
$this->assertTrue($us->isLogged());
}
public function testIsAdmin()
{
$us = new UserSession($this->container);
$this->assertFalse($us->isAdmin());
$this->container['sessionStorage']->user = array('is_admin' => '1');
$this->assertFalse($us->isAdmin());
$this->container['sessionStorage']->user = array('is_admin' => '2');
$this->assertFalse($us->isAdmin());
$this->container['sessionStorage']->user = array('is_admin' => false);
$this->assertFalse($us->isAdmin());
$this->container['sessionStorage']->user = array('is_admin' => true);
$this->assertTrue($us->isAdmin());
}
public function testIsProjectAdmin()
{
$us = new UserSession($this->container);
$this->assertFalse($us->isProjectAdmin());
$this->container['sessionStorage']->user = array('is_project_admin' => false);
$this->assertFalse($us->isProjectAdmin());
$this->container['sessionStorage']->user = array('is_project_admin' => true);
$this->assertTrue($us->isProjectAdmin());
}
public function testCommentSorting()
{
$us = new UserSession($this->container);
$this->assertEquals('ASC', $us->getCommentSorting());
$us->setCommentSorting('DESC');
$this->assertEquals('DESC', $us->getCommentSorting());
}
public function testBoardCollapseMode()
{
$us = new UserSession($this->container);
$this->assertFalse($us->isBoardCollapsed(2));
$us->setBoardDisplayMode(3, false);
$this->assertFalse($us->isBoardCollapsed(3));
$us->setBoardDisplayMode(3, true);
$this->assertTrue($us->isBoardCollapsed(3));
}
public function testFilters()
{
$us = new UserSession($this->container);
$this->assertEquals('status:open', $us->getFilters(1));
$us->setFilters(1, 'assignee:me');
$this->assertEquals('assignee:me', $us->getFilters(1));
$this->assertEquals('status:open', $us->getFilters(2));
$us->setFilters(2, 'assignee:bob');
$this->assertEquals('assignee:bob', $us->getFilters(2));
}
public function test2FA()
{
$us = new UserSession($this->container);
$this->assertFalse($us->check2FA());
$this->container['sessionStorage']->postAuth = array('validated' => false);
$this->assertFalse($us->check2FA());
$this->container['sessionStorage']->postAuth = array('validated' => true);
$this->assertTrue($us->check2FA());
$this->container['sessionStorage']->user = array();
$this->assertFalse($us->has2FA());
$this->container['sessionStorage']->user = array('twofactor_activated' => false);
$this->assertFalse($us->has2FA());
$this->container['sessionStorage']->user = array('twofactor_activated' => true);
$this->assertTrue($us->has2FA());
$us->disable2FA();
$this->assertFalse($us->has2FA());
}
}

108
tests/units/Model/UserTest.php
View File

@@ -9,34 +9,10 @@ use Kanboard\Model\Task;
use Kanboard\Model\TaskCreation;
use Kanboard\Model\TaskFinder;
use Kanboard\Model\Project;
use Kanboard\Core\Security\Role;
class UserTest extends Base
{
public function testFailedLogin()
{
$u = new User($this->container);
$this->assertEquals(0, $u->getFailedLogin('admin'));
$this->assertEquals(0, $u->getFailedLogin('not_found'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertTrue($u->incrementFailedLogin('admin'));
$this->assertEquals(2, $u->getFailedLogin('admin'));
$this->assertTrue($u->resetFailedLogin('admin'));
$this->assertEquals(0, $u->getFailedLogin('admin'));
}
public function testLocking()
{
$u = new User($this->container);
$this->assertFalse($u->isLocked('admin'));
$this->assertFalse($u->isLocked('not_found'));
$this->assertTrue($u->lock('admin', 1));
$this->assertTrue($u->isLocked('admin'));
}
public function testGetByEmail()
{
$u = new User($this->container);
@@ -47,33 +23,27 @@ class UserTest extends Base
$this->assertEmpty($u->getByEmail(''));
}
public function testGetByGitlabId()
public function testGetByExternalId()
{
$u = new User($this->container);
$this->assertNotFalse($u->create(array('username' => 'user1', 'password' => '123456', 'gitlab_id' => '1234')));
$this->assertNotEmpty($u->getByGitlabId('1234'));
$this->assertEmpty($u->getByGitlabId(''));
}
$this->assertNotEmpty($u->getByExternalId('gitlab_id', '1234'));
$this->assertEmpty($u->getByExternalId('gitlab_id', ''));
public function testGetByGithubId()
{
$u = new User($this->container);
$this->assertNotFalse($u->create(array('username' => 'user1', 'password' => '123456', 'github_id' => 'plop')));
$this->assertNotFalse($u->create(array('username' => 'user2', 'password' => '123456', 'github_id' => '')));
$this->assertNotFalse($u->create(array('username' => 'user2', 'password' => '123456', 'github_id' => 'plop')));
$this->assertNotFalse($u->create(array('username' => 'user3', 'password' => '123456', 'github_id' => '')));
$this->assertNotEmpty($u->getByGithubId('plop'));
$this->assertEmpty($u->getByGithubId(''));
}
$this->assertNotEmpty($u->getByExternalId('github_id', 'plop'));
$this->assertEmpty($u->getByExternalId('github_id', ''));
public function testGetByGoogleId()
{
$u = new User($this->container);
$this->assertNotFalse($u->create(array('username' => 'user1', 'password' => '123456', 'google_id' => '1234')));
$this->assertNotFalse($u->create(array('username' => 'user2', 'password' => '123456', 'google_id' => '')));
$this->assertNotFalse($u->create(array('username' => 'user4', 'password' => '123456', 'google_id' => '1234')));
$this->assertNotFalse($u->create(array('username' => 'user5', 'password' => '123456', 'google_id' => '')));
$this->assertNotEmpty($u->getByGoogleId('1234'));
$this->assertEmpty($u->getByGoogleId(''));
$this->assertNotEmpty($u->getByExternalId('google_id', '1234'));
$this->assertEmpty($u->getByExternalId('google_id', ''));
}
public function testGetByToken()
@@ -197,7 +167,7 @@ class UserTest extends Base
'password' => '1234',
'confirmation' => '1234',
'name' => 'me',
'is_admin' => '',
'role' => Role::APP_ADMIN,
);
$u->prepare($input);
@@ -207,9 +177,6 @@ class UserTest extends Base
$this->assertNotEquals('1234', $input['password']);
$this->assertNotEmpty($input['password']);
$this->assertArrayHasKey('is_admin', $input);
$this->assertInternalType('integer', $input['is_admin']);
$input = array(
'username' => 'user1',
'password' => '1234',
@@ -273,8 +240,8 @@ class UserTest extends Base
$u = new User($this->container);
$this->assertEquals(2, $u->create(array('username' => 'user #1', 'password' => '123456', 'name' => 'User')));
$this->assertEquals(3, $u->create(array('username' => 'user #2', 'is_ldap_user' => 1)));
$this->assertEquals(4, $u->create(array('username' => 'user #3', 'is_project_admin' => 1)));
$this->assertEquals(5, $u->create(array('username' => 'user #4', 'gitlab_id' => '')));
$this->assertEquals(4, $u->create(array('username' => 'user #3', 'role' => Role::APP_MANAGER)));
$this->assertEquals(5, $u->create(array('username' => 'user #4', 'gitlab_id' => '', 'role' => Role::APP_ADMIN)));
$this->assertEquals(6, $u->create(array('username' => 'user #5', 'gitlab_id' => '1234')));
$this->assertFalse($u->create(array('username' => 'user #1')));
@@ -283,7 +250,7 @@ class UserTest extends Base
$this->assertTrue(is_array($user));
$this->assertEquals('admin', $user['username']);
$this->assertEquals('', $user['name']);
$this->assertEquals(1, $user['is_admin']);
$this->assertEquals(Role::APP_ADMIN, $user['role']);
$this->assertEquals(0, $user['is_ldap_user']);
$user = $u->getById(2);
@@ -291,7 +258,7 @@ class UserTest extends Base
$this->assertTrue(is_array($user));
$this->assertEquals('user #1', $user['username']);
$this->assertEquals('User', $user['name']);
$this->assertEquals(0, $user['is_admin']);
$this->assertEquals(Role::APP_USER, $user['role']);
$this->assertEquals(0, $user['is_ldap_user']);
$user = $u->getById(3);
@@ -299,27 +266,28 @@ class UserTest extends Base
$this->assertTrue(is_array($user));
$this->assertEquals('user #2', $user['username']);
$this->assertEquals('', $user['name']);
$this->assertEquals(0, $user['is_admin']);
$this->assertEquals(Role::APP_USER, $user['role']);
$this->assertEquals(1, $user['is_ldap_user']);
$user = $u->getById(4);
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals('user #3', $user['username']);
$this->assertEquals(0, $user['is_admin']);
$this->assertEquals(1, $user['is_project_admin']);
$this->assertEquals(Role::APP_MANAGER, $user['role']);
$user = $u->getById(5);
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals('user #4', $user['username']);
$this->assertEquals('', $user['gitlab_id']);
$this->assertEquals(Role::APP_ADMIN, $user['role']);
$user = $u->getById(6);
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals('user #5', $user['username']);
$this->assertEquals('1234', $user['gitlab_id']);
$this->assertEquals(Role::APP_USER, $user['role']);
}
public function testUpdate()
@@ -336,7 +304,7 @@ class UserTest extends Base
$this->assertTrue(is_array($user));
$this->assertEquals('biloute', $user['username']);
$this->assertEquals('Toto', $user['name']);
$this->assertEquals(0, $user['is_admin']);
$this->assertEquals(Role::APP_USER, $user['role']);
$this->assertEquals(0, $user['is_ldap_user']);
$user = $u->getById(3);
@@ -423,4 +391,36 @@ class UserTest extends Base
$this->assertEquals('toto', $user['username']);
$this->assertEmpty($user['token']);
}
public function testValidatePasswordModification()
{
$u = new User($this->container);
$this->container['sessionStorage']->user = array(
'id' => 1,
'role' => Role::APP_ADMIN,
'username' => 'admin',
);
$result = $u->validatePasswordModification(array());
$this->assertFalse($result[0]);
$result = $u->validatePasswordModification(array('id' => 1));
$this->assertFalse($result[0]);
$result = $u->validatePasswordModification(array('id' => 1, 'password' => '123456'));
$this->assertFalse($result[0]);
$result = $u->validatePasswordModification(array('id' => 1, 'password' => '123456', 'confirmation' => 'wrong'));
$this->assertFalse($result[0]);
$result = $u->validatePasswordModification(array('id' => 1, 'password' => '123456', 'confirmation' => '123456'));
$this->assertFalse($result[0]);
$result = $u->validatePasswordModification(array('id' => 1, 'password' => '123456', 'confirmation' => '123456', 'current_password' => 'wrong'));
$this->assertFalse($result[0]);
$result = $u->validatePasswordModification(array('id' => 1, 'password' => '123456', 'confirmation' => '123456', 'current_password' => 'admin'));
$this->assertTrue($result[0]);
}
}