private static IEnumerable<DownloaderMatch> SearchDownloaders(IEnumerable<IEpisodeSubtitleDownloader> compatibleDownloaders, Language[] languageArray, TvReleaseIdentity tvReleaseIdentity)
{
var searchResults = compatibleDownloaders
.AsParallel()
.SelectMany(downloader => downloader.SearchSubtitle(tvReleaseIdentity, languageArray)
.Select(match => new DownloaderMatch(downloader, match)))
.AsSequential().ToArray();
return FilterOutLanguagesNotInRequest(searchResults, languageArray);
}
private static Subtitle CreateSubtitle(string fileHash, Language language, SearchQuery query)
{
return new Subtitle(fileHash, "", language)
{
SeriesName = query.SeriesTitle,
Season = query.Season,
Episode = query.Episode,
EndEpisode = query.Episode,
ReleaseGroup = query.ReleaseGroup
};
}
public void DownloadSubtitle_MatchingSubtitlesDownloaderFails_ShouldReturnFalse(
string file,
Language[] languages,
TvReleaseIdentity identity,
Subtitle[] matches,
Language language,
ISubtitleRanker subtitleRanker,
IEnhancementProvider enhancementProvider,
[Frozen]IEpisodeSubtitleDownloader fakeDownloader)
{
A.CallTo(() => fakeDownloader.SearchSubtitle(A<TvReleaseIdentity>._, A<Language[]>._)).Returns(matches);
A.CallTo(() => fakeDownloader.TryDownloadSubtitle(A<Subtitle>._, A<string>._)).Returns(false);
A.CallTo(() => fakeDownloader.CanHandleAtLeastOneOf(A<Language[]>._)).Returns(true);
var downloaders = new[] { fakeDownloader };
var service = new SubtitleDownloadService(downloaders, enhancementProvider, subtitleRanker);
bool success = service.DownloadSubtitle(file, identity, languages);
Assert.That(success, Is.False);
}
public void ProcessFile_AllLanguagesAlreadyDownloaded_ReturnsTrue(
Language[] languages,
string fileName,
TvReleaseIdentity tvRelease,
ILogger logger,
IEpisodeParser episodeParser,
ISubtitleDownloadService subtitleService,
[Frozen]IFileOperations fileOperations,
FileProcessor sut)
{
var settings = new LanguageSettings(languages);
A.CallTo(() => fileOperations.GetDowloadedSubtitleLanguages(A<string>._, languages)).Returns(languages);
A.CallTo(() => subtitleService.DownloadSubtitle(A<string>._, A<TvReleaseIdentity>._, A<IEnumerable<Language>>._))
.Returns(false);
A.CallTo(() => episodeParser.ParseEpisodeInfo(A<string>._)).Returns(tvRelease);
var processor = new FileProcessor(episodeParser, logger, subtitleService, fileOperations, settings);
bool result = processor.ProcessFile(fileName, new string[0]);
Assert.That(result, Is.True);
}
public Subtitle(string id, string fileName, Language language)
{
Id = id;
FileName = fileName;
Language = language;
}
private IOrderedEnumerable<DownloaderMatch> OrderByRanking(IEnumerable<DownloaderMatch> searchResults, Language[] languageArray, TvReleaseIdentity identity)
{
return searchResults.OrderByDescending(s => _subtitleRanker.GetRankingScore(s.Subtitle, languageArray, identity));
}
private IEpisodeSubtitleDownloader[] GetDownloadersForLanguages(Language[] languageArray)
{
return _subtitleDownloaders.Where(s => s.CanHandleAtLeastOneOf(languageArray)).ToArray();
}
private static IEnumerable<DownloaderMatch> FilterOutLanguagesNotInRequest(IEnumerable<DownloaderMatch> searchResults, Language[] validLanguages)
{
return searchResults.Where(m => validLanguages.Any(l => l == m.Subtitle.Language));
}
