private bool VerifyDuplication(ManagerTaskModel saveThis)
{
var allMTasks = _repositoryInstance.GetAll(); //TODO change for production will bring the all task in data base
var match = allMTasks.FirstOrDefault(temp => temp.Name == saveThis.Name) != null;
return(match);
}
public void ValidateTask_Model_DefaultConstructor_ReturnsFalse()
{
var task = new ManagerTaskModel();
var result = SystemUnderTest.IsValid(task);
Assert.False(result, "Should not pass validation.");
}
/// <summary>
/// From Model to Data Entity
/// </summary>
/// <param name="fromValue"></param>
/// <param name="toValue"></param>
public void Adapt(ManagerTaskModel fromValue, ManagerTask toValue)
{
Guard.Against.Null(fromValue, nameof(fromValue));
Guard.Against.Null(toValue, nameof(toValue));
toValue.Id = fromValue.Id;
toValue.CreationCount = fromValue.CreationCount;
toValue.ModificationCount = fromValue.ModificationCount;
}
/// <summary>
/// From Entity to Model
/// </summary>
/// <param name="expected"></param>
/// <param name="actual"></param>
public static void AssertAreEqual(ManagerTask expected, ManagerTaskModel actual)
{
Assert.Equal(expected.Id, actual.Id);
Assert.Equal <string>(expected.Name, actual.Name);
Assert.Equal <string>(expected.Status, actual.Status);
Assert.Equal <int>(expected.CreationCount, actual.CreationCount);
Assert.Equal <int>(expected.ModificationCount, actual.ModificationCount);
DateTimeAssertAreEqual(expected.TimeStamp, actual.TimeStamp, TimeSpan.FromMinutes(0.1));
}
/// <summary>
/// From database Entity to model
/// </summary>
/// <param name="fromValue"></param>
/// <param name="toValue"></param>
public void Adapt(ManagerTask fromValue, ManagerTaskModel toValue)
{
Guard.Against.Null(fromValue, nameof(fromValue));
Guard.Against.Null(toValue, nameof(toValue));
toValue.Id = fromValue.Id;
toValue.Name = fromValue.Name;
toValue.Status = fromValue.Status;
toValue.TimeStamp = fromValue.TimeStamp;
toValue.CreationCount = fromValue.CreationCount;
toValue.ModificationCount = fromValue.ModificationCount;
}
public void WhenSaveIsCalledThenIdIsNotZeroAndIsInRepository()
{
ManagerTaskModel saveThis = UnitTestUtility.GetManagerTaskAsModel_New_taskJob();
SystemUnderTest.Save(saveThis);
Assert.NotEqual(0, saveThis.Id);
var actual = MtRepositoryInstance.GetById(saveThis.Id);
Assert.NotNull(actual);
}
public void AdaptTaskFromDbToManagerTaskModel()
{
// Arrange
var fromValue = UnitTestUtility.GetManagerTaskAsEntityDb_TaskJob();
var toValue = new ManagerTaskModel();
// Act
SystemUnderTest.Adapt(fromValue, toValue);
// Assert
UnitTestUtility.AssertAreEqual(fromValue, toValue);
}
/// <summary>
/// Mock
/// </summary>
/// <returns></returns>
public static ManagerTaskModel GetTaskOnModelToEntity()
{
var info = new ManagerTaskModel()
{
Name = "Minha task on model",
Status = TaskManagerConstant.Open,
CreationCount = 1,
TimeStamp = DateTime.UtcNow,
ModificationCount = 2
};
return(info);
}
public static ManagerTaskModel GetManagerTaskAsModel_New_taskJob_unique()
{
var info = new ManagerTaskModel()
{
Name = "Create a new task this for work unique",
Status = TaskManagerConstant.Open,
ModificationCount = 1,
TimeStamp = DateTime.UtcNow,
CreationCount = 1,
};
return(info);
}
public void Adapt(IEnumerable <ManagerTask> fromValues, IList <ManagerTaskModel> toValues)
{
Guard.Against.Null(fromValues, nameof(fromValues));
ManagerTaskModel toValue;
foreach (var fvalue in fromValues)
{
toValue = new ManagerTaskModel();
Adapt(fvalue, toValue);
toValues.Add(toValue);
}
}
public void GetPresidentById()
{
PopulateWithTaskManagerData();
ManagerTask expected = GetManagerTaskDbByNameFromTestRepository("Create a new task this for work");
ManagerTaskModel actual = SystemUnderTest.GetTaskById(expected.Id);
Assert.NotNull(actual);
Assert.Equal(expected.Id, actual.Id);
Assert.Equal(expected.Name, actual.Name);
}
/// <summary>
/// Get Data From ManagerTask on Db and send to Model
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ManagerTaskModel GetTaskById(int id)
{
Guard.Against.Null(id, nameof(id));
Guard.Against.Zero(id, nameof(id));
var match = _repositoryInstance.GetById(id);
if (match == null)
{
return(null);
}
var totask = new ManagerTaskModel();
_adapter.Adapt(match, totask);
return(totask);
}
public void WhenSaveIsCalledUsingATaskWithAnInvalidIdThenAnExceptionIsThrown()
{
ManagerTaskModel presidentWithFakeId = UnitTestUtility.GetTaskOnModelToEntity();
presidentWithFakeId.Id = 1234123123;
bool haveAnException = false;
try
{
SystemUnderTest.Save(presidentWithFakeId);
}
catch (Exception e)
{
haveAnException = true;
Assert.Contains(TaskManagerConstant.MsgColdNotLocateATaskWithId, e.Message);
}
Assert.True(haveAnException, "Didn't get exception");
}
public IActionResult CreateTask([FromBody] ManagerTaskModel taskModel)
{
if (taskModel == null)
{
return(BadRequest());
}
if (!_validator.IsValid(taskModel))
{
return(BadRequest());
}
bool isCreateNew = false;
var toValue = _service.GetTaskById(taskModel.Id);
if (taskModel.Id == IdForCreateNewManagerTaskModel)
{
isCreateNew = true;
}
else
{
if (toValue == null)
{
return(new BadRequestObjectResult($"Unknown task id '{taskModel.Id}'."));
}
}
_service.Save(taskModel);
//Need revew result and return add unit test
if (isCreateNew)
{
return(CreatedAtRoute("GetTask", new { id = taskModel.Id }));
}
return(NoContent());
}
/// <summary>
/// Save with validation of task duplication
/// </summary>
/// <param name="saveThis"></param>
public void Save(ManagerTaskModel saveThis)
{
Guard.Against.Null(saveThis, nameof(saveThis));
if (_validatorInstance.IsValid(saveThis) == false)
{
throw new InvalidOperationException("Task is invalid.");
}
ManagerTask toValue;
if (saveThis.Id != 0)
{
toValue = _repositoryInstance.GetById(saveThis.Id);
if (toValue == null)
{
throw new InvalidOperationException(TaskManagerConstant.MsgColdNotLocateATaskWithId + $" '{saveThis.Id}'.");
}
}
var match = VerifyDuplication(saveThis);
if (match)
{
throw new InvalidOperationException(TaskManagerConstant.MsgCanNotSaveDuplicateTask);
}
toValue = new ManagerTask(saveThis.Name, saveThis.Status);
_adapter.Adapt(saveThis, toValue);
_repositoryInstance.Save(toValue);
saveThis.Id = toValue.Id;
}
public IActionResult Put([FromBody] ManagerTaskModel taskModel)
{
if (taskModel == null)
{
return(BadRequest());
}
if (!_validator.IsValid(taskModel))
{
return(BadRequest());
}
bool isCreateNew = false || taskModel.Id == IdForCreateNewManagerTaskModel;
var toValue = _service.GetTaskById(taskModel.Id);
if (toValue == null)
{
return(new BadRequestObjectResult($"Unknown task id '{taskModel.Id}'."));
}
_service.Save(taskModel);
return(NoContent());
}
private void ModifyTaskValues(ManagerTaskModel existingPresident)
{
existingPresident.Name = "Lollipop";
existingPresident.Status = TaskManagerConstant.Complete;
}
