public void Setup()
{
_sources = Substitute.For <ISources>();
_embyItemData = Substitute.For <IEmbyItemData>();
_embyItemData.Identifier.Returns(new ItemIdentifier(67, 1, "Name"));
_embyItemData.Language.Returns("en");
var aniDbSource = Substitute.For <IAniDbSource>();
_sources.AniDb.Returns(aniDbSource);
_mediaItem = Substitute.For <IMediaItem>();
_mediaItem.EmbyData.Returns(_embyItemData);
_mediaItem.ItemType.Returns(MediaItemTypes.Episode);
_aniDbEpisodeMatcher = Substitute.For <IAniDbEpisodeMatcher>();
_aniDbSeriesData = new AniDbSeriesData().WithStandardData();
_aniDbEpisodeData = new AniDbEpisodeData
{
RawEpisodeNumber = new EpisodeNumberData
{
RawNumber = "67",
RawType = 1
},
Titles = new[]
{
new EpisodeTitleData
{
Title = "Title"
}
}
};
}
private AniDbEpisodeData SetUpEpisodeMapping(int tvDbEpisodeIndex, int aniDbEpisodeIndex, ISeriesMapping seriesMapping, string title)
{
var aniDbEpisodeData = new AniDbEpisodeData
{
RawEpisodeNumber = new EpisodeNumberData
{
RawNumber = aniDbEpisodeIndex.ToString(),
RawType = 1
},
Titles = new []
{
new EpisodeTitleData
{
Title = title
}
}
};
_sources.AniDb.SelectTitle(aniDbEpisodeData.Titles, "en", Arg.Any <ProcessResultContext>())
.Returns(title);
_episodeMapper.MapTvDbEpisodeAsync(tvDbEpisodeIndex, seriesMapping, Option <EpisodeGroupMapping> .None)
.Returns(aniDbEpisodeData);
return(aniDbEpisodeData);
}
public void EpisodeMappings_DontMapEmptyFields()
{
var source = new AniDbEpisodeData
{
TotalMinutes = 0,
Summary = "",
Rating = null
};
var target = new MetadataResult <Episode>
{
Item = new Episode()
};
var aniDbSourceMappingConfiguration =
new AniDbSourceMappingConfiguration(Substitute.For <IAniDbParser>(), _titleSelector);
aniDbSourceMappingConfiguration.GetEpisodeMappings(0, false, false, TitleType.Localized, "en")
.Where(m => !m.CanApply(source, target))
.Select(m => m.TargetPropertyName)
.Should()
.BeEquivalentTo(nameof(target.Item.RunTimeTicks), nameof(target.Item.Overview),
nameof(target.Item.CommunityRating), nameof(target.Item.Studios), nameof(target.Item.Genres),
nameof(target.Item.Tags), nameof(target.People));
}
public async Task MapTvDbEpisodeAsync_UsesGroupMappingEpisodeMapper()
{
this.seriesMapping = new SeriesMapping(new SeriesIds(324, 523, Option <int> .None, Option <int> .None),
new AbsoluteTvDbSeason(), 2, new List <EpisodeGroupMapping>(), new List <SpecialEpisodePosition>());
var episodeGroupMapping = new EpisodeGroupMapping(1, 1, 3, 1, 1, new List <EpisodeMapping>());
var expected = new AniDbEpisodeData();
this.groupMappingEpisodeMapper.MapTvDbEpisodeAsync(3, episodeGroupMapping, 324).Returns(expected);
var episodeMapper = new EpisodeMapper(this.defaultSeasonEpisodeMapper, this.groupMappingEpisodeMapper);
var episodeData =
await episodeMapper.MapTvDbEpisodeAsync(3, this.seriesMapping, episodeGroupMapping).ToOption();
episodeData.ValueUnsafe().Should().Be(expected);
}
private AniDbEpisodeData SetUpAniDbEpisodeData(int episodeIndex, int season = 1)
{
if (season < 0 || season > 1)
{
throw new ArgumentOutOfRangeException("Invalid season number");
}
var episodeData = new AniDbEpisodeData
{
RawEpisodeNumber = new EpisodeNumberData
{
RawNumber = episodeIndex.ToString(),
RawType = season == 0 ? 2 : season
}
};
_aniDbSourceData.Data.Returns(episodeData);
return(episodeData);
}
public void Setup()
{
this.tvDbClient = Substitute.For <ITvDbClient>();
this.aniDbClient = Substitute.For <IAniDbClient>();
this.tvDbEpisodeA = TestData.TvDbTestData.Episode(12, 48, 2);
this.tvDbEpisodeB = TestData.TvDbTestData.Episode(45, 7, 2);
this.aniDbEpisodeA = new AniDbEpisodeData
{
RawEpisodeNumber = new EpisodeNumberData
{
RawNumber = "44",
RawType = 1
}
};
this.aniDbEpisodeB = new AniDbEpisodeData
{
RawEpisodeNumber = new EpisodeNumberData
{
RawNumber = "23",
RawType = 1
}
};
this.tvDbClient.GetEpisodesAsync(123)
.Returns(Option <List <TvDbEpisodeData> > .Some(new List <TvDbEpisodeData> {
this.tvDbEpisodeA, this.tvDbEpisodeB
}));
this.aniDbClient.GetSeriesAsync(77)
.Returns(Option <AniDbSeriesData> .Some(new AniDbSeriesData
{
Episodes = new[] { this.aniDbEpisodeA, this.aniDbEpisodeB }
}));
this.mapper = new GroupMappingEpisodeMapper(this.tvDbClient, this.aniDbClient, new ConsoleLogManager());
}
private string SelectTitle(AniDbEpisodeData aniDbEpisodeData, TitleType preferredTitleType,
string metadataLanguage)
{
return(_titleSelector.SelectTitle(aniDbEpisodeData.Titles, preferredTitleType, metadataLanguage)
.Match(t => t.Title, () => ""));
}
private ISourceData CreateSourceData(AniDbEpisodeData episodeData, string title)
{
return(new SourceData <AniDbEpisodeData>(this.sources.AniDb, episodeData.Id,
new ItemIdentifier(episodeData.EpisodeNumber.Number, episodeData.EpisodeNumber.SeasonNumber,
title), episodeData));
}
private Task <Either <ProcessFailedResult, TvDbEpisodeData> > MapEpisodeDataAsync(AniDbSeriesData aniDbSeriesData,
AniDbEpisodeData aniDbEpisodeData, ProcessResultContext resultContext)
{
var seriesMapping = _mappingList.GetSeriesMappingFromAniDb(aniDbSeriesData.Id, resultContext);
return(seriesMapping.BindAsync(sm =>
{
var episodeGroupMapping = sm.GetEpisodeGroupMapping(aniDbEpisodeData.EpisodeNumber);
var tvDbEpisodeData = _episodeMapper.MapAniDbEpisodeAsync(aniDbEpisodeData.EpisodeNumber.Number,
sm, episodeGroupMapping);
return tvDbEpisodeData.Match(
d => Right <ProcessFailedResult, TvDbEpisodeData>(d),
() => resultContext.Failed("Found a series mapping but failed to map the episode to TvDb"));
}));
}
private void SetUpEpisodeMapping(AniDbEpisodeData from, TvDbEpisodeData to, ISeriesMapping seriesMapping)
{
_episodeMapper
.MapAniDbEpisodeAsync(from.EpisodeNumber.Number, seriesMapping, Option <EpisodeGroupMapping> .None)
.Returns(to);
}
public void EpisodeMappings_MapsAllFields()
{
var seriesSource = new AniDbSeriesData
{
Ratings = new[]
{
new PermanentRatingData
{
Value = 45
}
}
};
var aniDbParser = Substitute.For <IAniDbParser>();
aniDbParser.GetGenres(seriesSource, 1, true).Returns(new List <string> {
"Genre"
});
aniDbParser.GetTags(seriesSource, 1, true).Returns(new List <string> {
"Tags"
});
aniDbParser.GetStudios(seriesSource).Returns(new List <string> {
"Studio"
});
aniDbParser.GetPeople(seriesSource)
.Returns(new List <PersonInfo>
{
new PersonInfo
{
Name = "Person",
Role = "Role"
}
});
var source = new AniDbEpisodeData
{
AirDate = new DateTime(2017, 1, 2, 3, 4, 5),
TotalMinutes = 35,
Summary = "Description",
Rating = new EpisodeRatingData {
Rating = 45
}
};
var target = new MetadataResult <Episode>
{
Item = new Episode()
};
var aniDbSourceMappingConfiguration =
new AniDbSourceMappingConfiguration(aniDbParser, _titleSelector);
var mappings = aniDbSourceMappingConfiguration.GetEpisodeMappings(1, true, true, TitleType.Localized, "en").ToList();
mappings
.Select(m => m.CanApply(source, target) || m.CanApply(seriesSource, target))
.All(v => v)
.Should()
.BeTrue();
mappings
.Where(m => m.CanApply(source, target))
.Iter(m => m.Apply(source, target));
mappings
.Where(m => m.CanApply(seriesSource, target))
.Iter(m => m.Apply(seriesSource, target));
target.Item.Name.Should().Be("SelectedTitle");
target.Item.PremiereDate.Should().Be(new DateTime(2017, 1, 2, 3, 4, 5));
target.Item.RunTimeTicks.Should().Be(21000000000L);
target.Item.Overview.Should().Be("Description");
target.Item.CommunityRating.Should().Be(45);
target.Item.Genres.Should().BeEquivalentTo("Genre");
target.Item.Studios.Should().BeEquivalentTo("Studio");
target.Item.Tags.Should().BeEquivalentTo("Tags");
target.People.Should()
.BeEquivalentTo(new List <PersonInfo>
{
new PersonInfo
{
Name = "Person",
Role = "Role"
}
});
}
private ISourceData CreateSourceData(AniDbEpisodeData e, string title, int seasonNumber)
{
return(new SourceData <AniDbEpisodeData>(this.sources.AniDb, e.Id,
new ItemIdentifier(e.EpisodeNumber.Number, seasonNumber, title), e));
}
