345 lines
11 KiB
PHP
345 lines
11 KiB
PHP
<?php
|
|
|
|
namespace Tests\unit\workflow\engine\src\ProcessMaker\Model;
|
|
|
|
use G;
|
|
use Illuminate\Foundation\Testing\DatabaseTransactions;
|
|
use ProcessMaker\Model\Process;
|
|
use ProcessMaker\Model\ProcessCategory;
|
|
use ProcessMaker\Model\Task;
|
|
use ProcessMaker\Model\User;
|
|
use Tests\TestCase;
|
|
|
|
/**
|
|
* Class ProcessTest
|
|
*
|
|
* @coversDefaultClass \ProcessMaker\Model\Process
|
|
*/
|
|
class ProcessTest extends TestCase
|
|
{
|
|
use DatabaseTransactions;
|
|
|
|
/**
|
|
* Call the setUp parent method
|
|
*/
|
|
public function setUp()
|
|
{
|
|
parent::setUp();
|
|
Process::query()->delete();
|
|
}
|
|
|
|
/**
|
|
* Test belongs to PRO_ID
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::tasks()
|
|
* @test
|
|
*/
|
|
public function it_has_tasks()
|
|
{
|
|
$process = factory(Process::class)->create();
|
|
factory(Task::class)->create([
|
|
'PRO_UID' => $process->PRO_UID,
|
|
'PRO_ID' => $process->PRO_ID
|
|
]);
|
|
$this->assertInstanceOf(Task::class, $process->tasks);
|
|
}
|
|
|
|
/**
|
|
* Test belongs to PRO_CREATE_USER
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::creator()
|
|
* @test
|
|
*/
|
|
public function it_has_a_creator()
|
|
{
|
|
$process = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => function () {
|
|
return factory(User::class)->create()->USR_UID;
|
|
}
|
|
]);
|
|
$this->assertInstanceOf(User::class, $process->creator);
|
|
}
|
|
|
|
/**
|
|
* Test belongs to PRO_CREATE_USER
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::category()
|
|
* @test
|
|
*/
|
|
public function it_has_an_category()
|
|
{
|
|
$process = factory(Process::class)->create([
|
|
'PRO_CATEGORY' => function () {
|
|
return factory(ProcessCategory::class)->create()->CATEGORY_UID;
|
|
}
|
|
]);
|
|
$this->assertInstanceOf(ProcessCategory::class, $process->category);
|
|
}
|
|
|
|
/**
|
|
* Test it returns all the processes for an specific user
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessList()
|
|
* @test
|
|
*/
|
|
public function it_should_return_all_the_processes_for_an_specific_user()
|
|
{
|
|
//Create process
|
|
$process = factory(Process::class, 2)->states('foreign_keys')->create([]);
|
|
//Create a Process object
|
|
$pro = new Process();
|
|
//Call the getProcessList() method
|
|
$res = $pro->getProcessList('', $process[0]->PRO_CREATE_USER);
|
|
//Assert the result is not empty
|
|
$this->assertNotEmpty($res);
|
|
//Assert there's one result
|
|
$this->assertCount(1, $res);
|
|
//Assert that the process returned is the one looked for
|
|
$this->assertEquals($process[0]->PRO_UID, $res[0]['PRO_UID']);
|
|
}
|
|
|
|
/**
|
|
* Tests that it returns the processes in an specific category
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessList()
|
|
* @test
|
|
*/
|
|
public function it_should_return_the_processes_in_an_specific_category()
|
|
{
|
|
$catUid1 = G::generateUniqueID();
|
|
$catUid2 = G::generateUniqueID();
|
|
|
|
//Create user
|
|
$user = factory(User::class)->create();
|
|
//Create process
|
|
$process1 = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_CATEGORY' => $catUid1
|
|
]);
|
|
$process2 = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_CATEGORY' => $catUid2
|
|
]);
|
|
|
|
//Create a Process object
|
|
$pro = new Process();
|
|
//Call the getProcessList() method
|
|
$res = $pro->getProcessList($process1['PRO_CATEGORY'], $user['USR_UID']);
|
|
|
|
//Assert the result is not empty
|
|
$this->assertNotEmpty($res);
|
|
//Assert there's one result
|
|
$this->assertCount(1, $res);
|
|
//Assert that the process returned belong to the category searched
|
|
$this->assertEquals($process1['PRO_UID'], $res[0]['PRO_UID']);
|
|
//Assert the process which their category was not searched is not in the result
|
|
$this->assertNotEquals($process2['PRO_UID'], $res[0]['PRO_UID']);
|
|
}
|
|
|
|
/**
|
|
* Tests that it returns an empty array if no processes where found
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessList()
|
|
* @test
|
|
*/
|
|
public function it_should_return_empty_if_no_processes_where_found()
|
|
{
|
|
//Create user
|
|
$user = factory(User::class)->create();
|
|
//Create a Process object
|
|
$process = new Process();
|
|
//Call the getProcessList() method
|
|
$res = $process->getProcessList('', $user['USR_UID']);
|
|
|
|
//Assert the result is not empty
|
|
$this->assertEmpty($res);
|
|
}
|
|
|
|
/**
|
|
* Test it returns all the processes in status active
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessList()
|
|
* @test
|
|
*/
|
|
public function it_should_return_all_the_processes_in_status_active()
|
|
{
|
|
//Create user
|
|
$user = factory(User::class)->create();
|
|
//Create process
|
|
$process1 = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_STATUS' => 'ACTIVE'
|
|
]);
|
|
$process2 = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_STATUS' => 'INACTIVE'
|
|
]);
|
|
$process3 = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_STATUS' => 'DISABLED'
|
|
]);
|
|
|
|
//Create a Process object
|
|
$process = new Process();
|
|
//Call the getProcessList() method
|
|
$res = $process->getProcessList('', $user['USR_UID']);
|
|
|
|
//Assert the result is not empty
|
|
$this->assertNotEmpty($res);
|
|
//Assert there's one result
|
|
$this->assertCount(1, $res);
|
|
//Assert that the process returned is the one that has ACTIVE status
|
|
$this->assertEquals($process1['PRO_UID'], $res[0]['PRO_UID']);
|
|
//Assert the processes that have not ACTIVE status are not in the result
|
|
$this->assertNotEquals($process2['PRO_UID'], $res[0]['PRO_UID']);
|
|
$this->assertNotEquals($process3['PRO_UID'], $res[0]['PRO_UID']);
|
|
}
|
|
|
|
/**
|
|
* It tests the getProcessPrivateListByUser method
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessPrivateListByUser()
|
|
* @test
|
|
*/
|
|
public function it_should_test_the_get_process_private_list_by_user_method()
|
|
{
|
|
//Create user
|
|
$user = factory(User::class)->create();
|
|
|
|
//Create process
|
|
factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_STATUS' => 'ACTIVE',
|
|
'PRO_TYPE_PROCESS' => 'PRIVATE',
|
|
]);
|
|
|
|
//Create a Process object
|
|
$process = new Process();
|
|
|
|
//Call the getProcessPrivateListByUser() method
|
|
$res = $process->getProcessPrivateListByUser($user['USR_UID']);
|
|
|
|
// This asserts the result contains one row
|
|
$this->assertCount(1, $res);
|
|
}
|
|
|
|
/**
|
|
* It tests the convertPrivateProcessesToPublicAndUpdateUser method
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::convertPrivateProcessesToPublicAndUpdateUser()
|
|
* @test
|
|
*/
|
|
public function it_should_test_the_convert_private_processes_to_public_method()
|
|
{
|
|
//Create user
|
|
$user = factory(User::class)->create();
|
|
|
|
//Create process
|
|
$pro = factory(Process::class)->create([
|
|
'PRO_CREATE_USER' => $user['USR_UID'],
|
|
'PRO_STATUS' => 'ACTIVE',
|
|
'PRO_TYPE_PROCESS' => 'PRIVATE',
|
|
]);
|
|
|
|
$p = Process::where('PRO_UID', $pro->PRO_UID)->get()->values()->toArray();
|
|
//Create a Process object
|
|
$process = new Process();
|
|
|
|
//Call the convertPrivateProcessesToPublicAndUpdateUser() method
|
|
$process->convertPrivateProcessesToPublicAndUpdateUser($p, $pro->PRO_CREATE_USER);
|
|
|
|
$p = Process::where('PRO_UID', $pro->PRO_UID)->get()->values();
|
|
|
|
// This asserts the process was converted from private to public
|
|
$this->assertEquals('PUBLIC', $p[0]->PRO_TYPE_PROCESS);
|
|
}
|
|
|
|
/**
|
|
* It tests the process list
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessesFilter()
|
|
* @covers \ProcessMaker\Model\Process::scopeNoStatus()
|
|
* @covers \ProcessMaker\Model\Process::scopeSubProcess()
|
|
* @test
|
|
*/
|
|
public function it_should_test_process_without_filter()
|
|
{
|
|
$process = factory(Process::class)->create();
|
|
$result = Process::getProcessesFilter(
|
|
null,
|
|
null,
|
|
null,
|
|
$process->PRO_CREATE_USER
|
|
);
|
|
$this->assertEquals($process->PRO_CREATE_USER, $result[0]['USR_UID']);
|
|
}
|
|
|
|
/**
|
|
* It tests the process list with specific category
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessesFilter()
|
|
* @covers \ProcessMaker\Model\Process::scopeCategory()
|
|
* @test
|
|
*/
|
|
public function it_should_test_process_with_category_filter()
|
|
{
|
|
$process = factory(Process::class)->create([
|
|
'PRO_CATEGORY' => function () {
|
|
return factory(ProcessCategory::class)->create()->CATEGORY_UID;
|
|
}
|
|
]);
|
|
$result = Process::getProcessesFilter(
|
|
$process->PRO_CATEGORY
|
|
);
|
|
$this->assertEquals($process->PRO_CATEGORY, $result[0]['PRO_CATEGORY']);
|
|
}
|
|
|
|
/**
|
|
* It tests the process list with specific process
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessesFilter()
|
|
* @covers \ProcessMaker\Model\Process::scopeProcess()
|
|
* @test
|
|
*/
|
|
public function it_should_test_process_with_process_filter()
|
|
{
|
|
$process = factory(Process::class)->create();
|
|
$result = Process::getProcessesFilter(
|
|
null,
|
|
$process->PRO_UID
|
|
);
|
|
$this->assertEquals($process->PRO_UID, $result[0]['PRO_UID']);
|
|
}
|
|
|
|
/**
|
|
* It tests the process list with specific process title
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getProcessesFilter()
|
|
* @covers \ProcessMaker\Model\Process::scopeTitle()
|
|
* @test
|
|
*/
|
|
public function it_should_test_process_with_title_filter()
|
|
{
|
|
$process = factory(Process::class)->create();
|
|
$result = Process::getProcessesFilter(
|
|
null,
|
|
null,
|
|
$process->PRO_TITLE
|
|
);
|
|
$this->assertEquals($process->PRO_TITLE, $result[0]['PRO_TITLE']);
|
|
}
|
|
|
|
/**
|
|
* It tests the count process
|
|
*
|
|
* @covers \ProcessMaker\Model\Process::getCounter()
|
|
* @test
|
|
*/
|
|
public function it_should_test_count_process()
|
|
{
|
|
$process = factory(Process::class)->create();
|
|
$total = Process::getCounter($process->PRO_CREATE_USER);
|
|
$this->assertEquals(1, $total);
|
|
}
|
|
}
|