public void ExecouteTest()
{
//Arrange
const TypeOfTask typeOfTask = TypeOfTask.Video;
var pipelineMediator = new Mock <IStepMediator>();
var webClient = new Mock <IEncodeWebClient>();
var pipelineStep = new GettingEntityStep(pipelineMediator.Object, webClient.Object);
var stepData = new TaskStepData()
{
TypeOfTask = typeOfTask
};
var encodeData = new Mock <IEncodeData>();
pipelineMediator.Setup(m => m.Send(stepData, pipelineStep));
webClient.Setup(m => m.GetEntity(typeOfTask)).Returns(encodeData.Object);
pipelineStep.SetData(stepData);
//Act
pipelineStep.Execute(It.IsAny <CancellationTokenSourceWrapper>());
//Assert
pipelineMediator.Verify(m => m.Send(It.Is <GettingEntityStepData>(d => d.EncodeData == encodeData.Object &&
d.EncoderState == EncoderState.Completed), pipelineStep));
}
public async Task <ObservableCollection <CalendarTask> > GetTasksByTypeAsync(TypeOfTask typeOfTask)
{
ObservableCollection <CalendarTask> result = null;
switch (typeOfTask)
{
case TypeOfTask.SingleUseTask:
result = await GetSingleUseTasksAsync();
break;
case TypeOfTask.EveryDayTask:
result = await GetEveryDayTasksAsync();
break;
case TypeOfTask.EveryMonthTask:
result = await GetEveryMonthTasksAsync();
break;
case TypeOfTask.EveryYearTask:
result = await GetEveryYearTasksAsync();
break;
}
return(result);
}
public void ExecuteMethodTest()
{
//Arrange
const string id = "id";
const string resource = "resource";
const TypeOfTask type = TypeOfTask.Video;
var taskData = new TaskData()
{
Id = id,
Resource = resource,
Type = type
};
var mediator = new Mock <IStepMediator>();
var webClient = new Mock <IEncodeWebClient>();
var pipelineStep = new GetTaskStep(mediator.Object, webClient.Object);
webClient.Setup(m => m.GetTask()).Returns(taskData);
//Act
pipelineStep.Execute(It.IsAny <CancellationTokenSourceWrapper>());
//Assert
webClient.Verify(m => m.GetTask(), Times.Once());
mediator.Verify(m => m.Send(It.Is <TaskStepData>(d => d.Resource == resource &&
d.TypeOfTask == type &&
d.TaskId == id &&
d.EncoderState == EncoderState.Completed), pipelineStep), Times.Once());
}
public IEncodeData GetEntity(TypeOfTask typeOfTask)
{
IRestRequest request = _restHelper.EncodeDataRequestCreate(Resource);
IRestResponse response = _restHelper.GetResponse(request);
IEncodeData encodeData = _restHelper.CreateEncodeData(response, typeOfTask);
return encodeData;
}
public Task(int id, string title, TypeOfTask type,int prior, DateTime date, decimal multiplier)
{
Id = id;
Title = title;
Type = type;
Prior = prior;
Date = date;
Multiplier = multiplier;
}
public IEncodeData EncodeDataDeserialize(IRestResponse response, TypeOfTask typeOfTask)
{
switch (typeOfTask)
{
case TypeOfTask.Video:
return(_deserializer.Deserialize <VideoEncodeData>(response));
case TypeOfTask.Screenshot:
return(_deserializer.Deserialize <ScreenshotEncodeData>(response));
default:
return(null);
}
}
public IEncodeData EncodeDataDeserialize(IRestResponse response, TypeOfTask typeOfTask)
{
switch (typeOfTask)
{
case TypeOfTask.Video:
return _deserializer.Deserialize<VideoEncodeData>(response);
case TypeOfTask.Screenshot:
return _deserializer.Deserialize<ScreenshotEncodeData>(response);
default:
return null;
}
}
public TaskData GetTaskData(IRestResponse response)
{
EncodeTaskData encodeTaskData = _deserializer.EncodeTaskDataDeserealize(response);
string resource = GetHeaderValue(response, HeaderParameters.Location);
string contentType = GetHeaderValue(response, HeaderParameters.ContentType);
TypeOfTask type = GetTypeOfTask(contentType);
var taskData = new TaskData
{
Id = encodeTaskData.TaskId,
Resource = resource,
Type = type
};
return(taskData);
}
public void CreateEncodeDataTest()
{
//Arrange
const TypeOfTask typeOfTask = TypeOfTask.Video;
var data = new Mock <IEncodeData>();
var mockResponse = new Mock <IRestResponse>();
_deserializer.Setup(m => m.EncodeDataDeserialize(mockResponse.Object, typeOfTask)).Returns(data.Object);
//Act
var encodeData = _helper.CreateEncodeData(mockResponse.Object, typeOfTask);
//Assert
Assert.AreEqual(data.Object, encodeData);
}
public void GetEntityTest()
{
//Arrange
const TypeOfTask typeOfTask = TypeOfTask.Video;
var data = new Mock <IEncodeData>();
_restHelper.Setup(m => m.EncodeDataRequestCreate(Resource)).Returns(_request.Object);
_restHelper.Setup(m => m.CreateEncodeData(_response.Object, typeOfTask)).Returns(data.Object);
//Act
var encodeData = _encodeWebClient.GetEntity(typeOfTask);
//Assert
Assert.AreEqual(data.Object, encodeData);
}
public void ScreenshotDataDeserializeTest()
{
//Arrange
const TypeOfTask typeOfType = TypeOfTask.Screenshot;
var deserializer = new Mock <IDeserializer>();
var response = new Mock <IRestResponse>();
var encodeDeserializer = new EncodeDeserializer(deserializer.Object);
var data = new ScreenshotEncodeData();
deserializer.Setup(m => m.Deserialize <ScreenshotEncodeData>(response.Object)).Returns(data);
//Act
var encodeData = encodeDeserializer.EncodeDataDeserialize(response.Object, typeOfType);
//Assert
Assert.AreEqual(data, encodeData);
}
public async Task AddAsync(TypeOfTask typeOfTask, string name, DateTime?date, PriorityOfTask priorityOfTask = PriorityOfTask.Neutral, string timeOfBegin = null, string timeOfEnd = null)
{
ITasksCreator taskFactory = null;
switch (typeOfTask)
{
case TypeOfTask.SingleUseTask:
taskFactory = new SingleUseTaskCreator();
break;
case TypeOfTask.EveryDayTask:
taskFactory = new EveryDayTaskCreator();
break;
case TypeOfTask.EveryMonthTask:
taskFactory = new EveryMonthTaskCreator();
break;
case TypeOfTask.EveryYearTask:
taskFactory = new EveryYearTaskCreator();
break;
}
await Task.Run(() => calendarTasks.Add(taskFactory.Create(name, date, priorityOfTask, timeOfBegin, timeOfEnd)));
}
public IEncodeData CreateEncodeData(IRestResponse restResponse, TypeOfTask typeOfTask)
{
IEncodeData encodeData = _deserializer.EncodeDataDeserialize(restResponse, typeOfTask);
return(encodeData);
}
public static TypeOfTaskDTO Map(TypeOfTask entity) => new TypeOfTaskDTO
{
Id = entity.Id,
Name = entity.Name
};
public IEncodeData CreateEncodeData(IRestResponse restResponse, TypeOfTask typeOfTask)
{
IEncodeData encodeData = _deserializer.EncodeDataDeserialize(restResponse, typeOfTask);
return encodeData;
}
public WorkerTask(TypeOfTask taskType, int roomId)
{
Type = taskType;
TimeIssued = DateTime.Now;
RoomId = roomId;
}
