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

Rewrite integration tests to run with Docker containers

Browse Source
This commit is contained in:
Frederic Guillot
2016-06-25 14:34:46 -04:00
parent fc93203e4d
commit 922e0fb6de
49 changed files with 1337 additions and 1637 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
tests/configs/config.mysql.php Normal file
View File

@@ -0,0 +1,12 @@
<?php
define('DB_DRIVER', 'mysql');
define('DB_USERNAME', 'root');
define('DB_PASSWORD', 'kanboard');
define('DB_HOSTNAME', 'mysql');
define('DB_NAME', 'kanboard');
define('DEBUG', true);
define('LOG_DRIVER', 'stderr');
define('API_AUTHENTICATION_TOKEN', 'test');

12
tests/configs/config.postgres.php Normal file
View File

@@ -0,0 +1,12 @@
<?php
define('DB_DRIVER', 'postgres');
define('DB_USERNAME', 'postgres');
define('DB_PASSWORD', 'postgres');
define('DB_HOSTNAME', 'postgres');
define('DB_NAME', 'kanboard');
define('DEBUG', true);
define('LOG_DRIVER', 'stderr');
define('API_AUTHENTICATION_TOKEN', 'test');

8
tests/configs/config.sqlite.php Normal file
View File

@@ -0,0 +1,8 @@
<?php
define('DB_DRIVER', 'sqlite');
define('DEBUG', true);
define('LOG_DRIVER', 'file');
define('API_AUTHENTICATION_TOKEN', 'test');

24
tests/docker/Dockerfile.xenial Normal file
View File

@@ -0,0 +1,24 @@
FROM ubuntu:16.04
RUN mkdir -p /var/lock/apache2 /var/run/apache2 /var/log/supervisor
RUN apt-get update -qq && \
apt-get install -y apache2 supervisor cron curl unzip \
libapache2-mod-php7.0 php7.0-cli php7.0-mbstring php7.0-xml php7.0-mysql php7.0-sqlite3 \
php7.0-opcache php7.0-json php7.0-pgsql php7.0-ldap php7.0-gd php7.0-zip && \
apt clean && \
echo "ServerName localhost" >> /etc/apache2/apache2.conf && \
sed -ri 's/AllowOverride None/AllowOverride All/g' /etc/apache2/apache2.conf && \
a2enmod rewrite && \
curl -sS https://getcomposer.org/installer | php -- --filename=/usr/local/bin/composer
COPY . /var/www/html
RUN chown -R www-data:www-data /var/www/html/data /var/www/html/plugins
COPY tests/docker/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
COPY tests/configs /configs/
EXPOSE 80
ENTRYPOINT ["/var/www/html/tests/docker/entrypoint.sh"]

27
tests/docker/compose.integration.mysql.yaml Normal file
View File

@@ -0,0 +1,27 @@
version: '2'
services:
mysql:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: "kanboard"
MYSQL_DATABASE: "kanboard"
MYSQL_USER: "kanboard"
MYSQL_PASSWORD: "kanboard"
ports:
- "3306:3306"
app:
build:
context: ../..
dockerfile: tests/docker/Dockerfile.xenial
ports:
- "8000:80"
depends_on:
- mysql
command: config-mysql
tests:
build:
context: ../..
dockerfile: tests/docker/Dockerfile.xenial
depends_on:
- app
command: integration-test-mysql

26
tests/docker/compose.integration.postgres.yaml Normal file
View File

@@ -0,0 +1,26 @@
version: '2'
services:
postgres:
image: postgres:9.5
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: kanboard
ports:
- "5432:5432"
app:
build:
context: ../..
dockerfile: tests/docker/Dockerfile.xenial
ports:
- "8000:80"
depends_on:
- postgres
command: config-postgres
tests:
build:
context: ../..
dockerfile: tests/docker/Dockerfile.xenial
depends_on:
- app
command: integration-test-postgres

16
tests/docker/compose.integration.sqlite.yaml Normal file
View File

@@ -0,0 +1,16 @@
version: '2'
services:
app:
build:
context: ../..
dockerfile: tests/docker/Dockerfile.xenial
ports:
- "8000:80"
command: config-sqlite
tests:
build:
context: ../..
dockerfile: tests/docker/Dockerfile.xenial
depends_on:
- app
command: integration-test-sqlite

33
tests/docker/entrypoint.sh Executable file
View File

@@ -0,0 +1,33 @@
#!/usr/bin/env bash
function wait_schema_creation() {
curl -s http://app/login > /dev/null
sleep $1
}
case "$1" in
"config-sqlite")
cp /configs/config.sqlite.php /var/www/html/config.php
/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
;;
"config-postgres")
cp /configs/config.postgres.php /var/www/html/config.php
/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
;;
"config-mysql")
cp /configs/config.mysql.php /var/www/html/config.php
/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
;;
"integration-test-sqlite")
wait_schema_creation 1
/var/www/html/vendor/phpunit/phpunit/phpunit -c /var/www/html/tests/integration.sqlite.xml
;;
"integration-test-postgres")
wait_schema_creation 5
/var/www/html/vendor/phpunit/phpunit/phpunit -c /var/www/html/tests/integration.postgres.xml
;;
"integration-test-mysql")
wait_schema_creation 15
/var/www/html/vendor/phpunit/phpunit/phpunit -c /var/www/html/tests/integration.mysql.xml
;;
esac

6
tests/docker/supervisord.conf Normal file
View File

@@ -0,0 +1,6 @@
[supervisord]
nodaemon=true
[program:apache2]
command=/bin/bash -c "source /etc/apache2/envvars && exec /usr/sbin/apache2 -DFOREGROUND"
autorestart=true

14
tests/integration.mysql.xml
View File

@@ -5,16 +5,8 @@
</testsuite>
</testsuites>
<php>
<const name="API_URL" value="http://localhost:8000/jsonrpc.php" />
<const name="API_KEY" value="19ffd9709d03ce50675c3a43d1c49c1ac207f4bc45f06c5b2701fbdf8929" />
<const name="DB_DRIVER" value="mysql" />
<const name="DB_NAME" value="kanboard" />
<const name="DB_HOSTNAME" value="localhost" />
<const name="DB_USERNAME" value="root" />
<const name="DB_PASSWORD" value="" />
<const name="DB_PORT" value="" />
<const name="DB_SSL_KEY" value="" />
<const name="DB_SSL_CA" value="" />
<const name="DB_SSL_CERT" value="" />
<const name="BASE_URL" value="http://app/" />
<const name="API_URL" value="http://app/jsonrpc.php" />
<const name="API_KEY" value="test" />
</php>
</phpunit>

13
tests/integration.postgres.xml
View File

@@ -5,13 +5,8 @@
</testsuite>
</testsuites>
<php>
<const name="API_URL" value="http://localhost:8000/jsonrpc.php" />
<const name="API_KEY" value="19ffd9709d03ce50675c3a43d1c49c1ac207f4bc45f06c5b2701fbdf8929" />
<const name="DB_DRIVER" value="postgres" />
<const name="DB_NAME" value="kanboard" />
<const name="DB_HOSTNAME" value="localhost" />
<const name="DB_USERNAME" value="postgres" />
<const name="DB_PASSWORD" value="postgres" />
<const name="DB_PORT" value="" />
<const name="BASE_URL" value="http://app/" />
<const name="API_URL" value="http://app/jsonrpc.php" />
<const name="API_KEY" value="test" />
</php>
</phpunit>
</phpunit>

9
tests/integration.sqlite.xml
View File

@@ -5,9 +5,8 @@
</testsuite>
</testsuites>
<php>
<const name="API_URL" value="http://127.0.0.1:8000/jsonrpc.php" />
<const name="API_KEY" value="19ffd9709d03ce50675c3a43d1c49c1ac207f4bc45f06c5b2701fbdf8929" />
<const name="DB_DRIVER" value="sqlite" />
<const name="DB_FILENAME" value="data/db.sqlite" />
<const name="BASE_URL" value="http://app/" />
<const name="API_URL" value="http://app/jsonrpc.php" />
<const name="API_KEY" value="test" />
</php>
</phpunit>
</phpunit>

66
tests/integration/ActionTest.php Normal file
View File

@@ -0,0 +1,66 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class ActionTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test actions';
public function testGetAvailableActions()
{
$actions = $this->app->getAvailableActions();
$this->assertNotEmpty($actions);
$this->assertInternalType('array', $actions);
$this->assertArrayHasKey('\Kanboard\Action\TaskCloseColumn', $actions);
}
public function testGetAvailableActionEvents()
{
$events = $this->app->getAvailableActionEvents();
$this->assertNotEmpty($events);
$this->assertInternalType('array', $events);
$this->assertArrayHasKey('task.move.column', $events);
}
public function testGetCompatibleActionEvents()
{
$events = $this->app->getCompatibleActionEvents('\Kanboard\Action\TaskCloseColumn');
$this->assertNotEmpty($events);
$this->assertInternalType('array', $events);
$this->assertArrayHasKey('task.move.column', $events);
}
public function testCRUD()
{
$this->assertCreateTeamProject();
$this->assertCreateAction();
$this->assertGetActions();
$this->assertRemoveAction();
}
public function assertCreateAction()
{
$actionId = $this->app->createAction($this->projectId, 'task.move.column', '\Kanboard\Action\TaskCloseColumn', array('column_id' => 1));
$this->assertNotFalse($actionId);
$this->assertTrue($actionId > 0);
}
public function assertGetActions()
{
$actions = $this->app->getActions($this->projectId);
$this->assertNotEmpty($actions);
$this->assertInternalType('array', $actions);
$this->assertArrayHasKey('id', $actions[0]);
$this->assertArrayHasKey('project_id', $actions[0]);
$this->assertArrayHasKey('event_name', $actions[0]);
$this->assertArrayHasKey('action_name', $actions[0]);
$this->assertArrayHasKey('params', $actions[0]);
$this->assertArrayHasKey('column_id', $actions[0]['params']);
}
public function assertRemoveAction()
{
$actionId = $this->app->createAction($this->projectId, 'task.move.column', '\Kanboard\Action\TaskCloseColumn', array('column_id' => 1));
$this->assertTrue($this->app->removeAction($actionId));
}
}

928
tests/integration/ApiTest.php
View File

