public async Task HandleAsync_GivenEmptyDatabase_ShouldNotThrowAndNotCallJikan()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var jikanServiceBuilder = new JikanServiceBuilder();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = 1
};
// When
var action = handler.Awaiting(x => x.HandleAsync(command));
// Then
using (new AssertionScope())
{
await action.Should().NotThrowAsync();
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(It.IsAny <long>()), Times.Never);
}
}
public async Task HandleAsync_GivenExceptionFromJikan_ShouldThrowAndCallJikan()
{
// Given
const int malId = 1;
var dbContext = InMemoryDbProvider.GetDbContext();
var jikanServiceBuilder = new JikanServiceBuilder().WithGetAnimeThrowing();
var anime = new AnimeBuilder()
.WithMalId(malId)
.Build();
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
var action = handler.Awaiting(x => x.HandleAsync(command));
// Then
using (new AssertionScope())
{
await action.Should().ThrowExactlyAsync <JikanRequestException>();
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
public async Task HandleAsync_GivenCorrectSeason_ShouldUpdateSeasonId()
{
// Given
const int malId = 1;
var returnedAnime = new Anime
{
Season = Season.Winter,
Year = 2000
};
var jikanServiceBuilder = new JikanServiceBuilder().WithAnimeReturned(returnedAnime);
var dbContext = InMemoryDbProvider.GetDbContext();
var anime = new AnimeBuilder()
.WithMalId(malId)
.WithTitle("PreUpdateTitle")
.WithAbout("PreUpdateAbout")
.WithEnglishTitle("PreUpdateEnglish")
.WithJapaneseTitle("PreUpdateJapaneses")
.WithImageUrl("PreUpdateImage")
.WithAnimeStatus(x => x.WithName("Airing"))
.WithAnimeType(x => x.WithId(Domain.Entities.AnimeTypeId.TV))
.WithPopularity(0)
.Build();
var season = new SeasonBuilder()
.WithId(10)
.WithYear(2000)
.WithName("Winter")
.Build();
await dbContext.AddAsync(anime);
await dbContext.AddAsync(season);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
await handler.HandleAsync(command);
// Then
var updatedAnime = await dbContext.Animes.FirstAsync(x => x.MalId == malId);
using (new AssertionScope())
{
updatedAnime.SeasonId.Should().Be(10);
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
public async Task PublishAnimeUpdateAsync(UpdateAnimeMessage updateAnimeMessage, int delayInSeconds = 0)
{
var sendMessageRequest = new SendMessageRequest
{
MessageBody = JsonSerializer.Serialize(updateAnimeMessage),
QueueUrl = _queueUrl,
DelaySeconds = delayInSeconds
};
await _sqsService.SendMessageAsync(sendMessageRequest);
}
public async Task HandleAsync_GivenPlaceholderOrEmptyImageUrl_ShouldUpdateWithEmpty(string imageUrl)
{
// Given
const int malId = 1;
var returnedAnime = new Anime
{
Images = new ImagesSet
{
JPG = new Image {
ImageUrl = imageUrl
}
}
};
var jikanServiceBuilder = new JikanServiceBuilder().WithAnimeReturned(returnedAnime);
var dbContext = InMemoryDbProvider.GetDbContext();
var anime = new AnimeBuilder()
.WithMalId(malId)
.WithTitle("PreUpdateTitle")
.WithAbout("PreUpdateAbout")
.WithEnglishTitle("PreUpdateEnglish")
.WithJapaneseTitle("PreUpdateJapaneses")
.WithImageUrl("PreUpdateImage")
.WithPopularity(0)
.Build();
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
await handler.HandleAsync(command);
// Then
var updatedAnime = await dbContext.Animes.FirstAsync(x => x.MalId == malId);
using (new AssertionScope())
{
updatedAnime.ImageUrl.Should().BeEmpty();
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
public async Task HandleAsync_GivenUnknownStatusAndType_ShouldNotUpdateStatusAndType()
{
// Given
const int malId = 1;
var returnedAnime = new Anime
{
Type = "test type",
Status = "test status"
};
var jikanServiceBuilder = new JikanServiceBuilder().WithAnimeReturned(returnedAnime);
var dbContext = InMemoryDbProvider.GetDbContext();
var anime = new AnimeBuilder()
.WithMalId(malId)
.WithTitle("PreUpdateTitle")
.WithAbout("PreUpdateAbout")
.WithEnglishTitle("PreUpdateEnglish")
.WithJapaneseTitle("PreUpdateJapaneses")
.WithImageUrl("PreUpdateImage")
.WithAnimeStatus(x => x.WithId(Domain.Entities.AnimeStatusId.CurrentlyAiring))
.WithAnimeType(x => x.WithId(Domain.Entities.AnimeTypeId.TV))
.WithPopularity(0)
.Build();
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
await handler.HandleAsync(command);
// Then
var updatedAnime = await dbContext.Animes.FirstAsync(x => x.MalId == malId);
using (new AssertionScope())
{
updatedAnime.TypeId.Should().Be(Domain.Entities.AnimeTypeId.TV);
updatedAnime.StatusId.Should().Be(Domain.Entities.AnimeStatusId.CurrentlyAiring);
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
public async Task HandleAsync_GivenManyTitleSynonyms_ShouldUpdateWithJoinedString()
{
// Given
const int malId = 1;
var returnedSynonyms = new List <string> {
"Synonym 1", "Synonym 2", "Synonym 3"
};
var returnedAnime = new Anime
{
TitleSynonyms = returnedSynonyms
};
var jikanServiceBuilder = new JikanServiceBuilder().WithAnimeReturned(returnedAnime);
var dbContext = InMemoryDbProvider.GetDbContext();
var anime = new AnimeBuilder()
.WithMalId(malId)
.WithTitle("PreUpdateTitle")
.WithAbout("PreUpdateAbout")
.WithEnglishTitle("PreUpdateEnglish")
.WithJapaneseTitle("PreUpdateJapaneses")
.WithImageUrl("PreUpdateImage")
.WithPopularity(0)
.Build();
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
await handler.HandleAsync(command);
// Then
var updatedAnime = await dbContext.Animes.FirstAsync(x => x.MalId == malId);
using (new AssertionScope())
{
updatedAnime.TitleSynonyms.Should().Be("Synonym 1;Synonym 2;Synonym 3");
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
public async Task HandleAsync(UpdateAnimeMessage updateAnimeMessage)
{
var animeToUpdate = await _animeRepository.GetAsync(updateAnimeMessage.MalId);
if (animeToUpdate == null)
{
return;
}
var updateData = await _malApiService.GetAnimeDataAsync(updateAnimeMessage.MalId);
if (updateData == null)
{
return;
}
await UpdateAnimeAsync(animeToUpdate, updateData);
await _animeRepository.UpdateAsync(animeToUpdate);
}
public async Task RunAsync()
{
var lambda = new UpdateAnimeLambda();
var message = new UpdateAnimeMessage
{
Id = Guid.Parse("5ab374d5-10cf-435e-9ae9-4c4caa3175a5"),
MalId = 1
};
var sqsMessage = new SQSEvent
{
Records = new List <SQSEvent.SQSMessage>
{
new SQSEvent.SQSMessage
{
Body = JsonSerializer.Serialize(message)
}
}
};
await lambda.InvokeAsync(sqsMessage);
}
public async Task HandleAsync_GivenBothOnlyAiringDateWithMatchingSeasonInDB_ShouldUpdateSeasonId(DateTime fromAiringDate, long expectedSeasonId)
{
// Given
const int malId = 1;
var returnedAnime = new Anime
{
Season = null,
Aired = new TimePeriod
{
From = fromAiringDate
}
};
var jikanServiceBuilder = new JikanServiceBuilder().WithAnimeReturned(returnedAnime);
var dbContext = InMemoryDbProvider.GetDbContext();
var anime = new AnimeBuilder()
.WithMalId(malId)
.WithTitle("PreUpdateTitle")
.WithAbout("PreUpdateAbout")
.WithEnglishTitle("PreUpdateEnglish")
.WithJapaneseTitle("PreUpdateJapaneses")
.WithImageUrl("PreUpdateImage")
.WithAnimeStatus(x => x.WithName("Airing"))
.WithAnimeType(x => x.WithId(Domain.Entities.AnimeTypeId.TV))
.WithPopularity(0)
.Build();
var seasons = new List <Domain.Entities.AnimeSeason>
{
new SeasonBuilder().WithId(10).WithYear(2000).WithName("Winter").Build(),
new SeasonBuilder().WithId(11).WithYear(2000).WithName("Spring").Build(),
new SeasonBuilder().WithId(12).WithYear(2000).WithName("Summer").Build(),
new SeasonBuilder().WithId(13).WithYear(2000).WithName("Fall").Build(),
new SeasonBuilder().WithId(14).WithYear(2001).WithName("Winter").Build(),
};
await dbContext.AddAsync(anime);
await dbContext.AddRangeAsync(seasons);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
await handler.HandleAsync(command);
// Then
var updatedAnime = await dbContext.Animes.FirstAsync(x => x.MalId == malId);
using (new AssertionScope())
{
updatedAnime.SeasonId.Should().Be(expectedSeasonId);
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
public async Task HandleAsync_GivenCorrectResponse_ShouldUpdateBasicProperties()
{
// Given
const int malId = 1;
const string returnedTitle = "PostUpdateTitle";
const string returnedAbout = "PostUpdateAbout";
const string returnedEnglishTitle = "PostUpdateEnglish";
const string returnedJapaneseTitle = "PostUpdateJapanese";
const string returnedImageUrl = "PostUpdateImageUrl";
const int returnedPopularity = 1;
var returnedAnime = new Anime
{
Title = returnedTitle,
Synopsis = returnedAbout,
TitleEnglish = returnedEnglishTitle,
TitleJapanese = returnedJapaneseTitle,
Images = new ImagesSet
{
JPG = new Image {
ImageUrl = returnedImageUrl
}
},
TitleSynonyms = new List <string>(),
Members = returnedPopularity
};
var jikanServiceBuilder = new JikanServiceBuilder().WithAnimeReturned(returnedAnime);
var dbContext = InMemoryDbProvider.GetDbContext();
var anime = new AnimeBuilder()
.WithMalId(malId)
.WithTitle("PreUpdateTitle")
.WithAbout("PreUpdateAbout")
.WithEnglishTitle("PreUpdateEnglish")
.WithJapaneseTitle("PreUpdateJapaneses")
.WithImageUrl("PreUpdateImage")
.WithPopularity(0)
.Build();
await dbContext.AddAsync(anime);
await dbContext.SaveChangesAsync();
var handler = CreateHandler(dbContext, jikanServiceBuilder.Build());
var command = new UpdateAnimeMessage
{
Id = Guid.NewGuid(),
MalId = malId
};
// When
await handler.HandleAsync(command);
// Then
var updatedAnime = await dbContext.Animes.FirstAsync(x => x.MalId == malId);
using (new AssertionScope())
{
updatedAnime.Title.Should().Be(returnedTitle);
updatedAnime.About.Should().Be(returnedAbout);
updatedAnime.EnglishTitle.Should().Be(returnedEnglishTitle);
updatedAnime.KanjiTitle.Should().Be(returnedJapaneseTitle);
updatedAnime.ImageUrl.Should().Be(returnedImageUrl);
updatedAnime.Popularity.Should().Be(returnedPopularity);
jikanServiceBuilder.JikanClient.Verify(x => x.GetAnimeAsync(malId), Times.Once);
}
}
