av-parser/tests/AvParser.UI.Tests/ParseViewModelTests.cs

using AvParser.Core.Parsing;
using AvParser.Core.Parsing.Samples;
using AvParser.Core.Settings;
using AvParser.UI.Tests.Fakes;
using AvParser.UI.ViewModels;
using Microsoft.Extensions.Logging.Abstractions;
using ReactiveUI.Primitives;
using ReactiveUI.Primitives.Concurrency;

namespace AvParser.UI.Tests;

public class ParseViewModelTests
{
    private static (ParseViewModel Page, FakeSettingsService Settings) Build(AppSettings? settings = null)
    {
        var catalog = new ParserCatalog([new DelimitedTextParser(), new KeyValueTextParser()]);
        var settingsService = new FakeSettingsService(settings);

        return (
            new ParseViewModel(
                catalog,
                settingsService,
                NullLogger<ParseViewModel>.Instance,
                ImmediateSequencer.Instance
            ),
            settingsService
        );
    }

    private static Task RunAsync(ParseViewModel page) => page.ParseCommand.Execute().ToTask();

    /// <summary>
    /// Waits until a command's gate opens.
    /// </summary>
    /// <remarks>
    /// <c>Execute()</c> completing and <c>IsExecuting</c> going false are not the same instant:
    /// the latter is published on the output scheduler. Commands gated on another command's
    /// IsExecuting therefore need the gate observed, not assumed — asserting straight after the
    /// await failed intermittently under load.
    /// </remarks>
    private static Task WhenExecutable<TParam, TResult>(ReactiveUI.ReactiveCommand<TParam, TResult> command) =>
        command.CanExecute.Where(static can => can).Take(1).ToTask(TestContext.Current.CancellationToken);

    [Fact]
    public void Restores_the_last_used_parser()
    {
        var (page, _) = Build(new AppSettings { LastParserId = "key-value" });

        page.SelectedParser.Id.ShouldBe("key-value");
    }

    [Fact]
    public void Falls_back_to_the_default_parser_for_an_unknown_id()
    {
        var (page, _) = Build(new AppSettings { LastParserId = "removed-in-a-past-version" });

        page.SelectedParser.Id.ShouldBe("delimited");
    }

    [Fact]
    public void Remembers_the_selected_parser()
    {
        var (page, settings) = Build();

        page.SelectedParser = page.Parsers.Single(p => p.Id == "key-value");

        settings.Current.LastParserId.ShouldBe("key-value");
    }

    [Theory]
    [InlineData("", false)]
    [InlineData("   ", false)]
    [InlineData("id,name\n1,Ada", true)]
    public void Parsing_requires_non_blank_input(string input, bool expected)
    {
        var (page, _) = Build();
        var canExecute = true;
        using var subscription = page.ParseCommand.CanExecute.Subscribe(value => canExecute = value);

        page.InputText = input;

        canExecute.ShouldBe(expected);
    }

    [Fact]
    public async Task Parsing_fills_the_records_collection()
    {
        var (page, _) = Build();
        page.InputText = "id,name\n1,Ada\n2,Grace";

        await RunAsync(page);

        page.Records.Count.ShouldBe(2);
        page.Errors.ShouldBeEmpty();
        page.Progress.ShouldBe(1d);
        page.StatusMessage!.ShouldContain("2 records");
    }

    [Fact]
    public async Task Bad_lines_land_in_the_errors_collection()
    {
        var (page, _) = Build();
        page.InputText = "id,name\n1\n2,Grace";

        await RunAsync(page);

        page.Records.Count.ShouldBe(1);
        page.Errors.Count.ShouldBe(1);
        page.StatusMessage!.ShouldContain("1 error");
    }

    [Fact]
    public async Task A_second_run_replaces_the_previous_results()
    {
        var (page, _) = Build();
        page.InputText = "id,name\n1,Ada\n2,Grace";
        await RunAsync(page);

        page.InputText = "id,name\n1,Ada";
        await RunAsync(page);

        page.Records.Count.ShouldBe(1);
    }

    [Fact]
    public async Task Cancelling_stops_the_run_and_says_so()
    {
        var (page, _) = Build();
        page.InputText = string.Join(
            '\n',
            Enumerable.Range(0, 200_000).Select(i => i == 0 ? "id,name" : $"{i},row{i}")
        );

        var run = RunAsync(page);
        page.CancelCommand.Execute().Subscribe(_ => { });
        await run;

        page.StatusMessage!.ShouldStartWith("Cancelled");
    }

    [Fact]
    public void Loading_the_sample_matches_the_selected_parser()
    {
        var (page, _) = Build();
        page.SelectedParser = page.Parsers.Single(p => p.Id == "key-value");

        page.LoadSampleCommand.Execute().Subscribe(_ => { });

        page.InputText.ShouldContain("host = localhost");
    }

    [Fact]
    public async Task Clearing_empties_the_input_and_the_results()
    {
        var (page, _) = Build();
        page.InputText = "id,name\n1,Ada";
        await RunAsync(page);

        await WhenExecutable(page.ClearCommand);
        await page.ClearCommand.Execute().ToTask(TestContext.Current.CancellationToken);

        page.InputText.ShouldBeEmpty();
        page.Records.ShouldBeEmpty();
        page.StatusMessage.ShouldBeNull();
        page.Progress.ShouldBe(0d);
    }
}