#nullable enable

​

using System;

using System.Collections.Generic;

using System.Text.RegularExpressions;

using FluentAssertions;

/// <summary>

/// Unit Test Tag!

///

/// PROBLEM STATEMENT: 

/// parse a bank account number string into a microtype.

/// Implementation is in class: BankAccountNumber

/// 

/// Second phase (dont start this yet): parse a facility number string into a microtype.

/// Implementation is in class: FacilityNumber

///

/// Press "Run" above, then check the output in the pane below to see if all the tests pass and

/// the program is correct. 

/// </summary>

public class TestProgram

{

    // UNIT TESTS.

    // Guide: Add new tests to this list to check for new cases not covered by existing code.

    private static IEnumerable<TestCase> TestCases => new [] {

        // INSERT HAPPY TESTS HERE

        TestCase.For("12-1234-1234567").ExpectBankToBe("12"),

        TestCase.For("12-1234-1234567").ExpectBranchToBe("1234"),

        TestCase.For("12-1234-1234567").ExpectStemToBe("1234567"),

        TestCase.For("12-1234-1234567").ExpectNormalizedFormattedNotationToBe("12-1234-1234567"),

        // INSERT NEGATIVE TESTS HERE

        TestCase.For("I-AM-NOT-A-VALID-ACCOUNT").ExpectToFail(),

        TestCase.For("121234123456701").ExpectToFail(),

    };

    #region Test Framework

    public static void Main()

    {

        foreach(var testCase in TestCases) {

            BankAccountNumberTest(testCase);

        }

        Results();

    }

    static int pass, fail;

    static void BankAccountNumberTest(TestCase testCase) {

        Console.WriteLine($"Test: {testCase}");

        if(testCase.ExpectFailure)

            BankAccountNumberNegativeTest(testCase.Input);

        else 

            BankAccountNumberHappyTest(testCase);

    }

    static void BankAccountNumberHappyTest(TestCase testCase)

    {

        try {

            // ACT

            var actual = BankAccountNumber.ParseBankAccountNumber(testCase.Input);

​

            // ASSERT

            if(testCase.ExpectedBank != null) 

                actual.Bank.Should().Be(testCase.ExpectedBank);

            if(testCase.ExpectedBranch != null) 

                actual.Branch.Should().Be(testCase.ExpectedBranch);

            if(testCase.ExpectedStem != null) 

                actual.Stem.Should().Be(testCase.ExpectedStem);

            if(testCase.ExpectedFormatted != null) 

                actual.ToString().Should().Be(testCase.ExpectedFormatted);

            pass++;

            Console.WriteLine("PASS.\n");

        } catch(Exception e) {

            fail++;

            Console.WriteLine("FAIL: " + e.Message);

            Console.WriteLine();

        }

    }

    static void BankAccountNumberNegativeTest(string input)

    {

        Console.WriteLine($"Negative Test: {input}");

        try {

            BankAccountNumber.ParseBankAccountNumber(input);

            fail++;

            Console.WriteLine("FAIL: expectedFormatException");

            Console.WriteLine();

        }

        catch(FormatException e) {

            pass++;

            var expectedMessage = $"FacilityNumb is not in format 00 - 0000 - 0000000 - 00 - 000. Got '{input}'";

            if(e.Message != expectedMessage)

                Console.WriteLine($"FAIL: expected FormatException to have message \"{expectedMessage}\", but got \"{e.Message}\"");

            Console.WriteLine("PASS.\n");

        }

        catch(Exception e)  {

            fail++;

            Console.WriteLine("FAIL: expected FormatException, but got " + e);

            Console.WriteLine();

        }

    }

    static void Results()

    {

        Console.WriteLine($"{pass} / {pass + fail} tests passed.\n");

        Console.WriteLine(fail == 0 ? "SUCCESS!" : "FAILURE!");

    }

    class TestCase {

        public static TestCase For(string input) => new TestCase(input);

        public TestCase(string input) { Input = input; }

        public string Input { get; }

        public string? ExpectedBank; 

        public string? ExpectedBranch;

        public string? ExpectedStem;

        public string? ExpectedFormatted;

        public bool ExpectFailure;

        public TestCase ExpectBankToBe(string bank) {

            ExpectedBank = bank;

            return this;

        }

        public TestCase ExpectBranchToBe(string branch) {

            ExpectedBranch = branch;

            return this;

        }

        public TestCase ExpectStemToBe(string stem) {

            ExpectedStem = stem;

            return this;

        }

        public TestCase ExpectNormalizedFormattedNotationToBe(string formatted) {

            ExpectedFormatted = formatted;

            return this;

        }

        public TestCase ExpectToFail() {

            ExpectFailure = true;

            return this;

        }

        public override string ToString() {

            if(ExpectFailure)

                return $"{Input}, Expecting failure";

            return $"{Input} - Expecting: " 

                + $"{(ExpectedBank != null ? $"Bank={ExpectedBank}, " : "")}"

                + $"{(ExpectedBranch != null ? $"Branch={ExpectedBranch}, " : "")}"

                + $"{(ExpectedStem != null ? $"Stem={ExpectedStem}, " : "")}"

                + $"{(ExpectedFormatted != null ? $"Formatted={ExpectedFormatted}, " : "")}";

        }

    }

    #endregion

}

​

// IMPLEMENTATION HERE!!

// Phase 1 of unit test tag.

public class BankAccountNumber

{

    protected BankAccountNumber() {}

    public string Bank => "12";

​

    public string Branch => "1234";

​

    public string Stem => "1234567";

    static Regex ValidPattern = new Regex(@"^\d{2}-\d{4}-\d{7}$", RegexOptions.Compiled);

    public static BankAccountNumber ParseBankAccountNumber(string formattedBankAccountNumber)

    {

        if (formattedBankAccountNumber.Length > 15) {

            throw FormatException(formattedBankAccountNumber);

        }

        if (!ValidPattern.IsMatch(formattedBankAccountNumber)) {

            throw FormatException(formattedBankAccountNumber);

        }

        return new BankAccountNumber();

    }

    // Must return the normalized notation: hyphen separated.

    public override string ToString() {

        return "12-1234-1234567";

    }

    static FormatException FormatException(string formattedBankAccountNumber)

    {

        return new FormatException($"FacilityNumb is not in format 00 - 0000 - 0000000 - 00 - 000. Got '{formattedBankAccountNumber}'");

    }

}

​

// LEAVE THIS FOR NOW

// Phase 2 of unit test tag:

public class FacilityNumber : BankAccountNumber

{

    private FacilityNumber() : base() {}

    public string Suffix => throw new NotImplementedException();

​

    public string PaymentNumber => throw new NotImplementedException();

​

    public static FacilityNumber ParseFacilityNumber(string formattedFacilityNumber)

    {

        throw new NotImplementedException();

    }

}

​