ConsoleAssertTests.cs

using System.Runtime.InteropServices;
using System.Threading.Tasks;

namespace IntelliTect.TestTools.Console.Tests;

[TestClass]
public class ConsoleAssertTests
{
    [TestMethod]
    public void ConsoleTester_Sample_InigoMontoya()
    {
        const string view =
@"First name: <<Inigo
>>Last name: <<Montoya
>>Hello, Inigo Montoya.";

        ConsoleAssert.Expect(view,
        () =>
        {
            System.Console.Write("First name: ");
            string fname = System.Console.ReadLine();

            System.Console.Write("Last name: ");
            string lname = System.Console.ReadLine();

            System.Console.Write("Hello, {0} {1}.", fname, lname);
        });
    }

    [TestMethod]
    public async Task ConsoleTester_SampleAsync_InigoMontoya()
    {
        const string view =
@"First name: <<Inigo
>>Last name: <<Montoya
>>Hello, Inigo Montoya.";

        await ConsoleAssert.ExpectAsync(view,
        async () =>
        {
            await Task.Yield();
            System.Console.Write("First name: ");
            string fname = System.Console.ReadLine();

            System.Console.Write("Last name: ");
            string lname = System.Console.ReadLine();

            System.Console.Write("Hello, {0} {1}.", fname, lname);
        });
    }

    [TestMethod]
    public void ConsoleTester_HelloWorld_NoInput()
    {
        const string view = "Hello World";

        ConsoleAssert.Expect(view, () =>
        {
            System.Console.Write("Hello World");
        }, NormalizeOptions.None);
    }

    [TestMethod]
    public async Task ConsoleTester_HelloWorldAsync_NoInput()
    {
        const string view = "Hello World";

        await ConsoleAssert.ExpectAsync(view, async () =>
        {
            await Task.Yield();
            System.Console.Write("Hello World");
        }, NormalizeOptions.None);
    }

    [TestMethod]
    public void ConsoleTester_HelloWorld_TrimLF()
    {
        const string view = "Hello World\n";

        ConsoleAssert.Expect(view, () =>
        {
            System.Console.WriteLine("Hello World");
        });
    }

    [TestMethod]
    [DataRow("\u001b[49mMontoya", "Montoya", true)]
    [DataRow("Inigo\u001b[49mMontoya", "InigoMontoya", true)]
    [DataRow("Inigo\u001b[49m", "Inigo", true)]
    [DataRow("\u001b[49m", "", true)]
    [DataRow("\u001b[101mMontoya", "Montoya", true)]
    [DataRow("\u001b[101mMontoya", "\u001b[101mMontoya", false)]
    public void ConsoleTester_StringWithVT100Characters_VT100Stripped(string input,
        string expected,
        bool stripVT100)
    {
        NormalizeOptions options = NormalizeOptions.NormalizeLineEndings;
        if (stripVT100) options |= NormalizeOptions.StripAnsiEscapeCodes;
        
        ConsoleAssert.Expect(expected, () =>
        {
            System.Console.WriteLine(input);
        }, options);
    }

    [TestMethod]
    public void ConsoleTester_ExplicitStrippingExplicitly_VT100Stripped()
    {
        string input = "\u001b[49mMontoya";
        string expected = "Montoya";

        ConsoleAssert.Expect(expected, () =>
        {
            System.Console.Write(input);
        }, NormalizeOptions.StripAnsiEscapeCodes);
    }

    [TestMethod]
    public void GivenStringLiteral_ExpectedOutputNormalized_OutputMatches()
    {
        const string view = @"Begin
Middle
End";
        ConsoleAssert.Expect(view, () =>
        {
            System.Console.WriteLine("Begin");
            System.Console.WriteLine("Middle");
            System.Console.WriteLine("End");
        });
    }

    [TestMethod]
    public void ConsoleTester_HelloWorld_TrimCRLF()
    {
        const string view = "Hello World";

        ConsoleAssert.Expect(view, () =>
        {
            System.Console.Write("Hello World");
        });
    }

    [TestMethod]
    public void ConsoleTester_HelloWorld_DontNormalizeCRLF()
    {
        const string view = "Hello World\r\n";

        Assert.ThrowsExactly<ConsoleAssertException>(() =>
        {
            ConsoleAssert.Expect(view, () =>
            {
                System.Console.Write("Hello World\r");
            }, NormalizeOptions.None);
        });
    }

