Musify/backend/Tests/Musify.Application.Tests/Services/YouTubeTrackProvisionerTests.cs

using Microsoft.EntityFrameworkCore;
using Musify.Application.Contracts;
using Musify.Application.Services;
using Musify.Application.Tests.TestSupport;
using NSubstitute;
using Xunit;

namespace Musify.Application.Tests.Services
{
    public sealed class YouTubeTrackProvisionerTests : HandlerTestBase
    {
        private readonly IYouTubeMusicService youTubeMusicService = Substitute.For<IYouTubeMusicService>();

        private YouTubeTrackProvisioner CreateProvisioner() =>
            new(Database, youTubeMusicService, TestConfigurations.Track(), NoOpLogger<YouTubeTrackProvisioner>());

        [Fact]
        public async Task FindAsync_UnknownVideo_ReturnsNull()
        {
            var track = await CreateProvisioner().FindAsync("missing-video", TestContext.Current.CancellationToken);

            Assert.Null(track);
        }

        [Fact]
        public async Task GetOrCreateAsync_KnownVideo_ReturnsExistingTrackWithoutCallingTheService()
        {
            var existing = TestEntities.ExternalTrack(externalId: "known-video");
            await SeedAsync(existing);

            var result = await CreateProvisioner().GetOrCreateAsync("known-video", TestContext.Current.CancellationToken);

            Assert.False(result.IsError);
            Assert.Equal(existing.Id, result.Value.Track.Id);
            await youTubeMusicService.DidNotReceiveWithAnyArgs().GetSongAsync(default!, TestContext.Current.CancellationToken);
        }

        [Fact]
        public async Task GetOrCreateAsync_NewVideo_CreatesTrackAndDeduplicatesArtistsByName()
        {
            youTubeMusicService.GetSongAsync("new-video", Arg.Any<CancellationToken>()).Returns(
                new YouTubeSongResult(
                    "new-video", "New Song", "New Artist", "Album", 210, "https://img/thumb.jpg", false,
                    [new YouTubeArtistRef(null, "New Artist"), new YouTubeArtistRef(null, "new artist")]));

            var result = await CreateProvisioner().GetOrCreateAsync("new-video", TestContext.Current.CancellationToken);

            Assert.False(result.IsError);
            Assert.Equal("New Song", result.Value.Track.Title);
            Assert.Single(await Database.Artists.ToListAsync(TestContext.Current.CancellationToken));
            Assert.Single(await Database.TrackArtists.ToListAsync(TestContext.Current.CancellationToken));
        }

        [Fact]
        public async Task GetOrCreateAsync_ServiceFails_ReturnsError()
        {
            youTubeMusicService.GetSongAsync("bad-video", Arg.Any<CancellationToken>())
                .Returns(ErrorOr.Error.NotFound(description: "Video not found"));

            var result = await CreateProvisioner().GetOrCreateAsync("bad-video", TestContext.Current.CancellationToken);

            Assert.True(result.IsError);
        }

        [Fact]
        public async Task MaterializeAlbumAsync_NewAlbum_CreatesAlbumTracksAndLinks()
        {
            var detail = new YouTubeAlbumDetail(
                new YouTubeAlbumResult("album-1", "Album Title", "Album Artist", "https://img/thumb.jpg", 2024, false, false,
                    [new YouTubeArtistRef(null, "Album Artist")]),
                Description: "desc",
                TotalDurationSeconds: 400,
                Tracks:
                [
                    new YouTubeAlbumTrack("track-1", "Track One", 200, 1, false),
                    new YouTubeAlbumTrack("track-2", "Track Two", 200, 2, false)
                ]);

            await CreateProvisioner().MaterializeAlbumAsync("album-1", detail, TestContext.Current.CancellationToken);

            Assert.Equal(2, await Database.ExternalTracks.CountAsync(TestContext.Current.CancellationToken));
            Assert.Equal(2, await Database.AlbumHasTracks.CountAsync(TestContext.Current.CancellationToken));
            Assert.Single(await Database.ExternalAlbums.ToListAsync(TestContext.Current.CancellationToken));
        }

        [Fact]
        public async Task MaterializeAlbumAsync_CalledTwice_DoesNotDuplicateTracksOrLinks()
        {
            var detail = new YouTubeAlbumDetail(
                new YouTubeAlbumResult("album-1", "Album Title", "Album Artist", "https://img/thumb.jpg", 2024, false, false, []),
                Description: "desc",
                TotalDurationSeconds: 200,
                Tracks: [new YouTubeAlbumTrack("track-1", "Track One", 200, 1, false)]);

            var provisioner = CreateProvisioner();
            await provisioner.MaterializeAlbumAsync("album-1", detail, TestContext.Current.CancellationToken);
            await provisioner.MaterializeAlbumAsync("album-1", detail, TestContext.Current.CancellationToken);

            Assert.Single(await Database.ExternalTracks.ToListAsync(TestContext.Current.CancellationToken));
            Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
            Assert.Single(await Database.ExternalAlbums.ToListAsync(TestContext.Current.CancellationToken));
        }
    }
}