578 lines
21 KiB
PHP
578 lines
21 KiB
PHP
<?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
|
|
*/
|
|
|
|
use FuzeWorks\Async\Events\TaskModifyEvent;
|
|
use FuzeWorks\Async\Task;
|
|
use FuzeWorks\Async\Tasks;
|
|
use FuzeWorks\Async\TasksException;
|
|
use FuzeWorks\Async\TaskStorage;
|
|
use FuzeWorks\Events;
|
|
use FuzeWorks\Priority;
|
|
use Mock\Handlers\EmptyHandler;
|
|
use PHPUnit\Framework\TestCase;
|
|
|
|
/**
|
|
* Class TaskStorageTest
|
|
*/
|
|
class TaskStorageTest extends TestCase
|
|
{
|
|
|
|
/**
|
|
* @var TaskStorage
|
|
*/
|
|
private $taskStorage;
|
|
|
|
public function setUp(): void
|
|
{
|
|
// Add TaskStorage
|
|
$tasks = new Tasks();
|
|
$this->taskStorage = $tasks->getTaskStorage();
|
|
$this->taskStorage->reset();
|
|
|
|
// Reset events
|
|
Events::$listeners = [];
|
|
}
|
|
|
|
public function testDummyTaskStorageClass()
|
|
{
|
|
$this->assertInstanceOf('FuzeWorks\Async\TaskStorage', $this->taskStorage);
|
|
}
|
|
|
|
/* ---------------------------------- Writing and reading tasks ----------------------- */
|
|
|
|
/**
|
|
* @depends testDummyTaskStorageClass
|
|
*/
|
|
public function testAddAndReadTasks()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testAddTask', new EmptyHandler());
|
|
|
|
// Nothing is written yet so it should be empty
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
|
|
// Write task to storage and test properties of readTasks
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask));
|
|
$output = $this->taskStorage->readTasks();
|
|
$this->assertCount(1, $output);
|
|
|
|
// Get first
|
|
$task = $output[0];
|
|
$this->assertEquals($dummyTask, $task);
|
|
|
|
// Test if the properties match
|
|
$this->assertEquals('testAddTask', $task->getId());
|
|
$this->assertInstanceOf(EmptyHandler::class, $task->getHandler());
|
|
}
|
|
|
|
/**
|
|
* @depends testAddAndReadTasks
|
|
*/
|
|
public function testReadUnfinishedTasks()
|
|
{
|
|
// Add the tasks
|
|
$finishedTask = new Task('finishedTask', new EmptyHandler());
|
|
$finishedTask->setStatus(Task::COMPLETED);
|
|
$unfinishedTask1 = new Task('unfinishedTask1', new EmptyHandler());
|
|
$unfinishedTask2 = new Task('unfinishedTask2', new EmptyHandler());
|
|
|
|
// Nothing is written yet so it should be empty
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
|
|
// Write the tasks to TaskStorage
|
|
$this->taskStorage->addTask($finishedTask);
|
|
$this->taskStorage->addTask($unfinishedTask1);
|
|
$this->taskStorage->addTask($unfinishedTask2);
|
|
|
|
// And check whether they get properly read
|
|
$this->assertCount(3, $this->taskStorage->readTasks());
|
|
|
|
// And whether the finished task gets omitted in the unfinished list
|
|
$this->assertCount(2, $this->taskStorage->readTasks(true));
|
|
}
|
|
|
|
/**
|
|
* @depends testAddAndReadTasks
|
|
*/
|
|
public function testAddExistingTask()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testAddExistingTask', new EmptyHandler());
|
|
|
|
// First check that the task storage starts empty
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
|
|
// Then add the first task
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask));
|
|
|
|
// But then add another task, which should raise an exception
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->addTask($dummyTask);
|
|
}
|
|
|
|
/**
|
|
* @depends testAddAndReadTasks
|
|
*/
|
|
public function testGetTaskById()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask1 = new Task('testGetTaskById1', new EmptyHandler());
|
|
$dummyTask2 = new Task('testGetTaskById2', new EmptyHandler());
|
|
|
|
// First we add both tasks
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask1));
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask2));
|
|
|
|
// Afterwards, we attempt to get the separate tasks
|
|
$retrievedTask1 = $this->taskStorage->getTaskById('testGetTaskById1');
|
|
$retrievedTask2 = $this->taskStorage->getTaskById('testGetTaskById2');
|
|
$this->assertInstanceOf('FuzeWorks\Async\Task', $retrievedTask1);
|
|
$this->assertInstanceOf('FuzeWorks\Async\Task', $retrievedTask2);
|
|
|
|
// Assert they have the values we seek
|
|
$this->assertEquals('testGetTaskById1', $retrievedTask1->getId());
|
|
$this->assertEquals('testGetTaskById2', $retrievedTask2->getId());
|
|
|
|
// Test they are not the same
|
|
$this->assertNotEquals($retrievedTask1, $retrievedTask2);
|
|
|
|
// And test they are the initial dummy tasks
|
|
$this->assertEquals($dummyTask1, $retrievedTask1);
|
|
$this->assertEquals($dummyTask2, $retrievedTask2);
|
|
}
|
|
|
|
/**
|
|
* @depends testGetTaskById
|
|
*/
|
|
public function testGetTaskByIdNotFound()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testGetTaskByIdNotFound', new EmptyHandler());
|
|
|
|
// First we add the task
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask));
|
|
|
|
// Afterwards we check if we can get this task
|
|
$this->assertInstanceOf('FuzeWorks\Async\Task', $this->taskStorage->getTaskById('testGetTaskByIdNotFound'));
|
|
|
|
// And afterwards we check if an exception is raised if none exist
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->getTaskById('DoesNotExist');
|
|
}
|
|
|
|
/**
|
|
* @depends testGetTaskById
|
|
*/
|
|
public function testModifyTask()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testModifyTask', new EmptyHandler());
|
|
$dummyTask->setStatus(Task::RUNNING);
|
|
|
|
// First we add the task
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask));
|
|
|
|
// Afterwards we check if this task has the known details
|
|
$this->assertEquals(Task::RUNNING, $this->taskStorage->getTaskById('testModifyTask')->getStatus());
|
|
|
|
// Then we change the task
|
|
$dummyTask->setStatus(Task::FAILED);
|
|
$this->assertTrue($this->taskStorage->modifyTask($dummyTask));
|
|
|
|
// And check if the details have been changed
|
|
$this->assertEquals(Task::FAILED, $this->taskStorage->getTaskById('testModifyTask')->getStatus());
|
|
}
|
|
|
|
/**
|
|
* @depends testModifyTask
|
|
*/
|
|
public function testModifyTaskNotFound()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testModifyTaskNotFound', new EmptyHandler());
|
|
|
|
// Attempt to change this task, which does not exist.
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->modifyTask($dummyTask);
|
|
}
|
|
|
|
/**
|
|
* @depends testModifyTask
|
|
*/
|
|
public function testModifyTaskEvent()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testModifyTaskEvent', new EmptyHandler());
|
|
$dummyTask->setStatus(Task::PENDING);
|
|
|
|
// Then add the Task
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
// Now prepare a listener to be fired
|
|
Events::addListener(function (TaskModifyEvent $event){
|
|
$task = $event->getTask();
|
|
$this->assertEquals(Task::PENDING, $task->getStatus());
|
|
$task->setStatus(Task::RUNNING);
|
|
$event->updateTask($task);
|
|
return $event;
|
|
}, 'TaskModifyEvent', Priority::NORMAL);
|
|
|
|
// Now update the task
|
|
$this->assertEquals(Task::PENDING, $dummyTask->getStatus());
|
|
$this->taskStorage->modifyTask($dummyTask);
|
|
|
|
// And check whether dummyTask got modified
|
|
$this->assertEquals(Task::RUNNING, $dummyTask->getStatus());
|
|
|
|
// And check whether the TaskStorage has this updated version as well
|
|
$modifiedTask = $this->taskStorage->getTaskById($dummyTask->getId());
|
|
$this->assertEquals(Task::RUNNING, $modifiedTask->getStatus());
|
|
}
|
|
|
|
/**
|
|
* @depends testModifyTaskEvent
|
|
*/
|
|
public function testModifyTaskCancel()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testModifyTaskCancel', new EmptyHandler());
|
|
$dummyTask->setStatus(Task::PENDING);
|
|
|
|
// Then add the Task
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
// Now prepare a listener to be fired
|
|
Events::addListener(function (TaskModifyEvent $event){
|
|
$event->setCancelled(true);
|
|
return $event;
|
|
}, 'TaskModifyEvent', Priority::NORMAL);
|
|
|
|
// Modify the task
|
|
$dummyTask->setStatus(Task::SUCCESS);
|
|
$this->assertFalse($this->taskStorage->modifyTask($dummyTask));
|
|
|
|
// And check that the task actually hasn't updated
|
|
$modifiedTask = $this->taskStorage->getTaskById($dummyTask->getId());
|
|
$this->assertEquals(Task::PENDING, $modifiedTask->getStatus());
|
|
}
|
|
|
|
/**
|
|
* @depends testGetTaskById
|
|
*/
|
|
public function testDeleteTask()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testDeleteTask', new EmptyHandler());
|
|
|
|
// Add the task to the storage
|
|
$this->assertEmpty($this->taskStorage->readTasks());
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask));
|
|
|
|
// Test that it exists
|
|
$this->assertEquals($dummyTask, $this->taskStorage->getTaskById('testDeleteTask'));
|
|
|
|
// Then remove the task
|
|
$this->assertTrue($this->taskStorage->deleteTask($dummyTask));
|
|
|
|
// And test that it can't be found
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->getTaskById('testDeleteTask');
|
|
}
|
|
|
|
/**
|
|
* @depends testDeleteTask
|
|
*/
|
|
public function testDeleteTaskNotFound()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testDeleteTaskNotFound', new EmptyHandler());
|
|
|
|
// Attempt to delete this task, which does not exist.
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->deleteTask($dummyTask);
|
|
}
|
|
|
|
/* ---------------------------------- Writing and reading task output ----------------- */
|
|
|
|
/**
|
|
* @depends testDummyTaskStorageClass
|
|
*/
|
|
public function testWriteAndReadTaskOutput()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskOutput', new EmptyHandler());
|
|
|
|
// First write the task output
|
|
$this->taskStorage->addTask($dummyTask);
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output', 'errors', 0));
|
|
|
|
// Then try to read the output
|
|
$output = $this->taskStorage->readTaskOutput($dummyTask, 1);
|
|
$this->assertEquals('output', $output['output']);
|
|
$this->assertEquals('errors', $output['errors']);
|
|
$this->assertEquals(0, $output['statusCode']);
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskOutput
|
|
*/
|
|
public function testWriteAndReadMultipleOutput()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadMultipleOutput', new EmptyHandler());
|
|
|
|
// Write some task output
|
|
$this->taskStorage->addTask($dummyTask);
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output1', 'errors1', 0));
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output2', 'errors2', 0));
|
|
|
|
// Then try to read all the output
|
|
$output = $this->taskStorage->readTaskOutput($dummyTask, -1);
|
|
$this->assertEquals([
|
|
['output' => 'output1', 'errors' => 'errors1', 'statusCode' => 0],
|
|
['output' => 'output2', 'errors' => 'errors2', 'statusCode' => 0]
|
|
], $output);
|
|
|
|
// Then try and read the latest
|
|
$this->assertEquals(['output' => 'output2', 'errors' => 'errors2', 'statusCode' => 0], $this->taskStorage->readTaskOutput($dummyTask));
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskOutput
|
|
*/
|
|
public function testWriteAndReadTaskOutputTaskNotExist()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskOutputTaskNotExist', new EmptyHandler());
|
|
|
|
// Write output while the task does not exist yet, expect exception
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->writeTaskOutput($dummyTask, 'output', 'errors', 0);
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskOutput
|
|
*/
|
|
public function testWriteAndReadTaskOutputAttempts()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskOutputAttempts', new EmptyHandler());
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
// Write the different outputs.
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output0', 'errors0', 100));
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output1', 'errors1', 101));
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output2', 'errors2', 102));
|
|
|
|
// Attempt to load the first output
|
|
$output0 = $this->taskStorage->readTaskOutput($dummyTask, 1);
|
|
$this->assertEquals('output0', $output0['output']);
|
|
$this->assertEquals('errors0', $output0['errors']);
|
|
$this->assertEquals(100, $output0['statusCode']);
|
|
|
|
// Attempt to load the second output
|
|
$output1 = $this->taskStorage->readTaskOutput($dummyTask, 2);
|
|
$this->assertEquals('output1', $output1['output']);
|
|
$this->assertEquals('errors1', $output1['errors']);
|
|
$this->assertEquals(101, $output1['statusCode']);
|
|
|
|
// Attempt to load the third output
|
|
$output2 = $this->taskStorage->readTaskOutput($dummyTask, 3);
|
|
$this->assertEquals('output2', $output2['output']);
|
|
$this->assertEquals('errors2', $output2['errors']);
|
|
$this->assertEquals(102, $output2['statusCode']);
|
|
|
|
// Attempt to load the default output
|
|
$output = $this->taskStorage->readTaskOutput($dummyTask);
|
|
$this->assertEquals('output2', $output['output']);
|
|
$this->assertEquals('errors2', $output['errors']);
|
|
$this->assertEquals(102, $output['statusCode']);
|
|
|
|
// And to load all
|
|
$this->assertEquals([
|
|
['output' => 'output0', 'errors' => 'errors0', 'statusCode' => 100],
|
|
['output' => 'output1', 'errors' => 'errors1', 'statusCode' => 101],
|
|
['output' => 'output2', 'errors' => 'errors2', 'statusCode' => 102]
|
|
], $this->taskStorage->readTaskOutput($dummyTask, -1));
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskOutput
|
|
*/
|
|
public function testWriteAndReadTaskOutputNotExist()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskOutputNotExist', new EmptyHandler());
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
$this->assertNull($this->taskStorage->readTaskOutput($dummyTask));
|
|
}
|
|
|
|
/* ---------------------------------- Writing and reading task post output ------------ */
|
|
|
|
/**
|
|
* @depends testDummyTaskStorageClass
|
|
*/
|
|
public function testWriteAndReadTaskPostOutput()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskPostOutput', new EmptyHandler());
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
// First write the task output
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'postOutput', 'errors', 0));
|
|
|
|
// Then try to read the output
|
|
$output = $this->taskStorage->readPostOutput($dummyTask, 1);
|
|
$this->assertEquals('postOutput', $output['output']);
|
|
$this->assertEquals('errors', $output['errors']);
|
|
$this->assertEquals(0, $output['statusCode']);
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskOutput
|
|
*/
|
|
public function testWriteAndReadMultiplePostOutput()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadMultiplePostOutput', new EmptyHandler());
|
|
|
|
// Write some task output
|
|
$this->taskStorage->addTask($dummyTask);
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'output1', 'errors1', 0));
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'output2', 'errors2', 0));
|
|
|
|
// Then try to read all the output
|
|
$output = $this->taskStorage->readPostOutput($dummyTask, -1);
|
|
$this->assertEquals([
|
|
['output' => 'output1', 'errors' => 'errors1', 'statusCode' => 0],
|
|
['output' => 'output2', 'errors' => 'errors2', 'statusCode' => 0]
|
|
], $output);
|
|
|
|
$this->assertEquals(['output' => 'output2', 'errors' => 'errors2', 'statusCode' => 0], $this->taskStorage->readPostOutput($dummyTask));
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskPostOutput
|
|
*/
|
|
public function testWriteAndReadTaskPostOutputAttempts()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskPostOutputAttempts', new EmptyHandler());
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
// Write the different outputs
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'output0', 'errors0', 100));
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'output1', 'errors1', 101));
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'output2', 'errors2', 102));
|
|
|
|
|
|
// Attempt to load the first output
|
|
$output0 = $this->taskStorage->readPostOutput($dummyTask, 1);
|
|
$this->assertEquals('output0', $output0['output']);
|
|
$this->assertEquals('errors0', $output0['errors']);
|
|
$this->assertEquals(100, $output0['statusCode']);
|
|
|
|
// Attempt to load the second output
|
|
$output1 = $this->taskStorage->readPostOutput($dummyTask, 2);
|
|
$this->assertEquals('output1', $output1['output']);
|
|
$this->assertEquals('errors1', $output1['errors']);
|
|
$this->assertEquals(101, $output1['statusCode']);
|
|
|
|
// Attempt to load the third output
|
|
$output2 = $this->taskStorage->readPostOutput($dummyTask, 3);
|
|
$this->assertEquals('output2', $output2['output']);
|
|
$this->assertEquals('errors2', $output2['errors']);
|
|
$this->assertEquals(102, $output2['statusCode']);
|
|
|
|
// Attempt to load the default output
|
|
$output = $this->taskStorage->readPostOutput($dummyTask);
|
|
$this->assertEquals('output2', $output['output']);
|
|
$this->assertEquals('errors2', $output['errors']);
|
|
$this->assertEquals(102, $output['statusCode']);
|
|
|
|
// And to load all
|
|
$this->assertEquals([
|
|
['output' => 'output0', 'errors' => 'errors0', 'statusCode' => 100],
|
|
['output' => 'output1', 'errors' => 'errors1', 'statusCode' => 101],
|
|
['output' => 'output2', 'errors' => 'errors2', 'statusCode' => 102]
|
|
], $this->taskStorage->readPostOutput($dummyTask, -1));
|
|
}
|
|
|
|
/**
|
|
* @depends testWriteAndReadTaskPostOutput
|
|
*/
|
|
public function testWriteAndReadTaskPostOutputNotExist()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testWriteAndReadTaskPostOutputNotExist', new EmptyHandler());
|
|
$this->taskStorage->addTask($dummyTask);
|
|
|
|
$this->assertNull($this->taskStorage->readPostOutput($dummyTask));
|
|
}
|
|
|
|
/* ---------------------------------- Data persistence and resets --------- ------------ */
|
|
|
|
/**
|
|
* @depends testAddAndReadTasks
|
|
* @depends testWriteAndReadTaskOutput
|
|
* @depends testWriteAndReadTaskPostOutput
|
|
*/
|
|
public function testReset()
|
|
{
|
|
// Prepare a dummy task
|
|
$dummyTask = new Task('testReset', new EmptyHandler());
|
|
|
|
// Add the task and some output
|
|
$this->assertTrue($this->taskStorage->addTask($dummyTask));
|
|
$this->assertTrue($this->taskStorage->writeTaskOutput($dummyTask, 'output', 'errors', 100));
|
|
$this->assertTrue($this->taskStorage->writePostOutput($dummyTask, 'postOutput', 'errors', 100));
|
|
|
|
// Then reset the data
|
|
$this->assertTrue($this->taskStorage->reset());
|
|
|
|
// And test if the data is actually gone
|
|
$this->assertNull($this->taskStorage->readTaskOutput($dummyTask));
|
|
$this->assertNull($this->taskStorage->readPostOutput($dummyTask));
|
|
$this->expectException(TasksException::class);
|
|
$this->taskStorage->getTaskById('testReset');
|
|
}
|
|
|
|
}
|