    [TestMethod]
    [DataRow("C++")]
    [DataRow("word + word")]
    [DataRow("+hello+world+")]
    public void ConsoleTester_OutputIncludesPluses_PlusesAreNotStripped(string consoleInput)
    {
        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
        {
            ConsoleAssert.Expect(consoleInput, () =>
            {
                System.Console.Write(""); // Always fail
            }, NormalizeOptions.None);
        });
        StringAssert.Contains(exception.Message, consoleInput);
    }

    [TestMethod]
    public void ConsoleTester_HelloWorld_MissingNewline()
    {
        const string view = @"Hello World
";

        ConsoleAssert.Expect(view, () =>
        {
            System.Console.WriteLine("Hello World");
        }, NormalizeOptions.None);
    }

    [TestMethod]
    public void ExecuteProcess_PingLocalhost_Success()
    {
        string expected = $@"*
Pinging * ?::1? with 32 bytes of data:
Reply from ::1: time*";
        string pingArgs = "-c 4 localhost";
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            pingArgs = pingArgs.Replace("-c ", "-n ");
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            expected = $@"PING *(::1) 56 data bytes
64 bytes from * (::1): icmp_seq=1 ttl=64 time=* ms*";
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
        {
            expected = $@"PING *(*): 56 data bytes
64 bytes from *: icmp_seq=? ttl=64 time=* ms*";
        }

        ConsoleAssert.ExecuteProcess(
            expected,
            "ping", pingArgs, out string _, out _);
    }

    [TestMethod]
    public void ExecuteLike_GivenVariableCRLFWithNLComparedToCRNL_Success()
    {
        const string expected = "(abstract, 1)\n(abstract, 2)\n\n";
        const string output = "(abstract, 1)\r\n(abstract, 2)\r\n";

        ConsoleAssert.ExpectLike(expected, () =>
        {
            System.Console.WriteLine(output);
        });
    }

    [TestMethod]
    public void ExecuteAsync_GivenVariableCRLFWithNLComparedToCRNL_Success()
    {
        const string expected = "(abstract, 1)\n(abstract, 2)\n\n";
        const string output = "(abstract, 1)\r\n(abstract, 2)\r\n";

        ConsoleAssert.ExpectLike(expected, () =>
        {
            System.Console.WriteLine(output);
        });
    }

    [TestMethod]
    public void ExpectThrows_WhenExceptionIsThrown_CapturesException()
    {
        const string view = @"Enter a number: <<invalid
>>Error: Invalid input";

        FormatException exception = ConsoleAssert.ExpectThrows<FormatException>(view, () =>
        {
            System.Console.Write("Enter a number: ");
            string input = System.Console.ReadLine();
            System.Console.Write("Error: Invalid input");
            int.Parse(input); // This will throw FormatException
        });

        Assert.IsNotNull(exception);
        Assert.IsInstanceOfType<FormatException>(exception);
    }

    [TestMethod]
    public async Task ExpectThrowsAsync_WhenExceptionIsThrown_CapturesException()
    {
        const string view = @"Enter a number: <<invalid
>>Error: Invalid input";

        FormatException exception = await ConsoleAssert.ExpectThrowsAsync<FormatException>(view, async () =>
        {
            await Task.Yield();
            System.Console.Write("Enter a number: ");
            string input = System.Console.ReadLine();
            System.Console.Write("Error: Invalid input");
            int.Parse(input); // This will throw FormatException
        });

        Assert.IsNotNull(exception);
        Assert.IsInstanceOfType<FormatException>(exception);
    }

    [TestMethod]
    public void ExpectThrows_WhenNoExceptionIsThrown_ThrowsException()
    {
        const string view = @"Hello World";

        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
        {
            ConsoleAssert.ExpectThrows<FormatException>(view, () =>
            {
                System.Console.Write("Hello World");
                // No exception thrown
            });
        });

        StringAssert.Contains(exception.Message, "Expected exception of type FormatException was not thrown");
    }

    [TestMethod]
    public async Task ExpectThrowsAsync_WhenNoExceptionIsThrown_ThrowsException()
    {
        const string view = @"Hello World";

        ConsoleAssertException exception = await Assert.ThrowsExactlyAsync<ConsoleAssertException>(async () =>
        {
            await ConsoleAssert.ExpectThrowsAsync<FormatException>(view, async () =>
            {
                await Task.Yield();
                System.Console.Write("Hello World");
                // No exception thrown
            });
        });

        StringAssert.Contains(exception.Message, "Expected exception of type FormatException was not thrown");
    }

    [TestMethod]
    public void ExpectThrows_WithDifferentExceptionType_ThrowsOriginalException()
    {
        const string view = @"Enter a number: <<invalid
>>Error: Invalid input";

        // Expecting ArgumentException but FormatException is thrown
        Assert.ThrowsExactly<FormatException>(() =>
        {
            ConsoleAssert.ExpectThrows<ArgumentException>(view, () =>
            {
                System.Console.Write("Enter a number: ");
                string input = System.Console.ReadLine();
                System.Console.Write("Error: Invalid input");
                int.Parse(input); // This throws FormatException, not ArgumentException
            });
        });
    }

    [TestMethod]
    public void ExpectThrows_WithNormalizeOptions_AppliesNormalization()
    {
        const string view = "Hello World\n";

        ArgumentException exception = ConsoleAssert.ExpectThrows<ArgumentException>(view, () =>
        {
            System.Console.WriteLine("Hello World");
            throw new ArgumentException("Test exception");
        }, NormalizeOptions.NormalizeLineEndings);

        Assert.IsNotNull(exception);
        StringAssert.Contains(exception.Message, "Test exception");
    }

    [TestMethod]
    public void ExpectThrows_WithWrongExpectedOutput_ThrowsConsoleAssertException()
    {
        const string view = "Wrong output <<invalid\n>>Error: Invalid input";

        Assert.ThrowsExactly<ConsoleAssertException>(() =>
        {
            ConsoleAssert.ExpectThrows<FormatException>(view, () =>
            {
                System.Console.Write("Enter a number: ");
                string input = System.Console.ReadLine();
                System.Console.Write("Error: Invalid input");
                int.Parse(input);
            });
        });
    }
}