public void ForAdviseSetFromFavoriteAdviseGroup_IfAdviseSetContainsDeletedSongs_FillsPlaylistOnlyWithActiveSongs()
{
// Arrange
var deletedSong = new SongModel {
Id = new ItemId("1"), DeleteDate = new DateTime(2017, 10, 06)
};
var activeSong1 = new SongModel {
Id = new ItemId("2")
};
var activeSong2 = new SongModel {
Id = new ItemId("3")
};
var adviseSetContent = new DiscModel
{
Id = new ItemId("1"),
}
.AddSongs(deletedSong, activeSong1, activeSong2)
.AddToFolder(new FolderModel {
Name = "Some Artist"
})
.ToAdviseSet();
// Act
var target = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSetContent);
// Assert
target.Songs.Should().BeEquivalentTo(new[] { activeSong1, activeSong2 }, x => x.WithStrictOrdering());
}
public async Task RegisterAdvicePlayback_SavesUpdatedPlaybacksMemoInSessionData()
{
// Arrange
var sessionDataServiceMock = new Mock <ISessionDataService>();
sessionDataServiceMock.Setup(x => x.GetData <PlaylistAdviserMemo>("PlaylistAdviserData", CancellationToken.None))
.ReturnsAsync(new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 3, playbacksSinceFavoriteAdviseGroup: 5));
var target = new CompositePlaylistAdviser(StubDiscGrouper(), StubEmptyPlaylistAdviser(), StubEmptyPlaylistAdviser(),
StubEmptyPlaylistAdviser(), sessionDataServiceMock.Object, Options.Create(new AdviserSettings()));
// This call is required for initializing playbacks memo.
await target.Advise(Enumerable.Empty <DiscModel>(), 30, CancellationToken.None);
// Act
await target.RegisterAdvicePlayback(AdvisedPlaylist.ForAdviseSet(CreateTestAdviseSet(1)), CancellationToken.None);
// Assert
Func <PlaylistAdviserMemo, bool> validateSavedMemo = memo => memo.PlaybacksSinceHighlyRatedSongsPlaylist == 4 && memo.PlaybacksSinceFavoriteAdviseGroup == 6;
sessionDataServiceMock.Verify(x => x.SaveData("PlaylistAdviserData", It.Is <PlaylistAdviserMemo>(memo => validateSavedMemo(memo)), CancellationToken.None), Times.Once);
}
public void ForAdviseSet_ForExplicitAdviseSet_FillsTitleCorrectly()
{
// Arrange
var adviseSet = new AdviseSetModel {
Id = new ItemId("Advise Set Id"), Name = "Some Advise Set"
};
var disc1 = new DiscModel {
Id = new ItemId("1"), AdviseSetInfo = new AdviseSetInfo(adviseSet, 1), Title = "Disc 1"
};
var disc2 = new DiscModel {
Id = new ItemId("2"), AdviseSetInfo = new AdviseSetInfo(adviseSet, 2), Title = "Disc 2"
};
var folder = new FolderModel {
Name = "Some Artist"
};
folder.AddDiscs(disc1, disc2);
var adviseSetContent = new AdviseSetContent("AdviseSetContent Id");
adviseSetContent.AddDisc(disc1);
adviseSetContent.AddDisc(disc2);
// Act
var target = AdvisedPlaylist.ForAdviseSet(adviseSetContent);
// Assert
target.Title.Should().Be("Some Advise Set");
}
public async Task Advise_SortsAdviseGroups()
{
// Arrange
var adviseSet1 = CreateTestAdviseSet("1");
var adviseSet2 = CreateTestAdviseSet("2");
var adviseGroups = CreateAdviseGroups(adviseSet1, adviseSet2).ToList();
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var adviseContentSorterStub = new Mock <IAdviseContentSorter>();
adviseContentSorterStub.Setup(x => x.SortAdviseGroups(adviseGroups, playbacksInfo)).Returns(new[] { adviseGroups[1], adviseGroups[0] });
adviseContentSorterStub.Setup(x => x.SortAdviseSets(It.IsAny <IEnumerable <AdviseSetContent> >(), playbacksInfo))
.Returns <IEnumerable <AdviseSetContent>, PlaybacksInfo>((adviseSets, _) => adviseSets);
var mocker = new AutoMocker();
mocker.Use(adviseContentSorterStub);
var target = mocker.CreateInstance <RankBasedAdviser>();
// Act
var advises = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedAdvises = new[]
{
AdvisedPlaylist.ForAdviseSet(adviseSet2),
AdvisedPlaylist.ForAdviseSet(adviseSet1),
};
advises.Should().BeEquivalentTo(expectedAdvises, x => x.WithStrictOrdering());
}
private IEnumerable <AdvisedPlaylist> SplitSongsToPlaylists(IReadOnlyCollection <SongModel> songs)
{
for (var i = 0; i + settings.OneAdviseSongsNumber <= songs.Count; i += settings.OneAdviseSongsNumber)
{
yield return(AdvisedPlaylist.ForHighlyRatedSongs(songs.Skip(i).Take(settings.OneAdviseSongsNumber)));
}
}
public async Task Advise_IfAdvisesForFavoriteAdviseGroupsProvided_AdvisesAdviseSetFromFavoriteAdviseGroupsAtConfiguredIntervals()
{
// Arrange
var settings = new AdviserSettings
{
PlaybacksBetweenFavoriteAdviseGroups = 10,
};
var favoriteAdviseGroupAdvise1 = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(CreateTestAdviseSet(101));
var favoriteAdviseGroupAdvise2 = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(CreateTestAdviseSet(102));
var rankBasedAdviserStub = new Mock <IPlaylistAdviser>();
rankBasedAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Enumerable.Range(0, 100).Select(i => AdvisedPlaylist.ForAdviseSet(CreateTestAdviseSet(i))).ToList());
var favoriteAdviseGroupsAdviserStub = new Mock <IPlaylistAdviser>();
favoriteAdviseGroupsAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { favoriteAdviseGroupAdvise1, favoriteAdviseGroupAdvise2 });
var target = new CompositePlaylistAdviser(StubDiscGrouper(), rankBasedAdviserStub.Object, StubEmptyPlaylistAdviser(),
favoriteAdviseGroupsAdviserStub.Object, Mock.Of <ISessionDataService>(), Options.Create(settings));
// Act
var advises = (await target.Advise(Enumerable.Empty <DiscModel>(), 30, CancellationToken.None)).ToList();
// Assert
advises.Where(x => x.AdvisedPlaylistType == AdvisedPlaylistType.AdviseSetFromFavoriteAdviseGroup).Should().HaveCount(2);
advises[0].Should().BeSameAs(favoriteAdviseGroupAdvise1);
advises[10].Should().BeSameAs(favoriteAdviseGroupAdvise2);
}
public void ForAdviseSetFromFavoriteAdviseGroup_FillsTitleCorrectly()
{
// Arrange
var adviseSetContent = new DiscModel
{
Id = new ItemId("1"),
Title = "Some Disc",
}
.AddSongs(new SongModel {
Id = new ItemId("12345"), Artist = new ArtistModel {
Name = "Another Artist"
}
})
.AddToFolder(new FolderModel {
Name = "Some Artist"
})
.ToAdviseSet();
// Act
var target = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSetContent);
// Assert
target.Title.Should().Be("*** Some Artist / Some Disc");
}
public async Task Advise_MixesDifferentAdviseTypesCorrectly()
{
// Arrange
var highlyRatedSongsAdvise1 = AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>());
var highlyRatedSongsAdvise2 = AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>());
var favoriteAdviseGroupAdvise1 = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(CreateTestAdviseSet(101));
var favoriteAdviseGroupAdvise2 = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(CreateTestAdviseSet(102));
var rankedBasedAdvises = Enumerable.Range(1, 10).Select(i => AdvisedPlaylist.ForAdviseSet(CreateTestAdviseSet(i))).ToList();
var rankBasedAdviserStub = new Mock <IPlaylistAdviser>();
rankBasedAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>())).ReturnsAsync(rankedBasedAdvises);
var highlyRatedSongsAdviserStub = new Mock <IPlaylistAdviser>();
highlyRatedSongsAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { highlyRatedSongsAdvise1, highlyRatedSongsAdvise2 });
var favoriteAdviseGroupsAdviserStub = new Mock <IPlaylistAdviser>();
favoriteAdviseGroupsAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { favoriteAdviseGroupAdvise1, favoriteAdviseGroupAdvise2 });
var settings = new AdviserSettings
{
PlaybacksBetweenFavoriteAdviseGroups = 5,
HighlyRatedSongsAdviser = new HighlyRatedSongsAdviserSettings
{
PlaybacksBetweenHighlyRatedSongs = 10,
},
};
var target = new CompositePlaylistAdviser(StubDiscGrouper(), rankBasedAdviserStub.Object, highlyRatedSongsAdviserStub.Object,
favoriteAdviseGroupsAdviserStub.Object, Mock.Of <ISessionDataService>(), Options.Create(settings));
// Act
var advises = (await target.Advise(Enumerable.Empty <DiscModel>(), 30, CancellationToken.None)).ToList();
// Assert
var expectedAdvises = new[]
{
highlyRatedSongsAdvise1,
favoriteAdviseGroupAdvise1,
rankedBasedAdvises[0], rankedBasedAdvises[1], rankedBasedAdvises[2], rankedBasedAdvises[3],
favoriteAdviseGroupAdvise2,
rankedBasedAdvises[4], rankedBasedAdvises[5], rankedBasedAdvises[6],
highlyRatedSongsAdvise2,
rankedBasedAdvises[7], rankedBasedAdvises[8], rankedBasedAdvises[9],
};
advises.Should().BeEquivalentTo(expectedAdvises);
}
public async Task Advise_IfSongsAreAdvised_ReturnsSongsWithHigherRankFirst()
{
// Arrange
var settings = new HighlyRatedSongsAdviserSettings
{
OneAdviseSongsNumber = 3,
MaxTerms = new[]
{
new MaxRatingTerm
{
Rating = RatingModel.R10,
Days = 30,
},
},
};
var song1 = CreateTestSong(1, RatingModel.R10, new DateTime(2017, 02, 01));
var song2 = CreateTestSong(2, RatingModel.R10, new DateTime(2017, 02, 01));
var song3 = CreateTestSong(3, RatingModel.R10, new DateTime(2017, 02, 01));
var adviseSet = CreateTestAdviseSet("1", new[] { song1, song2, song3 });
var adviseGroups = CreateAdviseGroups(adviseSet);
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var adviseRankCalculatorStub = new Mock <IAdviseRankCalculator>();
adviseRankCalculatorStub.Setup(x => x.CalculateSongRank(song1, playbacksInfo)).Returns(0.25);
adviseRankCalculatorStub.Setup(x => x.CalculateSongRank(song2, playbacksInfo)).Returns(0.75);
adviseRankCalculatorStub.Setup(x => x.CalculateSongRank(song3, playbacksInfo)).Returns(0.50);
var clockStub = new Mock <IClock>();
clockStub.Setup(x => x.Now).Returns(new DateTime(2017, 10, 01));
var mocker = new AutoMocker();
mocker.Use(adviseRankCalculatorStub);
mocker.Use(clockStub);
mocker.Use(Options.Create(settings));
var target = mocker.CreateInstance <HighlyRatedSongsAdviser>();
// Act
var advises = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedAdvises = new[]
{
AdvisedPlaylist.ForHighlyRatedSongs(new[] { song2, song3, song1 }),
};
advises.Should().BeEquivalentTo(expectedAdvises, x => x.WithStrictOrdering());
}
public async Task Advise_IfAllAdviseSetsAreActive_AdvisesSetsInCorrectOrder()
{
// Arrange
// Last playback time for each advise group:
//
// adviseGroup1: 3, 2
// adviseGroup2: null
// adviseGroup3: null, 1
//
// Expected order (order within advise group is provided by inner adviser and is not changed):
//
// adviseSet21, adviseSet11, adviseSet31
var adviseSet11 = CreateTestAdviseSet("11", new[] { CreateTestSong(1, new DateTime(2018, 08, 17)) });
var adviseSet12 = CreateTestAdviseSet("12", new[] { CreateTestSong(2, new DateTime(2018, 08, 18)) });
var adviseSet21 = CreateTestAdviseSet("21", new[] { CreateTestSong(3) });
var adviseSet31 = CreateTestAdviseSet("31", new[] { CreateTestSong(4) });
var adviseSet32 = CreateTestAdviseSet("32", new[] { CreateTestSong(5, new DateTime(2018, 08, 19)) });
var adviseGroups = new[]
{
CreateAdviseGroup("1", isFavorite: true, adviseSet11, adviseSet12),
CreateAdviseGroup("2", isFavorite: true, adviseSet21),
CreateAdviseGroup("3", isFavorite: true, adviseSet31, adviseSet32),
};
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var rankBasedAdviserStub = new Mock <IPlaylistAdviser>();
rankBasedAdviserStub.Setup(x => x.Advise(adviseGroups, playbacksInfo, It.IsAny <CancellationToken>())).ReturnsAsync(CreatedAdvisedPlaylists(adviseGroups));
var mocker = new AutoMocker();
mocker.Use(rankBasedAdviserStub);
var target = mocker.CreateInstance <FavoriteAdviseGroupsAdviser>();
// Act
var advisedPlaylists = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedPlaylists = new[]
{
AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSet21),
AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSet11),
AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSet31),
};
advisedPlaylists.Should().BeEquivalentTo(expectedPlaylists, x => x.WithStrictOrdering());
}
public void ForHighlyRatedSongs_DoesNotFillAdviseSet()
{
// Arrange
// Act
var target = AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>());
// Assert
target.AdviseSet.Should().BeNull();
}
public void ForHighlyRatedSongs_FillsTitleCorrectly()
{
// Arrange
// Act
var target = AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>());
// Assert
target.Title.Should().Be("Highly Rated Songs");
}
public void ForHighlyRatedSongs_FillsSongsCorrectly()
{
// Arrange
var song1 = new SongModel();
var song2 = new SongModel();
// Act
var target = AdvisedPlaylist.ForHighlyRatedSongs(new[] { song1, song2 });
// Assert
target.Songs.Should().BeEquivalentTo(new[] { song1, song2 }, x => x.WithStrictOrdering());
}
public void RegisterPlayback_IfPlaybackAdviseIsHighlyRatedSongs_SetsPlaybacksSinceHighlyRatedSongsPlaylistToZero()
{
// Arrange
var target = new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 3, playbacksSinceFavoriteAdviseGroup: 5);
// Act
var newMemo = target.RegisterPlayback(AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>()));
// Assert
var expectedMemo = new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 0, playbacksSinceFavoriteAdviseGroup: 6);
newMemo.Should().BeEquivalentTo(expectedMemo);
}
public async Task Advise_IfTooMuchSongsAreAdvised_SplitsThemIntoSmallerPlaylists()
{
// Arrange
var settings = new HighlyRatedSongsAdviserSettings
{
OneAdviseSongsNumber = 12,
MaxTerms = new[]
{
new MaxRatingTerm
{
Rating = RatingModel.R10,
Days = 30,
},
},
};
var songs1 = Enumerable.Range(1, 12).Select(id => CreateTestSong(id, RatingModel.R10, lastPlaybackTime: null)).ToList();
var songs2 = Enumerable.Range(13, 12).Select(id => CreateTestSong(id, RatingModel.R10, lastPlaybackTime: null)).ToList();
var adviseGroups = CreateAdviseGroups(CreateTestAdviseSet("1", songs1), CreateTestAdviseSet("2", songs2));
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var clockStub = new Mock <IClock>();
clockStub.Setup(x => x.Now).Returns(new DateTime(2017, 10, 01));
var mocker = new AutoMocker();
mocker.Use(clockStub);
mocker.Use(Options.Create(settings));
var target = mocker.CreateInstance <HighlyRatedSongsAdviser>();
// Act
var advises = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedAdvises = new[]
{
AdvisedPlaylist.ForHighlyRatedSongs(songs1),
AdvisedPlaylist.ForHighlyRatedSongs(songs2),
};
advises.Should().BeEquivalentTo(expectedAdvises, x => x.WithStrictOrdering());
}
public async Task Advise_ReturnsSongsWithHighRatingListenedEarlierThanConfiguredTerm()
{
// Arrange
var settings = new HighlyRatedSongsAdviserSettings
{
OneAdviseSongsNumber = 12,
MaxTerms = new[]
{
new MaxRatingTerm
{
Rating = RatingModel.R10,
Days = 30,
},
},
};
var songs = Enumerable.Range(1, 12).Select(id => CreateTestSong(id, RatingModel.R10, new DateTime(2017, 09, 01))).ToList();
var adviseSet = CreateTestAdviseSet("1", songs);
var adviseGroups = CreateAdviseGroups(adviseSet);
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var clockStub = new Mock <IClock>();
clockStub.Setup(x => x.Now).Returns(new DateTime(2017, 10, 07));
var mocker = new AutoMocker();
mocker.Use(clockStub);
mocker.Use(Options.Create(settings));
var target = mocker.CreateInstance <HighlyRatedSongsAdviser>();
// Act
var advises = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedAdvises = new[]
{
AdvisedPlaylist.ForHighlyRatedSongs(songs),
};
advises.Should().BeEquivalentTo(expectedAdvises, x => x.WithStrictOrdering());
}
public async Task Advise_IfPlaylistAdviserMemoIsLoaded_UsesPreviousPlaybacksSinceHighlyRatedSongs()
{
// Arrange
var settings = new AdviserSettings
{
HighlyRatedSongsAdviser = new HighlyRatedSongsAdviserSettings
{
PlaybacksBetweenHighlyRatedSongs = 10,
},
};
var highlyRatedSongsAdvise1 = AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>());
var highlyRatedSongsAdvise2 = AdvisedPlaylist.ForHighlyRatedSongs(Enumerable.Empty <SongModel>());
var rankBasedAdviserStub = new Mock <IPlaylistAdviser>();
rankBasedAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Enumerable.Range(0, 100).Select(i => AdvisedPlaylist.ForAdviseSet(CreateTestAdviseSet(i))).ToList());
var highlyRatedSongsAdviserStub = new Mock <IPlaylistAdviser>();
highlyRatedSongsAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { highlyRatedSongsAdvise1, highlyRatedSongsAdvise2 });
var sessionDataServiceStub = new Mock <ISessionDataService>();
sessionDataServiceStub.Setup(x => x.GetData <PlaylistAdviserMemo>("PlaylistAdviserData", CancellationToken.None))
.ReturnsAsync(new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 2, playbacksSinceFavoriteAdviseGroup: 0));
var target = new CompositePlaylistAdviser(StubDiscGrouper(), rankBasedAdviserStub.Object, highlyRatedSongsAdviserStub.Object,
StubEmptyPlaylistAdviser(), sessionDataServiceStub.Object, Options.Create(settings));
// Act
var advises = (await target.Advise(Enumerable.Empty <DiscModel>(), 30, CancellationToken.None)).ToList();
// Assert
advises.Where(x => x.AdvisedPlaylistType == AdvisedPlaylistType.HighlyRatedSongs).Should().HaveCount(2);
advises[7].Should().BeSameAs(highlyRatedSongsAdvise1);
advises[17].Should().BeSameAs(highlyRatedSongsAdvise2);
}
public async Task Advise_SkipsDuplicatedAdviseSetsBetweenAdvisers()
{
// Arrange
var settings = new AdviserSettings
{
PlaybacksBetweenFavoriteAdviseGroups = 10,
};
var adviseSet1 = CreateTestAdviseSet(101);
var adviseSet2 = CreateTestAdviseSet(102);
var favoriteAdviseGroupAdvise1 = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSet1);
var favoriteAdviseGroupAdvise2 = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSet2);
var rankedBasedAdvises = Enumerable.Range(0, 10).Select(i => AdvisedPlaylist.ForAdviseSet(CreateTestAdviseSet(i)))
.Concat(new[] { AdvisedPlaylist.ForAdviseSet(adviseSet1) })
.Concat(Enumerable.Range(10, 20).Select(i => AdvisedPlaylist.ForAdviseSet(CreateTestAdviseSet(i))))
.Concat(new[] { AdvisedPlaylist.ForAdviseSet(adviseSet2) })
.ToList();
var rankBasedAdviserStub = new Mock <IPlaylistAdviser>();
rankBasedAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>())).ReturnsAsync(rankedBasedAdvises);
var favoriteAdviseGroupsAdviserStub = new Mock <IPlaylistAdviser>();
favoriteAdviseGroupsAdviserStub.Setup(x => x.Advise(It.IsAny <IEnumerable <AdviseGroupContent> >(), It.IsAny <PlaybacksInfo>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { favoriteAdviseGroupAdvise1, favoriteAdviseGroupAdvise2 });
var target = new CompositePlaylistAdviser(StubDiscGrouper(), rankBasedAdviserStub.Object, StubEmptyPlaylistAdviser(),
favoriteAdviseGroupsAdviserStub.Object, Mock.Of <ISessionDataService>(), Options.Create(settings));
// Act
var advises = (await target.Advise(Enumerable.Empty <DiscModel>(), 30, CancellationToken.None)).ToList();
// Assert
advises.Should().ContainSingle(a => a.AdviseSet == adviseSet1);
advises.Should().ContainSingle(a => a.AdviseSet == adviseSet2);
}
public void ForAdviseSetFromFavoriteAdviseGroup_FillsAdviseSetCorrectly()
{
// Arrange
var adviseSetContent = new DiscModel {
Id = new ItemId("1")
}
.AddToFolder(new FolderModel {
Name = "Some Artist"
})
.ToAdviseSet();
// Act
var target = AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSetContent);
// Assert
target.AdviseSet.Should().BeSameAs(adviseSetContent);
}
public void ForAdviseSet_FillsPlaylistTypeCorrectly()
{
// Arrange
var adviseSetContent = new DiscModel {
Id = new ItemId("1")
}
.AddToFolder(new FolderModel {
Name = "Some Artist"
})
.ToAdviseSet();
// Act
var target = AdvisedPlaylist.ForAdviseSet(adviseSetContent);
// Assert
target.AdvisedPlaylistType.Should().Be(AdvisedPlaylistType.AdviseSet);
}
public void ForAdviseSet_ForImplicitAdviseSet_FillsTitleCorrectly()
{
// Arrange
var adviseSetContent = new DiscModel {
Id = new ItemId("1"), Title = "Some Disc"
}
.AddToFolder(new FolderModel {
Name = "Some Artist"
})
.ToAdviseSet();
// Act
var target = AdvisedPlaylist.ForAdviseSet(adviseSetContent);
// Assert
target.Title.Should().Be("Some Artist / Some Disc");
}
public async Task Advise_IfSomeAdviseSetsAreDeleted_SkipsDeletedAdviseSets()
{
// Arrange
var deletedDisc = CreateTestDisc("1", isDeleted: true);
var activeDisc = CreateTestDisc("2", isDeleted: false);
var adviseGroup = new AdviseGroupContent("1", isFavorite: false);
adviseGroup.AddDisc(deletedDisc);
adviseGroup.AddDisc(activeDisc);
var adviseGroups = new[] { adviseGroup };
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var adviseContentSorterStub = new Mock <IAdviseContentSorter>();
adviseContentSorterStub.Setup(x => x.SortAdviseGroups(It.IsAny <IEnumerable <AdviseGroupContent> >(), playbacksInfo))
.Returns <IEnumerable <AdviseGroupContent>, PlaybacksInfo>((adviseGroups, _) => adviseGroups);
adviseContentSorterStub.Setup(x => x.SortAdviseSets(It.IsAny <IEnumerable <AdviseSetContent> >(), playbacksInfo))
.Returns <IEnumerable <AdviseSetContent>, PlaybacksInfo>((adviseSets, _) => adviseSets);
var mocker = new AutoMocker();
mocker.Use(adviseContentSorterStub);
var target = mocker.CreateInstance <RankBasedAdviser>();
// Act
var advises = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedAdvises = new[]
{
AdvisedPlaylist.ForAdviseSet(activeDisc.ToAdviseSet()),
};
advises.Should().BeEquivalentTo(expectedAdvises, x => x.WithStrictOrdering());
}
public void RegisterPlayback_IfPlaybackAdviseIsForAdviseSetFromFavoriteAdviseGroup_SetsPlaybacksSinceFavoriteAdviseGroupToZero()
{
// Arrange
var disc = new DiscModel {
Id = new ItemId("1")
}
.AddToFolder(new FolderModel());
var target = new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 3, playbacksSinceFavoriteAdviseGroup: 5);
// Act
var newMemo = target.RegisterPlayback(AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(disc.ToAdviseSet()));
// Assert
var expectedMemo = new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 4, playbacksSinceFavoriteAdviseGroup: 0);
newMemo.Should().BeEquivalentTo(expectedMemo);
}
public void RegisterPlayback_IfPlaybackIsNotSpeciallyTracked_IncrementsAllPlaybacksCounters()
{
// Arrange
var disc = new DiscModel {
Id = new ItemId("1")
}
.AddToFolder(new FolderModel());
var target = new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 3, playbacksSinceFavoriteAdviseGroup: 5);
// Act
var newMemo = target.RegisterPlayback(AdvisedPlaylist.ForAdviseSet(disc.ToAdviseSet()));
// Assert
var expectedMemo = new PlaylistAdviserMemo(playbacksSinceHighlyRatedSongsPlaylist: 4, playbacksSinceFavoriteAdviseGroup: 6);
newMemo.Should().BeEquivalentTo(expectedMemo);
}
public async Task Advise_AdvisesOnlySetsFromFavoriteAdviseGroups()
{
// Arrange
var adviseSetFromFavoriteAdviseGroup = CreateTestAdviseSet("1", new[] { CreateTestSong(1) });
var adviseSetFromNonFavoriteAdviseGroup = CreateTestAdviseSet("2", new[] { CreateTestSong(2) });
var adviseGroups = new[]
{
CreateAdviseGroup("1", isFavorite: false, adviseSetFromNonFavoriteAdviseGroup),
CreateAdviseGroup("2", isFavorite: true, adviseSetFromFavoriteAdviseGroup),
};
var playbacksInfo = new PlaybacksInfo(adviseGroups);
var rankBasedAdviserStub = new Mock <IPlaylistAdviser>();
rankBasedAdviserStub.Setup(x => x.Advise(adviseGroups, playbacksInfo, It.IsAny <CancellationToken>()))
.ReturnsAsync(CreatedAdvisedPlaylists(adviseGroups));
var mocker = new AutoMocker();
mocker.Use(rankBasedAdviserStub);
var target = mocker.CreateInstance <FavoriteAdviseGroupsAdviser>();
// Act
var advisedPlaylists = await target.Advise(adviseGroups, playbacksInfo, CancellationToken.None);
// Assert
var expectedPlaylists = new[]
{
AdvisedPlaylist.ForAdviseSetFromFavoriteAdviseGroup(adviseSetFromFavoriteAdviseGroup),
};
advisedPlaylists.Should().BeEquivalentTo(expectedPlaylists, x => x.WithStrictOrdering());
}
public bool TryDequeueRankedAdvise(out AdvisedPlaylist currentAdvise)
{
return(rankedAdvises.TryDequeue(out currentAdvise));
}
public bool TryDequeueFavoriteAdviseGroupAdvise(out AdvisedPlaylist currentAdvise)
{
return(favoriteAdviseGroupsAdvises.TryDequeue(out currentAdvise));
}
public bool TryDequeueHighlyRatedSongsAdvise(out AdvisedPlaylist currentAdvise)
{
return(highlyRatedSongsAdvises.TryDequeue(out currentAdvise));
}
public async Task RegisterAdvicePlayback(AdvisedPlaylist advise, CancellationToken cancellationToken)
{
Memo = Memo.RegisterPlayback(advise);
await sessionDataService.SaveData(PlaylistAdviserDataKey, Memo, cancellationToken);
}
public void ForAdviseSet_IfAdviseSetContainsMultipleDiscs_OrdersPlaylistSongsCorrectly()
{
// Arrange
var adviseSet = new AdviseSetModel {
Id = new ItemId("Advise Set Id"), Name = "Some Advise Set"
};
var disc1 = new DiscModel
{
Id = new ItemId("1"),
TreeTitle = "Disc 1",
AdviseSetInfo = new AdviseSetInfo(adviseSet, 2),
};
var song11 = new SongModel {
Id = new ItemId("Song 1.1")
};
var song12 = new SongModel {
Id = new ItemId("Song 1.2")
};
disc1.AddSongs(song11, song12);
var disc2 = new DiscModel
{
Id = new ItemId("2"),
TreeTitle = "Disc 2",
AdviseSetInfo = new AdviseSetInfo(adviseSet, 1),
};
var song2 = new SongModel {
Id = new ItemId("Song 2.1")
};
disc2.AddSongs(song2);
var disc3 = new DiscModel
{
Id = new ItemId("3"),
TreeTitle = "Disc 3",
AdviseSetInfo = new AdviseSetInfo(adviseSet, 3),
};
var song3 = new SongModel {
Id = new ItemId("Song 3.1")
};
disc3.AddSongs(song3);
var adviseSetContent = new AdviseSetContent("AdviseSetContent Id");
adviseSetContent.AddDisc(disc1);
adviseSetContent.AddDisc(disc2);
adviseSetContent.AddDisc(disc3);
// Act
var target = AdvisedPlaylist.ForAdviseSet(adviseSetContent);
// Assert
var expectedSongs = new[]
{
song2,
song11,
song12,
song3,
};
target.Songs.Should().BeEquivalentTo(expectedSongs, x => x.WithStrictOrdering());
}
