Add likes, follows and playlist visibility; redesign web-player UI

Backend:
- New Likes feature (toggle/get liked tracks) and endpoints
- User follow/unfollow, listening stats, public user profile
- Playlist visibility (public/private) support
- Various auth and DTO/response adjustments to support the above

Frontend (web-player):
- New design system pass: theme tokens/mode (light/dark), glass menu,
  tabs bar, player dock/extras/queue components, mix tiles, artist link
- New routes: Liked, public user profile (/u/[id]), likes API proxy
- Search refactor: shared SearchBox component used by TopBar and
  MobileHeader (search now reachable on mobile), live results as you
  type instead of requiring Enter, dropped the "Buscando…" quick-result
  preview
- Removed now-unused components (MobileNav, CoverBadge, MixBentoTile,
  PlayPauseOverlay, SuggestionsTable, userDirectory)
- Design handoff reference docs added under web-player/design_handoff_musify_player
  and web-player/docs/design-system-refactor-plan.md

backend/Tests/Musify.Application.Tests/Likes/GetLikedTracksQueryHandlerTests.cs

@@ -0,0 +1,55 @@
+using Musify.Application.Likes;
+using Musify.Application.Tests.TestSupport;
+using Musify.Domain.Entities;
+using Xunit;
+
+namespace Musify.Application.Tests.Likes
+{
+    public sealed class GetLikedTracksQueryHandlerTests : HandlerTestBase
+    {
+        private GetLikedTracksQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_MultipleLikes_ReturnsMostRecentFirst()
+        {
+            var owner = TestEntities.User();
+            var older = TestEntities.LocalTrack(owner, "Older like");
+            var newer = TestEntities.LocalTrack(owner, "Newer like");
+            await SeedAsync(
+                owner, older, newer,
+                new TrackLike { UserId = owner.Id, TrackId = older.Id, CreatedAt = DateTime.UtcNow.AddMinutes(-10) },
+                new TrackLike { UserId = owner.Id, TrackId = newer.Id, CreatedAt = DateTime.UtcNow });
+
+            var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(["Newer like", "Older like"], result.Value.Items.Select(track => track.Title));
+        }
+
+        [Fact]
+        public async Task Handle_NoLikes_ReturnsEmpty()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
+
+            var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Empty(result.Value.Items);
+        }
+
+        [Fact]
+        public async Task Handle_OtherUsersLikes_AreExcluded()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var track = TestEntities.LocalTrack(owner);
+            await SeedAsync(owner, stranger, track, new TrackLike { UserId = stranger.Id, TrackId = track.Id });
+
+            var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Empty(result.Value.Items);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Likes/ToggleTrackLikeCommandHandlerTests.cs

@@ -0,0 +1,103 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Likes;
+using Musify.Application.Services;
+using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
+using NSubstitute;
+using Xunit;
+
+namespace Musify.Application.Tests.Likes
+{
+    public sealed class ToggleTrackLikeCommandHandlerTests : HandlerTestBase
+    {
+        private readonly IYouTubeMusicService youTubeMusicService = Substitute.For<IYouTubeMusicService>();
+
+        private ToggleTrackLikeCommandHandler CreateHandler()
+        {
+            var provisioner = new YouTubeTrackProvisioner(
+                Database, youTubeMusicService, TestConfigurations.Track(), NoOpLogger<YouTubeTrackProvisioner>());
+
+            return new ToggleTrackLikeCommandHandler(Database, provisioner, NoOpLogger<ToggleTrackLikeCommandHandler>());
+        }
+
+        private static YouTubeSongResult BuildSong(string videoId) => new(
+            videoId, "Song Title", "Song Artist", "Song Album", 200, "https://img.example/thumb.jpg", false,
+            [new YouTubeArtistRef("artist-id", "Song Artist")]);
+
+        [Fact]
+        public async Task Handle_LocalTrackNotLiked_LikesIt()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.LocalTrack(owner);
+            await SeedAsync(owner, track);
+
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, track.Id, null, null), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.True(result.Value);
+            Assert.Single(await Database.TrackLikes.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task Handle_LocalTrackAlreadyLiked_UnlikesIt()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.LocalTrack(owner);
+            await SeedAsync(owner, track, new Musify.Domain.Entities.TrackLike { UserId = owner.Id, TrackId = track.Id });
+
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, track.Id, null, null), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.False(result.Value);
+            Assert.Empty(await Database.TrackLikes.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
+
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, Guid.NewGuid(), null, null), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_UnknownExternalTrack_ProvisionsAndLikesIt()
+        {
+            youTubeMusicService.GetSongAsync("new-video", Arg.Any<CancellationToken>()).Returns(BuildSong("new-video"));
+
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
+
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, null, TrackSource.YouTube, "new-video"), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.True(result.Value);
+            var track = await Database.ExternalTracks.SingleAsync(t => t.ExternalId == "new-video", TestContext.Current.CancellationToken);
+            Assert.True(await Database.TrackLikes.AnyAsync(like => like.TrackId == track.Id, TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task Handle_ExistingExternalTrack_LikesItWithoutReprovisioning()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.ExternalTrack(externalId: "abc123");
+            await SeedAsync(owner, track);
+
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, null, TrackSource.YouTube, "abc123"), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.True(result.Value);
+            await youTubeMusicService.DidNotReceive().GetSongAsync(Arg.Any<string>(), Arg.Any<CancellationToken>());
+        }
+    }
+}

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

