public void UpdateTimer_update_Timer_and_return_trueAsJson()
{
var project = insertAndgetProject(getRandomProject());
var requirement = insertAndgetRequirement(getRandomRequirement(project));
var taskList = insertTasksAndgetList(requirement, 1);
var task = taskList.OrderBy(x => x.Id).FirstOrDefault();
var oldTimer = insertAndGetTimer(getRandomTimer(task));
var randonSecons = r.Next(90000);
var newTimer = new DTOTimer
{
TaskId = oldTimer.TaskId,
Id = oldTimer.Id,
TimeInSeconds = randonSecons
};
// Arrange
var taskController = Container.createTasksController();
// Act
var result = taskController.WriteTimer(newTimer) as JsonResult;
// Assert
var resultAsInt = result.Data as int?;
var expectedNewTimer = Container.createIDbContext().Timers.Where(x => x.TaskId == newTimer.TaskId).ToList().FirstOrDefault();
Assert.IsTrue(result != null && resultAsInt.Value > 0, "It is not returning a json result");
Assert.IsTrue(expectedNewTimer != null, "The record does not exist.");
Assert.IsTrue
(
newTimer.TimeInSeconds == expectedNewTimer.TimeInSeconds,
"The record was not updated."
);
}
// Timer =================================================
/// <summary>
/// Insert or update a timer in db.
/// </summary>
/// <param name="timer">Timer to be inserted or updated.</param>
/// <returns>The id of the inserted/updated record.</returns>
public int writeTimer(DTOTimer timer)
{
using (DbContext)
{
int ret;
// True if timer exist. Otherwise false.
bool timerAlreadyExist = taskRepository.timerExist(DbContext, timer);
// Update timer if it already exist
if (timerAlreadyExist)
{
taskRepository.updateTimer(DbContext, timer);
DbContext.SaveChanges();
ret = timer.Id;
}
// Insert timer if it does not exist
else
{
ret = taskRepository.insertTimerAndSaveChanges(DbContext, timer);
}
// Return inserted/updated record
return(ret);
}
}
public void InsertTimer_insert_Timer_and_return_idAsJson()
{
var project = insertAndgetProject(getRandomProject());
var requirement = insertAndgetRequirement(getRandomRequirement(project));
var taskList = insertTasksAndgetList(requirement, 3);
var taskId = taskList.OrderBy(x => x.Id).FirstOrDefault().Id;
var randonSeconds = r.Next(90000);
DTOTimer timer = new DTOTimer
{
TimeInSeconds = randonSeconds,
TaskId = taskId
};
// Arrange
var taskController = Container.createTasksController();
// Act
var result = taskController.WriteTimer(timer) as JsonResult;
// Assert
var resultAsInt = result.Data as int?;
var expectedTimer = Container.createIDbContext().Timers.Where(x => x.TaskId == taskId).ToList().FirstOrDefault();
Assert.IsTrue(result != null, "It is not returning a json result");
Assert.IsTrue(expectedTimer != null, "The record was not inserted.");
Assert.IsTrue
(
timer.TimeInSeconds == expectedTimer.TimeInSeconds &&
timer.TaskId == expectedTimer.TaskId,
"The record inserted does not correspond with the one created."
);
}
public DTOTimer insertAndGetTimer(DTOTimer timer)
{
int id = Container.createITaskRepository().insertTimerAndSaveChanges(Container.createIDbContext(), timer);
timer.Id = id;
return(timer);
}
// Timer ====================================================
/// <summary>
/// Check if the timer record exist in db.
/// </summary>
/// <param name="context">context of the database.</param>
/// <param name="timer">Timer record to check for existence.</param>
/// <returns>True if timer record exist. Otherwise false.</returns>
public bool timerExist(IDbContext context, DTOTimer timer)
{
var query = getAll <Timer>(context)
.Where(x => x.TaskId == timer.TaskId)
.Any();
return(query);
}
/// <summary>
/// Insert a timer and save changes.
/// </summary>
/// <param name="context">Context of the database.</param>
/// <param name="timer">Timer DTO to be inserted.</param>
/// <returns>The id of the inserted record.</returns>
public int insertTimerAndSaveChanges(IDbContext context, DTOTimer timer)
{
// Throw exception if fk is invalid
throwExceptionIfForeignKeyInvalid(timer.TaskId);
// Get entity from dto
var entity = Mapper.mapEntityTimer(timer);
return(insertAndSaveChanges <Timer>(context, entity));
}
// Timer
public DTOTimer getRandomTimer(DTOTask task)
{
var randonSeconds = getRLong();
DTOTimer timer = new DTOTimer
{
TimeInSeconds = randonSeconds,
TaskId = task.Id
};
return(timer);
}
/// <summary>
/// Update timer.
/// </summary>
/// <param name="context">Context of the database.</param>
/// <param name="timer">Timer DTO to be updated.</param>
public void updateTimer(IDbContext context, DTOTimer timer)
{
// Get old entity
var oldEntity = context.Timers.Where(x => x.Id == timer.Id).FirstOrDefault();
// Get new entity
var newEntity = Mapper.mapEntityTimer(timer);
oldEntity.TaskId = oldEntity.TaskId;
// Update changes
update <Timer>(context, newEntity, oldEntity);
}
/// <summary>
/// Delete a timer entity.
/// </summary>
/// <param name="context">Context of the database.</param>
/// <param name="timer">Timer DTO to be deleted</param>
public void deleteTimer(IDbContext context, DTOTimer timer)
{
// Delete entity
delete <Timer>(context, Mapper.mapEntityTimer(timer));
}
public ActionResult WriteTimer(DTOTimer timer)
{
int id = taskService.writeTimer(timer);
return(Json(id));
}
/// <summary>
/// Map Entity timer to DTO Complete.
/// </summary>
/// <param name="timer">timer DTO to map from.</param>
/// <returns>A Entity timer.</returns>
public Timer mapEntityTimer(DTOTimer timer)
{
return(map <Timer>(timer));
}
