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()); }