@@ -60,6 +60,34 @@ namespace Musify.Application.Tests.PlayLists
             await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
         }
 
+        [Fact]
+        public async Task Handle_NoVisibilitySpecified_DefaultsToPrivate()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
+
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Private, result.Value.Visibility);
+        }
+
+        [Fact]
+        public async Task Handle_PublicVisibility_PersistsIt()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
+
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null, Visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
+        }
+
         [Fact]
         public async Task Handle_UserMissing_ReturnsNotFound()
         {

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

@@ -14,7 +14,7 @@ namespace Musify.Application.Tests.PlayLists
         public async Task Handle_ExistingPlayList_ReturnsItWithCoverTrackIds()
         {
             var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
             var track = TestEntities.LocalTrack(owner);
             await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
 
@@ -32,5 +32,54 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
+
+        [Fact]
+        public async Task Handle_PrivatePlayList_RequestedByOwner_ReturnsIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Private);
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
+
+        [Fact]
+        public async Task Handle_PrivatePlayList_RequestedByStranger_ReturnsNotFound()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Private);
+            await SeedAsync(owner, stranger, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, stranger.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_PrivatePlayList_RequestedAnonymously_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Private);
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_PublicPlayList_RequestedAnonymously_ReturnsIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
     }
 }

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

@@ -27,6 +27,22 @@ namespace Musify.Application.Tests.PlayLists
             Assert.Equal("Mine", playList.Name);
         }
 
+        [Fact]
+        public async Task Handle_OnlyPublic_ReturnsOnlyPublicPlayLists()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(
+                owner,
+                TestEntities.PlayList(owner.Id, "Public one", visibility: PlaylistVisibility.Public),
+                TestEntities.PlayList(owner.Id, "Private one", visibility: PlaylistVisibility.Private));
+
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10, OnlyPublic: true), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var playList = Assert.Single(result.Value.Items);
+            Assert.Equal("Public one", playList.Name);
+        }
+
         [Fact]
         public async Task Handle_NameFilter_ReturnsOnlyMatchingPlayLists()
         {

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

@@ -62,6 +62,36 @@ namespace Musify.Application.Tests.PlayLists
             Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
         }
 
