/// <summary>
/// Finds the closest anime (based on the user query)
/// </summary>
public void GetAndSetToClosestAnime()
{
searchResultOfAnime = jikanInterface.SearchAnime(_animeName).Result;
if (searchResultOfAnime == null)
{
GetAndSetToRandomAnime();
}
else
{
_animeName = searchResultOfAnime.Results.First().Title;
_malId = searchResultOfAnime.Results.First().MalId;
anime = jikanInterface.GetAnime(_malId).Result;
//If NSFW content is looked up, search up another anime
if (anime.Rating.Contains("Rx"))
{
GetAndSetToRandomAnime();
}
else
{
animeName = _animeName;
_scoreOfAnime = (float)searchResultOfAnime.Results.First().Score;
_reviewsOfAnime = jikanInterface.GetAnimeReviews(_malId).Result;
_animePictures = jikanInterface.GetAnimePictures(_malId).Result;
}
}
}
public async Task SearchAnime_NonEmptyQuery_ShouldReturnNotNullSearchAnime(string query)
{
// When
AnimeSearchResult returnedAnime = await _jikan.SearchAnime(query);
// Then
returnedAnime.Should().NotBeNull();
}
public async Task SearchAnime_DanganronpaQuery_ShouldReturnDanganronpaAnime()
{
// When
AnimeSearchResult danganronpaAnime = await _jikan.SearchAnime("danganronpa");
// Then
danganronpaAnime.ResultLastPage.Should().Be(20);
}
public async Task SearchAnime_GirlQuerySecondPage_ShouldFindGirlAnime()
{
// When
AnimeSearchResult returnedAnime = await _jikan.SearchAnime("girl", 2);
// Then
returnedAnime.Results.Select(x => x.Title).Should().Contain("Sakura-sou no Pet na Kanojo");
}
public async Task <AnimeSearchEntry> GetAnimeFromSearch(string title)
{
IJikan jikan = new Jikan();
AnimeSearchResult searches = await jikan.SearchAnime(title);
var anime = searches.Results.First();
return(anime);
}
public void ShouldReturnHaibaneRenmeiAnime()
{
AnimeSearchResult haibaneRenmei = Task.Run(() => jikan.SearchAnime("haibane")).Result;
Assert.Equal("Haibane Renmei", haibaneRenmei.Results.First().Title);
Assert.Equal("TV", haibaneRenmei.Results.First().Type);
Assert.Equal(13, haibaneRenmei.Results.First().Episodes);
Assert.Equal(387, haibaneRenmei.Results.First().MalId);
}
public async Task SearchAnime_HaibaneQuery_ShouldReturnHaibaneRenmeiAnime()
{
AnimeSearchResult haibaneRenmei = await jikan.SearchAnime("haibane");
Assert.Equal("Haibane Renmei", haibaneRenmei.Results.First().Title);
Assert.Equal("TV", haibaneRenmei.Results.First().Type);
Assert.Equal(13, haibaneRenmei.Results.First().Episodes);
Assert.Equal(387, haibaneRenmei.Results.First().MalId);
}
private async Task <bool> LoadGlobalCatalogueAsync()
{
await App.DelayRequest(4);
try
{
AnimeSearchResult anime = null;
if (string.IsNullOrWhiteSpace(SearchQuery))
{
anime = await App.Jikan.SearchAnime(_animeSearchConfig, _pageCount ++);
}
else if (SearchQuery?.Length > 0)
{
ResetSearchConfig(_settingsPreferences.ShowNSFW, AnimeSearchSortable.Title, SortDirection.Descending);
anime = await App.Jikan.SearchAnime(SearchQuery, _pageCount ++, _animeSearchConfig);
}
Console.WriteLine($"Page count {_pageCount}");
if (anime?.Results != null)
{
anime.RequestCached = true;
IList <FavoritedAnime> animes = await anime.Results.ConvertAnimeSearchEntryToAnimeSubEntry()
.ConvertCatalogueAnimesToFavoritedAsync(_settingsPreferences.ShowNSFW);
var toAddAnimes = new List <FavoritedAnime>();
var equalityComparer = new FavoriteAnimeEqualityComparer();
foreach (var item in animes)
{
if (!Animes.Contains(item, equalityComparer))
{
toAddAnimes.Add(item);
}
}
_originalCollection.AddRange(toAddAnimes);
Animes.AddRange(toAddAnimes);
return(false);
}
}
catch (JikanRequestException ex)
{
ex.SaveExceptionData();
}
catch (OperationCanceledException ex)
{ }
catch (Exception ex)
{
ex.SaveExceptionData();
}
return(true);
}
public async Task SearchAnime_BlameMechaConfig_ShouldFilterBleachMecha()
{
var searchConfig = new AnimeSearchConfig();
searchConfig.Genres.Add(GenreSearch.Mecha);
AnimeSearchResult returnedAnime = await jikan.SearchAnime("Blame", searchConfig);
Assert.Contains("Blame! Movie", returnedAnime.Results.Select(x => x.Title));
}
public async Task SearchAnime_OnePieceAiringQuery_ShouldReturnAiringOnePieceAnime()
{
AnimeSearchConfig searchConfig = new AnimeSearchConfig()
{
Status = AiringStatus.Airing
};
AnimeSearchResult onePieceAnime = await jikan.SearchAnime("one p", searchConfig);
Assert.Equal("One Piece", onePieceAnime.Results.First().Title);
}
public async Task SearchAnime_TVConfig_ShouldReturnNotNullSearchAnime(string query)
{
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime(query, searchConfig);
Assert.NotNull(returnedAnime);
}
public async Task SearchAnime_DanganronpaTVConfig_ShouldReturnDanganronpaAnime()
{
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV
};
AnimeSearchResult danganronpaAnime = await jikan.SearchAnime("danganronpa", searchConfig);
Assert.Equal(1, danganronpaAnime.ResultLastPage);
}
public async Task SearchAnime_OneSortByIdConfig_ShouldSortByIdHachimitsuFirst()
{
var searchConfig = new AnimeSearchConfig
{
OrderBy = AnimeSearchSortable.Id,
SortDirection = SortDirection.Ascending
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime("one", searchConfig);
Assert.Equal("Hachimitsu to Clover", returnedAnime.Results.First().Title);
}
public async Task SearchAnime_VioletIncorrectProducerConfig_ShouldNotFilter()
{
var searchConfig = new AnimeSearchConfig
{
ProducerId = -1
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime("violet", searchConfig);
Assert.Contains("Violence Jack: Jigoku Gai-hen", returnedAnime.Results.Select(x => x.Title));
Assert.Contains("Violet Evergarden", returnedAnime.Results.Select(x => x.Title));
}
public async Task SearchAnime_BlameMechaConfig_ShouldFilterBleachMecha()
{
// Given
var searchConfig = new AnimeSearchConfig();
searchConfig.Genres.Add(GenreSearch.Mecha);
// When
AnimeSearchResult returnedAnime = await _jikan.SearchAnime("Blame", searchConfig);
// Then
returnedAnime.Results.Select(x => x.Title).Should().Contain("Blame! Movie");
}
public async Task SearchAnime_FairyTailTVAbove8Config_ShouldFilterFairyTailAnimeScore()
{
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV,
Score = 8
};
AnimeSearchResult fairyTailAnime = await jikan.SearchAnime("Fairy Tail", searchConfig);
Assert.Equal("Fairy Tail (2014)", fairyTailAnime.Results.First().Title);
Assert.Equal("Fairy Tail: Final Series", fairyTailAnime.Results.Skip(1).First().Title);
}
public async Task SearchAnime_VioletProducerKyotoAnimationConfig_ShouldReturnVEGAsTop3()
{
var searchConfig = new AnimeSearchConfig
{
ProducerId = 2
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime("violet", searchConfig);
Assert.Contains("Evergarden", returnedAnime.Results.First().Title);
Assert.Contains("Evergarden", returnedAnime.Results.Skip(1).First().Title);
Assert.Contains("Evergarden", returnedAnime.Results.Skip(2).First().Title);
}
public async Task SearchAnime_BleachAfter2017Config_ShouldFilterBleachAfter2017()
{
System.DateTime configDate = new System.DateTime(2018, 1, 1);
var searchConfig = new AnimeSearchConfig
{
StartDate = configDate
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime("Bleach", searchConfig);
Assert.Contains("Full Metal Panic! Invisible Victory", returnedAnime.Results.Select(x => x.Title));
Assert.Contains("Beatless", returnedAnime.Results.Select(x => x.Title));
}
public async Task SearchAnime_BlameMechaMovieConfig_ShouldFilterBleachMechaMovie()
{
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.Movie
};
searchConfig.Genres.Add(GenreSearch.Mecha);
AnimeSearchResult returnedAnime = await jikan.SearchAnime("Blame", searchConfig);
Assert.Equal("Blame! Movie", returnedAnime.Results.First().Title);
}
public async Task SearchAnime_DanganronpaTVConfig_ShouldReturnDanganronpaAnime()
{
// Given
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV
};
// When
AnimeSearchResult danganronpaAnime = await _jikan.SearchAnime("danganronpa", searchConfig);
// Then
danganronpaAnime.ResultLastPage.Should().Be(2);
}
public async Task SearchAnime_OnePieceAiringQuery_ShouldReturnAiringOnePieceAnime()
{
// Given
AnimeSearchConfig searchConfig = new AnimeSearchConfig()
{
Status = AiringStatus.Airing
};
// When
AnimeSearchResult onePieceAnime = await _jikan.SearchAnime("one p", searchConfig);
// Then
onePieceAnime.Results.First().Title.Should().Be("One Piece");
}
public async Task SearchAnime_OneSortByMembersConfig_ShouldSortByPopularityOPMFirst()
{
var searchConfig = new AnimeSearchConfig
{
OrderBy = AnimeSearchSortable.Members,
SortDirection = SortDirection.Descending
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime("one", searchConfig);
Assert.Contains("One Piece", returnedAnime.Results.Select(x => x.Title));
Assert.Contains("One Punch Man", returnedAnime.Results.Select(x => x.Title));
Assert.Equal("One Punch Man", returnedAnime.Results.First().Title);
}
public async Task SearchAnime_TVConfig_ShouldReturnNotNullSearchAnime(string query)
{
// Given
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV
};
// When
AnimeSearchResult returnedAnime = await _jikan.SearchAnime(query, searchConfig);
// Then
returnedAnime.Should().Be(returnedAnime);
}
public async Task mal(string keys)
{
// Initialize JikanWrapper
IJikan jikan = new Jikan(true);
// Send request to search anime with "haibane" key word
AnimeSearchResult animeSearchResult = await jikan.SearchAnime(keys);
await ReplyAsync(animeSearchResult.Results.First().Title);
//// Send request to search anime with "gundam" key word, second page of results
//animeSearchResult = await jikan.SearchAnime(keys, 2);
//AnimeSearchConfig animeSearchConfig = new AnimeSearchConfig()
//{
// Type = AnimeType.Movie,
// Score = 7
//};
//await ReplyAsync(animeSearchResult.Results.First().Title);
//// Send request to search anime with "gundam" key word, movies with score bigger than 7 only.
//animeSearchResult = await jikan.SearchAnime(keys, animeSearchConfig);
//animeSearchConfig = new AnimeSearchConfig()
//{
// Genres = { GenreSearch.Action, GenreSearch.Adventure },
// GenreIncluded = true
//};
//await ReplyAsync(animeSearchResult.Results.First().Title);
//// Send request to search anime with "samurai" key word, with action and/or adventure genre.
//animeSearchResult = await jikan.SearchAnime(keys, animeSearchConfig);
//animeSearchConfig = new AnimeSearchConfig()
//{
// Genres = { GenreSearch.Mecha, GenreSearch.Romance },
// GenreIncluded = false
//};
//await ReplyAsync(animeSearchResult.Results.First().Title);
//// Send request to search anime with "samurai" key word, without mecha and/or romance genre.
//animeSearchResult = await jikan.SearchAnime(keys, animeSearchConfig);
//animeSearchConfig = new AnimeSearchConfig()
//{
// Rating = AgeRating.RX
//};
//await ReplyAsync(animeSearchResult.Results.First().Title);
//// Send request to search anime with "xxx" key word, adult anime only, second page of results
//animeSearchResult = await jikan.SearchAnime(keys, 2, animeSearchConfig);
//await ReplyAsync(animeSearchResult.Results.First().Title);
}
public async Task SearchAnime_EmptyQueryActionTvAnimeSecondPage_ShouldFindAzurLaneAndBaccano()
{
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV,
Genres = new List <GenreSearch> {
GenreSearch.Action
}
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime(searchConfig, 2);
Assert.Contains("Azur Lane", returnedAnime.Results.Select(x => x.Title));
Assert.Contains("Baccano!", returnedAnime.Results.Select(x => x.Title));
}
public async Task SearchAnime_OneSortByIdConfig_ShouldSortByIdHachimitsuFirst()
{
// Given
var searchConfig = new AnimeSearchConfig
{
OrderBy = AnimeSearchSortable.Id,
SortDirection = SortDirection.Ascending
};
// When
AnimeSearchResult returnedAnime = await _jikan.SearchAnime("one", searchConfig);
// Then
returnedAnime.Results.First().Title.Should().Be("Hachimitsu to Clover");
}
private async void SearchButton_Click(object sender, EventArgs e)
{
WriteDebugLabel("Searching");
EnableAnimeBox();
AnimeSearchResult asr = await SearchAnime();
if (asr != null)
{
foreach (AnimeSearchEntry r in asr.Results)
{
AnimeBox.Items.Add(r.Title);
}
}
}
public async Task SearchAnime_EmptyQueryActionTvAnimeFirstPage_ShouldFindAfroSamuraiAndAjin()
{
var searchConfig = new AnimeSearchConfig
{
Type = AnimeType.TV,
Genres = new List <GenreSearch> {
GenreSearch.Action
}
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime(searchConfig, 1);
Assert.Contains("Ajin", returnedAnime.Results.Select(x => x.Title));
Assert.Contains("Afro Samurai", returnedAnime.Results.Select(x => x.Title));
}
public async Task SearchAnime_OneQueryActionCompletedAnimeSecondPage_ShouldReturnNotEmptyCollection()
{
var searchConfig = new AnimeSearchConfig
{
Status = AiringStatus.Completed,
Genres = new List <GenreSearch> {
GenreSearch.Action
}
};
AnimeSearchResult returnedAnime = await jikan.SearchAnime("one", 2, searchConfig);
Assert.NotNull(returnedAnime);
Assert.NotEmpty(returnedAnime.Results);
}
public async Task SearchAnime_HaibaneQuery_ShouldReturnHaibaneRenmeiAnime()
{
// When
AnimeSearchResult result = await _jikan.SearchAnime("haibane");
// Then
var firstResult = result.Results.First();
using (new AssertionScope())
{
firstResult.Title.Should().Be("Haibane Renmei");
firstResult.Type.Should().Be("TV");
firstResult.Episodes.Should().Be(13);
firstResult.MalId.Should().Be(387);
}
}
