public void import_new_file_with_better_same_quality_should_succeed(QualityTypes currentFileQuality, bool currentFileProper)
{
const string newFile = @"WEEDS.S03E01.DUAL.1080p.HELLYWOOD.mkv";
const int size = 12345;
//Fakes
var fakeSeries = Builder<Series>.CreateNew().Build();
var fakeEpisode = Builder<Episode>.CreateNew()
.With(e => e.EpisodeFile = Builder<EpisodeFile>.CreateNew()
.With(g => g.Quality = (QualityTypes)currentFileQuality)
.And(g => g.Proper = currentFileProper).Build()
).Build();
Mocker.GetMock<DiskProvider>()
.Setup(e => e.GetSize(newFile)).Returns(12345).Verifiable();
Mocker.GetMock<EpisodeProvider>()
.Setup(e => e.GetEpisodesByParseResult(It.IsAny<EpisodeParseResult>())).Returns(new List<Episode> { fakeEpisode });
//Act
var result = Mocker.Resolve<DiskScanProvider>().ImportFile(fakeSeries, newFile);
//Assert
VerifyFileImport(result, Mocker, fakeEpisode, size);
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
var value = bindingContext.ValueProvider.GetValue("quality");
var quality = QualityTypes.FindById(Convert.ToInt32(value.AttemptedValue));
return(quality);
}
public void quality_parse(string postTitle, QualityTypes quality, bool proper)
{
var result = Parser.ParseQuality(postTitle);
result.Quality.Should().Be(quality);
result.Proper.Should().Be(proper);
}
public void should_not_allow_if_quality_is_not_defined_in_profile(QualityTypes qualityType)
{
parseResult.Quality.Quality = qualityType;
parseResult.Series.QualityProfile.Allowed = new List<QualityTypes> { QualityTypes.DVD, QualityTypes.HDTV, QualityTypes.Bluray1080p };
_qualityAllowedByProfile.IsSatisfiedBy(parseResult).Should().BeFalse();
}
public void import_new_file_with_better_quality_should_succeed(QualityTypes currentFileQuality, bool currentFileProper)
{
const string newFile = @"WEEDS.S03E01.DUAL.1080p.HELLYWOOD.mkv";
//Fakes
var fakeSeries = Builder <Series> .CreateNew().Build();
var fakeEpisode = Builder <Episode> .CreateNew()
.With(e => e.EpisodeFile = Builder <EpisodeFile> .CreateNew()
.With(g => g.Quality = (QualityTypes)currentFileQuality)
.And(g => g.Proper = currentFileProper).Build()
).Build();
With80MBFile();
Mocker.GetMock <EpisodeProvider>()
.Setup(e => e.GetEpisodesByParseResult(It.IsAny <EpisodeParseResult>())).Returns(new List <Episode> {
fakeEpisode
});
//Act
var result = Mocker.Resolve <DiskScanProvider>().ImportFile(fakeSeries, newFile);
//Assert
VerifyFileImport(result, Mocker, fakeEpisode, SIZE);
}
public void parsing_our_own_quality_enum(QualityTypes quality)
{
var fileName = String.Format("My series S01E01 [{0}]", quality);
var result = Parser.ParseQuality(fileName);
result.Quality.Should().Be(quality);
}
public void should_not_allow_if_quality_is_not_defined_in_profile(QualityTypes qualityType)
{
parseResult.Quality.Quality = qualityType;
parseResult.Series.QualityProfile.Allowed = new List <QualityTypes> {
QualityTypes.DVD, QualityTypes.HDTV720p, QualityTypes.Bluray1080p
};
_qualityAllowedByProfile.IsSatisfiedBy(parseResult).Should().BeFalse();
}
public Item(int id, string name, ItemTypes itemType, QualityTypes quality, string description, int capacity, int buyprice, int sellprice, string spritepath)
{
this.ID = id;
this.Name = name;
this.ItemType = itemType;
this.Quality = quality;
this.Description = description;
this.Capacity = capacity;
this.BuyPrice = buyprice;
this.SellPrice = sellprice;
this.SpritePath = spritepath;
}
protected override List <QualityTypes> ResolveCore(List <QualityProfileType> source)
{
var ids = source.Where(s => s.Allowed).Select(s => s.Id).ToList();
var qualityTypes = new List <QualityTypes>();
ids.ForEach(id =>
{
qualityTypes.Add(QualityTypes.FindById(id));
});
return(qualityTypes);
}
public void SetupDefault_already_exists_should_insert_missing()
{
var db = TestDbHelper.GetEmptyDatabase();
Mocker.SetConstant(db);
db.Insert(new QualityType {
QualityTypeId = 1, Name = "SDTV", MinSize = 0, MaxSize = 100
});
//Act
Mocker.Resolve <QualityTypeProvider>().SetupDefault();
//Assert
var types = Mocker.Resolve <QualityTypeProvider>().All();
types.Should().HaveCount(QualityTypes.All().Count - 1);
}
public virtual bool IsSatisfiedBy(Quality currentQuality, Quality newQuality, QualityTypes cutOff)
{
if (currentQuality >= newQuality)
{
logger.Trace("existing item has better or equal quality. skipping");
return false;
}
if (currentQuality.QualityType == newQuality.QualityType && newQuality.Proper)
{
logger.Trace("Upgrading existing item to proper.");
return true;
}
if (currentQuality.QualityType >= cutOff)
{
logger.Trace("Existing item meets cut-off. skipping.");
return false;
}
return true;
}
public ActionResult Details(int seriesId)
{
var series = _seriesProvider.GetSeries(seriesId);
var model = new SeriesDetailsModel();
if (series.AirsDayOfWeek != null)
{
model.AirsDayOfWeek = series.AirsDayOfWeek.Value.ToString();
}
else
{
model.AirsDayOfWeek = "N/A";
}
model.Overview = series.Overview;
model.Title = series.Title;
model.SeriesId = series.SeriesId;
model.HasBanner = !String.IsNullOrEmpty(series.BannerUrl);
var seasons = _seasonProvider.All(seriesId).Select(s => new SeasonModel
{
SeriesId = seriesId,
SeasonNumber = s.SeasonNumber,
Ignored = s.Ignored,
Episodes = GetEpisodeModels(s.Episodes).OrderByDescending(e => e.EpisodeNumber).ToList(),
CommonStatus = GetCommonStatus(s.Episodes)
}).ToList();
model.Seasons = seasons;
var qualities = QualityTypes.All().ToList();
model.QualitySelectList = new SelectList(qualities.Where(q => q.Id > 0), "Id", "Name");
return(View(model));
}
public virtual void SetupDefault()
{
var inDb = All();
Logger.Debug("Setting up default quality types");
foreach (var qualityType in QualityTypes.All())
{
//Skip UNKNOWN
if (qualityType.Id == 0)
{
continue;
}
var db = inDb.SingleOrDefault(s => s.QualityTypeId == qualityType.Id);
if (db == null)
{
_database.Insert(new QualityType {
QualityTypeId = qualityType.Id, Name = qualityType.Name, MinSize = 0, MaxSize = 100
});
}
}
}
public void add_item()
{
WithRealDb();
var episode = Builder <Episode> .CreateNew().Build();
QualityTypes quality = QualityTypes.HDTV720p;
const bool proper = true;
var history = new History
{
Date = DateTime.Now,
EpisodeId = episode.EpisodeId,
SeriesId = episode.SeriesId,
NzbTitle = "my title",
Indexer = "Fake Indexer",
Quality = quality,
IsProper = proper
};
//Act
Mocker.Resolve <HistoryProvider>().Add(history);
//Assert
var storedHistory = Db.Fetch <History>();
storedHistory.Should().HaveCount(1);
history.Date.Should().BeWithin(TimeSpan.FromMinutes(1)).Before(storedHistory.First().Date);
history.EpisodeId.Should().Be(storedHistory.First().EpisodeId);
history.SeriesId.Should().Be(storedHistory.First().SeriesId);
history.NzbTitle.Should().Be(storedHistory.First().NzbTitle);
history.Indexer.Should().Be(storedHistory.First().Indexer);
history.Quality.Should().Be(storedHistory.First().Quality);
history.IsProper.Should().Be(storedHistory.First().IsProper);
}
public void IsUpgradeTest(QualityTypes current, bool currentProper, QualityTypes newQuality, bool newProper, QualityTypes cutoff, bool expected)
{
new QualityUpgradeSpecification().IsSatisfiedBy(new QualityModel(current, currentProper), new QualityModel(newQuality, newProper), cutoff)
.Should().Be(expected);
}
public virtual string GetNewFilename(IList<Episode> episodes, string seriesTitle, QualityTypes quality, bool proper)
{
var sortedEpisodes = episodes.OrderBy(e => e.EpisodeNumber);
var separatorStyle = EpisodeSortingHelper.GetSeparatorStyle(_configProvider.SortingSeparatorStyle);
var numberStyle = EpisodeSortingHelper.GetNumberStyle(_configProvider.SortingNumberStyle);
string episodeNames = sortedEpisodes.First().Title;
string result = String.Empty;
if (_configProvider.SortingIncludeSeriesName)
{
result += seriesTitle + separatorStyle.Pattern;
}
result += numberStyle.Pattern.Replace("%0e", String.Format("{0:00}", sortedEpisodes.First().EpisodeNumber));
if (episodes.Count > 1)
{
var multiEpisodeStyle = EpisodeSortingHelper.GetMultiEpisodeStyle(_configProvider.SortingMultiEpisodeStyle);
foreach (var episode in sortedEpisodes.Skip(1))
{
if (multiEpisodeStyle.Name == "Duplicate")
{
result += separatorStyle.Pattern + numberStyle.Pattern;
}
else
{
result += multiEpisodeStyle.Pattern;
}
result = result.Replace("%0e", String.Format("{0:00}", episode.EpisodeNumber));
episodeNames += String.Format(" + {0}", episode.Title);
}
}
result = result
.Replace("%s", String.Format("{0}", episodes.First().SeasonNumber))
.Replace("%0s", String.Format("{0:00}", episodes.First().SeasonNumber))
.Replace("%x", numberStyle.EpisodeSeparator)
.Replace("%p", separatorStyle.Pattern);
if (_configProvider.SortingIncludeEpisodeTitle)
{
episodeNames = episodeNames.TrimEnd(' ', '+');
result += separatorStyle.Pattern + episodeNames;
}
if (_configProvider.SortingAppendQuality)
{
result += String.Format(" [{0}]", quality);
if (proper)
result += " [Proper]";
}
if (_configProvider.SortingReplaceSpaces)
result = result.Replace(' ', '.');
Logger.Trace("New File Name is: [{0}]", result.Trim());
return CleanFilename(result.Trim());
}
public void create_proper_sab_titles(int seasons, int[] episodes, string title, QualityTypes quality, bool proper, string expected)
{
var series = Builder <Series> .CreateNew()
.With(c => c.Title = "My Series Name")
.Build();
var fakeEpisodes = new List <Episode>();
foreach (var episode in episodes)
{
fakeEpisodes.Add(Builder <Episode>
.CreateNew()
.With(e => e.EpisodeNumber = episode)
.With(e => e.Title = title)
.Build());
}
var parsResult = new EpisodeParseResult()
{
AirDate = DateTime.Now,
EpisodeNumbers = episodes.ToList(),
Quality = new QualityModel(quality, proper),
SeasonNumber = seasons,
Series = series,
EpisodeTitle = title,
Episodes = fakeEpisodes
};
Mocker.Resolve <DownloadProvider>().GetDownloadTitle(parsResult).Should().Be(expected);
}
public void IsUpgradeTest(QualityTypes current, bool currentProper, QualityTypes newQuality, bool newProper, QualityTypes cutoff, bool expected)
{
new QualityUpgradeSpecification().IsSatisfiedBy(new QualityModel(current, currentProper), new QualityModel(newQuality, newProper), cutoff)
.Should().Be(expected);
}
public void should_be_able_to_convert_int_to_qualityTypes(int source, QualityTypes expected)
{
var quality = (QualityTypes)source;
quality.Should().Be(expected);
}
public virtual void ChangeQuality(int episodeFileId, QualityTypes quality)
{
_database.Execute("UPDATE EpisodeFiles SET Quality = @quality WHERE EpisodeFileId = @episodeFileId", new { episodeFileId, quality });
}
public string create_proper_sab_titles(int seasons, int[] episodes, string title, QualityTypes quality, bool proper)
{
var series = Builder<Series>.CreateNew()
.With(c => c.Title = "My Series Name")
.Build();
var parsResult = new EpisodeParseResult()
{
AirDate = DateTime.Now,
EpisodeNumbers = episodes.ToList(),
Quality = new Quality(quality, proper),
SeasonNumber = seasons,
Series = series,
EpisodeTitle = title
};
return Mocker.Resolve<DownloadProvider>().GetDownloadTitle(parsResult);
}
public void should_be_able_to_convert_int_to_qualityTypes(int source, QualityTypes expected)
{
var quality = (QualityTypes)source;
quality.Should().Be(expected);
}
public void should_be_able_to_convert_qualityTypes_to_int(QualityTypes source, int expected)
{
var i = (int)source;
i.Should().Be(expected);
}
public JsonResult ChangeSeasonQuality(int seriesId, int seasonNumber, QualityTypes quality)
{
_mediaFileProvider.ChangeQuality(seriesId, seasonNumber, quality);
return(Json("ok"));
}
public bool IsUpgradeTest(QualityTypes current, bool currentProper, QualityTypes newQuality, bool newProper, QualityTypes cutoff)
{
return new QualityUpgradeSpecification().IsSatisfiedBy(new Quality(current, currentProper), new Quality(newQuality, newProper), cutoff);
}
public JsonResult ChangeEpisodeQuality(int episodeFileId, QualityTypes quality)
{
_mediaFileProvider.ChangeQuality(episodeFileId, quality);
return(Json("ok"));
}
public void create_proper_sab_titles(int seasons, int[] episodes, string title, QualityTypes quality, bool proper, string expected)
{
var series = Builder<Series>.CreateNew()
.With(c => c.Title = "My Series Name")
.Build();
var fakeEpisodes = new List<Episode>();
foreach(var episode in episodes)
fakeEpisodes.Add(Builder<Episode>
.CreateNew()
.With(e => e.EpisodeNumber = episode)
.With(e => e.Title = title)
.Build());
var parsResult = new EpisodeParseResult()
{
AirDate = DateTime.Now,
EpisodeNumbers = episodes.ToList(),
Quality = new QualityModel(quality, proper),
SeasonNumber = seasons,
Series = series,
EpisodeTitle = title,
Episodes = fakeEpisodes
};
Mocker.Resolve<DownloadProvider>().GetDownloadTitle(parsResult).Should().Be(expected);
}
public Consumable(int hp, int mp, int id, string name, ItemTypes itemType, QualityTypes quality, string description, int capacity, int buyprice, int sellprice, string spritepath)
: base(id, name, itemType, quality, description, capacity, buyprice, sellprice, spritepath)
{
this.Hp = hp;
this.Mp = mp;
}
public Equipment(int strength, int intellect, int agility, int stamina, EquipmentTypes equipmentType, int id, string name, ItemTypes itemType, QualityTypes quality, string description, int capacity, int buyprice, int sellprice, string spritepath)
: base(id, name, itemType, quality, description, capacity, buyprice, sellprice, spritepath)
{
this.Strength = strength;
this.Intellect = intellect;
this.Agility = agility;
this.Stamina = stamina;
this.EquipmentType = equipmentType;
}
public Affirmative()
{
_innerType = QualityTypes.Affirmative;
}
public virtual string GetNewFilename(IList<Episode> episodes, string seriesTitle, QualityTypes quality, bool proper, EpisodeFile episodeFile)
{
if (_configProvider.SortingUseSceneName)
{
Logger.Trace("Attempting to use scene name");
if (String.IsNullOrWhiteSpace(episodeFile.SceneName))
{
var name = Path.GetFileNameWithoutExtension(episodeFile.Path);
Logger.Trace("Unable to use scene name, because it is null, sticking with current name: {0}", name);
return name;
}
return episodeFile.SceneName;
}
var sortedEpisodes = episodes.OrderBy(e => e.EpisodeNumber);
var separatorStyle = EpisodeSortingHelper.GetSeparatorStyle(_configProvider.SortingSeparatorStyle);
var numberStyle = EpisodeSortingHelper.GetNumberStyle(_configProvider.SortingNumberStyle);
var episodeNames = new List<String>();
episodeNames.Add(Parser.CleanupEpisodeTitle(sortedEpisodes.First().Title));
string result = String.Empty;
if (_configProvider.SortingIncludeSeriesName)
{
result += seriesTitle + separatorStyle.Pattern;
}
result += numberStyle.Pattern.Replace("%0e", String.Format("{0:00}", sortedEpisodes.First().EpisodeNumber));
if (episodes.Count > 1)
{
var multiEpisodeStyle = EpisodeSortingHelper.GetMultiEpisodeStyle(_configProvider.SortingMultiEpisodeStyle);
foreach (var episode in sortedEpisodes.Skip(1))
{
if (multiEpisodeStyle.Name == "Duplicate")
{
result += separatorStyle.Pattern + numberStyle.Pattern;
}
else
{
result += multiEpisodeStyle.Pattern;
}
result = result.Replace("%0e", String.Format("{0:00}", episode.EpisodeNumber));
episodeNames.Add(Parser.CleanupEpisodeTitle(episode.Title));
}
}
result = result
.Replace("%s", String.Format("{0}", episodes.First().SeasonNumber))
.Replace("%0s", String.Format("{0:00}", episodes.First().SeasonNumber))
.Replace("%x", numberStyle.EpisodeSeparator)
.Replace("%p", separatorStyle.Pattern);
if (_configProvider.SortingIncludeEpisodeTitle)
{
if (episodeNames.Distinct().Count() == 1)
result += separatorStyle.Pattern + episodeNames.First();
else
result += separatorStyle.Pattern + String.Join(" + ", episodeNames.Distinct());
}
if (_configProvider.SortingAppendQuality)
{
result += String.Format(" [{0}]", quality);
if (proper)
result += " [Proper]";
}
if (_configProvider.SortingReplaceSpaces)
result = result.Replace(' ', '.');
Logger.Trace("New File Name is: [{0}]", result.Trim());
return CleanFilename(result.Trim());
}
public QualityModel(QualityTypes quality, Boolean proper)
{
Quality = quality;
Proper = proper;
}
public virtual void ChangeQuality(int seriesId, int seasonNumber, QualityTypes quality)
{
_database.Execute("UPDATE EpisodeFiles SET Quality = @quality WHERE SeriesId = @seriesId AND SeasonNumber = @seasonNumber", new { seriesId, seasonNumber, quality });
}
public void quality_parse(string postTitle, QualityTypes quality, bool proper)
{
var result = Parser.ParseQuality(postTitle);
result.Quality.Should().Be(quality);
result.Proper.Should().Be(proper);
}
public void IsInQueue_should_find_double_episodes_(int season, int[] episodes, string title, QualityTypes qualityType, bool proper)
{
WithFullQueue();
var parseResult = new EpisodeParseResult
{
EpisodeTitle = "Title",
EpisodeNumbers = new List<int>(episodes),
SeasonNumber = season,
Quality = new QualityModel { Quality = qualityType, Proper = proper },
Series = new Series { Title = title, CleanTitle = Parser.NormalizeTitle(title) },
};
var result = Mocker.Resolve<SabProvider>().IsInQueue(parseResult);
result.Should().BeTrue();
}
public virtual string GetNewFilename(IList <Episode> episodes, Series series, QualityTypes quality, bool proper, EpisodeFile episodeFile)
{
if (_configProvider.SortingUseSceneName)
{
Logger.Trace("Attempting to use scene name");
if (String.IsNullOrWhiteSpace(episodeFile.SceneName))
{
var name = Path.GetFileNameWithoutExtension(episodeFile.Path);
Logger.Trace("Unable to use scene name, because it is null, sticking with current name: {0}", name);
return(name);
}
return(episodeFile.SceneName);
}
var sortedEpisodes = episodes.OrderBy(e => e.EpisodeNumber);
var separatorStyle = EpisodeSortingHelper.GetSeparatorStyle(_configProvider.SortingSeparatorStyle);
var numberStyle = EpisodeSortingHelper.GetNumberStyle(_configProvider.SortingNumberStyle);
var episodeNames = new List <String>();
episodeNames.Add(Parser.CleanupEpisodeTitle(sortedEpisodes.First().Title));
string result = String.Empty;
if (_configProvider.SortingIncludeSeriesName)
{
result += series.Title + separatorStyle.Pattern;
}
if (!series.IsDaily)
{
result += numberStyle.Pattern.Replace("%0e",
String.Format("{0:00}", sortedEpisodes.First().EpisodeNumber));
if (episodes.Count > 1)
{
var multiEpisodeStyle =
EpisodeSortingHelper.GetMultiEpisodeStyle(_configProvider.SortingMultiEpisodeStyle);
foreach (var episode in sortedEpisodes.Skip(1))
{
if (multiEpisodeStyle.Name == "Duplicate")
{
result += separatorStyle.Pattern + numberStyle.Pattern;
}
else
{
result += multiEpisodeStyle.Pattern;
}
result = result.Replace("%0e", String.Format("{0:00}", episode.EpisodeNumber));
episodeNames.Add(Parser.CleanupEpisodeTitle(episode.Title));
}
}
result = result
.Replace("%s", String.Format("{0}", episodes.First().SeasonNumber))
.Replace("%0s", String.Format("{0:00}", episodes.First().SeasonNumber))
.Replace("%x", numberStyle.EpisodeSeparator)
.Replace("%p", separatorStyle.Pattern);
}
else
{
if (episodes.First().AirDate.HasValue)
{
result += episodes.First().AirDate.Value.ToString("yyyy-MM-dd");
}
else
{
result += "Unknown";
}
}
if (_configProvider.SortingIncludeEpisodeTitle)
{
if (episodeNames.Distinct().Count() == 1)
{
result += separatorStyle.Pattern + episodeNames.First();
}
else
{
result += separatorStyle.Pattern + String.Join(" + ", episodeNames.Distinct());
}
}
if (_configProvider.SortingAppendQuality)
{
result += String.Format(" [{0}]", quality);
if (proper)
{
result += " [Proper]";
}
}
if (_configProvider.SortingReplaceSpaces)
{
result = result.Replace(' ', '.');
}
Logger.Trace("New File Name is: [{0}]", result.Trim());
return(CleanFilename(result.Trim()));
}
public Affirmative()
{
_innerType = QualityTypes.Affirmative;
}
public virtual void ChangeQuality(int seriesId, int seasonNumber, QualityTypes quality)
{
_database.Execute("UPDATE EpisodeFiles SET Quality = @quality WHERE SeriesId = @seriesId AND SeasonNumber = @seasonNumber", new { seriesId, seasonNumber, quality });
}
public void should_be_able_to_convert_qualityTypes_to_int(QualityTypes source, int expected)
{
var i = (int)source;
i.Should().Be(expected);
}
public JsonResult ChangeSeasonQuality(int seriesId, int seasonNumber, QualityTypes quality)
{
_mediaFileProvider.ChangeQuality(seriesId, seasonNumber, quality);
return Json("ok");
}
public Negative()
{
_innerType = QualityTypes.Negative;
}
public virtual bool IsSatisfiedBy(QualityModel currentQuality, QualityModel newQuality, QualityTypes cutOff)
{
if (currentQuality >= newQuality)
{
logger.Trace("existing item has better or equal quality. skipping");
return(false);
}
if (currentQuality.Quality == newQuality.Quality && newQuality.Proper)
{
logger.Trace("Upgrading existing item to proper.");
return(true);
}
if (currentQuality.Quality >= cutOff)
{
logger.Trace("Existing item meets cut-off. skipping.");
return(false);
}
return(true);
}
public void parsing_our_own_quality_enum(QualityTypes quality)
{
var fileName = String.Format("My series S01E01 [{0}]", quality);
var result = Parser.ParseQuality(fileName);
result.Quality.Should().Be(quality);
}
public Negative()
{
_innerType = QualityTypes.Negative;
}
public virtual void ChangeQuality(int episodeFileId, QualityTypes quality)
{
_database.Execute("UPDATE EpisodeFiles SET Quality = @quality WHERE EpisodeFileId = @episodeFileId", new { episodeFileId, quality });
}
public Material(int id, string name, ItemTypes itemType, QualityTypes quality, string description, int capacity, int buyprice, int sellprice, string spritepath)
: base(id, name, itemType, quality, description, capacity, buyprice, sellprice, spritepath)
{
}
public JsonResult ChangeEpisodeQuality(int episodeFileId, QualityTypes quality)
{
_mediaFileProvider.ChangeQuality(episodeFileId, quality);
return Json("ok");
}
public void custome_parser_partial_success(string title, int season, int episode, QualityTypes quality)
{
const string summary = "My fake summary";
var fakeSettings = Builder<IndexerDefinition>.CreateNew().Build();
Mocker.GetMock<IndexerProvider>()
.Setup(c => c.GetSettings(It.IsAny<Type>()))
.Returns(fakeSettings);
var fakeRssItem = Builder<SyndicationItem>.CreateNew()
.With(c => c.Title = new TextSyndicationContent(title))
.With(c => c.Summary = new TextSyndicationContent(summary))
.Build();
var result = Mocker.Resolve<CustomParserIndexer>().ParseFeed(fakeRssItem);
Assert.IsNotNull(result);
Assert.AreEqual(LanguageType.Finnish, result.Language);
Assert.AreEqual(season, result.SeasonNumber);
Assert.AreEqual(episode, result.EpisodeNumbers[0]);
Assert.AreEqual(quality, result.Quality.QualityType);
}
public Weapon(int damage, WeaponTypes weaponType, int id, string name, ItemTypes itemType, QualityTypes quality, string description, int capacity, int buyprice, int sellprice, string spritepath)
: base(id, name, itemType, quality, description, capacity, buyprice, sellprice, spritepath)
{
this.Damage = damage;
this.WeaponType = weaponType;
}
public void IsInQueue_should_find_double_episodes_(int season, int[] episodes, string title, QualityTypes qualityType, bool proper)
{
WithFullQueue();
var parseResult = new EpisodeParseResult
{
EpisodeTitle = "Title",
EpisodeNumbers = new List <int>(episodes),
SeasonNumber = season,
Quality = new QualityModel {
Quality = qualityType, Proper = proper
},
Series = new Series {
Title = title, CleanTitle = Parser.NormalizeTitle(title)
},
};
var result = Mocker.Resolve <SabProvider>().IsInQueue(parseResult);
result.Should().BeTrue();
}