+        [Fact]
+        public async Task Handle_NewVisibility_UpdatesIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
+
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, null, Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
+        }
+
+        [Fact]
+        public async Task Handle_NoVisibilitySpecified_LeavesItUnchanged()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            await SeedAsync(owner, playList);
+
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
+        }
+
         [Fact]
         public async Task Handle_BlankNameAndDescription_LeavesThemUnchanged()
         {

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

@@ -126,6 +126,26 @@ namespace Musify.Application.Tests.TestSupport
 
             modelBuilder.Entity<MixItem>()
                 .HasIndex(item => new { item.MixId, item.Position });
+
+            modelBuilder.Entity<TrackLike>()
+                .HasIndex(like => new { like.UserId, like.TrackId })
+                .IsUnique();
+
+            modelBuilder.Entity<UserFollow>()
+                .HasOne(follow => follow.Follower)
+                .WithMany()
+                .HasForeignKey(follow => follow.FollowerId)
+                .OnDelete(DeleteBehavior.Restrict);
+
+            modelBuilder.Entity<UserFollow>()
+                .HasOne(follow => follow.Followed)
+                .WithMany()
+                .HasForeignKey(follow => follow.FollowedId)
+                .OnDelete(DeleteBehavior.Restrict);
+
+            modelBuilder.Entity<UserFollow>()
+                .HasIndex(follow => new { follow.FollowerId, follow.FollowedId })
+                .IsUnique();
         }
 
         public DbSet<User> Users => Set<User>();
@@ -164,6 +184,10 @@ namespace Musify.Application.Tests.TestSupport
 
         public DbSet<ListeningHistory> ListeningHistories => Set<ListeningHistory>();
 
+        public DbSet<TrackLike> TrackLikes => Set<TrackLike>();
+
+        public DbSet<UserFollow> UserFollows => Set<UserFollow>();
+
         public async Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken)
         {
             var transaction = await Database.BeginTransactionAsync(isolationLevel, cancellationToken);

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

@@ -111,7 +111,8 @@ namespace Musify.Application.Tests.TestSupport
             string name = "Test Playlist",
             string? description = null,
             PlayListPictures? pictures = null,
-            LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active) =>
+            LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active,
+            PlaylistVisibility visibility = PlaylistVisibility.Private) =>
             new()
             {
                 UserId = userId,
@@ -119,7 +120,8 @@ namespace Musify.Application.Tests.TestSupport
                 NormalizedName = name.ToUpperInvariant(),
                 Description = description,
                 Pictures = pictures ?? PlayListPictures(),
-                LifeCycleStatus = lifeCycleStatus
+                LifeCycleStatus = lifeCycleStatus,
+                Visibility = visibility
             };
 
         public static AlbumPictures AlbumPictures() => new()

backend/Tests/Musify.Application.Tests/Users/FollowUserCommandHandlerTests.cs