@@ -1,928 +0,0 @@
<?php
require_once __DIR__.'/../../vendor/autoload.php';
class Api extends PHPUnit_Framework_TestCase
{
private $client = null;
public static function setUpBeforeClass()
{
if (DB_DRIVER === 'sqlite') {
@unlink(DB_FILENAME);
} elseif (DB_DRIVER === 'mysql') {
$pdo = new PDO('mysql:host='.DB_HOSTNAME, DB_USERNAME, DB_PASSWORD);
$pdo->exec('DROP DATABASE '.DB_NAME);
$pdo->exec('CREATE DATABASE '.DB_NAME);
$pdo = null;
} elseif (DB_DRIVER === 'postgres') {
$pdo = new PDO('pgsql:host='.DB_HOSTNAME, DB_USERNAME, DB_PASSWORD);
$pdo->exec('DROP DATABASE '.DB_NAME);
$pdo->exec('CREATE DATABASE '.DB_NAME.' WITH OWNER '.DB_USERNAME);
$pdo = null;
}
$service = new Kanboard\ServiceProvider\DatabaseProvider;
$db = $service->getInstance();
$db->table('settings')->eq('option', 'api_token')->update(array('value' => API_KEY));
$db->table('settings')->eq('option', 'application_timezone')->update(array('value' => 'Europe/Paris'));
$db->closeConnection();
}
public function setUp()
{
$this->client = new JsonRPC\Client(API_URL);
$this->client->authentication('jsonrpc', API_KEY);
// $this->client->debug = true;
}
private function getTaskId()
{
$tasks = $this->client->getAllTasks(1, 1);
$this->assertNotEmpty($tasks);
return $tasks[0]['id'];
}
public function testRemoveAll()
{
$projects = $this->client->getAllProjects();
if ($projects) {
foreach ($projects as $project) {
$this->assertEquals('http://127.0.0.1:8000/?controller=BoardViewController&action=show&project_id='.$project['id'], $project['url']['board']);
$this->assertEquals('http://127.0.0.1:8000/?controller=CalendarController&action=show&project_id='.$project['id'], $project['url']['calendar']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskListController&action=show&project_id='.$project['id'], $project['url']['list']);
$this->assertTrue($this->client->removeProject($project['id']));
}
}
}
public function testCreateProject()
{
$project_id = $this->client->createProject('API test');
$this->assertNotFalse($project_id);
$this->assertInternalType('int', $project_id);
}
public function testGetProjectById()
{
$project = $this->client->getProjectById(1);
$this->assertNotEmpty($project);
$this->assertEquals(1, $project['id']);
$this->assertEquals('http://127.0.0.1:8000/?controller=BoardViewController&action=show&project_id='.$project['id'], $project['url']['board']);
$this->assertEquals('http://127.0.0.1:8000/?controller=CalendarController&action=show&project_id='.$project['id'], $project['url']['calendar']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskListController&action=show&project_id='.$project['id'], $project['url']['list']);
}
public function testGetProjectByName()
{
$project = $this->client->getProjectByName('API test');
$this->assertNotEmpty($project);
$this->assertEquals(1, $project['id']);
$this->assertEquals('http://127.0.0.1:8000/?controller=BoardViewController&action=show&project_id='.$project['id'], $project['url']['board']);
$this->assertEquals('http://127.0.0.1:8000/?controller=CalendarController&action=show&project_id='.$project['id'], $project['url']['calendar']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskListController&action=show&project_id='.$project['id'], $project['url']['list']);
$project = $this->client->getProjectByName(array('name' => 'API test'));
$this->assertNotEmpty($project);
$this->assertEquals(1, $project['id']);
$project = $this->client->getProjectByName('None');
$this->assertEmpty($project);
$this->assertNull($project);
}
public function testGetAllProjects()
{
$projects = $this->client->getAllProjects();
$this->assertNotEmpty($projects);
foreach ($projects as $project) {
$this->assertEquals('http://127.0.0.1:8000/?controller=BoardViewController&action=show&project_id='.$project['id'], $project['url']['board']);
$this->assertEquals('http://127.0.0.1:8000/?controller=CalendarController&action=show&project_id='.$project['id'], $project['url']['calendar']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskListController&action=show&project_id='.$project['id'], $project['url']['list']);
}
}
public function testUpdateProject()
{
$project = $this->client->getProjectById(1);
$this->assertNotEmpty($project);
$this->assertTrue($this->client->execute('updateProject', array('id' => 1, 'name' => 'API test 2')));
$project = $this->client->getProjectById(1);
$this->assertEquals('API test 2', $project['name']);
$this->assertTrue($this->client->execute('updateProject', array('id' => 1, 'name' => 'API test', 'description' => 'test')));
$project = $this->client->getProjectById(1);
$this->assertEquals('API test', $project['name']);
$this->assertEquals('test', $project['description']);
}
public function testDisableProject()
{
$this->assertTrue($this->client->disableProject(1));
$project = $this->client->getProjectById(1);
$this->assertNotEmpty($project);
$this->assertEquals(0, $project['is_active']);
}
public function testEnableProject()
{
$this->assertTrue($this->client->enableProject(1));
$project = $this->client->getProjectById(1);
$this->assertNotEmpty($project);
$this->assertEquals(1, $project['is_active']);
}
public function testEnableProjectPublicAccess()
{
$this->assertTrue($this->client->enableProjectPublicAccess(1));
$project = $this->client->getProjectById(1);
$this->assertNotEmpty($project);
$this->assertEquals(1, $project['is_public']);
$this->assertNotEmpty($project['token']);
}
public function testDisableProjectPublicAccess()
{
$this->assertTrue($this->client->disableProjectPublicAccess(1));
$project = $this->client->getProjectById(1);
$this->assertNotEmpty($project);
$this->assertEquals(0, $project['is_public']);
$this->assertEmpty($project['token']);
}
public function testgetProjectActivities()
{
$activities = $this->client->getProjectActivities(array('project_ids' => array(1)));
$this->assertInternalType('array', $activities);
$this->assertCount(0, $activities);
}
public function testgetProjectActivity()
{
$activities = $this->client->getProjectActivity(1);
$this->assertInternalType('array', $activities);
$this->assertCount(0, $activities);
}
public function testCreateTaskWithWrongMember()
{
$task = array(
'title' => 'Task #1',
'color_id' => 'blue',
'owner_id' => 1,
'project_id' => 1,
'column_id' => 2,
);
$task_id = $this->client->createTask($task);
$this->assertFalse($task_id);
}
public function testGetAllowedUsers()
{
$users = $this->client->getMembers(1);
$this->assertNotFalse($users);
$this->assertEquals(array(), $users);
}
public function testAddMember()
{
$this->assertTrue($this->client->allowUser(1, 1));
}
public function testCreateTask()
{
$task = array(
'title' => 'Task #1',
'color_id' => 'blue',
'owner_id' => 1,
'project_id' => 1,
'column_id' => 2,
);
$task_id = $this->client->createTask($task);
$this->assertNotFalse($task_id);
$this->assertInternalType('int', $task_id);
$this->assertTrue($task_id > 0);
}
/**
* @expectedException InvalidArgumentException
*/
public function testCreateTaskWithBadParams()
{
$task = array(
'title' => 'Task #1',
'color_id' => 'blue',
'owner_id' => 1,
);
$this->client->createTask($task);
}
public function testGetTask()
{
$task = $this->client->getTask(1);
$this->assertNotFalse($task);
$this->assertTrue(is_array($task));
$this->assertEquals('Task #1', $task['title']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskViewController&action=show&task_id='.$task['id'].'&project_id='.$task['project_id'], $task['url']);
}
public function testGetAllTasks()
{
$tasks = $this->client->getAllTasks(1, 1);
$this->assertNotFalse($tasks);
$this->assertTrue(is_array($tasks));
$this->assertEquals('Task #1', $tasks[0]['title']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskViewController&action=show&task_id='.$tasks[0]['id'].'&project_id='.$tasks[0]['project_id'], $tasks[0]['url']);
$tasks = $this->client->getAllTasks(2, 0);
$this->assertNotFalse($tasks);
$this->assertTrue(is_array($tasks));
$this->assertEmpty($tasks);
}
public function testMoveTaskSwimlane()
{
$task_id = $this->getTaskId();
$task = $this->client->getTask($task_id);
$this->assertNotFalse($task);
$this->assertTrue(is_array($task));
$this->assertEquals(1, $task['position']);
$this->assertEquals(2, $task['column_id']);
$this->assertEquals(0, $task['swimlane_id']);
$moved_timestamp = $task['date_moved'];
sleep(1);
$this->assertTrue($this->client->moveTaskPosition(1, $task_id, 4, 1, 2));
$task = $this->client->getTask($task_id);
$this->assertNotFalse($task);
$this->assertTrue(is_array($task));
$this->assertEquals(1, $task['position']);
$this->assertEquals(4, $task['column_id']);
$this->assertEquals(2, $task['swimlane_id']);
$this->assertNotEquals($moved_timestamp, $task['date_moved']);
}
public function testUpdateTask()
{
$task = $this->client->getTask(1);
$values = array();
$values['id'] = $task['id'];
$values['color_id'] = 'green';
$values['description'] = 'test';
$values['date_due'] = '';
$this->assertTrue($this->client->execute('updateTask', $values));
}
public function testRemoveTask()
{
$this->assertTrue($this->client->removeTask(1));
}
public function testRemoveUsers()
{
$users = $this->client->getAllUsers();
$this->assertNotFalse($users);
$this->assertNotEmpty($users);
foreach ($users as $user) {
if ($user['id'] > 1) {
$this->assertTrue($this->client->removeUser($user['id']));
}
}
}
public function testCreateUser()
{
$user = array(
'username' => 'toto',
'name' => 'Toto',
'password' => '123456',
);
$user_id = $this->client->execute('createUser', $user);
$this->assertNotFalse($user_id);
$this->assertInternalType('int', $user_id);
$this->assertTrue($user_id > 0);
}
public function testCreateManagerUser()
{
$user = array(
'username' => 'manager',
'name' => 'Manager',
'password' => '123456',
'role' => 'app-manager'
);
$user_id = $this->client->execute('createUser', $user);
$this->assertNotFalse($user_id);
$this->assertInternalType('int', $user_id);
$this->assertTrue($user_id > 0);
}
/**
* @expectedException InvalidArgumentException
*/
public function testCreateUserWithBadParams()
{
$user = array(
'name' => 'Titi',
'password' => '123456',
);
$this->assertNull($this->client->execute('createUser', $user));
}
public function testGetUser()
{
$user = $this->client->getUser(2);
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals('toto', $user['username']);
$user = $this->client->getUser(3);
$this->assertNotEmpty($user);
$this->assertEquals('app-manager', $user['role']);
$this->assertNull($this->client->getUser(2222));
}
public function testGetUserByName()
{
$user = $this->client->getUserByName('toto');
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals(2, $user['id']);
$user = $this->client->getUserByName('manager');
$this->assertNotEmpty($user);
$this->assertEquals('app-manager', $user['role']);
$this->assertNull($this->client->getUserByName('nonexistantusername'));
}
public function testUpdateUser()
{
$user = array();
$user['id'] = 2;
$user['username'] = 'titi';
$user['name'] = 'Titi';
$this->assertTrue($this->client->execute('updateUser', $user));
$user = $this->client->getUser(2);
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals('titi', $user['username']);
$this->assertEquals('Titi', $user['name']);
$user = array();
$user['id'] = 2;
$user['email'] = 'titi@localhost';
$this->assertTrue($this->client->execute('updateUser', $user));
$user = $this->client->getUser(2);
$this->assertNotFalse($user);
$this->assertTrue(is_array($user));
$this->assertEquals('titi@localhost', $user['email']);
}
public function testAllowedUser()
{
$this->assertTrue($this->client->allowUser(1, 2));
$users = $this->client->getMembers(1);
$this->assertNotFalse($users);
$this->assertEquals(array(1 => 'admin', 2 => 'Titi'), $users);
}
public function testRevokeUser()
{
$this->assertTrue($this->client->revokeUser(1, 2));
$users = $this->client->getMembers(1);
$this->assertNotFalse($users);
$this->assertEquals(array(1 => 'admin'), $users);
}
public function testCreateComment()
{
$task = array(
'title' => 'Task with comment',
'color_id' => 'red',
'owner_id' => 1,
'project_id' => 1,
'column_id' => 1,
);
$this->assertNotFalse($this->client->execute('createTask', $task));
$tasks = $this->client->getAllTasks(1, 1);
$this->assertNotEmpty($tasks);
$this->assertEquals(1, count($tasks));
$comment = array(
'task_id' => $tasks[0]['id'],
'user_id' => 2,
'content' => 'boo',
);
$comment_id = $this->client->execute('createComment', $comment);
$this->assertNotFalse($comment_id);
$this->assertInternalType('int', $comment_id);
$this->assertTrue($comment_id > 0);
}
public function testGetComment()
{
$comment = $this->client->getComment(1);
$this->assertNotFalse($comment);
$this->assertNotEmpty($comment);
$this->assertEquals(2, $comment['user_id']);
$this->assertEquals('boo', $comment['comment']);
}
public function testUpdateComment()
{
$comment = array();
$comment['id'] = 1;
$comment['content'] = 'test';
$this->assertTrue($this->client->execute('updateComment', $comment));
$comment = $this->client->getComment(1);
$this->assertEquals('test', $comment['comment']);
}
public function testGetAllComments()
{
$task_id = $this->getTaskId();
$comment = array(
'task_id' => $task_id,
'user_id' => 1,
'content' => 'blabla',
);
$comment_id = $this->client->createComment($comment);
$this->assertNotFalse($comment_id);
$this->assertInternalType('int', $comment_id);
$this->assertTrue($comment_id > 0);
$comments = $this->client->getAllComments($task_id);
$this->assertNotFalse($comments);
$this->assertNotEmpty($comments);
$this->assertTrue(is_array($comments));
$this->assertEquals(2, count($comments));
}
public function testRemoveComment()
{
$task_id = $this->getTaskId();
$comments = $this->client->getAllComments($task_id);
$this->assertNotFalse($comments);
$this->assertNotEmpty($comments);
$this->assertTrue(is_array($comments));
foreach ($comments as $comment) {
$this->assertTrue($this->client->removeComment($comment['id']));
}
$comments = $this->client->getAllComments($task_id);
$this->assertNotFalse($comments);
$this->assertEmpty($comments);
$this->assertTrue(is_array($comments));
}
public function testCreateSubtask()
{
$subtask = array(
'task_id' => $this->getTaskId(),
'title' => 'subtask #1',
);
$subtask_id = $this->client->createSubtask($subtask);
$this->assertNotFalse($subtask_id);
$this->assertInternalType('int', $subtask_id);
$this->assertTrue($subtask_id > 0);
}
public function testGetSubtask()
{
$subtask = $this->client->getSubtask(1);
$this->assertNotFalse($subtask);
$this->assertNotEmpty($subtask);
$this->assertEquals($this->getTaskId(), $subtask['task_id']);
$this->assertEquals(0, $subtask['user_id']);
$this->assertEquals('subtask #1', $subtask['title']);
}
public function testUpdateSubtask()
{
$subtask = array();
$subtask['id'] = 1;
$subtask['task_id'] = $this->getTaskId();
$subtask['title'] = 'test';
$this->assertTrue($this->client->execute('updateSubtask', $subtask));
$subtask = $this->client->getSubtask(1);
$this->assertEquals('test', $subtask['title']);
}
public function testGetAllSubtasks()
{
$subtask = array(
'task_id' => $this->getTaskId(),
'user_id' => 2,
'title' => 'Subtask #2',
);
$this->assertNotFalse($this->client->execute('createSubtask', $subtask));
$subtasks = $this->client->getAllSubtasks($this->getTaskId());
$this->assertNotFalse($subtasks);
$this->assertNotEmpty($subtasks);
$this->assertTrue(is_array($subtasks));
$this->assertEquals(2, count($subtasks));
}
public function testRemoveSubtask()
{
$this->assertTrue($this->client->removeSubtask(1));
$subtasks = $this->client->getAllSubtasks($this->getTaskId());
$this->assertNotFalse($subtasks);
$this->assertNotEmpty($subtasks);
$this->assertTrue(is_array($subtasks));
$this->assertEquals(1, count($subtasks));
}
public function testMoveTaskPosition()
{
$task_id = $this->getTaskId();
$this->assertTrue($this->client->moveTaskPosition(1, $task_id, 3, 1));
$task = $this->client->getTask($task_id);
$this->assertNotFalse($task);
$this->assertTrue(is_array($task));
$this->assertEquals(1, $task['position']);
$this->assertEquals(3, $task['column_id']);
}
public function testCategoryCreation()
{
$category = array(
'name' => 'Category',
'project_id' => 1,
);
$cat_id = $this->client->execute('createCategory', $category);
$this->assertNotFalse($cat_id);
$this->assertInternalType('int', $cat_id);
$this->assertTrue($cat_id > 0);
// Duplicate
$category = array(
'name' => 'Category',
'project_id' => 1,
);
$this->assertFalse($this->client->execute('createCategory', $category));
}
/**
* @expectedException InvalidArgumentException
*/
public function testCategoryCreationWithBadParams()
{
// Missing project id
$category = array(
'name' => 'Category',
);
$this->assertNull($this->client->execute('createCategory', $category));
}
public function testCategoryRead()
{
$category = $this->client->getCategory(1);
$this->assertTrue(is_array($category));
$this->assertNotEmpty($category);
$this->assertEquals(1, $category['id']);
$this->assertEquals('Category', $category['name']);
$this->assertEquals(1, $category['project_id']);
}
public function testGetAllCategories()
{
$categories = $this->client->getAllCategories(1);
$this->assertNotEmpty($categories);
$this->assertNotFalse($categories);
$this->assertTrue(is_array($categories));
$this->assertEquals(1, count($categories));
$this->assertEquals(1, $categories[0]['id']);
$this->assertEquals('Category', $categories[0]['name']);
$this->assertEquals(1, $categories[0]['project_id']);
}
public function testCategoryUpdate()
{
$category = array(
'id' => 1,
'name' => 'Renamed category',
);
$this->assertTrue($this->client->execute('updateCategory', $category));
$category = $this->client->getCategory(1);
$this->assertTrue(is_array($category));
$this->assertNotEmpty($category);
$this->assertEquals(1, $category['id']);
$this->assertEquals('Renamed category', $category['name']);
$this->assertEquals(1, $category['project_id']);
}
public function testCategoryRemove()
{
$this->assertTrue($this->client->removeCategory(1));
$this->assertFalse($this->client->removeCategory(1));
$this->assertFalse($this->client->removeCategory(1111));
}
public function testGetAvailableActions()
{
$actions = $this->client->getAvailableActions();
$this->assertNotEmpty($actions);
$this->assertInternalType('array', $actions);
$this->assertArrayHasKey('\Kanboard\Action\TaskCloseColumn', $actions);
}
public function testGetAvailableActionEvents()
{
$events = $this->client->getAvailableActionEvents();
$this->assertNotEmpty($events);
$this->assertInternalType('array', $events);
$this->assertArrayHasKey('task.move.column', $events);
}
public function testGetCompatibleActionEvents()
{
$events = $this->client->getCompatibleActionEvents('\Kanboard\Action\TaskCloseColumn');
$this->assertNotEmpty($events);
$this->assertInternalType('array', $events);
$this->assertArrayHasKey('task.move.column', $events);
}
public function testCreateAction()
{
$action_id = $this->client->createAction(1, 'task.move.column', '\Kanboard\Action\TaskCloseColumn', array('column_id' => 1));
$this->assertNotFalse($action_id);
$this->assertEquals(1, $action_id);
}
public function testGetActions()
{
$actions = $this->client->getActions(1);
$this->assertNotEmpty($actions);
$this->assertInternalType('array', $actions);
$this->assertCount(1, $actions);
$this->assertArrayHasKey('id', $actions[0]);
$this->assertArrayHasKey('project_id', $actions[0]);
$this->assertArrayHasKey('event_name', $actions[0]);
$this->assertArrayHasKey('action_name', $actions[0]);
$this->assertArrayHasKey('params', $actions[0]);
$this->assertArrayHasKey('column_id', $actions[0]['params']);
}
public function testRemoveAction()
{
$this->assertTrue($this->client->removeAction(1));
$actions = $this->client->getActions(1);
$this->assertEmpty($actions);
$this->assertCount(0, $actions);
}
public function testGetAllLinks()
{
$links = $this->client->getAllLinks();
$this->assertNotEmpty($links);
$this->assertArrayHasKey('id', $links[0]);
$this->assertArrayHasKey('label', $links[0]);
$this->assertArrayHasKey('opposite_id', $links[0]);
}
public function testGetOppositeLink()
{
$link = $this->client->getOppositeLinkId(1);
$this->assertEquals(1, $link);
$link = $this->client->getOppositeLinkId(2);
$this->assertEquals(3, $link);
}
public function testGetLinkByLabel()
{
$link = $this->client->getLinkByLabel('blocks');
$this->assertNotEmpty($link);
$this->assertEquals(2, $link['id']);
$this->assertEquals(3, $link['opposite_id']);
}
public function testGetLinkById()
{
$link = $this->client->getLinkById(4);
$this->assertNotEmpty($link);
$this->assertEquals(4, $link['id']);
$this->assertEquals(5, $link['opposite_id']);
$this->assertEquals('duplicates', $link['label']);
}
public function testCreateLink()
{
$link_id = $this->client->createLink(array('label' => 'test'));
$this->assertNotFalse($link_id);
$this->assertInternalType('int', $link_id);
$link_id = $this->client->createLink(array('label' => 'foo', 'opposite_label' => 'bar'));
$this->assertNotFalse($link_id);
$this->assertInternalType('int', $link_id);
}
public function testUpdateLink()
{
$link1 = $this->client->getLinkByLabel('bar');
$this->assertNotEmpty($link1);
$link2 = $this->client->getLinkByLabel('test');
$this->assertNotEmpty($link2);
$this->assertNotFalse($this->client->updateLink($link1['id'], $link2['id'], 'boo'));
$link = $this->client->getLinkById($link1['id']);
$this->assertNotEmpty($link);
$this->assertEquals($link2['id'], $link['opposite_id']);
$this->assertEquals('boo', $link['label']);
$this->assertTrue($this->client->removeLink($link1['id']));
}
public function testCreateTaskLink()
{
$task_id1 = $this->client->createTask(array('project_id' => 1, 'title' => 'A'));
$this->assertNotFalse($task_id1);
$task_id2 = $this->client->createTask(array('project_id' => 1, 'title' => 'B'));
$this->assertNotFalse($task_id2);
$task_id3 = $this->client->createTask(array('project_id' => 1, 'title' => 'C'));
$this->assertNotFalse($task_id3);
$task_link_id = $this->client->createTaskLink($task_id1, $task_id2, 1);
$this->assertNotFalse($task_link_id);
$task_link = $this->client->getTaskLinkById($task_link_id);
$this->assertNotEmpty($task_link);
$this->assertEquals($task_id1, $task_link['task_id']);
$this->assertEquals($task_id2, $task_link['opposite_task_id']);
$this->assertEquals(1, $task_link['link_id']);
$task_links = $this->client->getAllTaskLinks($task_id1);
$this->assertNotEmpty($task_links);
$this->assertCount(1, $task_links);
$this->assertTrue($this->client->updateTaskLink($task_link_id, $task_id1, $task_id3, 2));
$task_link = $this->client->getTaskLinkById($task_link_id);
$this->assertNotEmpty($task_link);
$this->assertEquals($task_id1, $task_link['task_id']);
$this->assertEquals($task_id3, $task_link['opposite_task_id']);
$this->assertEquals(2, $task_link['link_id']);
$this->assertTrue($this->client->removeTaskLink($task_link_id));
$this->assertEmpty($this->client->getAllTaskLinks($task_id1));
}
public function testCreateFile()
{
$this->assertNotFalse($this->client->createFile(1, $this->getTaskId(), 'My file', base64_encode('plain text file')));
}
public function testGetAllFiles()
{
$files = $this->client->getAllFiles(array('task_id' => $this->getTaskId()));
$this->assertNotEmpty($files);
$this->assertCount(1, $files);
$this->assertEquals('My file', $files[0]['name']);
$file = $this->client->getFile($files[0]['id']);
$this->assertNotEmpty($file);
$this->assertEquals('My file', $file['name']);
$content = $this->client->downloadFile($file['id']);
$this->assertNotEmpty($content);
$this->assertEquals('plain text file', base64_decode($content));
$content = $this->client->downloadFile(1234567);
$this->assertEmpty($content);
$this->assertTrue($this->client->removeFile($file['id']));
$this->assertEmpty($this->client->getAllFiles(1));
}
public function testRemoveAllFiles()
{
$this->assertNotFalse($this->client->createFile(1, $this->getTaskId(), 'My file 1', base64_encode('plain text file')));
$this->assertNotFalse($this->client->createFile(1, $this->getTaskId(), 'My file 2', base64_encode('plain text file')));
$files = $this->client->getAllFiles(array('task_id' => $this->getTaskId()));
$this->assertNotEmpty($files);
$this->assertCount(2, $files);
$this->assertTrue($this->client->removeAllFiles(array('task_id' => $this->getTaskId())));
$files = $this->client->getAllFiles(array('task_id' => $this->getTaskId()));
$this->assertEmpty($files);
}
public function testCreateTaskWithReference()
{
$task = array(
'title' => 'Task with external ticket number',
'reference' => 'TICKET-1234',
'project_id' => 1,
'description' => '[Link to my ticket](http://my-ticketing-system/1234)',
);
$task_id = $this->client->createTask($task);
$this->assertNotFalse($task_id);
$this->assertInternalType('int', $task_id);
$this->assertTrue($task_id > 0);
}
public function testGetTaskByReference()
{
$task = $this->client->getTaskByReference(array('project_id' => 1, 'reference' => 'TICKET-1234'));
$this->assertNotEmpty($task);
$this->assertEquals('Task with external ticket number', $task['title']);
$this->assertEquals('TICKET-1234', $task['reference']);
$this->assertEquals('http://127.0.0.1:8000/?controller=TaskViewController&action=show&task_id='.$task['id'].'&project_id='.$task['project_id'], $task['url']);
}
public function testCreateOverdueTask()
{
$this->assertNotFalse($this->client->createTask(array(
'title' => 'overdue task',
'project_id' => 1,
'date_due' => date('Y-m-d', strtotime('-2days')),
)));
}
public function testGetOverdueTasksByProject()
{
$tasks = $this->client->getOverdueTasksByProject(1);
$this->assertNotEmpty($tasks);
$this->assertCount(1, $tasks);
$this->assertEquals('overdue task', $tasks[0]['title']);
$this->assertEquals('API test', $tasks[0]['project_name']);
}
public function testGetOverdueTasks()
{
$tasks = $this->client->getOverdueTasks();
$this->assertNotEmpty($tasks);
$this->assertCount(1, $tasks);
$this->assertEquals('overdue task', $tasks[0]['title']);
$this->assertEquals('API test', $tasks[0]['project_name']);
}
}

24
tests/integration/AppTest.php
View File

@@ -1,8 +1,8 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class AppTest extends Base
class AppTest extends BaseIntegrationTest
{
public function testGetTimezone()
{
@@ -31,4 +31,24 @@ class AppTest extends Base
$this->assertEquals('Project Member', $roles['project-member']);
$this->assertEquals('Project Viewer', $roles['project-viewer']);
}
public function testGetDefaultColor()
{
$this->assertEquals('yellow', $this->user->getDefaultTaskColor());
}
public function testGetDefaultColors()
{
$colors = $this->user->getDefaultTaskColors();
$this->assertNotEmpty($colors);
$this->assertArrayHasKey('red', $colors);
}
public function testGetColorList()
{
$colors = $this->user->getColorList();
$this->assertNotEmpty($colors);
$this->assertArrayHasKey('red', $colors);
$this->assertEquals('Red', $colors['red']);
}
}

62
tests/integration/Base.php
View File

@@ -1,62 +0,0 @@
<?php
require_once __DIR__.'/../../vendor/autoload.php';
abstract class Base extends PHPUnit_Framework_TestCase
{
protected $app = null;
protected $admin = null;
protected $user = null;
public static function setUpBeforeClass()
{
if (DB_DRIVER === 'sqlite') {
@unlink(DB_FILENAME);
} elseif (DB_DRIVER === 'mysql') {
$pdo = new PDO('mysql:host='.DB_HOSTNAME, DB_USERNAME, DB_PASSWORD);
$pdo->exec('DROP DATABASE '.DB_NAME);
$pdo->exec('CREATE DATABASE '.DB_NAME);
$pdo = null;
} elseif (DB_DRIVER === 'postgres') {
$pdo = new PDO('pgsql:host='.DB_HOSTNAME, DB_USERNAME, DB_PASSWORD);
$pdo->exec('DROP DATABASE '.DB_NAME);
$pdo->exec('CREATE DATABASE '.DB_NAME.' WITH OWNER '.DB_USERNAME);
$pdo = null;
}
$service = new Kanboard\ServiceProvider\DatabaseProvider;
$db = $service->getInstance();
$db->table('settings')->eq('option', 'api_token')->update(array('value' => API_KEY));
$db->closeConnection();
}
public function setUp()
{
$this->app = new JsonRPC\Client(API_URL);
$this->app->authentication('jsonrpc', API_KEY);
$this->app->getHttpClient()->withDebug();
$this->admin = new JsonRPC\Client(API_URL);
$this->admin->authentication('admin', 'admin');
$this->admin->getHttpClient()->withDebug();
$this->user = new JsonRPC\Client(API_URL);
$this->user->authentication('user', 'password');
$this->user->getHttpClient()->withDebug();
}
protected function getProjectId()
{
$projects = $this->app->getAllProjects();
$this->assertNotEmpty($projects);
return $projects[0]['id'];
}
protected function getGroupId()
{
$groups = $this->app->getAllGroups();
$this->assertNotEmpty($groups);
return $groups[0]['id'];
}
}

122
tests/integration/BaseIntegrationTest.php Normal file
View File

@@ -0,0 +1,122 @@
<?php
require_once __DIR__.'/../../vendor/autoload.php';
abstract class BaseIntegrationTest extends PHPUnit_Framework_TestCase
{
protected $app = null;
protected $admin = null;
protected $manager = null;
protected $user = null;
protected $adminUserId = 0;
protected $managerUserId = 0;
protected $userUserId = 0;
protected $projectName = '';
protected $projectId = 0;
protected $taskTitle = 'My task';
protected $taskId = 0;
protected $groupName1 = 'My Group A';
protected $groupName2 = 'My Group B';
protected $groupId1;
protected $groupId2;
protected $username = 'test-user';
protected $userId;
public function setUp()
{
$this->setUpAppClient();
$this->setUpAdminUser();
$this->setUpManagerUser();
$this->setUpStandardUser();
}
public function setUpAppClient()
{
$this->app = new JsonRPC\Client(API_URL);
$this->app->authentication('jsonrpc', API_KEY);
$this->app->getHttpClient()->withDebug()->withTimeout(10);
}
public function setUpAdminUser()
{
$this->adminUserId = $this->getUserId('superuser');
if (! $this->adminUserId) {
$this->adminUserId = $this->app->createUser('superuser', 'password', 'Admin User', 'user@localhost', 'app-admin');
$this->assertNotFalse($this->adminUserId);
}
$this->admin = new JsonRPC\Client(API_URL);
$this->admin->authentication('superuser', 'password');
$this->admin->getHttpClient()->withDebug();
}
public function setUpManagerUser()
{
$this->managerUserId = $this->getUserId('manager');
if (! $this->managerUserId) {
$this->managerUserId = $this->app->createUser('manager', 'password', 'Manager User', 'user@localhost', 'app-manager');
$this->assertNotFalse($this->managerUserId);
}
$this->manager = new JsonRPC\Client(API_URL);
$this->manager->authentication('manager', 'password');
$this->manager->getHttpClient()->withDebug();
}
public function setUpStandardUser()
{
$this->userUserId = $this->getUserId('user');
if (! $this->userUserId) {
$this->userUserId = $this->app->createUser('user', 'password', 'Standard User', 'user@localhost', 'app-user');
$this->assertNotFalse($this->userUserId);
}
$this->user = new JsonRPC\Client(API_URL);
$this->user->authentication('user', 'password');
$this->user->getHttpClient()->withDebug();
}
public function getUserId($username)
{
$user = $this->app->getUserByName($username);
if (! empty($user)) {
return $user['id'];
}
return 0;
}
public function assertCreateTeamProject()
{
$this->projectId = $this->app->createProject($this->projectName, 'Description');
$this->assertNotFalse($this->projectId);
}
public function assertCreateUser()
{
$this->userId = $this->app->createUser($this->username, 'password');
$this->assertNotFalse($this->userId);
}
public function assertCreateGroups()
{
$this->groupId1 = $this->app->createGroup($this->groupName1);
$this->groupId2 = $this->app->createGroup($this->groupName2, 'External ID');
$this->assertNotFalse($this->groupId1);
$this->assertNotFalse($this->groupId2);
}
public function assertCreateTask()
{
$this->taskId = $this->app->createTask(array('title' => $this->taskTitle, 'project_id' => $this->projectId));
$this->assertNotFalse($this->taskId);
}
}

16
tests/integration/BoardTest.php
View File

@@ -1,17 +1,21 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class BoardTest extends Base
class BoardTest extends BaseIntegrationTest
{
public function testCreateProject()
protected $projectName = 'My project to test board';
public function testAll()
{
$this->assertEquals(1, $this->app->createProject('A project'));
$this->assertCreateTeamProject();
$this->assertGetBoard();
}
public function testGetBoard()
public function assertGetBoard()
{
$board = $this->app->getBoard(1);
$board = $this->app->getBoard($this->projectId);
$this->assertNotNull($board);
$this->assertCount(1, $board);
$this->assertEquals('Default swimlane', $board[0]['name']);

76
tests/integration/CategoryTest.php Normal file
View File

@@ -0,0 +1,76 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class CategoryTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test categories';
private $categoryId = 0;
public function testAll()
{
$this->assertCreateTeamProject();
$this->assertCreateCategory();
$this->assertThatCategoriesAreUnique();
$this->assertGetCategory();
$this->assertGetAllCategories();
$this->assertCategoryUpdate();
$this->assertRemoveCategory();
}
public function assertCreateCategory()
{
$this->categoryId = $this->app->createCategory(array(
'name' => 'Category',
'project_id' => $this->projectId,
));
$this->assertNotFalse($this->categoryId);
}
public function assertThatCategoriesAreUnique()
{
$this->assertFalse($this->app->execute('createCategory', array(
'name' => 'Category',
'project_id' => $this->projectId,
)));
}
public function assertGetCategory()
{
$category = $this->app->getCategory($this->categoryId);
$this->assertInternalType('array', $category);
$this->assertEquals($this->categoryId, $category['id']);
$this->assertEquals('Category', $category['name']);
$this->assertEquals($this->projectId, $category['project_id']);
}
public function assertGetAllCategories()
{
$categories = $this->app->getAllCategories($this->projectId);
$this->assertCount(1, $categories);
$this->assertEquals($this->categoryId, $categories[0]['id']);
$this->assertEquals('Category', $categories[0]['name']);
$this->assertEquals($this->projectId, $categories[0]['project_id']);
}
public function assertCategoryUpdate()
{
$this->assertTrue($this->app->execute('updateCategory', array(
'id' => $this->categoryId,
'name' => 'Renamed category',
)));
$category = $this->app->getCategory($this->categoryId);
$this->assertEquals('Renamed category', $category['name']);
}
public function assertRemoveCategory()
{
$this->assertTrue($this->app->removeCategory($this->categoryId));
$this->assertFalse($this->app->removeCategory($this->categoryId));
$this->assertFalse($this->app->removeCategory(1111));
}
}

78
tests/integration/ColumnTest.php
View File

@@ -1,65 +1,69 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class ColumnTest extends Base
class ColumnTest extends BaseIntegrationTest
{
public function testCreateProject()
protected $projectName = 'My project to test columns';
private $columns = array();
public function testAll()
{
$this->assertEquals(1, $this->app->createProject('A project'));
$this->assertCreateTeamProject();
$this->assertGetColumns();
$this->assertUpdateColumn();
$this->assertAddColumn();
$this->assertRemoveColumn();
$this->assertChangeColumnPosition();
}
public function testGetColumns()
public function assertGetColumns()
{
$columns = $this->app->getColumns($this->getProjectId());
$this->assertCount(4, $columns);
$this->assertEquals('Done', $columns[3]['title']);
$this->columns = $this->app->getColumns($this->projectId);
$this->assertCount(4, $this->columns);
$this->assertEquals('Done', $this->columns[3]['title']);
}
public function testUpdateColumn()
public function assertUpdateColumn()
{
$this->assertTrue($this->app->updateColumn(4, 'Boo', 2));
$this->assertTrue($this->app->updateColumn($this->columns[3]['id'], 'Another column', 2));
$columns = $this->app->getColumns($this->getProjectId());
$this->assertEquals('Boo', $columns[3]['title']);
$this->assertEquals(2, $columns[3]['task_limit']);
$this->columns = $this->app->getColumns($this->projectId);
$this->assertEquals('Another column', $this->columns[3]['title']);
$this->assertEquals(2, $this->columns[3]['task_limit']);
}
public function testAddColumn()
public function assertAddColumn()
{
$column_id = $this->app->addColumn($this->getProjectId(), 'New column');
$column_id = $this->app->addColumn($this->projectId, 'New column');
$this->assertNotFalse($column_id);
$this->assertInternalType('int', $column_id);
$this->assertTrue($column_id > 0);
$columns = $this->app->getColumns($this->getProjectId());
$this->assertCount(5, $columns);
$this->assertEquals('New column', $columns[4]['title']);
$this->columns = $this->app->getColumns($this->projectId);
$this->assertCount(5, $this->columns);
$this->assertEquals('New column', $this->columns[4]['title']);
}
public function testRemoveColumn()
public function assertRemoveColumn()
{
$this->assertTrue($this->app->removeColumn(5));
$this->assertTrue($this->app->removeColumn($this->columns[3]['id']));
$columns = $this->app->getColumns($this->getProjectId());
$this->assertCount(4, $columns);
$this->columns = $this->app->getColumns($this->projectId);
$this->assertCount(4, $this->columns);
}
public function testChangeColumnPosition()
public function assertChangeColumnPosition()
{
$this->assertTrue($this->app->changeColumnPosition($this->getProjectId(), 1, 3));
$this->assertTrue($this->app->changeColumnPosition($this->projectId, $this->columns[0]['id'], 3));
$columns = $this->app->getColumns($this->getProjectId());
$this->assertCount(4, $columns);
$this->assertEquals('Ready', $columns[0]['title']);
$this->assertEquals(1, $columns[0]['position']);
$this->assertEquals('Work in progress', $columns[1]['title']);
$this->assertEquals(2, $columns[1]['position']);
$this->assertEquals('Backlog', $columns[2]['title']);
$this->assertEquals(3, $columns[2]['position']);
$this->assertEquals('Boo', $columns[3]['title']);
$this->assertEquals(4, $columns[3]['position']);
$this->columns = $this->app->getColumns($this->projectId);
$this->assertEquals('Ready', $this->columns[0]['title']);
$this->assertEquals(1, $this->columns[0]['position']);
$this->assertEquals('Work in progress', $this->columns[1]['title']);
$this->assertEquals(2, $this->columns[1]['position']);
$this->assertEquals('Backlog', $this->columns[2]['title']);
$this->assertEquals(3, $this->columns[2]['position']);
$this->assertEquals('New column', $this->columns[3]['title']);
$this->assertEquals(4, $this->columns[3]['position']);
}
}

63
tests/integration/CommentTest.php Normal file
View File

@@ -0,0 +1,63 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class CommentTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test comments';
private $commentId = 0;
public function testAll()
{
$this->assertCreateTeamProject();
$this->assertCreateTask();
$this->assertCreateComment();
$this->assertUpdateComment();
$this->assertGetAllComments();
$this->assertRemoveComment();
}
public function assertCreateComment()
{
$this->commentId = $this->app->execute('createComment', array(
'task_id' => $this->taskId,
'user_id' => 1,
'content' => 'foobar',
));
$this->assertNotFalse($this->commentId);
}
public function assertGetComment()
{
$comment = $this->app->getComment($this->commentId);
$this->assertNotFalse($comment);
$this->assertNotEmpty($comment);
$this->assertEquals(1, $comment['user_id']);
$this->assertEquals('foobar', $comment['comment']);
}
public function assertUpdateComment()
{
$this->assertTrue($this->app->execute('updateComment', array(
'id' => $this->commentId,
'content' => 'test',
)));
$comment = $this->app->getComment($this->commentId);
$this->assertEquals('test', $comment['comment']);
}
public function assertGetAllComments()
{
$comments = $this->app->getAllComments($this->taskId);
$this->assertCount(1, $comments);
$this->assertEquals('test', $comments[0]['comment']);
}
public function assertRemoveComment()
{
$this->assertTrue($this->app->removeComment($this->commentId));
$this->assertFalse($this->app->removeComment($this->commentId));
}
}

58
tests/integration/GroupMemberTest.php
View File

@@ -1,47 +1,53 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class GroupMemberTest extends Base
class GroupMemberTest extends BaseIntegrationTest
{
public function testAddMember()
{
$this->assertNotFalse($this->app->createGroup('My Group A'));
$this->assertNotFalse($this->app->createGroup('My Group B'));
protected $username = 'user-group-member';
protected $groupName1 = 'My group member A';
protected $groupName2 = 'My group member B';
$groupId = $this->getGroupId();
$this->assertTrue($this->app->addGroupMember($groupId, 1));
public function testAll()
{
$this->assertCreateGroups();
$this->assertCreateUser();
$this->assertAddMember();
$this->assertGetMembers();
$this->assertIsGroupMember();
$this->assertGetGroups();
$this->assertRemove();
}
public function testGetMembers()
public function assertAddMember()
{
$groups = $this->app->getAllGroups();
$members = $this->app->getGroupMembers($groups[0]['id']);
$this->assertTrue($this->app->addGroupMember($this->groupId1, $this->userId));
}
public function assertGetMembers()
{
$members = $this->app->getGroupMembers($this->groupId1);
$this->assertCount(1, $members);
$this->assertEquals('admin', $members[0]['username']);
$this->assertSame(array(), $this->app->getGroupMembers($groups[1]['id']));
$this->assertEquals($this->username, $members[0]['username']);
}
public function testIsGroupMember()
public function assertIsGroupMember()
{
$groupId = $this->getGroupId();
$this->assertTrue($this->app->isGroupMember($groupId, 1));
$this->assertFalse($this->app->isGroupMember($groupId, 2));
$this->assertTrue($this->app->isGroupMember($this->groupId1, $this->userId));
$this->assertFalse($this->app->isGroupMember($this->groupId1, $this->adminUserId));
}
public function testGetGroups()
public function assertGetGroups()
{
$groups = $this->app->getMemberGroups(1);
$groups = $this->app->getMemberGroups($this->userId);
$this->assertCount(1, $groups);
$this->assertEquals(1, $groups[0]['id']);
$this->assertEquals('My Group A', $groups[0]['name']);
$this->assertEquals($this->groupId1, $groups[0]['id']);
$this->assertEquals($this->groupName1, $groups[0]['name']);
}
public function testRemove()
public function assertRemove()
{
$groupId = $this->getGroupId();
$this->assertTrue($this->app->removeGroupMember($groupId, 1));
$this->assertFalse($this->app->isGroupMember($groupId, 1));
$this->assertTrue($this->app->removeGroupMember($this->groupId1, $this->userId));
$this->assertFalse($this->app->isGroupMember($this->groupId1, $this->userId));
}
}

56
tests/integration/GroupTest.php
View File

@@ -1,48 +1,50 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class GroupTest extends Base
class GroupTest extends BaseIntegrationTest
{
public function testCreateGroup()
public function testAll()
{
$this->assertNotFalse($this->app->createGroup('My Group A'));
$this->assertNotFalse($this->app->createGroup('My Group B', '1234'));
$this->assertCreateGroups();
$this->assertGetAllGroups();
$this->assertGetGroup();
$this->assertUpdateGroup();
$this->assertRemove();
}
public function testGetter()
public function assertGetAllGroups()
{
$groups = $this->app->getAllGroups();
$this->assertCount(2, $groups);
$this->assertEquals('My Group A', $groups[0]['name']);
$this->assertEquals('', $groups[0]['external_id']);
$this->assertEquals('My Group B', $groups[1]['name']);
$this->assertEquals('1234', $groups[1]['external_id']);
$this->assertNotEmpty($groups);
$this->assertArrayHasKey('name', $groups[0]);
$this->assertArrayHasKey('external_id', $groups[0]);
}
$group = $this->app->getGroup($groups[0]['id']);
public function assertGetGroup()
{
$group = $this->app->getGroup($this->groupId1);
$this->assertNotEmpty($group);
$this->assertEquals('My Group A', $group['name']);
$this->assertEquals($this->groupName1, $group['name']);
$this->assertEquals('', $group['external_id']);
}
public function testUpdate()
public function assertUpdateGroup()
{
$groups = $this->app->getAllGroups();
$this->assertTrue($this->app->updateGroup(array(
'group_id' => $this->groupId2,
'name' => 'My Group C',
'external_id' => 'something else',
)));
$this->assertTrue($this->app->updateGroup(array('group_id' => $groups[0]['id'], 'name' => 'ABC', 'external_id' => 'something')));
$this->assertTrue($this->app->updateGroup(array('group_id' => $groups[1]['id'], 'external_id' => '')));
$groups = $this->app->getAllGroups();
$this->assertEquals('ABC', $groups[0]['name']);
$this->assertEquals('something', $groups[0]['external_id']);
$this->assertEquals('', $groups[1]['external_id']);
$group = $this->app->getGroup($this->groupId2);
$this->assertNotEmpty($group);
$this->assertEquals('My Group C', $group['name']);
$this->assertEquals('something else', $group['external_id']);
}
public function testRemove()
public function assertRemove()
{
$groups = $this->app->getAllGroups();
$this->assertTrue($this->app->removeGroup($groups[0]['id']));
$this->assertTrue($this->app->removeGroup($groups[1]['id']));
$this->assertSame(array(), $this->app->getAllGroups());
$this->assertTrue($this->app->removeGroup($this->groupId1));
}
}

70
tests/integration/LinkTest.php Normal file
View File

@@ -0,0 +1,70 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class LinkTest extends BaseIntegrationTest
{
public function testGetAllLinks()
{
$links = $this->app->getAllLinks();
$this->assertNotEmpty($links);
$this->assertArrayHasKey('id', $links[0]);
$this->assertArrayHasKey('label', $links[0]);
$this->assertArrayHasKey('opposite_id', $links[0]);
}
public function testGetOppositeLink()
{
$link = $this->app->getOppositeLinkId(1);
$this->assertEquals(1, $link);
$link = $this->app->getOppositeLinkId(2);
$this->assertEquals(3, $link);
}
public function testGetLinkByLabel()
{
$link = $this->app->getLinkByLabel('blocks');
$this->assertNotEmpty($link);
$this->assertEquals(2, $link['id']);
$this->assertEquals(3, $link['opposite_id']);
}
public function testGetLinkById()
{
$link = $this->app->getLinkById(4);
$this->assertNotEmpty($link);
$this->assertEquals(4, $link['id']);
$this->assertEquals(5, $link['opposite_id']);
$this->assertEquals('duplicates', $link['label']);
}
public function testCreateLink()
{
$link_id = $this->app->createLink(array('label' => 'test'));
$this->assertNotFalse($link_id);
$this->assertInternalType('int', $link_id);
$link_id = $this->app->createLink(array('label' => 'foo', 'opposite_label' => 'bar'));
$this->assertNotFalse($link_id);
$this->assertInternalType('int', $link_id);
}
public function testUpdateLink()
{
$link1 = $this->app->getLinkByLabel('bar');
$this->assertNotEmpty($link1);
$link2 = $this->app->getLinkByLabel('test');
$this->assertNotEmpty($link2);
$this->assertNotFalse($this->app->updateLink($link1['id'], $link2['id'], 'my link'));
$link = $this->app->getLinkById($link1['id']);
$this->assertNotEmpty($link);
$this->assertEquals($link2['id'], $link['opposite_id']);
$this->assertEquals('my link', $link['label']);
$this->assertTrue($this->app->removeLink($link1['id']));
}
}

230
tests/integration/MeTest.php
View File

@@ -1,207 +1,60 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class MeTest extends Base
class MeTest extends BaseIntegrationTest
{
public function testCreateProject()
protected $projectName = 'My private project';
public function testAll()
{
$this->assertEquals(1, $this->app->createProject('team project'));
$this->assertGetMe();
$this->assertCreateMyPrivateProject();
$this->assertGetMyProjectsList();
$this->assertGetMyProjects();
$this->assertCreateTask();
$this->assertGetMyDashboard();
$this->assertGetMyActivityStream();
}
public function testCreateUser()
{
$this->assertEquals(2, $this->app->createUser('user', 'password'));
}
/**
* @expectedException JsonRPC\Exception\AccessDeniedException
*/
public function testNotAllowedAppProcedure()
{
$this->app->getMe();
}
/**
* @expectedException JsonRPC\Exception\AccessDeniedException
*/
public function testNotAllowedUserProcedure()
{
$this->user->getAllProjects();
}
/**
* @expectedException JsonRPC\Exception\AccessDeniedException
*/
public function testNotAllowedProjectForUser()
{
$this->user->getProjectById(1);
}
public function testAllowedProjectForAdmin()
{
$this->assertNotEmpty($this->admin->getProjectById(1));
}
public function testGetTimezone()
{
$this->assertEquals('UTC', $this->user->getTimezone());
}
public function testGetVersion()
{
$this->assertEquals('master', $this->user->getVersion());
}
public function testGetDefaultColor()
{
$this->assertEquals('yellow', $this->user->getDefaultTaskColor());
}
public function testGetDefaultColors()
{
$colors = $this->user->getDefaultTaskColors();
$this->assertNotEmpty($colors);
$this->assertArrayHasKey('red', $colors);
}
public function testGetColorList()
{
$colors = $this->user->getColorList();
$this->assertNotEmpty($colors);
$this->assertArrayHasKey('red', $colors);
$this->assertEquals('Red', $colors['red']);
}
public function testGetMe()
public function assertGetMe()
{
$profile = $this->user->getMe();
$this->assertNotEmpty($profile);
$this->assertEquals(2, $profile['id']);
$this->assertEquals('user', $profile['username']);
$this->assertEquals('app-user', $profile['role']);
}
public function testCreateMyPrivateProject()
public function assertCreateMyPrivateProject()
{
$this->assertEquals(2, $this->user->createMyPrivateProject('my project'));
$this->projectId = $this->user->createMyPrivateProject($this->projectName);
$this->assertNotFalse($this->projectId);
}
public function testGetMyProjectsList()
public function assertGetMyProjectsList()
{
$projects = $this->user->getMyProjectsList();
$this->assertNotEmpty($projects);
$this->assertArrayNotHasKey(1, $projects);
$this->assertArrayHasKey(2, $projects);
$this->assertEquals('my project', $projects[2]);
$this->assertEquals($this->projectName, $projects[$this->projectId]);
}
public function testGetMyProjects()
public function assertGetMyProjects()
{
$projects = $this->user->getMyProjects();
$this->assertNotEmpty($projects);
$this->assertCount(1, $projects);
$this->assertEquals(2, $projects[0]['id']);
$this->assertEquals('my project', $projects[0]['name']);
$this->assertEquals($this->projectName, $projects[0]['name']);
$this->assertNotEmpty($projects[0]['url']['calendar']);
$this->assertNotEmpty($projects[0]['url']['board']);
$this->assertNotEmpty($projects[0]['url']['list']);
}
public function testGetProjectById()
public function assertCreateTask()
{
$project = $this->user->getProjectById(2);
$this->assertNotEmpty($project);
$this->assertEquals('my project', $project['name']);
$this->assertEquals(1, $project['is_private']);
$taskId = $this->user->createTask(array('title' => 'My task', 'project_id' => $this->projectId, 'owner_id' => $this->userUserId));
$this->assertNotFalse($taskId);
}
public function testCreateTask()
{
$this->assertEquals(1, $this->user->createTask('my user title', 2));
$this->assertEquals(2, $this->admin->createTask('my admin title', 1));
}
public function testCreateTaskWithWrongMember()
{
$this->assertFalse($this->user->createTask(array('title' => 'something', 'project_id' => 2, 'owner_id' => 1)));
$this->assertFalse($this->app->createTask(array('title' => 'something', 'project_id' => 1, 'owner_id' => 2)));
}
public function testGetTask()
{
$task = $this->user->getTask(1);
$this->assertNotEmpty($task);
$this->assertEquals('my user title', $task['title']);
$this->assertEquals('yellow', $task['color_id']);
$this->assertArrayHasKey('color', $task);
$this->assertArrayHasKey('name', $task['color']);
$this->assertArrayHasKey('border', $task['color']);
$this->assertArrayHasKey('background', $task['color']);
}
/**
* @expectedException JsonRPC\Exception\AccessDeniedException
*/
public function testGetAdminTask()
{
$this->user->getTask(2);
}
/**
* @expectedException JsonRPC\Exception\AccessDeniedException
*/
public function testGetProjectActivityDenied()
{
$this->user->getProjectActivity(1);
}
public function testGetProjectActivityAllowed()
{
$activity = $this->user->getProjectActivity(2);
$this->assertNotEmpty($activity);
}
public function testGetMyActivityStream()
{
$activity = $this->user->getMyActivityStream();
$this->assertNotEmpty($activity);
}
public function testCloseTask()
{
$this->assertTrue($this->user->closeTask(1));
}
public function testOpenTask()
{
$this->assertTrue($this->user->openTask(1));
}
public function testMoveTaskPosition()
{
$this->assertTrue($this->user->moveTaskPosition(2, 1, 2, 1));
}
public function testUpdateTaskWithWrongMember()
{
$this->assertFalse($this->user->updateTask(array('id' => 1, 'title' => 'new title', 'reference' => 'test', 'owner_id' => 1)));
}
public function testUpdateTask()
{
$this->assertTrue($this->user->updateTask(array('id' => 1, 'title' => 'new title', 'reference' => 'test', 'owner_id' => 2)));
}
public function testGetbyReference()
{
$task = $this->user->getTaskByReference(2, 'test');
$this->assertNotEmpty($task);
$this->assertEquals('new title', $task['title']);
$this->assertEquals(2, $task['column_id']);
$this->assertEquals(1, $task['position']);
}
public function testGetMyDashboard()
public function assertGetMyDashboard()
{
$dashboard = $this->user->getMyDashboard();
$this->assertNotEmpty($dashboard);
@@ -212,36 +65,9 @@ class MeTest extends Base
$this->assertNotEmpty($dashboard['tasks']);
}
public function testGetBoard()
public function assertGetMyActivityStream()
{
$this->assertNotEmpty($this->user->getBoard(2));
}
public function testCreateOverdueTask()
{
$this->assertNotFalse($this->user->createTask(array(
'title' => 'overdue task',
'project_id' => 2,
'date_due' => date('Y-m-d', strtotime('-2days')),
'owner_id' => 2,
)));
}
public function testGetMyOverdueTasks()
{
$tasks = $this->user->getMyOverdueTasks();
$this->assertNotEmpty($tasks);
$this->assertCount(1, $tasks);
$this->assertEquals('overdue task', $tasks[0]['title']);
$this->assertEquals('my project', $tasks[0]['project_name']);
}
public function testGetOverdueTasksByProject()
{
$tasks = $this->user->getOverdueTasksByProject(2);
$this->assertNotEmpty($tasks);
$this->assertCount(1, $tasks);
$this->assertEquals('overdue task', $tasks[0]['title']);
$this->assertEquals('my project', $tasks[0]['project_name']);
$activity = $this->user->getMyActivityStream();
$this->assertNotEmpty($activity);
}
}

43
tests/integration/OverdueTaskTest.php Normal file
View File

@@ -0,0 +1,43 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class OverdueTaskTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test overdue tasks';
public function testAll()
{
$this->assertCreateTeamProject();
$this->assertCreateOverdueTask();
$this->assertGetOverdueTasksByProject();
$this->assertGetOverdueTasks();
}
public function assertCreateOverdueTask()
{
$this->assertNotFalse($this->app->createTask(array(
'title' => 'overdue task',
'project_id' => $this->projectId,
'date_due' => date('Y-m-d', strtotime('-2days')),
)));
}
public function assertGetOverdueTasksByProject()
{
$tasks = $this->app->getOverdueTasksByProject($this->projectId);
$this->assertNotEmpty($tasks);
$this->assertCount(1, $tasks);
$this->assertEquals('overdue task', $tasks[0]['title']);
$this->assertEquals($this->projectName, $tasks[0]['project_name']);
}
public function assertGetOverdueTasks()
{
$tasks = $this->app->getOverdueTasks();
$this->assertNotEmpty($tasks);
$this->assertCount(1, $tasks);
$this->assertEquals('overdue task', $tasks[0]['title']);
$this->assertEquals($this->projectName, $tasks[0]['project_name']);
}
}

111
tests/integration/ProjectPermissionTest.php
View File

@@ -1,64 +1,89 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class ProjectPermissionTest extends Base
class ProjectPermissionTest extends BaseIntegrationTest
{
public function testGetProjectUsers()
protected $projectName = 'Project with permission';
protected $username = 'user-project-permission';
protected $groupName1 = 'My group A for project permission';
protected $groupName2 = 'My group B for project permission';
public function testAll()
{
$this->assertNotFalse($this->app->createProject('Test'));
$this->assertNotFalse($this->app->createGroup('Test'));
$this->assertCreateTeamProject();
$this->assertCreateGroups();
$this->assertCreateUser();
$projectId = $this->getProjectId();
$groupId = $this->getGroupId();
$this->assertAddProjectUser();
$this->assertGetProjectUsers();
$this->assertGetAssignableUsers();
$this->assertChangeProjectUserRole();
$this->assertRemoveProjectUser();
$this->assertTrue($this->app->addGroupMember($projectId, $groupId));
$this->assertSame(array(), $this->app->getProjectUsers($projectId));
$this->assertAddProjectGroup();
$this->assertGetProjectUsers();
$this->assertGetAssignableUsers();
$this->assertChangeProjectGroupRole();
$this->assertRemoveProjectGroup();
}
public function testProjectUser()
public function assertAddProjectUser()
{
$projectId = $this->getProjectId();
$this->assertTrue($this->app->addProjectUser($projectId, 1));
$users = $this->app->getProjectUsers($projectId);
$this->assertCount(1, $users);
$this->assertEquals('admin', $users[1]);
$users = $this->app->getAssignableUsers($projectId);
$this->assertCount(1, $users);
$this->assertEquals('admin', $users[1]);
$this->assertTrue($this->app->changeProjectUserRole($projectId, 1, 'project-viewer'));
$users = $this->app->getAssignableUsers($projectId);
$this->assertCount(0, $users);
$this->assertTrue($this->app->removeProjectUser($projectId, 1));
$this->assertSame(array(), $this->app->getProjectUsers($projectId));
$this->assertTrue($this->app->addProjectUser($this->projectId, $this->userId));
}
public function testProjectGroup()
public function assertGetProjectUsers()
{
$projectId = $this->getProjectId();
$groupId = $this->getGroupId();
$members = $this->app->getProjectUsers($this->projectId);
$this->assertCount(1, $members);
$this->assertArrayHasKey($this->userId, $members);
$this->assertEquals($this->username, $members[$this->userId]);
}
$this->assertTrue($this->app->addProjectGroup($projectId, $groupId));
public function assertGetAssignableUsers()
{
$members = $this->app->getAssignableUsers($this->projectId);
$this->assertCount(1, $members);
$this->assertArrayHasKey($this->userId, $members);
$this->assertEquals($this->username, $members[$this->userId]);
}
$users = $this->app->getProjectUsers($projectId);
$this->assertCount(1, $users);
$this->assertEquals('admin', $users[1]);
public function assertChangeProjectUserRole()
{
$this->assertTrue($this->app->changeProjectUserRole($this->projectId, $this->userId, 'project-viewer'));
$users = $this->app->getAssignableUsers($projectId);
$this->assertCount(1, $users);
$this->assertEquals('admin', $users[1]);
$members = $this->app->getAssignableUsers($this->projectId);
$this->assertCount(0, $members);
}
$this->assertTrue($this->app->changeProjectGroupRole($projectId, $groupId, 'project-viewer'));
public function assertRemoveProjectUser()
{
$this->assertTrue($this->app->removeProjectUser($this->projectId, $this->userId));
$users = $this->app->getAssignableUsers($projectId);
$this->assertCount(0, $users);
$members = $this->app->getProjectUsers($this->projectId);
$this->assertCount(0, $members);
}
$this->assertTrue($this->app->removeProjectGroup($projectId, 1));
$this->assertSame(array(), $this->app->getProjectUsers($projectId));
public function assertAddProjectGroup()
{
$this->assertTrue($this->app->addGroupMember($this->groupId1, $this->userId));
$this->assertTrue($this->app->addProjectGroup($this->projectId, $this->groupId1));
}
public function assertChangeProjectGroupRole()
{
$this->assertTrue($this->app->changeProjectGroupRole($this->projectId, $this->groupId1, 'project-viewer'));
$members = $this->app->getAssignableUsers($this->projectId);
$this->assertCount(0, $members);
}
public function assertRemoveProjectGroup()
{
$this->assertTrue($this->app->removeProjectGroup($this->projectId, $this->groupId1));
$members = $this->app->getProjectUsers($this->projectId);
$this->assertCount(0, $members);
}
}

89
tests/integration/ProjectTest.php Normal file
View File

@@ -0,0 +1,89 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class ProjectTest extends BaseIntegrationTest
{
protected $projectName = 'My team project';
public function testAll()
{
$this->assertCreateTeamProject();
$this->assertGetProjectById();
$this->assertGetProjectByName();
$this->assertGetAllProjects();
$this->assertUpdateProject();
$this->assertGetProjectActivity();
$this->assertGetProjectsActivity();
$this->assertEnableDisableProject();
$this->assertEnableDisablePublicAccess();
$this->assertRemoveProject();
}
public function assertGetProjectById()
{
$project = $this->app->getProjectById($this->projectId);
$this->assertNotNull($project);
$this->assertEquals($this->projectName, $project['name']);
$this->assertEquals('Description', $project['description']);
}
public function assertGetProjectByName()
{
$project = $this->app->getProjectByName($this->projectName);
$this->assertNotNull($project);
$this->assertEquals($this->projectId, $project['id']);
$this->assertEquals($this->projectName, $project['name']);
$this->assertEquals('Description', $project['description']);
}
public function assertGetAllProjects()
{
$projects = $this->app->getAllProjects();
$this->assertNotEmpty($projects);
}
public function assertGetProjectActivity()
{
$activities = $this->app->getProjectActivity($this->projectId);
$this->assertInternalType('array', $activities);
$this->assertCount(0, $activities);
}
public function assertGetProjectsActivity()
{
$activities = $this->app->getProjectActivities(array('project_ids' => array($this->projectId)));
$this->assertInternalType('array', $activities);
$this->assertCount(0, $activities);
}
public function assertUpdateProject()
{
$this->assertTrue($this->app->updateProject(array('project_id' => $this->projectId, 'name' => 'test', 'description' => 'test')));
$project = $this->app->getProjectById($this->projectId);
$this->assertNotNull($project);
$this->assertEquals('test', $project['name']);
$this->assertEquals('test', $project['description']);
$this->assertTrue($this->app->updateProject(array('project_id' => $this->projectId, 'name' => $this->projectName)));
}
public function assertEnableDisableProject()
{
$this->assertTrue($this->app->disableProject($this->projectId));
$this->assertTrue($this->app->enableProject($this->projectId));
}
public function assertEnableDisablePublicAccess()
{
$this->assertTrue($this->app->disableProjectPublicAccess($this->projectId));
$this->assertTrue($this->app->enableProjectPublicAccess($this->projectId));
}
public function assertRemoveProject()
{
$this->assertTrue($this->app->removeProject($this->projectId));
$this->assertNull($this->app->getProjectById($this->projectId));
}
}

64
tests/integration/SubtaskTest.php Normal file
View File

@@ -0,0 +1,64 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class SubtaskTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test subtasks';
private $subtaskId = 0;
public function testAll()
{
$this->assertCreateTeamProject();
$this->assertCreateTask();
$this->assertCreateSubtask();
$this->assertGetSubtask();
$this->assertUpdateSubtask();
$this->assertGetAllSubtasks();
$this->assertRemoveSubtask();
}
public function assertCreateSubtask()
{
$this->subtaskId = $this->app->createSubtask(array(
'task_id' => $this->taskId,
'title' => 'subtask #1',
));
$this->assertNotFalse($this->subtaskId);
}
public function assertGetSubtask()
{
$subtask = $this->app->getSubtask($this->subtaskId);
$this->assertEquals($this->taskId, $subtask['task_id']);
$this->assertEquals('subtask #1', $subtask['title']);
}
public function assertUpdateSubtask()
{
$this->assertTrue($this->app->execute('updateSubtask', array(
'id' => $this->subtaskId,
'task_id' => $this->taskId,
'title' => 'test',
)));
$subtask = $this->app->getSubtask($this->subtaskId);
$this->assertEquals('test', $subtask['title']);
}
public function assertGetAllSubtasks()
{
$subtasks = $this->app->getAllSubtasks($this->taskId);
$this->assertCount(1, $subtasks);
$this->assertEquals('test', $subtasks[0]['title']);
}
public function assertRemoveSubtask()
{
$this->assertTrue($this->app->removeSubtask($this->subtaskId));
$subtasks = $this->app->getAllSubtasks($this->taskId);
$this->assertCount(0, $subtasks);
}
}

90
tests/integration/SwimlaneTest.php
View File

@@ -1,103 +1,93 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class SwimlaneTest extends Base
class SwimlaneTest extends BaseIntegrationTest
{
public function testCreateProject()
protected $projectName = 'My project to test swimlanes';
private $swimlaneId = 0;
public function testAll()
{
$this->assertEquals(1, $this->app->createProject('A project'));
$this->assertCreateTeamProject();
}
public function testGetDefaultSwimlane()
public function assertGetDefaultSwimlane()
{
$swimlane = $this->app->getDefaultSwimlane(1);
$swimlane = $this->app->getDefaultSwimlane($this->projectId);
$this->assertNotEmpty($swimlane);
$this->assertEquals('Default swimlane', $swimlane['default_swimlane']);
}
public function testAddSwimlane()
public function assertAddSwimlane()
{
$swimlane_id = $this->app->addSwimlane(1, 'Swimlane 1');
$this->assertNotFalse($swimlane_id);
$this->assertInternalType('int', $swimlane_id);
$this->swimlaneId = $this->app->addSwimlane($this->projectId, 'Swimlane 1');
$this->assertNotFalse($this->swimlaneId);
$this->assertNotFalse($this->app->addSwimlane($this->projectId, 'Swimlane 2'));
}
$swimlane = $this->app->getSwimlaneById($swimlane_id);
$this->assertNotEmpty($swimlane);
public function assertGetSwimlane()
{
$swimlane = $this->app->getSwimlane($this->swimlaneId);
$this->assertInternalType('array', $swimlane);
$this->assertEquals('Swimlane 1', $swimlane['name']);
}
public function testGetSwimlane()
public function assertUpdateSwimlane()
{
$swimlane = $this->app->getSwimlane(1);
$this->assertInternalType('array', $swimlane);
$this->assertEquals('Swimlane 1', $swimlane['name']);
}
$this->assertTrue($this->app->updateSwimlane($this->swimlaneId, 'Another swimlane'));
public function testUpdateSwimlane()
{
$swimlane = $this->app->getSwimlaneByName(1, 'Swimlane 1');
$this->assertInternalType('array', $swimlane);
$this->assertEquals(1, $swimlane['id']);
$this->assertEquals('Swimlane 1', $swimlane['name']);
$this->assertTrue($this->app->updateSwimlane($swimlane['id'], 'Another swimlane'));
$swimlane = $this->app->getSwimlaneById($swimlane['id']);
$swimlane = $this->app->getSwimlaneById($this->swimlaneId);
$this->assertEquals('Another swimlane', $swimlane['name']);
}
public function testDisableSwimlane()
public function assertDisableSwimlane()
{
$this->assertTrue($this->app->disableSwimlane(1, 1));
$this->assertTrue($this->app->disableSwimlane($this->projectId, $this->swimlaneId));
$swimlane = $this->app->getSwimlaneById(1);
$swimlane = $this->app->getSwimlaneById($this->swimlaneId);
$this->assertEquals(0, $swimlane['is_active']);
}
public function testEnableSwimlane()
public function assertEnableSwimlane()
{
$this->assertTrue($this->app->enableSwimlane(1, 1));
$this->assertTrue($this->app->enableSwimlane($this->projectId, $this->swimlaneId));
$swimlane = $this->app->getSwimlaneById(1);
$swimlane = $this->app->getSwimlaneById($this->swimlaneId);
$this->assertEquals(1, $swimlane['is_active']);
}
public function testGetAllSwimlanes()
public function assertGetAllSwimlanes()
{
$this->assertNotFalse($this->app->addSwimlane(1, 'Swimlane A'));
$swimlanes = $this->app->getAllSwimlanes(1);
$swimlanes = $this->app->getAllSwimlanes($this->projectId);
$this->assertCount(2, $swimlanes);
$this->assertEquals('Another swimlane', $swimlanes[0]['name']);
$this->assertEquals('Swimlane A', $swimlanes[1]['name']);
$this->assertEquals('Swimlane 2', $swimlanes[1]['name']);
}
public function testGetActiveSwimlane()
public function assertGetActiveSwimlane()
{
$this->assertTrue($this->app->disableSwimlane(1, 1));
$this->assertTrue($this->app->disableSwimlane($this->projectId, $this->swimlaneId));
$swimlanes = $this->app->getActiveSwimlanes(1);
$swimlanes = $this->app->getActiveSwimlanes($this->projectId);
$this->assertCount(2, $swimlanes);
$this->assertEquals('Default swimlane', $swimlanes[0]['name']);
$this->assertEquals('Swimlane A', $swimlanes[1]['name']);
$this->assertEquals('Swimlane 2', $swimlanes[1]['name']);
}
public function testRemoveSwimlane()
public function assertRemoveSwimlane()
{
$this->assertTrue($this->app->removeSwimlane(1, 2));
$this->assertTrue($this->app->removeSwimlane($this->projectId, $this->swimlaneId));
}
public function testChangePosition()
public function assertChangePosition()
{
$this->assertNotFalse($this->app->addSwimlane(1, 'Swimlane 1'));
$this->assertNotFalse($this->app->addSwimlane(1, 'Swimlane 2'));
$swimlaneId1 = $this->app->addSwimlane($this->projectId, 'Swimlane A');
$this->assertNotFalse($this->app->addSwimlane($this->projectId, 'Swimlane B'));
$swimlanes = $this->app->getAllSwimlanes(1);
$swimlanes = $this->app->getAllSwimlanes($this->projectId);
$this->assertCount(3, $swimlanes);
$this->assertTrue($this->app->changeSwimlanePosition(1, 1, 3));
$this->assertFalse($this->app->changeSwimlanePosition(1, 1, 6));
$this->assertTrue($this->app->changeSwimlanePosition($this->projectId, $swimlaneId1, 3));
}
}

67
tests/integration/TaskFileTest.php Normal file
View File

@@ -0,0 +1,67 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class TaskFileTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test task files';
protected $fileId;
public function testAll()
{
$this->assertCreateTeamProject();
$this->assertCreateTask();
$this->assertCreateTaskFile();
$this->assertGetTaskFile();
$this->assertDownloadTaskFile();
$this->assertGetAllFiles();
$this->assertRemoveTaskFile();
$this->assertRemoveAllTaskFiles();
}
public function assertCreateTaskFile()
{
$this->fileId = $this->app->createTaskFile(1, $this->taskId, 'My file', base64_encode('plain text file'));
$this->assertNotFalse($this->fileId);
}
public function assertGetTaskFile()
{
$file = $this->app->getTaskFile($this->fileId);
$this->assertNotEmpty($file);
$this->assertEquals('My file', $file['name']);
}
public function assertDownloadTaskFile()
{
$content = $this->app->downloadTaskFile($this->fileId);
$this->assertNotEmpty($content);
$this->assertEquals('plain text file', base64_decode($content));
}
public function assertGetAllFiles()
{
$files = $this->app->getAllTaskFiles(array('task_id' => $this->taskId));
$this->assertCount(1, $files);
$this->assertEquals('My file', $files[0]['name']);
}
public function assertRemoveTaskFile()
{
$this->assertTrue($this->app->removeTaskFile($this->fileId));
$files = $this->app->getAllTaskFiles(array('task_id' => $this->taskId));
$this->assertEmpty($files);
}
public function assertRemoveAllTaskFiles()
{
$this->assertCreateTaskFile();
$this->assertCreateTaskFile();
$this->assertTrue($this->app->removeAllTaskFiles($this->taskId));
$files = $this->app->getAllTaskFiles(array('task_id' => $this->taskId));
$this->assertEmpty($files);
}
}

68
tests/integration/TaskLinkTest.php Normal file
View File

@@ -0,0 +1,68 @@
<?php
require_once __DIR__.'/BaseIntegrationTest.php';
class TaskLinkTest extends BaseIntegrationTest
{
protected $projectName = 'My project to test task links';
protected $taskLinkId;
protected $taskId1;
protected $taskId2;
public function testAll()
{
$this->assertCreateTeamProject();
$this->taskId1 = $this->app->createTask(array('project_id' => $this->projectId, 'title' => 'Task 1'));
$this->taskId2 = $this->app->createTask(array('project_id' => $this->projectId, 'title' => 'Task 2'));
$this->assertNotFalse($this->taskId1);
$this->assertNotFalse($this->taskId2);
$this->assertCreateTaskLink();
$this->assertGetTaskLink();
$this->assertGetAllTaskLinks();
$this->assertUpdateTaskLink();
$this->assertRemoveTaskLink();
}
public function assertCreateTaskLink()
{
$this->taskLinkId = $this->app->createTaskLink($this->taskId1, $this->taskId2, 1);
$this->assertNotFalse($this->taskLinkId);
}
public function assertGetTaskLink()
{
$link = $this->app->getTaskLinkById($this->taskLinkId);
$this->assertNotNull($link);
$this->assertEquals($this->taskId1, $link['task_id']);
$this->assertEquals($this->taskId2, $link['opposite_task_id']);
$this->assertEquals(1, $link['link_id']);
}
public function assertGetAllTaskLinks()
{
$links = $this->app->getAllTaskLinks($this->taskId2);
$this->assertCount(1, $links);
}
public function assertUpdateTaskLink()
{
$this->assertTrue($this->app->updateTaskLink($this->taskLinkId, $this->taskId1, $this->taskId2, 3));
$link = $this->app->getTaskLinkById($this->taskLinkId);
$this->assertNotNull($link);
$this->assertEquals($this->taskId1, $link['task_id']);
$this->assertEquals($this->taskId2, $link['opposite_task_id']);
$this->assertEquals(3, $link['link_id']);
}
public function assertRemoveTaskLink()
{
$this->assertTrue($this->app->removeTaskLink($this->taskLinkId));
$links = $this->app->getAllTaskLinks($this->taskId2);
$this->assertCount(0, $links);
}
}

141
tests/integration/TaskTest.php
View File

@@ -1,132 +1,55 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class TaskTest extends Base
class TaskTest extends BaseIntegrationTest
{
public function testSearchTasks()
protected $projectName = 'My project to test tasks';
public function testAll()
{
$project_id1 = $this->app->createProject('My project');
$project_id2 = $this->app->createProject('My project');
$this->assertNotFalse($project_id1);
$this->assertNotFalse($project_id2);
$this->assertNotFalse($this->app->createTask(array('project_id' => $project_id1, 'title' => 'T1')));
$this->assertNotFalse($this->app->createTask(array('project_id' => $project_id1, 'title' => 'T2')));
$this->assertNotFalse($this->app->createTask(array('project_id' => $project_id2, 'title' => 'T3')));
$tasks = $this->app->searchTasks($project_id1, 't2');
$this->assertCount(1, $tasks);
$this->assertEquals('T2', $tasks[0]['title']);
$tasks = $this->app->searchTasks(array('project_id' => $project_id2, 'query' => 'assignee:nobody'));
$this->assertCount(1, $tasks);
$this->assertEquals('T3', $tasks[0]['title']);
$this->assertCreateTeamProject();
$this->assertCreateTask();
$this->assertUpdateTask();
$this->assertGetTaskById();
$this->assertGetTaskByReference();
$this->assertGetAllTasks();
$this->assertOpenCloseTask();
}
public function testPriorityAttribute()
public function assertUpdateTask()
{
$project_id = $this->app->createProject('My project');
$this->assertNotFalse($project_id);
$task_id = $this->app->createTask(array('project_id' => $project_id, 'title' => 'My task', 'priority' => 2));
$task = $this->app->getTask($task_id);
$this->assertEquals(2, $task['priority']);
$this->assertTrue($this->app->updateTask(array('id' => $task_id, 'project_id' => $project_id, 'priority' => 3)));
$task = $this->app->getTask($task_id);
$this->assertEquals(3, $task['priority']);
$this->assertTrue($this->app->updateTask(array('id' => $this->taskId, 'color_id' => 'red')));
}
public function testChangeAssigneeToAssignableUser()
public function assertGetTaskById()
{
$project_id = $this->app->createProject('My project');
$this->assertNotFalse($project_id);
$user_id = $this->app->createUser('user0', 'password');
$this->assertNotFalse($user_id);
$this->assertTrue($this->app->addProjectUser($project_id, $user_id, 'project-member'));
$task_id = $this->app->createTask(array('project_id' => $project_id, 'title' => 'My task'));
$this->assertNotFalse($task_id);
$this->assertTrue($this->app->updateTask(array('id' => $task_id, 'project_id' => $project_id, 'owner_id' => $user_id)));
$task = $this->app->getTask($task_id);
$this->assertEquals($user_id, $task['owner_id']);
$task = $this->app->getTask($this->taskId);
$this->assertNotNull($task);
$this->assertEquals('red', $task['color_id']);
$this->assertEquals($this->taskTitle, $task['title']);
}
public function testChangeAssigneeToNotAssignableUser()
public function assertGetTaskByReference()
{
$project_id = $this->app->createProject('My project');
$this->assertNotFalse($project_id);
$taskId = $this->app->createTask(array('title' => 'task with reference', 'project_id' => $this->projectId, 'reference' => 'test'));
$this->assertNotFalse($taskId);
$task_id = $this->app->createTask(array('project_id' => $project_id, 'title' => 'My task'));
$this->assertNotFalse($task_id);
$this->assertFalse($this->app->updateTask(array('id' => $task_id, 'project_id' => $project_id, 'owner_id' => 1)));
$task = $this->app->getTask($task_id);
$this->assertEquals(0, $task['owner_id']);
$task = $this->app->getTaskByReference($this->projectId, 'test');
$this->assertNotNull($task);
$this->assertEquals($taskId, $task['id']);
}
public function testChangeAssigneeToNobody()
public function assertGetAllTasks()
{
$project_id = $this->app->createProject('My project');
$this->assertNotFalse($project_id);
$user_id = $this->app->createUser('user1', 'password');
$this->assertNotFalse($user_id);
$this->assertTrue($this->app->addProjectUser($project_id, $user_id, 'project-member'));
$task_id = $this->app->createTask(array('project_id' => $project_id, 'title' => 'My task', 'owner_id' => $user_id));
$this->assertNotFalse($task_id);
$this->assertTrue($this->app->updateTask(array('id' => $task_id, 'project_id' => $project_id, 'owner_id' => 0)));
$task = $this->app->getTask($task_id);
$this->assertEquals(0, $task['owner_id']);
$tasks = $this->app->getAllTasks($this->projectId);
$this->assertInternalType('array', $tasks);
$this->assertNotEmpty($tasks);
}
public function testMoveTaskToAnotherProject()
public function assertOpenCloseTask()
{
$project_id1 = $this->app->createProject('My project');
$this->assertNotFalse($project_id1);
$project_id2 = $this->app->createProject('My project');
$this->assertNotFalse($project_id2);
$task_id = $this->app->createTask(array('project_id' => $project_id1, 'title' => 'My task'));
$this->assertNotFalse($task_id);
$this->assertTrue($this->app->moveTaskToProject($task_id, $project_id2));
$task = $this->app->getTask($task_id);
$this->assertEquals($project_id2, $task['project_id']);
}
public function testMoveCopyToAnotherProject()
{
$project_id1 = $this->app->createProject('My project');
$this->assertNotFalse($project_id1);
$project_id2 = $this->app->createProject('My project');
$this->assertNotFalse($project_id2);
$task_id1 = $this->app->createTask(array('project_id' => $project_id1, 'title' => 'My task'));
$this->assertNotFalse($task_id1);
$task_id2 = $this->app->duplicateTaskToProject($task_id1, $project_id2);
$this->assertNotFalse($task_id2);
$task = $this->app->getTask($task_id1);
$this->assertEquals($project_id1, $task['project_id']);
$task = $this->app->getTask($task_id2);
$this->assertEquals($project_id2, $task['project_id']);
$this->assertTrue($this->app->closeTask($this->taskId));
$this->assertTrue($this->app->openTask($this->taskId));
}
}

63
tests/integration/UserTest.php
View File

@@ -1,18 +1,63 @@
<?php
require_once __DIR__.'/Base.php';
require_once __DIR__.'/BaseIntegrationTest.php';
class UserTest extends Base
class UserTest extends BaseIntegrationTest
{
public function testDisableUser()
public function testAll()
{
$this->assertEquals(2, $this->app->createUser(array('username' => 'someone', 'password' => 'test123')));
$this->assertTrue($this->app->isActiveUser(2));
$this->assertCreateUser();
$this->assertGetUserById();
$this->assertGetUserByName();
$this->assertGetAllUsers();
$this->assertEnableDisableUser();
$this->assertUpdateUser();
$this->assertRemoveUser();
}
$this->assertTrue($this->app->disableUser(2));
$this->assertFalse($this->app->isActiveUser(2));
public function assertGetUserById()
{
$user = $this->app->getUser($this->userId);
$this->assertNotNull($user);
$this->assertEquals($this->username, $user['username']);
}
$this->assertTrue($this->app->enableUser(2));
$this->assertTrue($this->app->isActiveUser(2));
public function assertGetUserByName()
{
$user = $this->app->getUserByName($this->username);
$this->assertNotNull($user);
$this->assertEquals($this->username, $user['username']);
}
public function assertGetAllUsers()
{
$users = $this->app->getAllUsers();
$this->assertInternalType('array', $users);
$this->assertNotEmpty($users);
}
public function assertEnableDisableUser()
{
$this->assertTrue($this->app->disableUser($this->userId));
$this->assertFalse($this->app->isActiveUser($this->userId));
$this->assertTrue($this->app->enableUser($this->userId));
$this->assertTrue($this->app->isActiveUser($this->userId));
}
public function assertUpdateUser()
{
$this->assertTrue($this->app->updateUser(array(
'id' => $this->userId,
'name' => 'My user',
)));
$user = $this->app->getUser($this->userId);
$this->assertNotNull($user);
$this->assertEquals('My user', $user['name']);
}
public function assertRemoveUser()
{
$this->assertTrue($this->app->removeUser($this->userId));
}
}