public async Task ListAsync_AsExpected()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
ITasksGroup tasksGroup1 = mTasksGroupBuilder.CreateGroup("group1");
IWorkTask workTask1 = mTasksGroupBuilder.CreateTask(tasksGroup1, "task1");
IWorkTask workTask2 = mTasksGroupBuilder.CreateTask(tasksGroup1, "task2");
ITasksGroup tasksGroup2 = mTasksGroupBuilder.CreateGroup("group2");
IWorkTask workTask3 = mTasksGroupBuilder.CreateTask(tasksGroup2, "task3");
database.Entities.Add(tasksGroup1);
database.Entities.Add(tasksGroup2);
List <IWorkTask> workTasks = (await workTaskRepository.ListAsync().ConfigureAwait(false)).ToList();
Assert.Equal(workTask1, workTasks[0]);
Assert.Equal(workTask2, workTasks[1]);
Assert.Equal(workTask3, workTasks[2]);
}
public async Task UpdateTaskAsync_TaskExists_SuccessResponseReturned()
{
IWorkTask taskToUpdate = A.Fake <IWorkTask>();
A.CallTo(() => taskToUpdate.Description).Returns("some-description");
A.CallTo(() => taskToUpdate.ID).Returns("some-id");
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
OperationResult <IWorkTask> getTaskResult = new OperationResult <IWorkTask>(true, taskToUpdate);
A.CallTo(() => tasksGroup.GetTask(A <string> .Ignored)).Returns(getTaskResult);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response = await tasksGroupService.UpdateTaskAsync(
new WorkTaskResource
{
TaskId = taskToUpdate.ID,
Description = taskToUpdate.Description
}).ConfigureAwait(false);
Assert.True(response.IsSuccess);
Assert.Equal(taskToUpdate, response.ResponseObject);
}
public async Task UpdateTaskAsync_TaskExists_TaskUpdated()
{
IWorkTask taskToUpdate = A.Fake <IWorkTask>();
A.CallTo(() => taskToUpdate.Description).Returns("some-description");
A.CallTo(() => taskToUpdate.ID).Returns("some-id");
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
OperationResult <IWorkTask> getTaskResult = new OperationResult <IWorkTask>(true, taskToUpdate);
A.CallTo(() => tasksGroup.GetTask(A <string> .Ignored)).Returns(getTaskResult);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.UpdateTaskAsync(
new WorkTaskResource
{
TaskId = taskToUpdate.ID,
Description = taskToUpdate.Description
}).ConfigureAwait(false);
A.CallTo(() => dbRepository.UpdateAsync(tasksGroup)).MustHaveHappenedOnceExactly();
}
public async Task SaveTaskAsync_DescriptionExistsInTheSameGroup_SaveNotPerformed()
{
IWorkTask workTask = A.Fake <IWorkTask>();
workTask.GroupName = "groupName";
workTask.Description = "description";
IWorkTask workTaskWithSameDescription = A.Fake <IWorkTask>();
workTask.GroupName = workTask.GroupName;
workTask.Description = workTask.Description;
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
tasksGroup.SetGroupName(workTask.GroupName);
A.CallTo(() => tasksGroup.GetAllTasks()).Returns(new List <IWorkTask> {
workTask
});
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.SaveTaskAsync(workTask.GroupName, workTask.Description).ConfigureAwait(false);
A.CallTo(() => dbRepository.UpdateAsync(A <ITasksGroup> .Ignored)).MustNotHaveHappened();
}
public async Task SaveTaskAsync_DescriptionExistsInTheSameGroup_FailResponseReturned()
{
IWorkTask workTask = A.Fake <IWorkTask>();
workTask.GroupName = "groupName";
workTask.Description = "description";
IWorkTask workTaskWithSameDescription = A.Fake <IWorkTask>();
workTask.GroupName = workTask.GroupName;
workTask.Description = workTask.Description;
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
tasksGroup.SetGroupName(workTask.GroupName);
A.CallTo(() => tasksGroup.GetAllTasks()).Returns(new List <IWorkTask> {
workTask
});
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response =
await tasksGroupService.SaveTaskAsync(workTask.GroupName, workTask.Description).ConfigureAwait(false);
Assert.False(response.IsSuccess);
Assert.Null(response.ResponseObject);
}
public async Task AddAsync_TaskGroupNameAlreadyExist_NotAdded()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
TasksGroupRepository tasksGroupRepository =
new TasksGroupRepository(database, NullLogger <TasksGroupRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group1");
ITasksGroup tasksGroupWithSameName = mTasksGroupFactory.CreateGroup("group1");
Assert.NotEqual(tasksGroup.ID, tasksGroupWithSameName.ID);
Assert.False((await tasksGroupRepository.ListAsync().ConfigureAwait(false)).Any());
await tasksGroupRepository.AddAsync(tasksGroup).ConfigureAwait(false);
await tasksGroupRepository.AddAsync(tasksGroupWithSameName).ConfigureAwait(false);
Assert.NotNull(await tasksGroupRepository.FindAsync(tasksGroup.ID).ConfigureAwait(false));
Assert.Null(await tasksGroupRepository.FindAsync(tasksGroupWithSameName.ID).ConfigureAwait(false));
Assert.Single(await tasksGroupRepository.ListAsync().ConfigureAwait(false));
}
public async Task SaveTaskAsync_ValidWorkTaskToAdd_SuccessResponseReturnedAndSavePerformed()
{
IWorkTask validWorkTask = A.Fake <IWorkTask>();
validWorkTask.GroupName = "groupName";
validWorkTask.Description = "validDescription";
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("bla");
tasksGroup.SetGroupName(validWorkTask.GroupName);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup>()
{
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response =
await tasksGroupService.SaveTaskAsync(validWorkTask.GroupName, validWorkTask.Description)
.ConfigureAwait(false);
Assert.True(response.IsSuccess);
Assert.Equal(tasksGroup.GetAllTasks().First(), response.ResponseObject);
A.CallTo(() => dbRepository.UpdateAsync(A <ITasksGroup> .Ignored)).MustHaveHappenedOnceExactly();
}
public async Task UpdateAsync_GroupExists_GroupUpdated()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
TasksGroupRepository tasksGroupRepository =
new TasksGroupRepository(database, NullLogger <TasksGroupRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group1");
database.Entities.Add(tasksGroup);
Assert.Single(await tasksGroupRepository.ListAsync().ConfigureAwait(false));
ITasksGroup tasksGroupWithUpdate = await tasksGroupRepository.FindAsync(tasksGroup.ID).ConfigureAwait(false);
const string newGroupName = "group1_changed";
tasksGroupWithUpdate.SetGroupName(newGroupName);
await tasksGroupRepository.UpdateAsync(tasksGroupWithUpdate).ConfigureAwait(false);
Assert.Single(await tasksGroupRepository.ListAsync().ConfigureAwait(false));
ITasksGroup updatedTasksGroup = await tasksGroupRepository.FindAsync(tasksGroup.ID).ConfigureAwait(false);
Assert.Equal(newGroupName, updatedTasksGroup.Name);
}
public async Task <IResponse <ITasksGroup> > SaveAsync(string groupName)
{
try
{
ITasksGroup tasksGroup = mTaskGroupFactory.CreateGroup(groupName);
if (!mTasksGroupNameValidator.IsNameValid(tasksGroup.Name))
{
return(new FailResponse <ITasksGroup>(
$"Group name '{tasksGroup.Name}' exceeds the maximal group name length: {NameLengths.MaximalGroupNameLength}"));
}
if (!await mTasksGroupRepository.AddAsync(tasksGroup).ConfigureAwait(false))
{
return(new FailResponse <ITasksGroup>(
$"Group name '{tasksGroup.Name}' already exist"));
}
return(new SuccessResponse <ITasksGroup>(tasksGroup));
}
catch (Exception ex)
{
return(new FailResponse <ITasksGroup>($"An error occurred when saving tasks group name {groupName}: {ex.Message}"));
}
}
public async Task <IResponse <ITasksGroup> > RemoveAsync(string id)
{
ITasksGroup groupToRemove = await mTasksGroupRepository.FindAsync(id).ConfigureAwait(false);
if (groupToRemove == null)
{
return(new FailResponse <ITasksGroup>($"Entity group {id} not found. No deletion performed"));
}
if (groupToRemove.Size > 0)
{
StringBuilder idsInGroup = new StringBuilder();
groupToRemove.GetAllTasks().Select(task => task.ID).ToList().ForEach(id => idsInGroup.Append(id).Append(", "));
return(new FailResponse <ITasksGroup>(groupToRemove, $"Entity group {id} cannot be deleted. Please move or remove" +
$" the next work tasks ids: {idsInGroup}"));
}
try
{
await mTasksGroupRepository.RemoveAsync(groupToRemove).ConfigureAwait(false);
return(new SuccessResponse <ITasksGroup>(groupToRemove));
}
catch (Exception ex)
{
return(new FailResponse <ITasksGroup>($"An error occurred when removing tasks group id {id}: {ex.Message}"));
}
}
public async Task AddAsync_WorkTaskAlreadyExist_NotAdded()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
const string tasksGroupName = "group1";
ITasksGroup tasksGroup = mTasksGroupBuilder.CreateGroup(tasksGroupName);
IWorkTask workTask = mTasksGroupBuilder.CreateTask(tasksGroup, "taskDescription");
database.Entities.Add(tasksGroup);
Assert.Single(await workTaskRepository.ListAsync().ConfigureAwait(false));
await workTaskRepository.AddAsync(workTask).ConfigureAwait(false);
Assert.NotNull(await workTaskRepository.FindAsync(workTask.ID).ConfigureAwait(false));
Assert.Single(await workTaskRepository.ListAsync().ConfigureAwait(false));
}
public async Task SaveTaskAsync_InvalidTaskName_FailResponseReturnedAndSaveNotPerformed()
{
const string groupName = "groupName";
IWorkTask workTask = A.Fake <IWorkTask>();
workTask.GroupName = groupName;
workTask.Description = mInvalidTaskName;
OperationResult <IWorkTask> createTaskResult = new OperationResult <IWorkTask>(true, workTask);
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
tasksGroup.SetGroupName(groupName);
A.CallTo(() => tasksGroup.CreateTask(A <string> .Ignored, A <string> .Ignored)).Returns(createTaskResult);
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.ListAsync()).Returns(new List <ITasksGroup> {
tasksGroup
});
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
IResponse <IWorkTask> response =
await tasksGroupService.SaveTaskAsync(workTask.GroupName, workTask.Description).ConfigureAwait(false);
Assert.False(response.IsSuccess);
Assert.Null(response.ResponseObject);
A.CallTo(() => dbRepository.AddAsync(A <ITasksGroup> .Ignored)).MustNotHaveHappened();
}
public async Task LoadDatabase_NextIdToProduceLoadedAsExpected()
{
string tempDirectory = CopyDirectoryToTempDirectory();
try
{
IOptions <DatabaseConfigurtaion> databaseOptions = Options.Create(new DatabaseConfigurtaion()
{
DatabaseDirectoryPath = tempDirectory
});
AppDbContext database = new AppDbContext(
databaseOptions,
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
await database.LoadDatabase().ConfigureAwait(false);
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group");
Assert.Equal("1022", tasksGroup.ID);
}
finally
{
Directory.Delete(tempDirectory, recursive: true);
}
}
public OperationResult <ITasksGroup> CreateGroup(string groupName, ITasksGroupProducer tasksGroupProducer)
{
ITasksGroup taskGroup = tasksGroupProducer.CreateGroup(mIDProducer.ProduceID(), groupName);
mLogger.LogInformation($"New group id {taskGroup.ID} created with name: {taskGroup.Name}");
return(new OperationResult <ITasksGroup>(true, taskGroup));
}
private Task UpdateGroupNamesForAllChildren(ITasksGroup tasksGroup)
{
foreach (IWorkTask workTaskChild in tasksGroup.GetAllTasks())
{
mLogger.LogDebug($"Updating task's group name from {workTaskChild.GroupName} to {tasksGroup.Name}");
workTaskChild.GroupName = tasksGroup.Name;
}
return(Task.CompletedTask);
}
public void Size_NumberOfTasks3()
{
ITasksGroup taskGroup = mTaskGroupFactory.CreateGroup("TestGroup", mTasksGroupProducer).Value;
mTaskGroupFactory.CreateTask(taskGroup, "task1", mWorkTaskProducer);
mTaskGroupFactory.CreateTask(taskGroup, "task2", mWorkTaskProducer);
mTaskGroupFactory.CreateTask(taskGroup, "task3", mWorkTaskProducer);
Assert.Equal(3, taskGroup.Size);
}
public async Task SaveAsync_ValidTasksGroupToAdd_SavePerformed()
{
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("ValidGroupName");
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.SaveAsync(tasksGroup.Name).ConfigureAwait(false);
A.CallTo(() => dbRepository.AddAsync(A <ITasksGroup> .Ignored)).MustHaveHappenedOnceExactly();
}
private bool ValidateUniqueTaskDescription(ITasksGroup tasksGroup, string workTaskDescription)
{
foreach (IWorkTask workTask in tasksGroup.GetAllTasks())
{
if (workTask.Description.Equals(workTaskDescription))
{
return(false);
}
}
return(true);
}
public void IsFinished_HasOpenTasks_False()
{
ITasksGroup taskGroup = mTaskGroupFactory.CreateGroup("TestGroup", mTasksGroupProducer).Value;
mTaskGroupFactory.CreateTask(taskGroup, "task1", mWorkTaskProducer);
IWorkTask task2 = mTaskGroupFactory.CreateTask(taskGroup, "task2", mWorkTaskProducer).Value;
IWorkTask task3 = mTaskGroupFactory.CreateTask(taskGroup, "task3", mWorkTaskProducer).Value;
task2.CloseTask(string.Empty);
task3.CloseTask(string.Empty);
Assert.False(taskGroup.IsFinished);
}
public async Task RemoveAsync_EmptyGroup_RemovePerformed()
{
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("emptyGroup");
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.FindAsync(tasksGroup.ID)).Returns(tasksGroup);
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.RemoveAsync(tasksGroup.ID).ConfigureAwait(false);
A.CallTo(() => dbRepository.RemoveAsync(A <ITasksGroup> .Ignored)).MustHaveHappenedOnceExactly();
}
public async Task UpdateAsync_GroupWithInvalidName_UpdateNotPerformed()
{
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group");
IDbRepository <ITasksGroup> dbRepository = A.Fake <IDbRepository <ITasksGroup> >();
A.CallTo(() => dbRepository.FindAsync(tasksGroup.ID)).Returns(tasksGroup);
TasksGroupService tasksGroupService =
new TasksGroupService(dbRepository, mTasksGroupFactory, NullLogger <TasksGroupService> .Instance);
await tasksGroupService.UpdateGroupAsync(tasksGroup.ID, mInvalidGroupName).ConfigureAwait(false);
A.CallTo(() => dbRepository.UpdateAsync(A <ITasksGroup> .Ignored)).MustNotHaveHappened();
}
public async Task RemoveAsync_EmptyGroup_SuccessResponseReturned()
{
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("emptyGroup");
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.True(response.IsSuccess);
Assert.Equal(tasksGroup, response.ResponseObject);
}
private async Task <ITasksGroup> GetSpecificGroup(string groupNameOrId)
{
mLogger.LogDebug($"Requesting all tasks from group id {groupNameOrId}");
IEnumerable <ITasksGroup> taskGroups = await mTasksGroupService.ListAsync().ConfigureAwait(false);
ITasksGroup group = taskGroups.SingleOrDefault(group => group.ID.Equals(groupNameOrId));
if (group != null)
{
return(group);
}
mLogger.LogTrace($"Could not find tasks by id {groupNameOrId}, searching by name");
return(taskGroups.SingleOrDefault(group => group.Name.Equals(groupNameOrId)));
}
public async Task RemoveAsync_GroupExists_DatabaseIsLoadedAndSavedOnce()
{
IAppDbContext database = A.Fake <IAppDbContext>();
TasksGroupRepository tasksGroupRepository =
new TasksGroupRepository(database, NullLogger <TasksGroupRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group1");
database.Entities.Add(tasksGroup);
await tasksGroupRepository.RemoveAsync(tasksGroup).ConfigureAwait(false);
A.CallTo(() => database.LoadDatabase()).MustNotHaveHappened();
A.CallTo(() => database.SaveCurrentDatabase()).MustHaveHappenedOnceExactly();
}
public async Task RemoveAsync_GroupWithChildren_RemoveNotPerformed()
{
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);
await tasksGroupService.RemoveAsync(tasksGroup.ID).ConfigureAwait(false);
A.CallTo(() => dbRepository.RemoveAsync(A <ITasksGroup> .Ignored)).MustNotHaveHappened();
}
public async Task ListTasksOfSpecificGroupAsync_SuccessStatusCode()
{
const string groupId = "some-id";
ITasksGroup tasksGroup = A.Fake <ITasksGroup>();
A.CallTo(() => tasksGroup.ID).Returns(groupId);
ITasksGroupService tasksGroupService = A.Fake <ITasksGroupService>();
A.CallTo(() => tasksGroupService.ListAsync()).Returns(new List <ITasksGroup>());
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes(tasksGroupService);
using HttpClient httpClient = testServer.CreateClient();
using HttpResponseMessage response = await httpClient.GetAsync($"{MainRoute}/{groupId}").ConfigureAwait(false);
response.EnsureSuccessStatusCode();
}
public async Task FindAsync_IdExist_Found()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
TasksGroupRepository tasksGroupRepository =
new TasksGroupRepository(database, NullLogger <TasksGroupRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group1");
database.Entities.Add(tasksGroup);
Assert.NotNull(await tasksGroupRepository.FindAsync(tasksGroup.ID).ConfigureAwait(false));
}
public async Task UpdateAsync_GroupNotExists_GroupNotAdded()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
TasksGroupRepository tasksGroupRepository =
new TasksGroupRepository(database, NullLogger <TasksGroupRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group1");
await tasksGroupRepository.UpdateAsync(tasksGroup).ConfigureAwait(false);
Assert.Empty(await tasksGroupRepository.ListAsync().ConfigureAwait(false));
}
public async Task UpdateAsync_GroupWithInvalidName_FailResponseReturned()
{
ITasksGroup tasksGroup = mTasksGroupFactory.CreateGroup("group");
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.UpdateGroupAsync(tasksGroup.ID, mInvalidGroupName).ConfigureAwait(false);
Assert.False(response.IsSuccess);
Assert.Null(response.ResponseObject);
}
public async Task FindAsync_IdExist_Found()
{
AppDbContext database = new AppDbContext(
Options.Create(new DatabaseConfigurtaion()),
mObjectSerializer,
mIDProducer,
NullLogger <AppDbContext> .Instance);
WorkTaskRepository workTaskRepository =
new WorkTaskRepository(database, NullLogger <WorkTaskRepository> .Instance);
ITasksGroup tasksGroup = mTasksGroupBuilder.CreateGroup("group1");
IWorkTask workTask = mTasksGroupBuilder.CreateTask(tasksGroup, "taskDescription");
database.Entities.Add(tasksGroup);
Assert.NotNull(await workTaskRepository.FindAsync(workTask.ID).ConfigureAwait(false));
}
