public void should_delete_orphaned_items_by_book()
{
GivenAuthor();
var history = Builder <EntityHistory> .CreateNew()
.With(h => h.Quality = new QualityModel())
.With(h => h.AuthorId = _author.Id)
.BuildNew();
Db.Insert(history);
Subject.Clean();
AllStoredModels.Should().BeEmpty();
}
public void should_delete_orphaned_items_by_artist()
{
GivenAlbum();
var history = Builder <History.History> .CreateNew()
.With(h => h.Quality = new QualityModel())
.With(h => h.BookId = _album.Id)
.BuildNew();
Db.Insert(history);
Subject.Clean();
AllStoredModels.Should().BeEmpty();
}
public void should_not_delete_unorphaned_indexerstatus()
{
GivenIndexer();
var status = Builder <IndexerStatus> .CreateNew()
.With(h => h.IndexerId = _indexer.Id)
.BuildNew();
Db.Insert(status);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
AllStoredModels.Should().Contain(h => h.IndexerId == _indexer.Id);
}
public void should_not_delete_unorphaned()
{
GivenSeries();
var history = Builder <History.History> .CreateNew()
.With(h => h.Quality = new QualityModel())
.With(h => h.MovieId = _movie.Id)
.BuildNew();
Db.Insert(history);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_change_last_execution_time_when_its_in_the_past()
{
var expectedTime = DateTime.UtcNow.AddHours(-1);
var tasks = Builder <ScheduledTask> .CreateListOfSize(5)
.All()
.With(t => t.LastExecution = expectedTime)
.BuildListOfNew();
Db.InsertMany(tasks);
Subject.Clean();
AllStoredModels.ForEach(t => t.LastExecution.Should().Be(expectedTime));
}
public void should_delete_extra_files_that_dont_have_a_coresponding_movie_file()
{
var movie = Builder <Movie> .CreateNew()
.BuildNew();
Db.Insert(movie);
var extraFile = Builder <OtherExtraFile> .CreateNew()
.With(m => m.MovieId = movie.Id)
.With(m => m.MovieFileId = 10)
.BuildNew();
Db.Insert(extraFile);
Subject.Clean();
AllStoredModels.Should().BeEmpty();
}
public void should_delete_metadata_files_that_dont_have_a_coresponding_album()
{
var artist = Builder <Author> .CreateNew()
.BuildNew();
Db.Insert(artist);
var metadataFile = Builder <MetadataFile> .CreateNew()
.With(m => m.AuthorId = artist.Id)
.With(m => m.BookFileId = null)
.BuildNew();
Db.Insert(metadataFile);
Subject.Clean();
AllStoredModels.Should().BeEmpty();
}
public void should_remove_missing_import_lists_on_startup()
{
var repo = Mocker.Resolve <ImportListRepository>();
Mocker.SetConstant <IImportListRepository>(repo);
var existingImportLists = Builder <ImportListDefinition> .CreateNew().BuildNew();
existingImportLists.ConfigContract = typeof(LidarrListsSettings).Name;
repo.Insert(existingImportLists);
Subject.Handle(new ApplicationStartedEvent());
AllStoredModels.Should().NotContain(c => c.Id == existingImportLists.Id);
}
public void should_not_delete_metadata_files_that_have_a_coresponding_movie()
{
var movie = Builder <Movie> .CreateNew()
.BuildNew();
Db.Insert(movie);
var metadataFile = Builder <MetadataFile> .CreateNew()
.With(m => m.MovieId = movie.Id)
.With(m => m.MovieFileId = null)
.BuildNew();
Db.Insert(metadataFile);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_used_tags()
{
var tags = Builder <Tag> .CreateListOfSize(2).BuildList();
Db.InsertMany(tags);
var restrictions = Builder <Restriction> .CreateListOfSize(2)
.All()
.With(v => v.Tags.Add(tags[0].Id))
.BuildList();
Db.InsertMany(restrictions);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_remove_missing_indexers_on_startup()
{
var repo = Mocker.Resolve <IndexerRepository>();
Mocker.SetConstant <IIndexerRepository>(repo);
var existingIndexers = Builder <IndexerDefinition> .CreateNew().BuildNew();
repo.Insert(existingIndexers);
Subject.Handle(new ApplicationStartedEvent());
AllStoredModels.Should().NotContain(c => c.Id == existingIndexers.Id);
}
public void should_delete_metadata_files_that_dont_have_a_coresponding_episode_file()
{
var series = Builder <Series> .CreateNew()
.BuildNew();
Db.Insert(series);
var metadataFile = Builder <MetadataFile> .CreateNew()
.With(m => m.SeriesId = series.Id)
.With(m => m.EpisodeFileId = 10)
.BuildNew();
Db.Insert(metadataFile);
Subject.Clean();
AllStoredModels.Should().BeEmpty();
}
public void should_not_delete_unorphaned_pending_items()
{
var series = Builder <Movie> .CreateNew().BuildNew();
Db.Insert(series);
var pendingRelease = Builder <PendingRelease> .CreateNew()
.With(h => h.MovieId = series.Id)
.With(h => h.ParsedMovieInfo = new ParsedMovieInfo())
.With(h => h.Release = new ReleaseInfo())
.BuildNew();
Db.Insert(pendingRelease);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_delete_movie_metadata_files_that_have_moviefileid_of_zero()
{
var movie = Builder <Movie> .CreateNew()
.BuildNew();
Db.Insert(movie);
var metadataFile = Builder <MetadataFile> .CreateNew()
.With(m => m.MovieId = movie.Id)
.With(m => m.Type = MetadataType.MovieMetadata)
.With(m => m.MovieFileId = 0)
.BuildNew();
Db.Insert(metadataFile);
Subject.Clean();
AllStoredModels.Should().HaveCount(0);
}
public void should_not_delete_unorphaned_blacklist_items()
{
var movie = Builder <Movie> .CreateNew().BuildNew();
Db.Insert(movie);
var blacklist = Builder <Blacklist> .CreateNew()
.With(h => h.MovieId = new int())
.With(h => h.Quality = new QualityModel())
.With(b => b.MovieId = movie.Id)
.BuildNew();
Db.Insert(blacklist);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_unorphaned_episodes()
{
var series = Builder <Series> .CreateNew()
.BuildNew();
Db.Insert(series);
var episodes = Builder <Episode> .CreateListOfSize(2)
.TheFirst(1)
.With(e => e.SeriesId = series.Id)
.BuildListOfNew();
Db.InsertMany(episodes);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
AllStoredModels.Should().Contain(e => e.SeriesId == series.Id);
}
public void should_delete_track_metadata_files_that_have_trackfileid_of_zero()
{
var artist = Builder <Author> .CreateNew()
.BuildNew();
Db.Insert(artist);
var metadataFile = Builder <MetadataFile> .CreateNew()
.With(m => m.AuthorId = artist.Id)
.With(m => m.Type = MetadataType.BookMetadata)
.With(m => m.BookFileId = 0)
.BuildNew();
Db.Insert(metadataFile);
Subject.Clean();
AllStoredModels.Should().HaveCount(0);
}
public void should_delete_episode_metadata_files_that_have_episodefileid_of_zero()
{
var series = Builder <Series> .CreateNew()
.BuildNew();
Db.Insert(series);
var metadataFile = Builder <MetadataFile> .CreateNew()
.With(m => m.SeriesId = series.Id)
.With(m => m.Type = MetadataType.EpisodeMetadata)
.With(m => m.EpisodeFileId = 0)
.BuildNew();
Db.Insert(metadataFile);
Subject.Clean();
AllStoredModels.Should().HaveCount(0);
}
public void should_delete_subtitle_files_that_dont_have_a_coresponding_movie_file()
{
var movie = Builder <Movie> .CreateNew()
.BuildNew();
Db.Insert(movie);
var subtitleFile = Builder <SubtitleFile> .CreateNew()
.With(m => m.MovieId = movie.Id)
.With(m => m.MovieFileId = 10)
.With(m => m.Language = Language.English)
.BuildNew();
Db.Insert(subtitleFile);
Subject.Clean();
AllStoredModels.Should().BeEmpty();
}
public void should_not_delete_unorphaned_blacklist_items()
{
var artist = Builder <Artist> .CreateNew().BuildNew();
Db.Insert(artist);
var blacklist = Builder <Blacklist> .CreateNew()
.With(h => h.AlbumIds = new List <int>())
.With(h => h.Quality = new QualityModel())
.With(b => b.ArtistId = artist.Id)
.BuildNew();
Db.Insert(blacklist);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_unorphaned_blocklist_items()
{
var author = Builder <Author> .CreateNew().BuildNew();
Db.Insert(author);
var blocklist = Builder <Blocklist> .CreateNew()
.With(h => h.BookIds = new List <int>())
.With(h => h.Quality = new QualityModel())
.With(b => b.AuthorId = author.Id)
.BuildNew();
Db.Insert(blocklist);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_unorphaned_tracks()
{
var release = Builder <AlbumRelease> .CreateNew()
.BuildNew();
Db.Insert(release);
var tracks = Builder <Track> .CreateListOfSize(2)
.TheFirst(1)
.With(e => e.AlbumReleaseId = release.Id)
.BuildListOfNew();
Db.InsertMany(tracks);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
AllStoredModels.Should().Contain(e => e.AlbumReleaseId == release.Id);
}
public void New_value_should_update_old_value_new_value()
{
const string key = "MY_KEY";
const string originalValue = "OLD_VALUE";
const string newValue = "NEW_VALUE";
Db.Insert(new Config {
Key = key, Value = originalValue
});
Subject.SetValue(key, newValue);
var result = Subject.GetValue(key, "");
result.Should().Be(newValue);
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_unorphaned_episode_files()
{
var episodeFiles = Builder <EpisodeFile> .CreateListOfSize(2)
.BuildListOfNew();
Db.InsertMany(episodeFiles);
var episode = Builder <Episode> .CreateNew()
.With(e => e.EpisodeFileId = episodeFiles.First().Id)
.BuildNew();
Db.Insert(episode);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
Db.All <Episode>().Should().Contain(e => e.EpisodeFileId == AllStoredModels.First().Id);
}
public void should_not_delete_unorphaned_blacklist_items()
{
var series = Builder <Series> .CreateNew().BuildNew();
Db.Insert(series);
var blacklist = Builder <Blacklist> .CreateNew()
.With(h => h.EpisodeIds = new List <int>())
.With(h => h.Quality = new QualityModel())
.With(b => b.SeriesId = series.Id)
.BuildNew();
Db.Insert(blacklist);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_unorphaned_pending_items()
{
var artist = Builder <Artist> .CreateNew().BuildNew();
Db.Insert(artist);
var pendingRelease = Builder <PendingRelease> .CreateNew()
.With(h => h.ArtistId = artist.Id)
.With(h => h.ParsedAlbumInfo = new ParsedAlbumInfo())
.With(h => h.Release = new ReleaseInfo())
.BuildNew();
Db.Insert(pendingRelease);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void should_not_delete_unorphaned_pending_items()
{
var author = Builder <Author> .CreateNew().BuildNew();
Db.Insert(author);
var pendingRelease = Builder <PendingRelease> .CreateNew()
.With(h => h.AuthorId = author.Id)
.With(h => h.ParsedBookInfo = new ParsedBookInfo())
.With(h => h.Release = new ReleaseInfo())
.BuildNew();
Db.Insert(pendingRelease);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
}
public void Trim_Items()
{
var historyItem = Builder <History.History> .CreateListOfSize(30)
.All()
.With(c => c.Id = 0)
.TheFirst(10).With(c => c.Date = DateTime.Now)
.TheNext(20).With(c => c.Date = DateTime.Now.AddDays(-31))
.Build();
Db.InsertMany(historyItem);
AllStoredModels.Should().HaveCount(30);
Subject.Trim();
AllStoredModels.Should().HaveCount(10);
AllStoredModels.Should().OnlyContain(s => s.Date > DateTime.Now.AddDays(-30));
}
public void should_not_delete_unorphaned_albums()
{
var artist = Builder<Artist>.CreateNew()
.With(e => e.Metadata = new ArtistMetadata {Id = 1})
.BuildNew();
Db.Insert(artist);
var albums = Builder<Album>.CreateListOfSize(2)
.TheFirst(1)
.With(e => e.ArtistMetadataId = artist.Metadata.Value.Id)
.BuildListOfNew();
Db.InsertMany(albums);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
AllStoredModels.Should().Contain(e => e.ArtistMetadataId == artist.Metadata.Value.Id);
}
public void should_not_delete_unorphaned_data_by_episode()
{
GivenSeries();
GivenEpisode();
var history = Builder <History.History> .CreateListOfSize(2)
.All()
.With(h => h.SeriesId = _series.Id)
.TheFirst(1)
.With(h => h.EpisodeId = _episode.Id)
.BuildListOfNew();
Db.InsertMany(history);
Subject.Clean();
AllStoredModels.Should().HaveCount(1);
AllStoredModels.Should().Contain(h => h.EpisodeId == _episode.Id);
}
