public async Task GetAsync_GivenMultipleExistingAnimeOneOfWhichWithId_ShouldReturnResult()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
var anime1 = new AnimeBuilder().WithMalId(1).Build();
var anime2 = new AnimeBuilder().WithMalId(2).Build();
var anime3 = new AnimeBuilder().WithMalId(3).Build();
var anime4 = new AnimeBuilder().WithMalId(4).Build();
var anime5 = new AnimeBuilder().WithMalId(5).Build();
await dbContext.Animes.AddAsync(anime1);
await dbContext.Animes.AddAsync(anime2);
await dbContext.Animes.AddAsync(anime3);
await dbContext.Animes.AddAsync(anime4);
await dbContext.Animes.AddAsync(anime5);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetAsync(3);
// Then
result.Should().NotBeNull();
result.MalId.Should().Be(3);
}
public async Task GetOrderedPageByPopularityAsync_GivenMultipleWithDifferentPopularityWithPagesize_ShouldReturnOnlyOnePageByPopularity()
{
// Given
const int pageSize = 2;
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
var anime1 = new AnimeBuilder().WithTitle("Test1").WithPopularity(10).Build();
var anime2 = new AnimeBuilder().WithTitle("Test2").WithPopularity(50).Build();
var anime3 = new AnimeBuilder().WithTitle("Test3").WithPopularity(30).Build();
await dbContext.Animes.AddAsync(anime1);
await dbContext.Animes.AddAsync(anime2);
await dbContext.Animes.AddAsync(anime3);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetOrderedPageByPopularityAsync(x => true, 0, pageSize);
// Then// Then
using (new AssertionScope())
{
result.TotalCount.Should().Be(3);
result.Results.Should().HaveCount(2);
result.PageSize.Should().Be(pageSize);
result.Results.First().Title.Should().Be("Test2");
result.Results.First().Popularity.Should().Be(50);
result.Results.Last().Title.Should().Be("Test3");
result.Results.Last().Popularity.Should().Be(30);
}
}
public async Task UpdateAsync_GivenExistingAnime_ShouldUpdate()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
var anime = new AnimeBuilder().WithTitle("Test").Build();
await dbContext.Animes.AddAsync(anime);
await dbContext.SaveChangesAsync();
anime.Title = "Updated";
// When
await repository.UpdateAsync(anime);
// Then
var allAnimes = await dbContext.Animes.ToListAsync();
using (new AssertionScope())
{
var updateAnime = allAnimes.SingleOrDefault();
updateAnime.Should().NotBeNull();
updateAnime.Title.Should().Be("Updated");
updateAnime.ModificationDate.Should().HaveDay(DateTime.UtcNow.Day);
}
}
//
public DetailsViewModel EditExisting(Anime anime)
{
Editing = true;
Anime = anime;
SetupImage();
ExitCommand = new RelayCommand(() =>
{
AnimeRepository.Save();
MessengerInstance.Send(Display.Anime);
});
DetailsBar = SimpleIoc.Default.GetInstance <DetailsBarViewModel>().Load(Anime);
NextCommand = new RelayCommand(Next);
PreviousCommand = new RelayCommand(Previous);
// Button
Text = "Edit";
Command = new RelayCommand(
Edit,
() => Anime?.Name?.Length > 0
);
Anime.PropertyChanged -= AnimeOnPropertyChanged;
Anime.PropertyChanged += AnimeOnPropertyChanged;
return(this);
}
public async Task <int> DownloadSpecificEpisodes(Dictionary <Anime, List <int> > animes, Action <string> output)
{
var downloaded = 0;
foreach (var anime in animes.Keys)
{
foreach (var episode in animes[anime])
{
var download = await AttemptDownload(anime, episode, await GetMedia(anime, episode), output);
if (download)
{
downloaded++;
anime.Details.NeedsUpdating = true;
}
}
}
if (downloaded > 0)
{
AnimeRepository.Save();
}
return(downloaded);
}
private UpdateAnimeHandler CreateHandler(SeiyuuMoeContext dbcontext, IMalApiService apiService)
{
var animeRepository = new AnimeRepository(dbcontext);
var seasonRepository = new SeasonRepository(dbcontext);
return(new UpdateAnimeHandler(animeRepository, seasonRepository, apiService));
}
private static InsertSeiyuuHandler CreateHandler(SeiyuuMoeContext dbContext)
{
var scheduleConfiguration = ConfigurationReader.MalBgJobsScheduleConfiguration;
var animeRepository = new AnimeRepository(dbContext);
var seiyuuRepository = new SeiyuuRepository(dbContext);
var characterRepository = new CharacterRepository(dbContext);
var animeRoleRepository = new AnimeRoleRepository(dbContext);
var seasonRepository = new SeasonRepository(dbContext);
var jikanUrl = ConfigurationReader.JikanUrl;;
var jikanConfiguration = new JikanClientConfiguration {
Endpoint = jikanUrl, SuppressException = true
};
var jikanClient = new Jikan(jikanConfiguration);
var jikanService = new JikanService(jikanClient);
var s3Client = new S3Service();
return(new InsertSeiyuuHandler(
scheduleConfiguration.InsertSeiyuuBatchSize,
scheduleConfiguration.DelayBetweenCallsInSeconds,
seiyuuRepository,
seasonRepository,
characterRepository,
animeRepository,
animeRoleRepository,
jikanService,
s3Client
));
}
public async Task GetOrderedPageByPopularityAsync_GivenMultipleAnime_ShouldReturnAll()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
var anime1 = new AnimeBuilder().WithTitle("Test1").Build();
var anime2 = new AnimeBuilder().WithTitle("Test2").Build();
var anime3 = new AnimeBuilder().WithTitle("Test3").Build();
await dbContext.Animes.AddAsync(anime1);
await dbContext.Animes.AddAsync(anime2);
await dbContext.Animes.AddAsync(anime3);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetOrderedPageByPopularityAsync(x => true);
// Then
using (new AssertionScope())
{
result.TotalCount.Should().Be(3);
result.Results.Should().HaveCount(3);
}
}
// POST: api/Serie
public string Post([FromBody] Anime anime)
{
var repo = new AnimeRepository();
string result = repo.Save(anime);
return(result);
}
private SearchAnimeQueryHandler CreateHandler(SeiyuuMoeContext seiyuuMoeContext)
{
var animeRepository = new AnimeRepository(seiyuuMoeContext);
var animeSearchCriteriaService = new AnimeSearchCriteriaService();
return(new SearchAnimeQueryHandler(animeRepository, animeSearchCriteriaService));
}
// GET: api/Serie/5
public IEnumerable <Anime> Get(int id)
{
var repo = new AnimeRepository();
List <Anime> anime = repo.GetAnimeUsuario(id);
return(anime);
}
// GET: api/Anime
public IEnumerable <Anime> Get()
{
var repo = new AnimeRepository();
List <Anime> animes = repo.GetAnimes();
return(animes);
}
public ActionResult EditAnime(AnimeViewModel viewModel)
{
if (LoginUserSession.Current.IsAuthenticated)
{
if (viewModel == null)
{
TempData["Message"] = "No View Model";
return(RedirectToAction("Edit"));
}
AnimeRepository repo = new AnimeRepository();
Anime anime = repo.GetByID(viewModel.ID);
if (anime == null)
{
anime = new Anime();
}
anime.Name = viewModel.Name;
anime.AnimeCategory = viewModel.Category;
anime.Category = viewModel.CategoryID;
anime.Rating = viewModel.Rating;
repo.Save(anime);
TempData["Mesage"] = "Anime was successfully saved!";
return(RedirectToAction("Edit"));
}
TempData["ErrorMessage"] = "Please log in";
return(RedirectToAction("Login", "Login"));
}
public ActionResult EditAnime(int id = 0)
{
if (!LoginUserSession.Current.IsAdministrator)
{
return(RedirectToAction("Edit"));
}
CategoryRepository categoriesRepo = new CategoryRepository();
List <Category> categories = categoriesRepo.GetAll();
Category category = new Category();
ViewBag.Categories = new SelectList(categories, "ID", "Name");
AnimeRepository animeRepo = new AnimeRepository();
AnimeViewModel anime;
if (id != 0)
{
anime = new AnimeViewModel(animeRepo.GetByID(id));
}
else
{
anime = new AnimeViewModel(new Anime());
}
return(View(anime));
}
public async Task <int> DownloadAll(IEnumerable <Anime> animes, Action <string> output)
{
var downloaded = 0;
foreach (var anime in animes)
{
var result = await GetMedia(anime, anime.NextEpisode);
var download = await AttemptDownload(anime, anime.NextEpisode, result, output);
if (download)
{
downloaded++;
anime.Episode++;
anime.Details.NeedsUpdating = true;
}
}
if (downloaded > 0)
{
AnimeRepository.Save();
}
return(downloaded);
}
public async Task GetOrderedPageByPopularityAsync_GivenMultipleWithPredicate_ShouldReturnEmpty()
{
// Given
const int pageSize = 2;
const int pageNumber = 2;
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
var anime1 = new AnimeBuilder().WithTitle("Test1").Build();
var anime2 = new AnimeBuilder().WithTitle("Test2").Build();
var anime3 = new AnimeBuilder().WithTitle("Test3").Build();
await dbContext.Animes.AddAsync(anime1);
await dbContext.Animes.AddAsync(anime2);
await dbContext.Animes.AddAsync(anime3);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetOrderedPageByPopularityAsync(x => x.Title.EndsWith("1"), pageNumber, pageSize);
// Then// Then
using (new AssertionScope())
{
result.TotalCount.Should().Be(1);
result.Results.Should().BeEmpty();
result.Page.Should().Be(pageNumber);
result.PageSize.Should().Be(pageSize);
}
}
public async Task GetAllBySeasonAndTypeAsync_GivenMultipleAnimeOnlyOneInSeasonWithType_ShouldReturnSingle()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
const int seasonId1 = 100;
const int seasonId2 = 101;
const AnimeTypeId animeTypeId = AnimeTypeId.TV;
var animeType = new AnimeTypeBuilder().WithId(animeTypeId).Build();
var season1 = new SeasonBuilder().WithId(seasonId1).WithName("Winter").WithYear(2000).Build();
var season2 = new SeasonBuilder().WithId(seasonId2).WithName("Spring").WithYear(2000).Build();
var anime1 = new AnimeBuilder().WithTitle("Test1").WithSeason(season1).WithAnimeType(animeType).Build();
var anime2 = new AnimeBuilder().WithTitle("Test2").WithSeason(season1).WithAnimeType(animeType).Build();
var anime3 = new AnimeBuilder().WithTitle("Test3").WithSeason(season2).WithAnimeType(animeType).Build();
await dbContext.Animes.AddAsync(anime1);
await dbContext.Animes.AddAsync(anime2);
await dbContext.Animes.AddAsync(anime3);
await dbContext.SaveChangesAsync();
// When
var result = await repository.GetAllBySeasonAndTypeAsync(seasonId2, animeTypeId);
// Then
result.Should().ContainSingle();
}
public ActionResult Edit()
{
AnimeRepository repo = new AnimeRepository();
AnimeViewModel model = new AnimeViewModel(repo.GetAll());
return(View(model));
}
public UnitOfWork(ANDbContext context)
{
_context = context;
Animes = new AnimeRepository(_context);
Favorites = new FavoriteRepository(_context);
Forums = new ForumRepository(_context);
Messages = new MessageRepository(_context);
Genres = new GenreRepository(_context);
Ratings = new RatingRepository(_context);
Studios = new StudioRepository(_context);
}
private static UpdateAnimeHandler CreateHandler(SeiyuuMoeContext dbContext)
{
var animeRepository = new AnimeRepository(dbContext);
var seasonRepository = new SeasonRepository(dbContext);
var jikanUrl = ConfigurationReader.JikanUrl;
var jikanClient = new Jikan(jikanUrl);
var jikanService = new JikanService(jikanClient);
return(new UpdateAnimeHandler(animeRepository, seasonRepository, jikanService));
}
public void UpdateAsync_GivenNotExistingAnime_ShouldThrowExcepton()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
// When
Func <Task> func = repository.Awaiting(x => x.UpdateAsync(new AnimeBuilder().WithId(Guid.NewGuid()).Build()));
// Then
func.Should().Throw <Exception>();
}
public async Task CountAsync_GivenNoAnime_ShouldReturnZero()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
// When
var result = await repository.GetAnimeCountAsync();
// Then
result.Should().Be(0);
}
/// <summary>
/// A one time but potentially expensive cost to find out the preferred name
/// </summary>
private async Task <IEnumerable <RemoteMedia> > GetMedia(Anime anime, int episode)
{
IEnumerable <RemoteMedia> media;
// If there is both an english and romanji title
if (!string.IsNullOrEmpty(anime.Details.Title) && !string.IsNullOrEmpty(anime.Details.English))
{
if (!string.IsNullOrEmpty(anime.Details.PreferredSearchTitle))
{
media = await FindAllMedia(anime, anime.Details.PreferredSearchTitle, episode);
}
// If there is no preference toward either of them, time to set them
else
{
var english = (await FindAllMedia(anime, anime.Details.English, episode)).ToList();
var romanji = (await FindAllMedia(anime, anime.Details.Title, episode)).ToList();
var englishScore = HealthScore(english);
var romanjiScore = HealthScore(romanji);
// Set it to romanji, but don't save any titles
if (englishScore == -1 && romanjiScore == -1)
{
media = romanji;
}
else if (englishScore > romanjiScore)
{
anime.Details.PreferredSearchTitle = anime.Details.English;
media = english;
}
else
{
anime.Details.PreferredSearchTitle = anime.Details.Title;
media = romanji;
}
AnimeRepository.Save();
}
}
else
{
media = await FindAllMedia(anime, anime.Name, episode);
}
return(media);
}
private static UpdateAnimeHandler CreateHandler(SeiyuuMoeContext dbContext)
{
var animeRepository = new AnimeRepository(dbContext);
var seasonRepository = new SeasonRepository(dbContext);
var jikanUrl = ConfigurationReader.JikanUrl;;
var jikanConfiguration = new JikanClientConfiguration {
Endpoint = jikanUrl, SuppressException = true
};
var jikanClient = new Jikan(jikanConfiguration);
var jikanService = new JikanService(jikanClient);
return(new UpdateAnimeHandler(animeRepository, seasonRepository, jikanService));
}
private static ScheduleAnimesHandler CreateHandler(SeiyuuMoeContext dbContext)
{
var animeRepository = new AnimeRepository(dbContext);
var queueUrl = Environment.GetEnvironmentVariable("AnimeToUpdateQueueUrl");
var animeUpdatePublisher = new SqsAnimeUpdatePublisher(new AmazonSQSClient(), queueUrl);
var scheduleConfiguration = ConfigurationReader.MalBgJobsScheduleConfiguration;
return(new ScheduleAnimesHandler(
scheduleConfiguration.UpdateBatchSize,
scheduleConfiguration.DelayBetweenMessagesInSeconds,
animeRepository,
animeUpdatePublisher
));
}
public async Task AddAsync_GivenEmptyAnime_ShouldAddAnime()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
// When
await repository.AddAsync(new AnimeBuilder().Build());
// Then
var allAnime = await dbContext.Animes.ToListAsync();
allAnime.Should().ContainSingle();
}
public async Task AddAsync_GivenAnime_ShouldAddAnime()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
const string expectedTitle = "ExpectedTitle";
const string expectedImageUrl = "ExpectedImageUrl";
const string expectedJapaneseTitle = "期待される日本語タイトル";
const string expectedTitleSynonyms = "expectedTitleSynonyms";
const string expectedAbout = "ExpectedAbout";
const string expectedStatus = "ExpectedStatus";
var expectedType = AnimeTypeId.TV;
const long expectedMalId = 1;
var anime = new AnimeBuilder()
.WithTitle(expectedTitle)
.WithImageUrl(expectedImageUrl)
.WithMalId(expectedMalId)
.WithJapaneseTitle(expectedJapaneseTitle)
.WithTitleSynonyms(expectedTitleSynonyms)
.WithAbout(expectedAbout)
.WithAnimeType(at => at.WithId(expectedType))
.WithAnimeStatus(at => at.WithName(expectedStatus))
.Build();
// When
await repository.AddAsync(anime);
// Then
var allAnime = await dbContext.Animes.ToListAsync();
var newAnime = await dbContext.Animes.FirstOrDefaultAsync();
using (new AssertionScope())
{
allAnime.Should().ContainSingle();
newAnime.Should().NotBeNull();
newAnime.Title.Should().Be(expectedTitle);
newAnime.ImageUrl.Should().Be(expectedImageUrl);
newAnime.MalId.Should().Be(expectedMalId);
newAnime.KanjiTitle.Should().Be(expectedJapaneseTitle);
newAnime.TitleSynonyms.Should().Be(expectedTitleSynonyms);
newAnime.About.Should().Be(expectedAbout);
newAnime.Type.Id.Should().Be(expectedType);
newAnime.Status.Description.Should().Be(expectedStatus);
}
}
private static UpdateSeiyuuHandler CreateHandler(SeiyuuMoeContext dbContext)
{
var animeRepository = new AnimeRepository(dbContext);
var seiyuuRepository = new SeiyuuRepository(dbContext);
var characterRepository = new CharacterRepository(dbContext);
var seiyuuRoleRepository = new SeiyuuRoleRepository(dbContext);
var animeRoleRepository = new AnimeRoleRepository(dbContext);
var seasonRepository = new SeasonRepository(dbContext);
var jikanUrl = ConfigurationReader.JikanUrl;
var jikanClient = new Jikan(jikanUrl, true);
var jikanService = new JikanService(jikanClient);
return(new UpdateSeiyuuHandler(seiyuuRepository, animeRepository, characterRepository, seiyuuRoleRepository, animeRoleRepository, seasonRepository, jikanService));
}
public async Task AddAsync_GivenDuplicatedKeyAnime_ShouldThrowException()
{
// Given
var id = Guid.NewGuid();
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
await repository.AddAsync(new AnimeBuilder().WithId(id).Build());
// When
Func <Task> func = repository.Awaiting(x => x.AddAsync(new AnimeBuilder().WithId(id).Build()));
// Then
func.Should().Throw <Exception>();
}
public async Task GetOrderedPageByPopularityAsync_GivenNoAnime_ShouldReturnEmpty()
{
// Given
var dbContext = InMemoryDbProvider.GetDbContext();
var repository = new AnimeRepository(dbContext);
// When
var result = await repository.GetOrderedPageByPopularityAsync(x => true);
// Then
using (new AssertionScope())
{
result.TotalCount.Should().Be(0);
result.Results.Should().BeEmpty();
}
}
