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; $this->post = $post;
// Fetch the callable // Fetch the callable
$class = $this->task->getHandlerClass(); $object = $this->task->getHandler();
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();
if (!$object instanceof Handler) 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) if (!$post)
$this->taskStorage->writeTaskOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries()); $this->taskStorage->writeTaskOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries());
else else
$this->taskStorage->writePostOutput($this->task, '', $errors, Task::PFAILED, $this->task->getRetries()); $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 // Run postHandler if post mode is requested

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

@ -116,9 +116,9 @@ class Task
protected $taskId; protected $taskId;
/** /**
* @var string * @var Handler
*/ */
protected $handlerClass; protected $handler;
/** /**
* @var bool * @var bool
@ -184,16 +184,20 @@ class Task
* *
* Creates a Task object, which can be added to the TaskQueue. * 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 $identifier The unique identifier of this task. Make sure it is always unique!
* @param string $handlerClass The class that shall handle this task * @param Handler $handler The Handler object which will run the Task in the Worker
* @param bool $usePostHandler Whether the postHandler on handlerClass should also be used * @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 * @param mixed $parameters,... The arguments provided to the method that shall handle this class
* @throws TasksException * @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->taskId = $identifier;
$this->handlerClass = $handlerClass; $this->handler = $handler;
$this->usePostHandler = $usePostHandler; $this->usePostHandler = $usePostHandler;
if (func_num_args() > 3) if (func_num_args() > 3)
$args = array_slice(func_get_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 * @return bool
*/ */
@ -470,6 +474,7 @@ class Task
* *
* @param $value * @param $value
* @return bool * @return bool
* @todo Improve so it is properly tested
*/ */
private function isSerializable($value) private function isSerializable($value)
{ {

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

@ -284,6 +284,7 @@ class ArrayTaskStorage implements TaskStorage
{ {
// Get the task // Get the task
$task = $this->tasks[$i]; $task = $this->tasks[$i];
$taskId = $task->getId();
// Remove all task output and post output // Remove all task output and post output
$settings = $task->getRetrySettings(); $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\Tasks;
use FuzeWorks\Async\TasksException; use FuzeWorks\Async\TasksException;
use FuzeWorks\Async\TaskStorage; use FuzeWorks\Async\TaskStorage;
use Mock\Handlers\EmptyHandler;
use Mock\Handlers\TestStartAndReadTasksHandler;
use Mock\Handlers\TestStopTaskHandler;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
/** /**
@ -131,7 +134,7 @@ class ShellExecutorTest extends TestCase
public function testStartAndReadTasks() public function testStartAndReadTasks()
{ {
// First we create a dummy task // 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 // Then we write this task to the TaskStorage
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
@ -161,7 +164,7 @@ class ShellExecutorTest extends TestCase
public function testGetStats() public function testGetStats()
{ {
// First we create a dummy task, using the previous handler since nothing changes // 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 // Then we write this task to the TaskStorage
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
@ -190,7 +193,7 @@ class ShellExecutorTest extends TestCase
public function testGetStatsNotExist() public function testGetStatsNotExist()
{ {
// First we create a dummy task, using the previous handler since nothing changes // 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 // And add a fake PID, since otherwise it will immediately fail
$dummyTask->addAttribute('pid', 1005); $dummyTask->addAttribute('pid', 1005);
@ -205,7 +208,7 @@ class ShellExecutorTest extends TestCase
public function testStopTask() public function testStopTask()
{ {
// First we create a dummy task // 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 // Then we write this task to the TaskStorage
$this->taskStorage->addTask($dummyTask); $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\Async\TaskStorage\DummyTaskStorage;
use FuzeWorks\Events; use FuzeWorks\Events;
use FuzeWorks\Priority; use FuzeWorks\Priority;
use Mock\Handlers\EmptyHandler;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
/** /**
@ -79,7 +80,7 @@ class TaskStorageTest extends TestCase
public function testAddAndReadTasks() public function testAddAndReadTasks()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testAddTask', 'none'); $dummyTask = new Task('testAddTask', new EmptyHandler());
// Nothing is written yet so it should be empty // Nothing is written yet so it should be empty
$this->assertEmpty($this->taskStorage->readTasks()); $this->assertEmpty($this->taskStorage->readTasks());
@ -95,7 +96,7 @@ class TaskStorageTest extends TestCase
// Test if the properties match // Test if the properties match
$this->assertEquals('testAddTask', $task->getId()); $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() public function testAddExistingTask()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testAddExistingTask', 'none'); $dummyTask = new Task('testAddExistingTask', new EmptyHandler());
// First check that the task storage starts empty // First check that the task storage starts empty
$this->assertEmpty($this->taskStorage->readTasks()); $this->assertEmpty($this->taskStorage->readTasks());
@ -123,8 +124,8 @@ class TaskStorageTest extends TestCase
public function testGetTaskById() public function testGetTaskById()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask1 = new Task('testGetTaskById1', 'none'); $dummyTask1 = new Task('testGetTaskById1', new EmptyHandler());
$dummyTask2 = new Task('testGetTaskById2', 'none'); $dummyTask2 = new Task('testGetTaskById2', new EmptyHandler());
// First we add both tasks // First we add both tasks
$this->assertEmpty($this->taskStorage->readTasks()); $this->assertEmpty($this->taskStorage->readTasks());
@ -155,7 +156,7 @@ class TaskStorageTest extends TestCase
public function testGetTaskByIdNotFound() public function testGetTaskByIdNotFound()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testGetTaskByIdNotFound', 'none'); $dummyTask = new Task('testGetTaskByIdNotFound', new EmptyHandler());
// First we add the task // First we add the task
$this->assertEmpty($this->taskStorage->readTasks()); $this->assertEmpty($this->taskStorage->readTasks());
@ -175,7 +176,7 @@ class TaskStorageTest extends TestCase
public function testModifyTask() public function testModifyTask()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testModifyTask', 'none'); $dummyTask = new Task('testModifyTask', new EmptyHandler());
$dummyTask->setStatus(Task::RUNNING); $dummyTask->setStatus(Task::RUNNING);
// First we add the task // First we add the task
@ -199,7 +200,7 @@ class TaskStorageTest extends TestCase
public function testModifyTaskNotFound() public function testModifyTaskNotFound()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testModifyTaskNotFound', 'none'); $dummyTask = new Task('testModifyTaskNotFound', new EmptyHandler());
// Attempt to change this task, which does not exist. // Attempt to change this task, which does not exist.
$this->expectException(TasksException::class); $this->expectException(TasksException::class);
@ -212,7 +213,7 @@ class TaskStorageTest extends TestCase
public function testModifyTaskEvent() public function testModifyTaskEvent()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testModifyTaskEvent', 'none'); $dummyTask = new Task('testModifyTaskEvent', new EmptyHandler());
$dummyTask->setStatus(Task::PENDING); $dummyTask->setStatus(Task::PENDING);
// Then add the Task // Then add the Task
@ -245,7 +246,7 @@ class TaskStorageTest extends TestCase
public function testModifyTaskCancel() public function testModifyTaskCancel()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testModifyTaskCancel', 'none'); $dummyTask = new Task('testModifyTaskCancel', new EmptyHandler());
$dummyTask->setStatus(Task::PENDING); $dummyTask->setStatus(Task::PENDING);
// Then add the Task // Then add the Task
@ -272,7 +273,7 @@ class TaskStorageTest extends TestCase
public function testDeleteTask() public function testDeleteTask()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testDeleteTask', 'none'); $dummyTask = new Task('testDeleteTask', new EmptyHandler());
// Add the task to the storage // Add the task to the storage
$this->assertEmpty($this->taskStorage->readTasks()); $this->assertEmpty($this->taskStorage->readTasks());
@ -295,7 +296,7 @@ class TaskStorageTest extends TestCase
public function testDeleteTaskNotFound() public function testDeleteTaskNotFound()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testDeleteTaskNotFound', 'none'); $dummyTask = new Task('testDeleteTaskNotFound', new EmptyHandler());
// Attempt to delete this task, which does not exist. // Attempt to delete this task, which does not exist.
$this->expectException(TasksException::class); $this->expectException(TasksException::class);
@ -310,7 +311,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutput() public function testWriteAndReadTaskOutput()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutput', 'none'); $dummyTask = new Task('testWriteAndReadTaskOutput', new EmptyHandler());
// First write the task output // First write the task output
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
@ -329,7 +330,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputTaskNotExist() public function testWriteAndReadTaskOutputTaskNotExist()
{ {
// Prepare a dummy task // 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 // Write output while the task does not exist yet, expect exception
$this->expectException(TasksException::class); $this->expectException(TasksException::class);
@ -342,7 +343,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputAttempts() public function testWriteAndReadTaskOutputAttempts()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputAttempts', 'none'); $dummyTask = new Task('testWriteAndReadTaskOutputAttempts', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
// Write the different outputs. Done in a weird order to make sure the default is inserted not first or last // 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() public function testWriteAndReadTaskOutputAlreadyExists()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputAlreadyExists', 'none'); $dummyTask = new Task('testWriteAndReadTaskOutputAlreadyExists', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
// Write a first time // Write a first time
@ -399,7 +400,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskOutputNotExist() public function testWriteAndReadTaskOutputNotExist()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskOutputNotExist', 'none'); $dummyTask = new Task('testWriteAndReadTaskOutputNotExist', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
$this->assertNull($this->taskStorage->readTaskOutput($dummyTask)); $this->assertNull($this->taskStorage->readTaskOutput($dummyTask));
@ -413,7 +414,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutput() public function testWriteAndReadTaskPostOutput()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutput', 'none'); $dummyTask = new Task('testWriteAndReadTaskPostOutput', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
// First write the task output // First write the task output
@ -432,7 +433,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutputAttempts() public function testWriteAndReadTaskPostOutputAttempts()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutputAttempts', 'none'); $dummyTask = new Task('testWriteAndReadTaskPostOutputAttempts', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
// Write the different outputs. Done in a weird order to make sure the default is inserted not first or last // 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() public function testWriteAndReadTaskPostOutputAlreadyExists()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutputAlreadyExists', 'none'); $dummyTask = new Task('testWriteAndReadTaskPostOutputAlreadyExists', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
// Write a first time // Write a first time
@ -489,7 +490,7 @@ class TaskStorageTest extends TestCase
public function testWriteAndReadTaskPostOutputNotExist() public function testWriteAndReadTaskPostOutputNotExist()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testWriteAndReadTaskPostOutputNotExist', 'none'); $dummyTask = new Task('testWriteAndReadTaskPostOutputNotExist', new EmptyHandler());
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
$this->assertNull($this->taskStorage->readPostOutput($dummyTask)); $this->assertNull($this->taskStorage->readPostOutput($dummyTask));
@ -505,7 +506,7 @@ class TaskStorageTest extends TestCase
public function testReset() public function testReset()
{ {
// Prepare a dummy task // Prepare a dummy task
$dummyTask = new Task('testReset', 'none'); $dummyTask = new Task('testReset', new EmptyHandler());
// Add the task and some output // Add the task and some output
$this->assertTrue($this->taskStorage->addTask($dummyTask)); $this->assertTrue($this->taskStorage->addTask($dummyTask));

29
test/base/TaskTest.php
View File

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

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

@ -42,19 +42,20 @@ class ArgumentedHandler implements Handler
{ {
private $output; private $output;
private $sleepTime;
private $sleeptime; public function __construct(int $sleepTime, string $output)
{
$this->sleepTime = $sleepTime;
$this->output = $output;
}
/** /**
* @inheritDoc * @inheritDoc
*/ */
public function primaryHandler(Task $task): bool public function primaryHandler(Task $task): bool
{ {
$arguments = $task->getArguments(); sleep($this->sleepTime);
$this->sleeptime = $arguments[0];
$this->output = $arguments[1];
sleep($this->sleeptime);
return true; return true;
} }
@ -71,11 +72,7 @@ class ArgumentedHandler implements Handler
*/ */
public function postHandler(Task $task) public function postHandler(Task $task)
{ {
$arguments = $task->getArguments(); sleep($this->sleepTime);
$this->sleeptime = $arguments[0];
$this->output = $arguments[1];
sleep($this->sleeptime);
return true; 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) public function postHandler(Task $task)
{ {
} }
/** /**
@ -71,6 +70,5 @@ class TestStopTaskHandler implements Handler
*/ */
public function getPostOutput() 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\Tasks;
use FuzeWorks\Async\TaskStorage; use FuzeWorks\Async\TaskStorage;
use FuzeWorks\Events; use FuzeWorks\Events;
use Mock\Handlers\ArgumentedHandler;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
class ParallelSuperVisorTest extends TestCase class ParallelSuperVisorTest extends TestCase
@ -78,7 +79,7 @@ class ParallelSuperVisorTest extends TestCase
'workerFile' => dirname(__DIR__, 2) . DIRECTORY_SEPARATOR . 'bin' . DIRECTORY_SEPARATOR . 'worker' '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() public function testClass()
@ -99,7 +100,7 @@ class ParallelSuperVisorTest extends TestCase
public function testToRunning() public function testToRunning()
{ {
// First create a dummy task // 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 // Write the dummy to TaskStorage
$this->taskStorage->addTask($dummyTask); $this->taskStorage->addTask($dummyTask);
@ -128,7 +129,7 @@ class ParallelSuperVisorTest extends TestCase
public function testConstrainedPending() public function testConstrainedPending()
{ {
// First create a dummy task // 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 // Add a constraint
$dummyTask->addConstraint(new FixedTimeConstraint(time() + 3600)); $dummyTask->addConstraint(new FixedTimeConstraint(time() + 3600));
@ -160,7 +161,7 @@ class ParallelSuperVisorTest extends TestCase
public function testChangeDelayedToPending() public function testChangeDelayedToPending()
{ {
// First create a dummy task // 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 // Set to delayed and set to NOW
$dummyTask->setStatus(Task::DELAYED); $dummyTask->setStatus(Task::DELAYED);
@ -193,7 +194,7 @@ class ParallelSuperVisorTest extends TestCase
public function testKeepDelayed() public function testKeepDelayed()
{ {
// First create a dummy task // 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 // Set to delayed and set to NOW
$dummyTask->setStatus(Task::DELAYED); $dummyTask->setStatus(Task::DELAYED);
@ -226,7 +227,7 @@ class ParallelSuperVisorTest extends TestCase
public function testFinishedTask() public function testFinishedTask()
{ {
// First create a dummy task // 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 // Set status to running
$dummyTask->setStatus(Task::RUNNING); $dummyTask->setStatus(Task::RUNNING);
@ -260,7 +261,7 @@ class ParallelSuperVisorTest extends TestCase
public function testMissingTask() public function testMissingTask()
{ {
// First create a dummy task // 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 // Set status to running
$dummyTask->setStatus(Task::RUNNING); $dummyTask->setStatus(Task::RUNNING);
@ -292,7 +293,7 @@ class ParallelSuperVisorTest extends TestCase
public function testFailedTask() public function testFailedTask()
{ {
// First create a dummy task // 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 // Set status to running
$dummyTask->setStatus(Task::RUNNING); $dummyTask->setStatus(Task::RUNNING);
@ -326,10 +327,10 @@ class ParallelSuperVisorTest extends TestCase
public function testRetryFailedTask() public function testRetryFailedTask()
{ {
// First create the dummy tasks // First create the dummy tasks
$dummyTaskFailedYes = new Task('testRetryFailedTaskY', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTaskFailedYes = new Task('testRetryFailedTaskY', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskPFailedYes = new Task('testRetryFailedTaskPY', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTaskPFailedYes = new Task('testRetryFailedTaskPY', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskFailedNo = new Task('testRetryFailedTaskN', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTaskFailedNo = new Task('testRetryFailedTaskN', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskPFailedNo = new Task('testRetryFailedTaskPN', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTaskPFailedNo = new Task('testRetryFailedTaskPN', new ArgumentedHandler(10, 'Some Output'), false);
// Set statuses // Set statuses
$dummyTaskFailedYes->setStatus(Task::FAILED); $dummyTaskFailedYes->setStatus(Task::FAILED);
@ -378,8 +379,8 @@ class ParallelSuperVisorTest extends TestCase
public function testExceedMaxRetries() public function testExceedMaxRetries()
{ {
// First create the dummy tasks // First create the dummy tasks
$dummyTask = new Task('testExceedMaxRetries', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTask = new Task('testExceedMaxRetries', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTask2 = new Task('testExceedMaxRetries2', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTask2 = new Task('testExceedMaxRetries2', new ArgumentedHandler(10, 'Some Output'), false);
// Set status and retry settings // Set status and retry settings
$dummyTask->setStatus(Task::FAILED); $dummyTask->setStatus(Task::FAILED);
@ -415,7 +416,7 @@ class ParallelSuperVisorTest extends TestCase
public function testFailedToPost() public function testFailedToPost()
{ {
// First create the dummy tasks // 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 // Set status and settings
$dummyTask->setStatus(Task::FAILED); $dummyTask->setStatus(Task::FAILED);
@ -444,8 +445,8 @@ class ParallelSuperVisorTest extends TestCase
public function testSuccessfulTasks() public function testSuccessfulTasks()
{ {
// First create the dummy tasks // First create the dummy tasks
$dummyTaskPostNo = new Task('testSuccessfulTasksN', 'Mock\Handlers\ArgumentedHandler', false, 10, 'Some Output'); $dummyTaskPostNo = new Task('testSuccessfulTasksN', new ArgumentedHandler(10, 'Some Output'), false);
$dummyTaskPostYes = new Task('testSuccessfulTasksY', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output'); $dummyTaskPostYes = new Task('testSuccessfulTasksY', new ArgumentedHandler(10, 'Some Output'), true);
// Set status and settings // Set status and settings
$dummyTaskPostNo->setStatus(Task::SUCCESS); $dummyTaskPostNo->setStatus(Task::SUCCESS);
@ -472,8 +473,8 @@ class ParallelSuperVisorTest extends TestCase
public function testPostTasks() public function testPostTasks()
{ {
// First create the dummy tasks // First create the dummy tasks
$dummyTaskFinished = new Task('testPostTasksFinished', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output'); $dummyTaskFinished = new Task('testPostTasksFinished', new ArgumentedHandler(10, 'Some Output'), true);
$dummyTaskMissing = new Task('testPostTasksMissing', 'Mock\Handlers\ArgumentedHandler', true, 10, 'Some Output'); $dummyTaskMissing = new Task('testPostTasksMissing', new ArgumentedHandler(10, 'Some Output'), true);
// Set status and settings // Set status and settings
$dummyTaskFinished->setStatus(Task::POST); $dummyTaskFinished->setStatus(Task::POST);