@@ -0,0 +1,61 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Users;
+using Xunit;
+
+namespace Musify.Application.Tests.Users
+{
+    public sealed class FollowUserCommandHandlerTests : HandlerTestBase
+    {
+        private FollowUserCommandHandler CreateHandler() => new(Database, NoOpLogger<FollowUserCommandHandler>());
+
+        [Fact]
+        public async Task Handle_ValidTarget_CreatesFollow()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed);
+
+            var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Single(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task Handle_AlreadyFollowing_IsIdempotent()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed, new Musify.Domain.Entities.UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
+
+            var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Single(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task Handle_SelfFollow_ReturnsValidationError()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
+
+            var result = await CreateHandler().Handle(new FollowUserCommand(user.Id, user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_TargetMissing_ReturnsNotFound()
+        {
+            var follower = TestEntities.User();
+            await SeedAsync(follower);
+
+            var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, 404), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Users/GetListeningStatsQueryHandlerTests.cs

@@ -0,0 +1,87 @@
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Users;
+using Xunit;
+
+namespace Musify.Application.Tests.Users
+{
+    public sealed class GetListeningStatsQueryHandlerTests : HandlerTestBase
+    {
+        private GetListeningStatsQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_NoHistory_ReturnsZeroes()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(0, result.TracksThisWeek);
+            Assert.Equal(0, result.SecondsThisWeek);
+            Assert.Equal(0, result.StreakDays);
+        }
+
+        [Fact]
+        public async Task Handle_ListensThisWeek_CountsDistinctTracksAndTotalSeconds()
+        {
+            var user = TestEntities.User();
+            var trackA = TestEntities.LocalTrack(user, "Track A", durationSeconds: 200);
+            var trackB = TestEntities.LocalTrack(user, "Track B", durationSeconds: 100);
+            await SeedAsync(
+                user, trackA, trackB,
+                TestEntities.ListeningHistory(user.Id, trackA.Id, DateTime.UtcNow.AddDays(-1)),
+                TestEntities.ListeningHistory(user.Id, trackA.Id, DateTime.UtcNow.AddHours(-1)),
+                TestEntities.ListeningHistory(user.Id, trackB.Id, DateTime.UtcNow),
+                TestEntities.ListeningHistory(user.Id, trackB.Id, DateTime.UtcNow.AddDays(-10)));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(2, result.TracksThisWeek);
+            Assert.Equal(500, result.SecondsThisWeek);
+        }
+
+        [Fact]
+        public async Task Handle_ListenedTodayAndYesterday_StreakIsTwo()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.LocalTrack(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow),
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-1)));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(2, result.StreakDays);
+        }
+
+        [Fact]
+        public async Task Handle_GapBeforeToday_StopsStreakAtGap()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.LocalTrack(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow),
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-2)));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(1, result.StreakDays);
+        }
+
+        [Fact]
+        public async Task Handle_NoListenToday_StreakIsZero()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.LocalTrack(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-1)));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(0, result.StreakDays);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Users/GetUserProfileQueryHandlerTests.cs

@@ -0,0 +1,41 @@
+using ErrorOr;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Users;
+using Musify.Domain.Entities;
+using Xunit;
+
+namespace Musify.Application.Tests.Users
+{
+    public sealed class GetUserProfileQueryHandlerTests : HandlerTestBase
+    {
+        private GetUserProfileQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_ExistingUser_ReturnsFollowerAndFollowingCounts()
+        {
+            var user = TestEntities.User(1, "user");
+            var followerA = TestEntities.User(2, "followerA");
+            var followerB = TestEntities.User(3, "followerB");
+            var followed = TestEntities.User(4, "followed");
+            await SeedAsync(
+                user, followerA, followerB, followed,
+                new UserFollow { FollowerId = followerA.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = followerB.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = user.Id, FollowedId = followed.Id });
+
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(2, result.Value.FollowersCount);
+            Assert.Equal(1, result.Value.FollowingCount);
+        }
+
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(404), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Users/IsFollowingUserQueryHandlerTests.cs

@@ -0,0 +1,36 @@
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Users;
+using Musify.Domain.Entities;
+using Xunit;
+
+namespace Musify.Application.Tests.Users
+{
+    public sealed class IsFollowingUserQueryHandlerTests : HandlerTestBase
+    {
+        private IsFollowingUserQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_Following_ReturnsTrue()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed, new UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
+
+            var result = await CreateHandler().Handle(new IsFollowingUserQuery(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.True(result);
+        }
+
+        [Fact]
+        public async Task Handle_NotFollowing_ReturnsFalse()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed);
+
+            var result = await CreateHandler().Handle(new IsFollowingUserQuery(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Users/UnfollowUserCommandHandlerTests.cs

@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Users;
+using Musify.Domain.Entities;
+using Xunit;
+
+namespace Musify.Application.Tests.Users
+{
+    public sealed class UnfollowUserCommandHandlerTests : HandlerTestBase
+    {
+        private UnfollowUserCommandHandler CreateHandler() => new(Database, NoOpLogger<UnfollowUserCommandHandler>());
+
+        [Fact]
+        public async Task Handle_ExistingFollow_RemovesIt()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed, new UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
+
+            var result = await CreateHandler().Handle(new UnfollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Empty(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task Handle_NotFollowing_IsIdempotent()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed);
+
+            var result = await CreateHandler().Handle(new UnfollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
+    }
+}