FuzeWorks/Async
FuzeWorks
/
Async
1
0
Fork 0
Code Issues 5 Pull Requests Releases 1 Activity

Release of RC1 #7

Merged
abelhooge merged 34 commits from 3-features into master 2020-06-07 13:54:20 +00:00
Conversation 0 Commits 34 Files Changed 39 +166 -101
10 changed files with 166 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 4555957292 - Show all commits

20
src/FuzeWorks/Async/ShellWorker.php
View File

@ -91,30 +91,16 @@ class ShellWorker
$this->post = $post;
// Fetch the callable
$class = $this->task->getHandlerClass();
if (!class_exists($class, true))
{
$errors = 'Could not run task. HandlerClass \'' . $class . '\' not found.';
if (!$post)
$this->taskStorage->writeTaskOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries());
else
$this->taskStorage->writePostOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries());
throw new TasksException("Could not run task. '$class' not found.");
}
// Create the handler
/** @var Handler $object */
$object = new $class();
$object = $this->task->getHandler();
if (!$object instanceof Handler)
{
$errors = "Could not run task. '$class' is not instance of Handler.";
$errors = "Could not run task. '".get_class($object)."' is not instance of Handler.";
if (!$post)
$this->taskStorage->writeTaskOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries());
else
$this->taskStorage->writePostOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries());
throw new TasksException("Could not run task. '$class' is not instance of Handler.");
throw new TasksException("Could not run task. '".get_class($object)."' is not instance of Handler.");
}
// Run postHandler if post mode is requested

29
src/FuzeWorks/Async/Task.php
View File

