public async Task SaveDatabase_EntitiesSavedAsExpected()
{
string tempDirectory = Directory.CreateDirectory(Guid.NewGuid().ToString()).FullName;
try
{
IOptions <DatabaseConfigurtaion> databaseOptions = Options.Create(new DatabaseConfigurtaion()
{
DatabaseDirectoryPath = tempDirectory
});
AppDbContext database = new AppDbContext(
databaseOptions,
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
ITasksGroup tasksGroup1 = mTasksGroupFactory.CreateGroup("group1");
mTasksGroupFactory.CreateTask(tasksGroup1, "workTask1");
mTasksGroupFactory.CreateTask(tasksGroup1, "workTask2");
ITasksGroup tasksGroup2 = mTasksGroupFactory.CreateGroup("group2");
mTasksGroupFactory.CreateTask(tasksGroup2, "workTask3");
database.Entities.Add(tasksGroup1);
database.Entities.Add(tasksGroup2);
await database.SaveCurrentDatabase().ConfigureAwait(false);
File.Exists(database.DatabaseFilePath);
}
finally
{
Directory.Delete(tempDirectory, recursive: true);
}
}
public async Task <IResponse <IWorkTask> > SaveTaskAsync(string taskGroupIdentifier, string workTaskDescription)
{
try
{
ITasksGroup tasksGroup =
(await FindTasksGroupsByConditionAsync(group => group.ID == taskGroupIdentifier)
.ConfigureAwait(false))
.FirstOrDefault();
if (tasksGroup == null && taskGroupIdentifier != null)
{
tasksGroup = (await FindTasksGroupsByConditionAsync(group =>
string.Equals(group.Name, taskGroupIdentifier, StringComparison.OrdinalIgnoreCase))
.ConfigureAwait(false))
.FirstOrDefault();
}
if (tasksGroup == null)
{
return(new FailResponse <IWorkTask>($"Tasks group {taskGroupIdentifier} does not exist"));
}
if (!ValidateUniqueTaskDescription(tasksGroup, workTaskDescription))
{
return(new FailResponse <IWorkTask>($"Tasks group {tasksGroup.Name} " +
$"has already work task with description {workTaskDescription}"));
}
IWorkTask workTask = mTaskGroupFactory.CreateTask(tasksGroup, workTaskDescription);
if (!mWorkTaskNameValidator.IsNameValid(workTask.Description))
{
return(new FailResponse <IWorkTask>($"Task description'{workTask.Description}' is invalid"));
}
await mTasksGroupRepository.UpdateAsync(tasksGroup).ConfigureAwait(false);
return(new SuccessResponse <IWorkTask>(workTask));
}
catch (Exception ex)
{
return(new FailResponse <IWorkTask>($"An error occurred when saving work task {taskGroupIdentifier}: {ex.Message}"));
}
}
public async Task RemoveAsync_GroupWithChildren_FailResponseReturned()
{
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group");
mTasksGroupFactory.CreateTask(tasksGroup, "task1");
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.FindAsync(tasksGroup.ID)).Returns(tasksGroup);
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <ITasksGroup> response = await tasksGroupService.RemoveAsync(tasksGroup.ID).ConfigureAwait(false);
Assert.False(response.IsSuccess);
Assert.Equal(tasksGroup, response.ResponseObject);
}
public async Task AddAsync_WorkTaskNotExist_Success()
{
string tempDirectory = CopyDirectoryToTempDirectory(mNewDatabaseDirectoryPath);
try
{
DatabaseConfigurtaion databaseConfigurtaion = new DatabaseConfigurtaion
{
DatabaseDirectoryPath = tempDirectory
};
AppDbContext database = new AppDbContext(
Options.Create(databaseConfigurtaion),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupBuilder.CreateGroup("group1");
database.Entities.Add(tasksGroup);
IWorkTask workTask = mTasksGroupBuilder.CreateTask(tasksGroup, "worktask1");
await workTaskRepository.AddAsync(workTask).ConfigureAwait(false);
Assert.NotNull(await workTaskRepository.FindAsync(workTask.ID).ConfigureAwait(false));
Assert.Single(await workTaskRepository.ListAsync().ConfigureAwait(false));
}
finally
{
Directory.Delete(tempDirectory, recursive: true);
}
}
