fernando/luos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PMC-1150

Browse Source
This commit is contained in:
Paula Quispe
2019-10-22 11:15:57 -04:00
parent 4806c865f3
commit aca8de3886
7 changed files with 167 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
database/factories/DelegationFactory.php
View File

@@ -53,7 +53,7 @@ $factory->state(\ProcessMaker\Model\Delegation::class, 'foreign_keys', function
'DEL_TASK_DUE_DATE' => $faker->dateTime(),
'DEL_RISK_DATE' => $faker->dateTime(),
'USR_ID' => $user->USR_ID,
'PRO_ID' => $process->id,
'PRO_ID' => $process->PRO_ID,
'TAS_ID' => $task->TAS_ID,
'DEL_DATA' => ''
];

101
database/factories/ProcessFactory.php
View File

@@ -5,57 +5,66 @@
use Faker\Generator as Faker;
$factory->define(\ProcessMaker\Model\Process::class, function(Faker $faker) {
/**
* @todo Determine if we need more base columns populated
*/
$process = [
// Return with default values
return [
'PRO_UID' => G::generateUniqueID(),
'PRO_ID' => $faker->unique()->numberBetween(1, 200000),
'PRO_TITLE' => $faker->sentence(3),
'PRO_DESCRIPTION' => $faker->paragraph(3),
'PRO_CREATE_USER' => '00000000000000000000000000000001',
'PRO_DYNAFORMS' => '',
'PRO_ITEE' => 1,
'PRO_STATUS' => 'ACTIVE'
'PRO_STATUS' => 'ACTIVE',
'PRO_STATUS_ID' => 1,
'PRO_TYPE_PROCESS' => 'PUBLIC',
'PRO_UPDATE_DATE' => $faker->dateTime(),
'PRO_CREATE_DATE' => $faker->dateTime(),
'PRO_CATEGORY' => '',
];
$task1 = factory(\ProcessMaker\Model\Task::class)
->create([
'PRO_UID' => $process['PRO_UID'],
'TAS_START'=>'TRUE'
]);
$task2 = factory(\ProcessMaker\Model\Task::class)
->create([
'PRO_UID' => $process['PRO_UID'],
]);
//routes
factory(\ProcessMaker\Model\Route::class)
->create([
'PRO_UID' => $process['PRO_UID'],
'TAS_UID' => $task2['TAS_UID'],
'ROU_NEXT_TASK' => '-1',
]);
factory(\ProcessMaker\Model\Route::class)
->create([
'PRO_UID' => $process['PRO_UID'],
'TAS_UID' => $task1['TAS_UID'],
'ROU_NEXT_TASK' => $task2['TAS_UID']
]);
//User assignments
factory(\ProcessMaker\Model\TaskUser::class)
->create([
'TAS_UID' => $task1['TAS_UID'],
'USR_UID' => \ProcessMaker\Model\User::all()->random()->USR_UID
]);
factory(\ProcessMaker\Model\TaskUser::class)
->create([
'TAS_UID' => $task2['TAS_UID'],
'USR_UID' => \ProcessMaker\Model\User::all()->random()->USR_UID
]);
return $process;
});
// Create a process with the foreign keys
$factory->state(\ProcessMaker\Model\Process::class, 'foreign_keys', function (Faker $faker) {
$user = factory(\ProcessMaker\Model\User::class)->create();
return [
'PRO_UID' => G::generateUniqueID(),
'PRO_ID' => $faker->unique()->numberBetween(1, 200000),
'PRO_TITLE' => $faker->sentence(3),
'PRO_DESCRIPTION' => $faker->paragraph(3),
'PRO_CREATE_USER' => $user->USR_UID,
'PRO_DYNAFORMS' => '',
'PRO_ITEE' => 1,
'PRO_STATUS' => 'ACTIVE',
'PRO_STATUS_ID' => 1,
'PRO_TYPE_PROCESS' => 'PUBLIC',
'PRO_UPDATE_DATE' => $faker->dateTime(),
'PRO_CREATE_DATE' => $faker->dateTime(),
'PRO_CATEGORY' => '',
];
});
// Create a process related to the flow designer
$factory->state(\ProcessMaker\Model\Process::class, 'flow', function (Faker $faker) {
// Create values in the foreign key relations
$user = factory(\ProcessMaker\Model\User::class)->create();
$process = [
'PRO_UID' => G::generateUniqueID(),
'PRO_ID' => $faker->unique()->numberBetween(1, 200000),
'PRO_TITLE' => $faker->sentence(3),
'PRO_DESCRIPTION' => $faker->paragraph(3),
'PRO_CREATE_USER' => $user->USR_UID,
'PRO_DYNAFORMS' => '',
'PRO_ITEE' => 1,
'PRO_STATUS' => 'ACTIVE',
'PRO_STATUS_ID' => 1,
'PRO_TYPE_PROCESS' => 'PUBLIC',
'PRO_UPDATE_DATE' => $faker->dateTime(),
'PRO_CREATE_DATE' => $faker->dateTime(),
'PRO_CATEGORY' => '',
];
// Create a task related to this process
$task = factory(\ProcessMaker\Model\Task::class)->create([
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID,
]);
});

7
database/factories/TaskFactory.php
View File

@@ -8,6 +8,7 @@ use Faker\Generator as Faker;
$factory->define(\ProcessMaker\Model\Task::class, function(Faker $faker) {
return [
'PRO_UID' => G::generateUniqueID(),
'PRO_ID' => $faker->unique()->numberBetween(),
'TAS_UID' => G::generateUniqueID(),
'TAS_ID' => $faker->unique()->numberBetween(),
'TAS_TITLE' => $faker->sentence(2),
@@ -33,10 +34,10 @@ $factory->define(\ProcessMaker\Model\Task::class, function(Faker $faker) {
// Create a delegation with the foreign keys
$factory->state(\ProcessMaker\Model\Task::class, 'foreign_keys', function (Faker $faker) {
$process = factory(\ProcessMaker\Model\Process::class)->create();
return [
'PRO_UID' => function() {
return $process = factory(\ProcessMaker\Model\Process::class)->create();
},
'PRO_UID' => $process->PRO_UID,
'PRO_ID' => $process->PRO_ID,
'TAS_UID' => G::generateUniqueID(),
'TAS_ID' => $faker->unique()->numberBetween(1, 200000),
'TAS_TITLE' => $faker->sentence(2),

36
tests/unit/workflow/engine/src/ProcessMaker/Model/DelegationTest.php
View File

@@ -81,16 +81,16 @@ class DelegationTest extends TestCase
$process = factory(Process::class)->create();
factory(Delegation::class, 51)->states('foreign_keys')->create([
'PRO_ID' => $process->id
'PRO_ID' => $process->PRO_ID
]);
// Get first page, which is 25
$results = Delegation::search(null, 0, 25, null, $process->id);
$results = Delegation::search(null, 0, 25, null, $process->PRO_ID);
$this->assertCount(25, $results['data']);
// Get second page, which is 25 results
$results = Delegation::search(null, 25, 25, null, $process->id);
$results = Delegation::search(null, 25, 25, null, $process->PRO_ID);
$this->assertCount(25, $results['data']);
// Get third page, which is only 1 result
$results = Delegation::search(null, 50, 25, null, $process->id);
$results = Delegation::search(null, 50, 25, null, $process->PRO_ID);
$this->assertCount(1, $results['data']);
}
@@ -373,7 +373,7 @@ class DelegationTest extends TestCase
{
factory(Delegation::class, 3)->states('foreign_keys')->create([
'PRO_ID' => function () {
return factory(Process::class)->create()->id;
return factory(Process::class)->create()->PRO_ID;
}
]);
// Get first page, all process ordering ASC
@@ -541,7 +541,7 @@ class DelegationTest extends TestCase
]);
// Delegations to found
factory(Delegation::class, 51)->states('foreign_keys')->create([
'PRO_ID' => $processSearch->id
'PRO_ID' => $processSearch->PRO_ID
]);
// Get first page, which is 25
$results = Delegation::search(null, 0, 25, null, null, null, null, null, $category->CATEGORY_UID);
@@ -639,7 +639,7 @@ class DelegationTest extends TestCase
$application = factory(Application::class)->create();
// Create the threads for a parallel process
factory(Delegation::class, 5)->states('foreign_keys')->create([
'PRO_ID' => $process->id,
'PRO_ID' => $process->PRO_ID,
'TAS_ID' => $parallelTask->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_THREAD_STATUS' => 'CLOSED'
@@ -666,7 +666,7 @@ class DelegationTest extends TestCase
$application = factory(Application::class)->create();
// Create the threads for a parallel process
factory(Delegation::class, 5)->states('foreign_keys')->create([
'PRO_ID' => $process->id,
'PRO_ID' => $process->PRO_ID,
'TAS_ID' => $parallelTask->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
'DEL_THREAD_STATUS' => 'OPEN'
@@ -693,7 +693,7 @@ class DelegationTest extends TestCase
$application = factory(Application::class)->create(['APP_STATUS_ID' => 2]);
// Create the threads for a parallel process closed
factory(Delegation::class)->states('closed')->create([
'PRO_ID' => $process->id,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'TAS_ID' => $parallelTask->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
@@ -701,7 +701,7 @@ class DelegationTest extends TestCase
]);
// Create the threads for a parallel process closed
factory(Delegation::class)->states('open')->create([
'PRO_ID' => $process->id,
'PRO_ID' => $process->PRO_ID,
'PRO_UID' => $process->PRO_UID,
'TAS_ID' => $parallelTask->TAS_ID,
'APP_NUMBER' => $application->APP_NUMBER,
@@ -745,27 +745,27 @@ class DelegationTest extends TestCase
//Create a process with category
$processWithCat = factory(Process::class)->create(['PRO_CATEGORY' => $category[0]->CATEGORY_UID]);
factory(Delegation::class)->states('foreign_keys')->create([
'PRO_ID' => $processWithCat->id
'PRO_ID' => $processWithCat->PRO_ID
]);
// Create a process without category
$processWithoutCat = factory(Process::class)->create(['PRO_CATEGORY' => '']);
factory(Delegation::class, 5)->states('foreign_keys')->create([
'PRO_ID' => $processWithoutCat->id
'PRO_ID' => $processWithoutCat->PRO_ID
]);
// Search the cases when the process has related to the category and search by another category
$results = Delegation::search(null, 0, 25, null, $processWithCat->id, null, null, null,
$results = Delegation::search(null, 0, 25, null, $processWithCat->PRO_ID, null, null, null,
$category[1]->CATEGORY_UID);
$this->assertCount(0, $results['data']);
// Search the cases when the process has related to the category and search by this relation
$results = Delegation::search(null, 0, 25, null, $processWithCat->id, null, null, null,
$results = Delegation::search(null, 0, 25, null, $processWithCat->PRO_ID, null, null, null,
$category[0]->CATEGORY_UID);
$this->assertCount(1, $results['data']);
// Search the cases when the process does not have relation with category and search by a category
$results = Delegation::search(null, 0, 25, null, $processWithoutCat->id, null, null, null,
$results = Delegation::search(null, 0, 25, null, $processWithoutCat->PRO_ID, null, null, null,
$category[1]->CATEGORY_UID);
$this->assertCount(0, $results['data']);
// Search the cases when the process does not have relation with category empty
$results = Delegation::search(null, 0, 25, null, $processWithoutCat->id, null, null, null,
$results = Delegation::search(null, 0, 25, null, $processWithoutCat->PRO_ID, null, null, null,
'');
$this->assertCount(5, $results['data']);
}
@@ -786,7 +786,7 @@ class DelegationTest extends TestCase
]);
//Create a delegation related to this process
factory(Delegation::class)->create([
'PRO_ID' => $processWithCat->id
'PRO_ID' => $processWithCat->PRO_ID
]);
//Define a process related with he previous category
$process = factory(Process::class)->create([
@@ -794,7 +794,7 @@ class DelegationTest extends TestCase
]);
//Create a delegation related to other process
factory(Delegation::class, 5)->create([
'PRO_ID' => $process->id,
'PRO_ID' => $process->PRO_ID,
]);
}

117
tests/unit/workflow/engine/src/ProcessMaker/Model/ProcessTest.php
View File

@@ -5,53 +5,92 @@ 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;
/**
* @coversDefaultClass ProcessMaker\BusinessModel\Model\Process
*/
class ProcessTest extends TestCase
{
use DatabaseTransactions;
/**
* Test belongs to PRO_ID
*
* @covers \ProcessMaker\Model\Process::tasks()
* @test
*/
public function it_has_tasks()
{
$process = factory(Process::class)->create([
'PRO_ID' => function () {
return factory(Task::class)->create()->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
*
* @covers \ProcessMaker\Model\Process::getProcessList()
* @test
*/
public function it_should_return_all_the_processes_for_an_specific_user()
{
//Create user
$user1 = factory(User::class)->create();
$user2 = factory(User::class)->create();
//Create process
$process1 = factory(Process::class)->create(
['PRO_CREATE_USER' => $user1['USR_UID']]
);
$process2 = factory(Process::class)->create(
['PRO_CREATE_USER' => $user2['USR_UID']]
);
$process = factory(Process::class, 2)->states('foreign_keys')->create([]);
//Create a Process object
$process = new Process();
$pro = new Process();
//Call the getProcessList() method
$res = $process->getProcessList('', $user2['USR_UID']);
$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($process2['PRO_UID'], $res[0]['PRO_UID']);
//Assert the process that was not searched is not in the result
$this->assertNotEquals($process1['PRO_UID'], $res[0]['PRO_UID']);
$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
*
* @covers \ProcessMaker\Model\Process::getProcessList()
* @test
*/
public function it_should_return_the_processes_in_an_specific_category()
@@ -62,23 +101,19 @@ class ProcessTest extends TestCase
//Create user
$user = factory(User::class)->create();
//Create process
$process1 = factory(Process::class)->create(
[
$process1 = factory(Process::class)->create([
'PRO_CREATE_USER' => $user['USR_UID'],
'PRO_CATEGORY' => $catUid1
]
);
$process2 = factory(Process::class)->create(
[
]);
$process2 = factory(Process::class)->create([
'PRO_CREATE_USER' => $user['USR_UID'],
'PRO_CATEGORY' => $catUid2
]
);
]);
//Create a Process object
$process = new Process();
$pro = new Process();
//Call the getProcessList() method
$res = $process->getProcessList($process1['PRO_CATEGORY'], $user['USR_UID']);
$res = $pro->getProcessList($process1['PRO_CATEGORY'], $user['USR_UID']);
//Assert the result is not empty
$this->assertNotEmpty($res);
@@ -92,7 +127,8 @@ class ProcessTest extends TestCase
/**
* Tests that it returns an empty array if no processes where found
* @covers \ProcessMaker\Model\Process::getProcessList
*
* @covers \ProcessMaker\Model\Process::getProcessList()
* @test
*/
public function it_should_return_empty_if_no_processes_where_found()
@@ -110,7 +146,8 @@ class ProcessTest extends TestCase
/**
* Test it returns all the processes in status active
* @covers \ProcessMaker\Model\Process::getProcessList
*
* @covers \ProcessMaker\Model\Process::getProcessList()
* @test
*/
public function it_should_return_all_the_processes_in_status_active()
@@ -118,24 +155,18 @@ class ProcessTest extends TestCase
//Create user
$user = factory(User::class)->create();
//Create process
$process1 = factory(Process::class)->create(
[
$process1 = factory(Process::class)->create([
'PRO_CREATE_USER' => $user['USR_UID'],
'PRO_STATUS' => 'ACTIVE'
]
);
$process2 = factory(Process::class)->create(
[
]);
$process2 = factory(Process::class)->create([
'PRO_CREATE_USER' => $user['USR_UID'],
'PRO_STATUS' => 'INACTIVE'
]
);
$process3 = factory(Process::class)->create(
[
]);
$process3 = factory(Process::class)->create([
'PRO_CREATE_USER' => $user['USR_UID'],
'PRO_STATUS' => 'DISABLED'
]
);
]);
//Create a Process object
$process = new Process();

2
tests/unit/workflow/engine/src/ProcessMaker/Services/Api/LightTest.php
View File

@@ -34,6 +34,8 @@ class LightTest extends TestCase
*/
protected function setUp()
{
$this->markTestIncomplete();//@todo: we need to correct this before the epic PMC-857 because this test use Unassigned cases
parent::setUp();
$this->workspace = env("DB_DATABASE", "test");
$this->clientId = config("oauthClients.pm.clientId");

14
workflow/engine/src/ProcessMaker/Model/Process.php
View File

@@ -14,30 +14,24 @@ class Process extends Model
{
// Set our table name
protected $table = 'PROCESS';
protected $primaryKey = 'PRO_ID';
// Our custom timestamp columns
const CREATED_AT = 'PRO_CREATE_DATE';
const UPDATED_AT = 'PRO_UPDATE_DATE';
/**
* Retrieve all applications that belong to this process
*/
public function applications()
{
return $this->hasMany(Application::class, 'PRO_ID', 'PRO_ID');
}
public function tasks()
{
return $this->hasMany(Task::class, 'PRO_UID', 'PRO_UID');
return $this->belongsTo(Task::class, 'PRO_ID', 'PRO_ID');
}
public function creator()
{
return $this->hasOne(User::class, 'PRO_CREATE_USER', 'USR_UID');
return $this->belongsTo(User::class, 'PRO_CREATE_USER', 'USR_UID');
}
public function category()
{
return $this->hasOne(ProcessCategory::class, 'PRO_CATEGORY', 'CATEGORY_UID');
return $this->belongsTo(ProcessCategory::class, 'PRO_CATEGORY', 'CATEGORY_UID');
}
/**