public async Task <Response> RemoveAsync(Guid code)
{
var response = Response.Create();
if (code.Equals(Guid.Empty))
{
return(response.WithBusinessError($"{nameof(code)} is invalid"));
}
var character = await CharacterRepository.FindAsync(code);
if (!character.HasValue)
{
return(response.WithBusinessError($"Character with code {code} not found"));
}
character.Value.Delete();
await CharacterRepository.UpdateAsync(character);
if (!await Uow.CommitAsync())
{
return(response.WithCriticalError("Failed to try to delete the character"));
}
return(response);
}
public async Task Find_given_non_existing_id_returns_null()
{
var builder = new DbContextOptionsBuilder <FuturamaContext>()
.UseInMemoryDatabase(nameof(Find_given_non_existing_id_returns_null));
using (var context = new FuturamaContext(builder.Options))
using (var repository = new CharacterRepository(context))
{
var character = await repository.FindAsync(42);
Assert.Null(character);
}
}
public async Task Find_given_existing_id_returns_mapped_CharacterDTO()
{
using (var connection = new SqliteConnection("DataSource=:memory:"))
{
connection.Open();
var builder = new DbContextOptionsBuilder <FuturamaContext>()
.UseSqlite(connection);
var context = new FuturamaContext(builder.Options);
await context.Database.EnsureCreatedAsync();
var entity = new Character
{
Name = "Name",
Species = "Species",
Planet = "Planet",
Image = "Image",
Actor = new Actor {
Name = "Actor"
},
Episodes = new[] { new EpisodeCharacter {
Episode = new Episode {
Title = "Episode 1"
}
}, new EpisodeCharacter {
Episode = new Episode {
Title = "Episode 2"
}
} }
};
context.Characters.Add(entity);
await context.SaveChangesAsync();
var id = entity.Id;
using (var repository = new CharacterRepository(context))
{
var character = await repository.FindAsync(id);
Assert.Equal("Name", character.Name);
Assert.Equal("Species", character.Species);
Assert.Equal("Planet", character.Planet);
Assert.Equal("Image", character.Image);
Assert.Equal("Actor", character.ActorName);
Assert.Equal(2, character.NumberOfEpisodes);
}
}
}
public async Task FindAsync_given_id_exists_returns_dto()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var entity = new Character
{
Name = "Fry",
Species = "Human",
Planet = "Earth",
Actor = new Actor {
Name = "Billy West"
},
EpisodeCharacters = new[]
{
new EpisodeCharacter {
Episode = new Episode {
Title = "Space Pilot 3000"
}
},
new EpisodeCharacter {
Episode = new Episode {
Title = "The Series Has Landed"
}
}
}
};
context.Characters.Add(entity);
await context.SaveChangesAsync();
var repository = new CharacterRepository(context);
var character = await repository.FindAsync(1);
Assert.Equal(1, character.Id);
Assert.Equal("Fry", character.Name);
Assert.Equal("Human", character.Species);
Assert.Equal("Earth", character.Planet);
Assert.Equal(1, character.ActorId);
Assert.Equal("Billy West", character.ActorName);
Assert.Equal(2, character.NumberOfEpisodes);
}
}
public async Task <Response <Model.Character> > UpdateAsync(UpdateCharacterDto dto)
{
var response = Response <Model.Character> .Create();
if (dto == null)
{
return(response.WithBusinessError("Character is invalid"));
}
var character = await CharacterRepository.FindAsync(dto.Code);
if (!character.HasValue)
{
return(response.WithBusinessError($"Character {dto.Code} not found"));
}
var getHouseResponse = await GetHouseAsync(dto.House, character.Value.House);
if (getHouseResponse.HasError)
{
return(response.WithMessages(getHouseResponse.Messages));
}
var updateResponse = character.Value.Update(dto.Name, dto.Role, dto.School, getHouseResponse, dto.Patronus);
if (updateResponse.HasError)
{
return(response.WithMessages(updateResponse.Messages));
}
await CharacterRepository.UpdateAsync(character);
if (!await Uow.CommitAsync())
{
return(response.WithCriticalError("Failed to try to update the character"));
}
return(response.SetValue(character));
}
