Instrumenting AnsiConsole for testing

[yenneferofvengerberg]

All of our tools heavily use spectre.console, however depending on the purpose of the test and which interactivity we need, there are several mocks (at different levels). To avoid serializing the tests on the System.Console object we relegated all the console-based operations into methods that are protected by an ugly (but effective) if (IsUnitTesting)....

This works like a charm, but leaves out more that 50% of the code from the unit test, and usually the defects are there.

In order to at least perform a smoke test on the remaining part, AnsiConsoleshould be turned into a moral equivalent ofITestOutputHelper`. I couldn't find a viable solution (or alternative) to achieve that in the source code. To achieve my goal I could introduce several other mocks and further reorganize the code, but I would like to solve the problem in a transparent way if possible.

Assuming that the tests are asynchronous, by altering AnsiConsole as follows

+public interface IAnsiConsoleInstrumenter
+{
+    IAnsiConsole? Instrument();
+}

public static partial class AnsiConsole
{
    public static IAnsiConsole Console
    {
        get
        {
-            return _recorder ?? _console.Value;
+            return Instrumenter?.Instrument() ?? _recorder ?? _console.Value;
        }
        set
        {
            _console = new Lazy<IAnsiConsole>(() => value);

            if (_recorder != null)
            {
                // Recreate the recorder
                _recorder = _recorder.Clone(value);
            }

            Created = true;
        }
    }

+    public static IAnsiConsoleInstrumenter? Instrumenter { get; set; } 
}

AnsiConsole can now be fed with an instrumenter like this:

internal sealed class Instrumenter: IAnsiConsoleInstrumenter
{
    private static readonly AsyncLocal<InstrumenterContext> _context = new AsyncLocal<InstrumenterContext>();
    
    public IAsyncConsole Instrument()
    {
        return _context.Value?.Console ?? throw new InvalidMockException("The call cannot be instrumented since the async context lacks the necessary data.");
    }
    
    public static void InitializeContext(InstrumenterContext context)
    {
        ArgumentNullException.ThrowIfNull(context);
        
        _context.Value = context;
    }
}

internal sealed class InstrumenterContext
{
    public TestConsole Console {get; set;}
}

The rationale is that the test would be responsible for initializing the context via Initialize, the rest would be unchanged.

Is this a viable solution? Is this something you are interested in integrate if I create a PR for it?

[patriksvensson]

@yenneferofvengerberg Out of curiousity, have you taken a look at the Spectre.Console.Testing library and the TestConsole?

[yenneferofvengerberg]

I see no global side effect, each test invokes it's own instance. While the application will use the AnsiConsole singleton, which should be a per test instance, accessible via AnsiConsole.

[patriksvensson]

The recommended approach is to inject IAnsiConsole in your app (should be registered automstically). That way you can use a TestConsole (or any other implementation) in your tests.

[yenneferofvengerberg]

If I inject IAnsiConsole, I must ensure that nobody calls AnsiConsole.XXX ever, right?

[patriksvensson]

Yes, correct. If you reference the "Spectre.Console.Analyzer" package, you will get warnings and suggestions for where you need to update your code.

[yenneferofvengerberg]

Thank you! The analyzer was silent because I wasn't propagating IAnsiConsole. Now I can see my the design flaws!