597 lines
20 KiB
PHP
597 lines
20 KiB
PHP
<?php
|
|
|
|
namespace Tests\unit\workflow\engine\src\ProcessMaker\TaskScheduler;
|
|
|
|
use App\Jobs\TaskScheduler;
|
|
use Faker\Factory;
|
|
use Illuminate\Support\Facades\Queue;
|
|
use ProcessMaker\Model\Application;
|
|
use ProcessMaker\Model\AppThread;
|
|
use ProcessMaker\Model\Delegation;
|
|
use ProcessMaker\TaskScheduler\Task;
|
|
use Tests\TestCase;
|
|
|
|
/**
|
|
* Class TaskTest
|
|
*
|
|
* @coversDefaultClass \ProcessMaker\TaskScheduler\Task
|
|
*/
|
|
class TaskTest extends TestCase
|
|
{
|
|
private $faker;
|
|
|
|
/**
|
|
* This method is called before the first test of this test class is run.
|
|
* @return void
|
|
*/
|
|
public static function setUpBeforeClass(): void
|
|
{
|
|
parent::setUpBeforeClass();
|
|
self::truncateNonInitialModels();
|
|
}
|
|
|
|
/**
|
|
* Method setUp.
|
|
*/
|
|
public function setUp(): void
|
|
{
|
|
parent::setUp();
|
|
$this->faker = Factory::create();
|
|
}
|
|
|
|
/**
|
|
* Method tearDown.
|
|
*/
|
|
public function tearDown(): void
|
|
{
|
|
parent::tearDown();
|
|
}
|
|
|
|
/**
|
|
* Test synchronous asynchronous cases.
|
|
*/
|
|
public function asynchronousCases()
|
|
{
|
|
return [
|
|
[true],
|
|
[false]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* This test verify the setExecutionMessage method.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::setExecutionMessage()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_setExecutionMessage_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
$message = $this->faker->paragraph;
|
|
|
|
ob_start();
|
|
$task->setExecutionMessage($message);
|
|
$printing = ob_get_clean();
|
|
|
|
//assert if message is contained in output buffer
|
|
if ($asynchronous === false) {
|
|
$this->assertMatchesRegularExpression("/{$message}/", $printing);
|
|
}
|
|
//assert if not showing message
|
|
if ($asynchronous === true) {
|
|
$this->assertEmpty($printing);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the setExecutionResultMessage method.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::setExecutionResultMessage()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_setExecutionResultMessage_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
$message = $this->faker->paragraph;
|
|
|
|
ob_start();
|
|
$task->setExecutionResultMessage($message, 'error');
|
|
$printing = ob_get_clean();
|
|
//assert if message is contained in output buffer
|
|
if ($asynchronous === false) {
|
|
$this->assertMatchesRegularExpression("/{$message}/", $printing);
|
|
}
|
|
//assert if not showing message
|
|
if ($asynchronous === true) {
|
|
$this->assertEmpty($printing);
|
|
}
|
|
|
|
ob_start();
|
|
$task->setExecutionResultMessage($message, 'info');
|
|
$printing = ob_get_clean();
|
|
//assert if message is contained in output buffer
|
|
if ($asynchronous === false) {
|
|
$this->assertMatchesRegularExpression("/{$message}/", $printing);
|
|
}
|
|
//assert if not showing message
|
|
if ($asynchronous === true) {
|
|
$this->assertEmpty($printing);
|
|
}
|
|
|
|
ob_start();
|
|
$task->setExecutionResultMessage($message, 'warning');
|
|
$printing = ob_get_clean();
|
|
//assert if message is contained in output buffer
|
|
if ($asynchronous === false) {
|
|
$this->assertMatchesRegularExpression("/{$message}/", $printing);
|
|
}
|
|
//assert if not showing message
|
|
if ($asynchronous === true) {
|
|
$this->assertEmpty($printing);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the saveLog method.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::saveLog()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_saveLog_method($asynchronous)
|
|
{
|
|
$task = new Task(false, '');
|
|
$task->saveLog('', '', $this->faker->paragraph);
|
|
$file = PATH_DATA . "log/cron.log";
|
|
$this->assertFileExists($file);
|
|
|
|
if ($asynchronous === false) {
|
|
$description = $this->faker->paragraph;
|
|
$task = new Task($asynchronous, '');
|
|
$task->saveLog('', '', $description);
|
|
$contentLog = file_get_contents($file);
|
|
|
|
$this->assertMatchesRegularExpression("/{$description}/", $contentLog);
|
|
}
|
|
if ($asynchronous === true) {
|
|
$description = $this->faker->paragraph;
|
|
$task = new Task($asynchronous, '');
|
|
$task->saveLog('', '', $description);
|
|
$contentLog = file_get_contents($file);
|
|
|
|
$this->assertDoesNotMatchRegularExpression("/{$description}/", $contentLog);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the resendEmails activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::resendEmails()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_resendEmails_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
$dateSystem = $this->faker->date();
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->resendEmails('', $dateSystem);
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/DONE/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->resendEmails('', $dateSystem);
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the unpauseApplications activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::unpauseApplications()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_unpauseApplications_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->unpauseApplications(date('Y-m-d'));
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/DONE/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->unpauseApplications(date('Y-m-d'));
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the calculateDuration activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::calculateDuration()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_calculateDuration_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->calculateDuration();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/DONE/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->calculateDuration();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the calculateDuration activity method for synchronous and asynchronous execution.
|
|
* @covers ProcessMaker\TaskScheduler\Task::executeCaseSelfService()
|
|
* @test
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_unassignedcase($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
// Assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->executeCaseSelfService();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/Unassigned case/", $printing);
|
|
}
|
|
|
|
// Assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->executeCaseSelfService();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the calculateAppDuration activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::calculateAppDuration()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_calculateAppDuration_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->calculateAppDuration();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/DONE/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->calculateAppDuration();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the cleanSelfServiceTables activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::cleanSelfServiceTables()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_cleanSelfServiceTables_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->cleanSelfServiceTables();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/DONE/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->cleanSelfServiceTables();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the executePlugins activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::executePlugins()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_executePlugins_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->executePlugins();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/plugins/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->executePlugins();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the fillReportByUser activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::fillReportByUser()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_fillReportByUser_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
$dateInit = $this->faker->dateTime->format("Y-m-d H:i:s");
|
|
$dateFinish = $this->faker->dateTime->format("Y-m-d H:i:s");
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->fillReportByUser($dateInit, $dateFinish);
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/User Reporting/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->fillReportByUser($dateInit, $dateFinish);
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the fillReportByProcess activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::fillReportByProcess()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_fillReportByProcess_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
$dateInit = $this->faker->dateTime->format("Y-m-d H:i:s");
|
|
$dateFinish = $this->faker->dateTime->format("Y-m-d H:i:s");
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->fillReportByProcess($dateInit, $dateFinish);
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/Process Reporting/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->fillReportByProcess($dateInit, $dateFinish);
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the ldapcron activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::ldapcron()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_ldapcron_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->ldapcron(false);
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/\+---/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->ldapcron(false);
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the sendNotifications activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::sendNotifications()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_sendNotifications_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->sendNotifications();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/Resending Notifications/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->sendNotifications();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the actionsByEmailResponse activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::actionsByEmailResponse()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_actionsByEmailResponse_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->actionsByEmailResponse();
|
|
$printing = ob_get_clean();
|
|
$this->assertEmpty($printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->actionsByEmailResponse();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test verify the messageeventcron activity method for synchronous and asynchronous execution.
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::messageeventcron()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_messageeventcron_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->messageeventcron();
|
|
$printing = ob_get_clean();
|
|
$this->assertMatchesRegularExpression("/Message-Events/", $printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->messageeventcron();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the timerEventCron method with jobs in the task scheduler
|
|
*
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::timerEventCron()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_the_timer_event_cron_method($asynchronous)
|
|
{
|
|
//Creates a new task
|
|
$task = new Task($asynchronous, '');
|
|
//Sets the currect date
|
|
$date = date('Y-m-d H:i:s');
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
//Calls the timerEventCron method
|
|
$task->timerEventCron($date, true);
|
|
//Gets the result
|
|
$printing = ob_get_clean();
|
|
//Asserts the result is printing that there is no exisiting records to continue a case in the determined date
|
|
$this->assertMatchesRegularExpression('/There are no records to start new cases, on date "' . $date . '/', $printing);
|
|
}
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->timerEventCron($date, true);
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the webEntriesCron method with jobs in the task scheduler
|
|
*
|
|
* @test
|
|
* @covers ProcessMaker\TaskScheduler\Task::runTask()
|
|
* @covers ProcessMaker\TaskScheduler\Task::webEntriesCron()
|
|
* @dataProvider asynchronousCases
|
|
*/
|
|
public function it_should_test_webEntriesCron_method($asynchronous)
|
|
{
|
|
$task = new Task($asynchronous, '');
|
|
|
|
//assert synchronous for cron file
|
|
if ($asynchronous === false) {
|
|
ob_start();
|
|
$task->webEntriesCron();
|
|
$printing = ob_get_clean();
|
|
$this->assertEmpty($printing);
|
|
}
|
|
|
|
//assert asynchronous for job process
|
|
if ($asynchronous === true) {
|
|
Queue::fake();
|
|
Queue::assertNothingPushed();
|
|
$task->webEntriesCron();
|
|
Queue::assertPushed(TaskScheduler::class);
|
|
}
|
|
}
|
|
}
|