@ -116,9 +116,9 @@ class Task
protected $taskId;
/**
* @var string
* @var Handler
*/
protected $handlerClass;
protected $handler;
/**
* @var bool
@ -184,16 +184,20 @@ class Task
*
* Creates a Task object, which can be added to the TaskQueue.
*
* @param string $identifier The unique identifier of this task. Make sure it is always unique!
* @param string $handlerClass The class that shall handle this task
* @param bool $usePostHandler Whether the postHandler on handlerClass should also be used
* @param string $identifier The unique identifier of this task. Make sure it is always unique!
* @param Handler $handler The Handler object which will run the Task in the Worker
* @param bool $usePostHandler Whether the postHandler on Handler should also be used
* @param mixed $parameters,... The arguments provided to the method that shall handle this class
* @throws TasksException
*/
public function __construct(string $identifier, string $handlerClass, bool $usePostHandler = false)
public function __construct(string $identifier, Handler $handler, bool $usePostHandler = false)
{
// Check if the provided Handler is serializable
if (!$this->isSerializable($handler))
throw new TasksException("Could not create Task. Provided Handler is not serializable.");
$this->taskId = $identifier;
$this->handlerClass = $handlerClass;
$this->handler = $handler;
$this->usePostHandler = $usePostHandler;
if (func_num_args() > 3)
$args = array_slice(func_get_args(), 3);
@ -218,17 +222,17 @@ class Task
}
/**
* Gets the name of the class that shall process this task
* Gets the Handler that shall process this task
*
* @return string
* @return Handler
*/
public function getHandlerClass(): string
public function getHandler(): Handler
{
return $this->handlerClass;
return $this->handler;
}
/**
* Whether the postHandler on the handlerClass should be invoked after processing the initial task.
* Whether the postHandler on the Handler should be invoked after processing the initial task.
*
* @return bool
*/
@ -470,6 +474,7 @@ class Task
*
* @param $value
* @return bool
* @todo Improve so it is properly tested
*/
private function isSerializable($value)
{

1
src/FuzeWorks/Async/TaskStorage/ArrayTaskStorage.php
View File

@ -284,6 +284,7 @@ class ArrayTaskStorage implements TaskStorage
{
// Get the task
$task = $this->tasks[$i];
$taskId = $task->getId();
// Remove all task output and post output
$settings = $task->getRetrySettings();

11
test/base/ShellExecutorTest.php
View File

@ -39,6 +39,9 @@ use FuzeWorks\Async\Task;
use FuzeWorks\Async\Tasks;
use FuzeWorks\Async\TasksException;
use FuzeWorks\Async\TaskStorage;
use Mock\Handlers\EmptyHandler;
use Mock\Handlers\TestStartAndReadTasksHandler;
use Mock\Handlers\TestStopTaskHandler;
use PHPUnit\Framework\TestCase;
/**
@ -131,7 +134,7 @@ class ShellExecutorTest extends TestCase
public function testStartAndReadTasks()
{
// First we create a dummy task
$dummyTask = new Task('testStartAndReadTasks', 'Mock\Handlers\TestStartAndReadTasksHandler');
$dummyTask = new Task('testStartAndReadTasks', new TestStartAndReadTasksHandler());
// Then we write this task to the TaskStorage
$this->taskStorage->addTask($dummyTask);
@ -161,7 +164,7 @@ class ShellExecutorTest extends TestCase
public function testGetStats()
{
// First we create a dummy task, using the previous handler since nothing changes
$dummyTask = new Task('testGetStats', 'Mock\Handlers\TestStartAndReadTasksHandler');
$dummyTask = new Task('testGetStats', new TestStartAndReadTasksHandler());
// Then we write this task to the TaskStorage
$this->taskStorage->addTask($dummyTask);
@ -190,7 +193,7 @@ class ShellExecutorTest extends TestCase
public function testGetStatsNotExist()
{
// First we create a dummy task, using the previous handler since nothing changes
$dummyTask = new Task('testGetStatsNotExist', 'none');
$dummyTask = new Task('testGetStatsNotExist', new EmptyHandler());
// And add a fake PID, since otherwise it will immediately fail
$dummyTask->addAttribute('pid', 1005);
@ -205,7 +208,7 @@ class ShellExecutorTest extends TestCase
public function testStopTask()
{
// First we create a dummy task
$dummyTask = new Task('testStopTask', 'Mock\Handlers\TestStopTaskHandler');
$dummyTask = new Task('testStopTask', new TestStopTaskHandler());
// Then we write this task to the TaskStorage
$this->taskStorage->addTask($dummyTask);

45
test/base/TaskStorageTest.php
View File

@ -42,6 +42,7 @@ use FuzeWorks\Async\TaskStorage;
use FuzeWorks\Async\TaskStorage\DummyTaskStorage;
use FuzeWorks\Events;
use FuzeWorks\Priority;
use Mock\Handlers\EmptyHandler;
use PHPUnit\Framework\TestCase;
/**
@ -79,7 +80,7 @@ class TaskStorageTest extends TestCase
public function testAddAndReadTasks()
{
// Prepare a dummy task
$dummyTask = new Task('testAddTask', 'none');
$dummyTask = new Task('testAddTask', new EmptyHandler());
// Nothing is written yet so it should be empty
$this->assertEmpty($this->taskStorage->readTasks());
@ -95,7 +96,7 @@ class TaskStorageTest extends TestCase
// Test if the properties match
$this->assertEquals('testAddTask', $task->getId());
$this->assertEquals('none', $task->getHandlerClass());
$this->assertInstanceOf(EmptyHandler::class, $task->getHandler());
}
/**
@ -104,7 +105,7 @@ class TaskStorageTest extends TestCase
public function testAddExistingTask()
{
// Prepare a dummy task
$dummyTask = new Task('testAddExistingTask', 'none');
$dummyTask = new Task('testAddExistingTask', new EmptyHandler());
// First check that the task storage starts empty
$this->assertEmpty($this->taskStorage->readTasks());
@ -123,8 +124,8 @@ class TaskStorageTest extends TestCase
public function testGetTaskById()
{
// Prepare a dummy task
$dummyTask1 = new Task('testGetTaskById1', 'none');
$dummyTask2 = new Task('testGetTaskById2', 'none');
$dummyTask1 = new Task('testGetTaskById1', new EmptyHandler());
$dummyTask2 = new Task('testGetTaskById2', new EmptyHandler());
// First we add both tasks
$this->assertEmpty($this->taskStorage->readTasks());
@ -155,7 +156,7 @@ class TaskStorageTest extends TestCase
public function testGetTaskByIdNotFound()
{
// Prepare a dummy task
$dummyTask = new Task('testGetTaskByIdNotFound', 'none');
$dummyTask = new Task('testGetTaskByIdNotFound', new EmptyHandler());
// First we add the task
$this->assertEmpty($this->taskStorage->readTasks());
@ -175,7 +176,7 @@ class TaskStorageTest extends TestCase
public function testModifyTask()
{
// Prepare a dummy task
$dummyTask = new Task('testModifyTask', 'none');
$dummyTask = new Task('testModifyTask', new EmptyHandler());
$dummyTask->setStatus(Task::RUNNING);
// First we add the task
@ -199,7 +200,7 @@ class TaskStorageTest extends TestCase
public function testModifyTaskNotFound()
{
// Prepare a dummy task
$dummyTask = new Task('testModifyTaskNotFound', 'none');
$dummyTask = new Task('testModifyTaskNotFound', new EmptyHandler());
// Attempt to change this task, which does not exist.
$this->expectException(TasksException::class);
@ -212,7 +213,7 @@ class TaskStorageTest extends TestCase
public function testModifyTaskEvent()
{
// Prepare a dummy task
$dummyTask = new Task('testModifyTaskEvent', 'none');
$dummyTask = new Task('testModifyTaskEvent', new EmptyHandler());
$dummyTask->setStatus(Task::PENDING);
// Then add the Task
@ -245,7 +246,7 @@ class TaskStorageTest extends TestCase
public function testModifyTaskCancel()
{
// Prepare a dummy task
$dummyTask = new Task('testModifyTaskCancel', 'none');
$dummyTask = new Task('testModifyTaskCancel', new EmptyHandler());
$dummyTask->setStatus(Task::PENDING);
// Then add the Task
@ -272,7 +273,7 @@ class TaskStorageTest extends TestCase
public function testDeleteTask()
{
// Prepare a dummy task
$dummyTask = new Task('testDeleteTask', 'none');
$dummyTask = new Task('testDeleteTask', new EmptyHandler());
// Add the task to the storage
$this->assertEmpty($this->taskStorage->readTasks());
@ -295,7 +296,7 @@ class TaskStorageTest extends TestCase
public function testDeleteTaskNotFound()
{
// Prepare a dummy task
$dummyTask = new Task('testDeleteTaskNotFound', 'none');
$dummyTask = new Task('testDeleteTaskNotFound', new EmptyHandler());
// Attempt to delete this task, which does not exist.
$this->expectException(TasksException::class);
@ -310,7 +311,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutput()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutput', 'none');
$dummyTask = new Task('testWriteAndReadTaskOutput', new EmptyHandler());
// First write the task output
$this->taskStorage->addTask($dummyTask);
@ -329,7 +330,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputTaskNotExist()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputTaskNotExist', 'none');
$dummyTask = new Task('testWriteAndReadTaskOutputTaskNotExist', new EmptyHandler());
// Write output while the task does not exist yet, expect exception
$this->expectException(TasksException::class);
@ -342,7 +343,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputAttempts()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputAttempts', 'none');
$dummyTask = new Task('testWriteAndReadTaskOutputAttempts', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
// Write the different outputs. Done in a weird order to make sure the default is inserted not first or last
@ -382,7 +383,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputAlreadyExists()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputAlreadyExists', 'none');
$dummyTask = new Task('testWriteAndReadTaskOutputAlreadyExists', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
// Write a first time
@ -399,7 +400,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputNotExist()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputNotExist', 'none');
$dummyTask = new Task('testWriteAndReadTaskOutputNotExist', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
$this->assertNull($this->taskStorage->readTaskOutput($dummyTask));
@ -413,7 +414,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutput()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutput', 'none');
$dummyTask = new Task('testWriteAndReadTaskPostOutput', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
// First write the task output
@ -432,7 +433,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutputAttempts()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutputAttempts', 'none');
$dummyTask = new Task('testWriteAndReadTaskPostOutputAttempts', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
// Write the different outputs. Done in a weird order to make sure the default is inserted not first or last
@ -472,7 +473,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutputAlreadyExists()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutputAlreadyExists', 'none');
$dummyTask = new Task('testWriteAndReadTaskPostOutputAlreadyExists', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
// Write a first time
@ -489,7 +490,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutputNotExist()
{
// Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutputNotExist', 'none');
$dummyTask = new Task('testWriteAndReadTaskPostOutputNotExist', new EmptyHandler());
$this->taskStorage->addTask($dummyTask);
$this->assertNull($this->taskStorage->readPostOutput($dummyTask));
@ -505,7 +506,7 @@ class TaskStorageTest extends TestCase
public function testReset()
{
// Prepare a dummy task
$dummyTask = new Task('testReset', 'none');
$dummyTask = new Task('testReset', new EmptyHandler());
// Add the task and some output
$this->assertTrue($this->taskStorage->addTask($dummyTask));

29
test/base/TaskTest.php
View File

@ -37,6 +37,7 @@
use FuzeWorks\Async\Constraint;
use FuzeWorks\Async\Task;
use FuzeWorks\Async\TasksException;
use Mock\Handlers\EmptyHandler;
use PHPUnit\Framework\TestCase;
class TaskTest extends TestCase
@ -45,7 +46,7 @@ class TaskTest extends TestCase
public function testClass()
{
// Create dummy task
$dummyTask = new Task('testClass', 'none');
$dummyTask = new Task('testClass', new EmptyHandler());
// And check the class. A pretty useless but standard test
$this->assertInstanceOf('FuzeWorks\Async\Task', $dummyTask);
@ -59,11 +60,11 @@ class TaskTest extends TestCase
public function testBaseVariables()
{
// Create dummy task
$dummyTask = new Task('testBaseVariables', 'someThing', true);
$dummyTask = new Task('testBaseVariables', new EmptyHandler(), true);
// test the values
$this->assertEquals('testBaseVariables', $dummyTask->getId());
$this->assertEquals('someThing', $dummyTask->getHandlerClass());
$this->assertInstanceOf(EmptyHandler::class, $dummyTask->getHandler());
$this->assertTrue($dummyTask->getUsePostHandler());
}
@ -73,11 +74,11 @@ class TaskTest extends TestCase
public function testArguments()
{
// Create task without arguments
$dummyTask1 = new Task('testArguments1', 'none', true);
$dummyTask1 = new Task('testArguments1', new EmptyHandler(), true);
$this->assertEmpty($dummyTask1->getArguments());
// Now create a task with some arguments
$dummyTask2 = new Task('testArguments2', 'none', true, 'some', 'arguments');
$dummyTask2 = new Task('testArguments2', new EmptyHandler(), true, 'some', 'arguments');
$this->assertEquals(['some', 'arguments'], $dummyTask2->getArguments());
}
@ -87,8 +88,8 @@ class TaskTest extends TestCase
public function testPostHandler()
{
// Create dummy tasks
$dummyTask1 = new Task('testPostHandler1', 'someThing', true);
$dummyTask2 = new Task('testPostHandler2', 'someThing', false);
$dummyTask1 = new Task('testPostHandler1', new EmptyHandler(), true);
$dummyTask2 = new Task('testPostHandler2', new EmptyHandler(), false);
$this->assertTrue($dummyTask1->getUsePostHandler());
$this->assertFalse($dummyTask2->getUsePostHandler());
@ -103,7 +104,7 @@ class TaskTest extends TestCase
$stub = $this->createMock(Constraint::class);
// Then add it to the task
$dummyTask = new Task('testConstraints', 'someThing', false);
$dummyTask = new Task('testConstraints', new EmptyHandler(), false);
$dummyTask->addConstraint($stub);
// Assert it exists
@ -116,7 +117,7 @@ class TaskTest extends TestCase
public function testStatusCodes()
{
// Create dummy task
$dummyTask = new Task('testStatusCodes', 'someThing', true);
$dummyTask = new Task('testStatusCodes', new EmptyHandler(), true);
for ($i = 1; $i <= 9; $i++) {
$dummyTask->setStatus($i);
@ -130,7 +131,7 @@ class TaskTest extends TestCase
public function testDelayTime()
{
// Create dummy task
$dummyTask = new Task('testDelayTime', 'someThing', true);
$dummyTask = new Task('testDelayTime', new EmptyHandler(), true);
$this->assertEquals(0, $dummyTask->getDelayTime());
$dummyTask->setDelayTime(1000);
@ -143,7 +144,7 @@ class TaskTest extends TestCase
public function testAttributes()
{
// Create dummy task
$dummyTask = new Task('testAttributes', 'someThing', true);
$dummyTask = new Task('testAttributes', new EmptyHandler(), true);
// First test a non-existing attribute
$this->assertNull($dummyTask->attribute('testKey'));
@ -167,7 +168,7 @@ class TaskTest extends TestCase
public function testOutputsAndErrors()
{
// Create dummy task
$dummyTask = new Task('testOutputsAndErrors', 'someThing', true);
$dummyTask = new Task('testOutputsAndErrors', new EmptyHandler(), true);
// Check if non are filled
$this->assertNull($dummyTask->getOutput());
@ -192,7 +193,7 @@ class TaskTest extends TestCase
public function testRetrySettings()
{
// Create dummy task
$dummyTask = new Task('testRetrySettings', 'someThing', true);
$dummyTask = new Task('testRetrySettings', new EmptyHandler(), true);
// Test starting position
$this->assertEquals([
@ -222,7 +223,7 @@ class TaskTest extends TestCase
public function testRetries()
{
// Create dummy task
$dummyTask = new Task('testRetries', 'someThing', true);
$dummyTask = new Task('testRetries', new EmptyHandler(), true);
// First test the starting position
$this->assertEquals(0, $dummyTask->getRetries());

19
test/mock/Handlers/ArgumentedHandler.php
View File

@ -42,19 +42,20 @@ class ArgumentedHandler implements Handler
{
private $output;
private $sleepTime;
private $sleeptime;
public function __construct(int $sleepTime, string $output)
{
$this->sleepTime = $sleepTime;
$this->output = $output;
}
/**
* @inheritDoc
*/
public function primaryHandler(Task $task): bool
{
$arguments = $task->getArguments();
$this->sleeptime = $arguments[0];
$this->output = $arguments[1];
sleep($this->sleeptime);
sleep($this->sleepTime);
return true;
}
@ -71,11 +72,7 @@ class ArgumentedHandler implements Handler
*/
public function postHandler(Task $task)
{
$arguments = $task->getArguments();
$this->sleeptime = $arguments[0];
$this->output = $arguments[1];
sleep($this->sleeptime);
sleep($this->sleepTime);
return true;
}

72
test/mock/Handlers/EmptyHandler.php Normal file
View File

@ -0,0 +1,72 @@
<?php
/**
* FuzeWorks Async Library
*
* The FuzeWorks PHP FrameWork
*
* Copyright (C) 2013-2020 TechFuze
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* @author TechFuze
* @copyright Copyright (c) 2013 - 2020, TechFuze. (http://techfuze.net)
* @license https://opensource.org/licenses/MIT MIT License
*
* @link http://techfuze.net/fuzeworks
* @since Version 1.0.0
*
* @version Version 1.0.0
*/
namespace Mock\Handlers;
use FuzeWorks\Async\Handler;
use FuzeWorks\Async\Task;
class EmptyHandler implements Handler
{
/**
* @inheritDoc
*/
public function primaryHandler(Task $task): bool
{
return true;
}
/**
* @inheritDoc
*/
public function getOutput()
{
}
/**
* @inheritDoc
*/
public function postHandler(Task $task)
{
}
/**
* @inheritDoc
*/
public function getPostOutput()
{
}
}

2
test/mock/Handlers/TestStopTaskHandler.php
View File

@ -63,7 +63,6 @@ class TestStopTaskHandler implements Handler
*/
public function postHandler(Task $task)
{
}
/**
@ -71,6 +70,5 @@ class TestStopTaskHandler implements Handler
*/
public function getPostOutput()
{
}
}

39
test/system/ParallelSuperVisorTest.php
View File

@ -42,6 +42,7 @@ use FuzeWorks\Async\Task;
use FuzeWorks\Async\Tasks;
use FuzeWorks\Async\TaskStorage;
use FuzeWorks\Events;
use Mock\Handlers\ArgumentedHandler;
use PHPUnit\Framework\TestCase;
class ParallelSuperVisorTest extends TestCase
@ -78,7 +79,7 @@ class ParallelSuperVisorTest extends TestCase
'workerFile' => dirname(__DIR__, 2) . DIRECTORY_SEPARATOR . 'bin' . DIRECTORY_SEPARATOR . 'worker'
]);
$this->superVisor = new ParallelSuperVisor($this->taskStorage, $this->executor, ['outstream' => null]);
$this->superVisor = new ParallelSuperVisor($this->taskStorage, $this->executor);
}
public function testClass()
@ -99,7 +100,7 @@ class ParallelSuperVisorTest extends TestCase
public function testToRunning()
{
// First create a dummy task
$dummyTask = new Task('testToRunning', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testToRunning', new ArgumentedHandler(10, 'Some Output'), false);
// Write the dummy to TaskStorage
$this->taskStorage->addTask($dummyTask);
@ -128,7 +129,7 @@ class ParallelSuperVisorTest extends TestCase
public function testConstrainedPending()
{
// First create a dummy task
$dummyTask = new Task('testConstrainedPending', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testConstrainedPending', new ArgumentedHandler(10, 'Some Output'), false);
// Add a constraint
$dummyTask->addConstraint(new FixedTimeConstraint(time() + 3600));
@ -160,7 +161,7 @@ class ParallelSuperVisorTest extends TestCase
public function testChangeDelayedToPending()
{
// First create a dummy task
$dummyTask = new Task('testChangeDelayedToPending', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testChangeDelayedToPending', new ArgumentedHandler(10, 'Some Output'), false);
// Set to delayed and set to NOW
$dummyTask->setStatus(Task::DELAYED);
@ -193,7 +194,7 @@ class ParallelSuperVisorTest extends TestCase
public function testKeepDelayed()
{
// First create a dummy task
$dummyTask = new Task('testKeepDelayed', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testKeepDelayed', new ArgumentedHandler(10, 'Some Output'), false);
// Set to delayed and set to NOW
$dummyTask->setStatus(Task::DELAYED);
@ -226,7 +227,7 @@ class ParallelSuperVisorTest extends TestCase
public function testFinishedTask()
{
// First create a dummy task
$dummyTask = new Task('testFinishedTask', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testFinishedTask', new ArgumentedHandler(10, 'Some Output'), false);
// Set status to running
$dummyTask->setStatus(Task::RUNNING);
@ -260,7 +261,7 @@ class ParallelSuperVisorTest extends TestCase
public function testMissingTask()
{
// First create a dummy task
$dummyTask = new Task('testMissingTask', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testMissingTask', new ArgumentedHandler(10, 'Some Output'), false);
// Set status to running
$dummyTask->setStatus(Task::RUNNING);
@ -292,7 +293,7 @@ class ParallelSuperVisorTest extends TestCase
public function testFailedTask()
{
// First create a dummy task
$dummyTask = new Task('testFailedTask', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testFailedTask', new ArgumentedHandler(10, 'Some Output'), false);
// Set status to running
$dummyTask->setStatus(Task::RUNNING);
@ -326,10 +327,10 @@ class ParallelSuperVisorTest extends TestCase
public function testRetryFailedTask()
{
// First create the dummy tasks
$dummyTaskFailedYes = new Task('testRetryFailedTaskY', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTaskPFailedYes = new Task('testRetryFailedTaskPY', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTaskFailedNo = new Task('testRetryFailedTaskN', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTaskPFailedNo = new Task('testRetryFailedTaskPN', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTaskFailedYes = new Task('testRetryFailedTaskY', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskPFailedYes = new Task('testRetryFailedTaskPY', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskFailedNo = new Task('testRetryFailedTaskN', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskPFailedNo = new Task('testRetryFailedTaskPN', new ArgumentedHandler(10, 'Some Output'), false);
// Set statuses
$dummyTaskFailedYes->setStatus(Task::FAILED);
@ -378,8 +379,8 @@ class ParallelSuperVisorTest extends TestCase
public function testExceedMaxRetries()
{
// First create the dummy tasks
$dummyTask = new Task('testExceedMaxRetries', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask2 = new Task('testExceedMaxRetries2', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTask = new Task('testExceedMaxRetries', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTask2 = new Task('testExceedMaxRetries2', new ArgumentedHandler(10, 'Some Output'), false);
// Set status and retry settings
$dummyTask->setStatus(Task::FAILED);
@ -415,7 +416,7 @@ class ParallelSuperVisorTest extends TestCase
public function testFailedToPost()
{
// First create the dummy tasks
$dummyTask = new Task('testFailedToPost', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output');
$dummyTask = new Task('testFailedToPost', new ArgumentedHandler(10, 'Some Output'), true);
// Set status and settings
$dummyTask->setStatus(Task::FAILED);
@ -444,8 +445,8 @@ class ParallelSuperVisorTest extends TestCase
public function testSuccessfulTasks()
{
// First create the dummy tasks
$dummyTaskPostNo = new Task('testSuccessfulTasksN', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output');
$dummyTaskPostYes = new Task('testSuccessfulTasksY', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output');
$dummyTaskPostNo = new Task('testSuccessfulTasksN', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskPostYes = new Task('testSuccessfulTasksY', new ArgumentedHandler(10, 'Some Output'), true);
// Set status and settings
$dummyTaskPostNo->setStatus(Task::SUCCESS);
@ -472,8 +473,8 @@ class ParallelSuperVisorTest extends TestCase
public function testPostTasks()
{
// First create the dummy tasks
$dummyTaskFinished = new Task('testPostTasksFinished', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output');
$dummyTaskMissing = new Task('testPostTasksMissing', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output');
$dummyTaskFinished = new Task('testPostTasksFinished', new ArgumentedHandler(10, 'Some Output'), true);
$dummyTaskMissing = new Task('testPostTasksMissing', new ArgumentedHandler(10, 'Some Output'), true);
// Set status and settings
$dummyTaskFinished->setStatus(Task::POST);