Update packages

backend/Tests/Musify.Application.Tests/PlayLists/CreatePlayListCommandHandlerTests.cs

@@ -23,7 +23,7 @@ namespace Musify.Application.Tests.PlayLists
             TestConfigurations.UploadIntent());
 
         [Fact]
-        public async Task Handle_NoPictureIntent_CreatesPlayListWithPresetPictures()
+        public async Task Handle_NoPictureIntent_CreatesPlayListWithoutPictures()
         {
             var user = TestEntities.User();
             await SeedAsync(user);
@@ -34,7 +34,7 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.False(result.IsError);
             Assert.Equal("My Playlist", result.Value.Name);
-            Assert.Equal("PresetSmallPicture.webp", result.Value.SmallImageKeyName);
+            Assert.Null(result.Value.SmallImageKeyName);
             await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
         }
 

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListCoverQueryHandlerTests.cs

@@ -34,5 +34,18 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
+
+        [Fact]
+        public async Task Handle_PlayListWithoutPictures_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            playList.Pictures = null;
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListCoverQuery(playList.Id, "small"), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

backend/Tests/Musify.Application.Tests/TestSupport/TestDatabase.cs

@@ -45,8 +45,14 @@ namespace Musify.Application.Tests.TestSupport
                 .HasForeignKey(track => track.OwnerUserId)
                 .OnDelete(DeleteBehavior.Restrict);
 
-            modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures);
-            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired();
+            modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures, pictures =>
+            {
+                pictures.Property(p => p.OriginalName).IsRequired(false);
+                pictures.Property(p => p.SmallName).IsRequired(false);
+                pictures.Property(p => p.MediumName).IsRequired(false);
+                pictures.Property(p => p.LargeName).IsRequired(false);
+            });
+            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired(false);
 
             modelBuilder.Entity<Album>().OwnsOne(album => album.Pictures);
             modelBuilder.Entity<Album>().Navigation(album => album.Pictures).IsRequired(false);

backend/Tests/Musify.Application.Tests/Tracks/GetLastTrackListenedByUserIdQueryHandlerTests.cs

@@ -0,0 +1,40 @@
+using ErrorOr;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class GetLastTrackListenedByUserIdQueryHandlerTests : HandlerTestBase
+    {
+        private GetLastTrackListenedByUserIdQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_MultipleListens_ReturnsMostRecentlyListenedTrack()
+        {
+            var owner = TestEntities.User();
+            var older = TestEntities.Track(owner, "Older listen");
+            var newer = TestEntities.Track(owner, "Newer listen");
+            await SeedAsync(
+                owner, older, newer,
+                TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
+                TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
+
+            var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal("Newer listen", result.Value.Title);
+        }
+
+        [Fact]
+        public async Task Handle_NoHistory_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
+
+            var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+    }
+}