Release of RC1 #7
@ -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
|
||||
|
@ -116,9 +116,9 @@ class Task
|
||||
protected $taskId;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
* @var Handler
|
||||
*/
|
||||
protected $handlerClass;
|
||||
protected $handler;
|
||||
|
||||
/**
|
||||
* @var bool
|
||||
@ -185,15 +185,19 @@ 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 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)
|
||||
{
|
||||
|
@ -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();
|
||||
|
@ -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);
|
||||
|
@ -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));
|
||||
|
@ -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());
|
||||
|
@ -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
72
test/mock/Handlers/EmptyHandler.php
Normal 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()
|
||||
{
|
||||
}
|
||||
}
|
@ -63,7 +63,6 @@ class TestStopTaskHandler implements Handler
|
||||
*/
|
||||
public function postHandler(Task $task)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
@ -71,6 +70,5 @@ class TestStopTaskHandler implements Handler
|
||||
*/
|
||||
public function getPostOutput()
|
||||
{
|
||||
|
||||
}
|
||||
}
|
@ -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);
|
||||
|
Loading…
Reference in New Issue
Block a user