DodoSSH/tests/DodoSSH.Client.App.Tests/TransferQueueingTests.cs

using Avalonia.Threading;
using DodoSSH.Client.Shell.ViewModels;
using DodoSSH.Client.Ssh;
using NSubstitute;

namespace DodoSSH.Client.App.Tests;

/// <summary>
/// What may be queued for transfer, and what is said about the rest.
/// </summary>
/// <remarks>
/// <para>
/// This is the whole of what drag and drop decides. The handlers on the screen extract paths or rows from a
/// drop and hand them here; every rule about which of them can be moved, which are skipped and what the
/// status line says lives in the view model, where it needs no window.
/// </para>
/// <para>
/// <b>What these cannot cover is the drag itself.</b> Headless Avalonia has no native window and cannot
/// synthesise a platform drag, so a test that pretended to drop a file from the file manager would pass
/// while confirming nothing. The wiring is verified by hand — see <c>docs/manual-checks.md</c> — and what
/// is automated is the half that a person checking by eye would most easily get wrong: the counting.
/// </para>
/// </remarks>
public sealed class TransferQueueingTests : IDisposable
{
    private readonly string directory =
        Path.Combine(Path.GetTempPath(), $"dodossh-drop-{Guid.CreateVersion7():N}");

    private readonly TransfersViewModel transfers =
        new(Substitute.For<ISftpSessionFactory>(), TimeProvider.System);

    public TransferQueueingTests() => Directory.CreateDirectory(directory);

    /// <inheritdoc />
    public void Dispose()
    {
        if (Directory.Exists(directory))
        {
            Directory.Delete(directory, recursive: true);
        }
    }

    /// <remarks>
    /// The refusal that has to happen before anything else: there is nowhere to put a file until a host is
    /// connected, and a queue that filled up first would start failing the moment one was.
    /// </remarks>
    [Fact]
    public void DroppingFilesWhileDisconnected_QueuesNothingAndSaysWhy()
    {
        transfers.IsConnected = false;

        transfers.QueueUploads([File("one.txt")]);

        Queued().ShouldBeEmpty();
        transfers.Status.ShouldContain("Connect to a host first");
    }

    [Fact]
    public void DroppingSeveralFiles_QueuesEachOfThem()
    {
        Connected();

        transfers.QueueUploads([File("one.txt"), File("two.txt"), File("three.txt")]);

        Queued().Count.ShouldBe(3);
        transfers.Status.ShouldContain("3 files");
        transfers.Status.ShouldContain("/srv/app");
    }

    /// <remarks>
    /// The queue moves files. There is no recursive upload, and a folder dragged in and silently ignored
    /// looks exactly like a transfer that failed to start — so it is counted and reported.
    /// </remarks>
    [Fact]
    public void DroppingAFolderAmongFiles_SkipsItAndSaysSo()
    {
        Connected();

        var folder = Path.Combine(directory, "a-folder");
        Directory.CreateDirectory(folder);

        transfers.QueueUploads([File("one.txt"), folder]);

        Queued().ShouldHaveSingleItem();
        transfers.Status.ShouldContain("1 file");
        transfers.Status.ShouldContain("1 folder was skipped");
    }

    /// <remarks>
    /// The paths in an operating-system drop come from another process and are not obliged to still be
    /// right by the time the drop lands.
    /// </remarks>
    [Fact]
    public void DroppingAFileThatHasGone_SkipsItAndSaysSo()
    {
        Connected();

        transfers.QueueUploads([File("one.txt"), Path.Combine(directory, "never-existed.txt")]);

        Queued().ShouldHaveSingleItem();
        transfers.Status.ShouldContain("1 item was no longer there");
    }

    [Fact]
    public void DroppingOnlyFolders_QueuesNothingAndDoesNotClaimOtherwise()
    {
        Connected();

        var folder = Path.Combine(directory, "a-folder");
        Directory.CreateDirectory(folder);

        transfers.QueueUploads([folder]);

        Queued().ShouldBeEmpty();
        transfers.Status.ShouldContain("Nothing was queued");
        transfers.Status.ShouldContain("1 folder was skipped");
    }

    [Fact]
    public void DroppingRemoteRowsOnTheLocalPane_QueuesDownloads()
    {
        Connected();

        transfers.QueueDownloads([RemoteFile("one.log"), RemoteFile("two.log")]);

        Queued().Count.ShouldBe(2);
        transfers.Status.ShouldContain("2 files");
        transfers.Status.ShouldContain("download into");
    }

    [Fact]
    public void DroppingARemoteDirectory_SkipsItAndSaysSo()
    {
        Connected();

        transfers.QueueDownloads([RemoteFile("one.log"), RemoteDirectory("logs")]);

        Queued().ShouldHaveSingleItem();
        transfers.Status.ShouldContain("1 folder was skipped");
    }

    /// <remarks>
    /// The buttons were the only way to queue anything before drag and drop, and they now go through the
    /// same two methods — so there is one set of rules rather than two that have to agree. This is what
    /// says they still do.
    /// </remarks>
    [Fact]
    public void TheDownloadButton_GoesThroughTheSamePathAsADrop()
    {
        Connected();

        transfers.SelectedRemoteEntry = RemoteFile("one.log");
        transfers.DownloadCommand.Execute(null);

        Queued().ShouldHaveSingleItem();

        // And refuses a directory in the same words, rather than with the button's own message.
        transfers.SelectedRemoteEntry = RemoteDirectory("logs");
        transfers.DownloadCommand.Execute(null);

        Queued().Count.ShouldBe(1);
        transfers.Status.ShouldContain("1 folder was skipped");
    }

    /// <summary>The queue's rows, once the posts that create them have been let run.</summary>
    /// <remarks>
    /// <c>TransfersViewModel</c> adds a row from the queue's own <c>Changed</c> event, which it marshals
    /// through <c>Dispatcher.UIThread</c> because the queue raises it from a pump thread. There is no
    /// Avalonia application here to drain that, so the posts are run by hand — the alternative is asserting
    /// on the status line alone, which is a string this code wrote about itself and proves nothing about
    /// anything having been enqueued.
    /// </remarks>
    private IReadOnlyList<TransferRowViewModel> Queued()
    {
        Dispatcher.UIThread.RunJobs();

        return transfers.Transfers;
    }

    private void Connected()
    {
        transfers.IsConnected = true;
        transfers.RemotePath = "/srv/app";
        transfers.LocalPath = directory;
    }

    private string File(string name)
    {
        var path = Path.Combine(directory, name);
        System.IO.File.WriteAllText(path, "contents");

        return path;
    }

    private static RemoteEntryRowViewModel RemoteFile(string name) => new(
        new SftpEntry(name, $"/srv/app/{name}", SftpEntryKind.File, 128, DateTimeOffset.UnixEpoch, "-rw-r--r--"));

    private static RemoteEntryRowViewModel RemoteDirectory(string name) => new(
        new SftpEntry(name, $"/srv/app/{name}", SftpEntryKind.Directory, 0, DateTimeOffset.UnixEpoch, "drwxr-xr-x"));
}