public void ProcessTaskTest_WorksFine()
{
// arrange
var inputFilePath = "inputPath";
var outputFilePath = "outputPath";
var filePaths = new FilePaths
{
InputFilePath = inputFilePath,
OutputFilePath = outputFilePath
};
var taskNumber = 1;
var resetEvent = new ManualResetEventSlim();
Func <int, bool> callback = number => true;
var taskSyncParams = new TaskSynchronizationParams
{
TaskNumber = taskNumber,
ResetEvent = resetEvent,
CanProceedFunc = callback
};
var startPosition = 10;
var readBytes = 200;
var fileChunk = new FileChunk
{
StartPosition = startPosition,
ReadBytes = readBytes
};
var operation = new Mock <IOperation>();
var gzipTask = new GZipTask(filePaths, taskSyncParams, fileChunk, operation.Object);
var fileChunkRead = new byte[] { 0, 100, 120, 210, 255 };
var fileChunkProcessed = new byte[] { 10, 11, 12 };
// expectations
fileManager.Setup(_ => _.ReadFileChunk(inputFilePath, startPosition, readBytes))
.Returns(fileChunkRead);
operation.Setup(_ => _.ProcessChunk(fileChunkRead))
.Returns(fileChunkProcessed);
fileManager.Setup(_ => _.WriteFileChunk(outputFilePath, fileChunkProcessed))
.Verifiable();
// act
target.ProcessTask(gzipTask);
// assert
fileManager.VerifyAll();
}
public void CreateTest_WorksFine()
{
// arrange
var pathParams = new FilePaths();
var syncParams = new TaskSynchronizationParams();
var chunk = new FileChunk();
var operation = new Mock <IOperation>();
var expected = new GZipTask(pathParams, syncParams, chunk, operation.Object);
// act
var actual = target.Create(pathParams, syncParams, chunk, operation.Object);
// assert
actual.Should().BeEquivalentTo(expected);
}
public void NotEmpty_WorksFine_QueueNotEmpty()
{
// arrange
var pathParams = new FilePaths();
var syncParams = new TaskSynchronizationParams();
var chunk = new FileChunk();
var operation = new Mock <IOperation>();
var task = new GZipTask(pathParams, syncParams, chunk, operation.Object);
target.Queue.Enqueue(task);
// act
var actual = target.NotEmpty();
// assert
Assert.True(actual);
}
public void EnqueueTest_WorksFine()
{
// arrange
var pathParams = new FilePaths();
var syncParams = new TaskSynchronizationParams();
var chunk = new FileChunk();
var operation = new Mock <IOperation>();
var task = new GZipTask(pathParams, syncParams, chunk, operation.Object);
GZipTask actual;
// act
target.Enqueue(task);
target.Queue.TryDequeue(out actual);
// assert
Assert.Equal(task, actual);
}
public void CreateTest_WorksFine()
{
// arrange
var taskNumber = 12;
var resetEvent = new ManualResetEventSlim(false);
Func <int, bool> func = (param) => { return(true); };
var expected = new TaskSynchronizationParams
{
TaskNumber = taskNumber,
ResetEvent = resetEvent,
CanProceedFunc = func
};
// act
var actual = target.Create(taskNumber, resetEvent, func);
// assert
actual.Should().BeEquivalentTo(expected);
}
public void CreateTasksTest_WorksFine()
{
// arrange
var inputFilePath = "path";
var filePaths = new FilePaths
{
InputFilePath = inputFilePath
};
var operation = new Mock <IOperation>();
var chunk = new FileChunk {
StartPosition = 0, ReadBytes = 10
};
var fileChunks = new List <FileChunk> {
chunk
};
var taskNumber = 0;
var syncParams = new TaskSynchronizationParams
{
TaskNumber = taskNumber,
ResetEvent = target.ResetEvent,
CanProceedFunc = target.CanProceed
};
var gZipTask = new GZipTask(filePaths, syncParams, chunk, operation.Object);
// expectations
operation.Setup(_ => _.SplitFile(inputFilePath)).Returns(fileChunks);
taskSyncParamsFactory.Setup(_ => _.Create(taskNumber, target.ResetEvent, target.CanProceed)).Returns(syncParams);
gzipTaskFactory.Setup(_ => _.Create(filePaths, syncParams, chunk, operation.Object)).Returns(gZipTask);
taskQueue.Setup(_ => _.Enqueue(gZipTask));
// act
target.CreateTasks(filePaths, operation.Object);
// assert
operation.VerifyAll();
}
public void ExecuteTest()
{
// arrange
Action <Exception> exceptionHandler = (ex) => { };
var filePath = new FilePaths();
var syncParams = new TaskSynchronizationParams();
var chunk = new FileChunk();
var operation = new Mock <IOperation>();
var gZipTask = new GZipTask(filePath, syncParams, chunk, operation.Object);
// expectation
taskQueue.SetupSequence(_ => _.NotEmpty())
.Returns(true)
.Returns(false);
taskQueue.Setup(_ => _.TryDequeue(out gZipTask));
taskProcessLogic.Setup(_ => _.ProcessTask(gZipTask));
// act
target.Execute(exceptionHandler);
// assert
taskProcessLogic.VerifyAll();
}
