QA Needs AI Help Too

using System.Xml;
using System.Xml.Schema;

namespace Iso20022.Tsmt.Tests
{
    public class ReconciliationAdviceValidationTests
    {
        private const string AdviceNamespace =
            "urn:iso:std:iso:20022:tech:xsd:tsmt.053.001.01";
        private const string StatusNamespace =
            "urn:iso:std:iso:20022:tech:xsd:tsmt.054.001.01";

        // Load schema once for the test suite
        private static XmlSchemaSet LoadSchema(string xsdPath)
        {
            var schemas = new XmlSchemaSet();
            schemas.Add(null, xsdPath);
            schemas.Compile();
            return schemas;
        }

        // Validate any XML string against a compiled schema
        private static List<string> ValidateXml(string xml, XmlSchemaSet schemas)
        {
            var errors = new List<string>();
            var settings = new XmlReaderSettings { ValidationType = ValidationType.Schema };
            settings.Schemas = schemas;
            settings.ValidationEventHandler += (_, e) => errors.Add(e.Message);

            using var reader = XmlReader.Create(new StringReader(xml), settings);
            while (reader.Read()) { }
            return errors;
        }

        // --- Category 1: XML Structure ---

        [Fact]
        public void MalformedXml_ShouldThrowParserException()
        {
            var xml = "<Document><InvcPmtRcncltnAdvc></Document>"; // unclosed element
            Assert.Throws<XmlException>(() =>
                XmlReader.Create(new StringReader(xml)).Read());
        }

        [Fact]
        public void WrongNamespace_ShouldFailValidation()
        {
            var xml = WrapInDocument(
                "urn:iso:std:iso:20022:tech:xsd:tsin.008.001.01",
                "<InvcAssgnmtNtfctn/>");
            var errors = ValidateXml(xml, LoadSchema("tsmt.053.001.01.xsd"));
            Assert.NotEmpty(errors);
        }

        // --- Category 3: ReconciliationList ---

        [Fact]
        public void ItemCountMismatch_ShouldFailBusinessRule()
        {
            var msg = BuildAdvice(declaredItemCount: 3, actualItems: 1);
            var result = MessageValidator.Validate(msg);
            Assert.Contains(result.Errors, e => e.Code == "ITEM_COUNT_MISMATCH");
        }

        [Fact]
        public void ControlSumMismatch_ShouldFailBusinessRule()
        {
            var msg = BuildAdvice(declaredControlSum: 999.99m, actualSum: 4750.00m);
            var result = MessageValidator.Validate(msg);
            Assert.Contains(result.Errors, e => e.Code == "CONTROL_SUM_MISMATCH");
        }

        [Fact]
        public void ZeroPaymentAmount_ShouldFailBusinessRule()
        {
            var msg = BuildAdvice(paymentAmount: 0m);
            var result = MessageValidator.Validate(msg);
            Assert.Contains(result.Errors, e => e.Code == "ZERO_PAYMENT_AMOUNT");
        }

        // --- Category 4: FinancialItem ---

        [Fact]
        public void InvalidCreditDebitCode_ShouldFailSchema()
        {
            var xml = BuildAdviceXml(creditDebitCode: "MAYBE");
            var errors = ValidateXml(xml, LoadSchema("tsmt.053.001.01.xsd"));
            Assert.NotEmpty(errors);
        }

        [Fact]
        public void AmountArithmeticFailure_TaxPlusPretaxNotEqualTotal()
        {
            var msg = BuildAdvice(taxableAmount: 4000m, taxAmount: 500m, totalAmount: 9999m);
            var result = MessageValidator.Validate(msg);
            Assert.Contains(result.Errors, e => e.Code == "AMOUNT_ARITHMETIC_FAILURE");
        }

        // --- Category 6: Outbound Response Conformance ---

        [Fact]
        public void GeneratedStatus_ShouldPassXsdValidation()
        {
            var advice = BuildValidAdvice();
            var status = StatusGenerator.GenerateFrom(advice);
            var xml = status.Serialize();
            var errors = ValidateXml(xml, LoadSchema("tsmt.054.001.01.xsd"));
            Assert.Empty(errors); // Must be empty — a non-conformant response is never sent
        }

        [Fact]
        public void GeneratedStatus_ShouldReferenceOriginalAdvice()
        {
            var advice = BuildValidAdvice(letterId: "ADVICE-2026-001");
            var status = StatusGenerator.GenerateFrom(advice);
            Assert.Equal("ADVICE-2026-001", status.Header.RelatedDocument.Identification);
        }

        [Fact]
        public void GeneratedStatus_RecipientShouldBeOriginalAdvisor()
        {
            var advice = BuildValidAdvice(advisorBic: "BSTRUSXX");
            var status = StatusGenerator.GenerateFrom(advice);
            Assert.Equal("BSTRUSXX", status.Header.PrimaryRecipient.Party.Id.AnyBic);
        }

        // --- Category 7: Edge Cases ---

        [Fact]
        public void MaxLengthField_ExactlyAtLimit_ShouldPass()
        {
            var xml = BuildAdviceXml(partyName: new string('A', 35));
            var errors = ValidateXml(xml, LoadSchema("tsmt.053.001.01.xsd"));
            Assert.Empty(errors);
        }

        [Fact]
        public void MaxLengthField_OneBeyondLimit_ShouldFail()
        {
            var xml = BuildAdviceXml(partyName: new string('A', 36));
            var errors = ValidateXml(xml, LoadSchema("tsmt.053.001.01.xsd"));
            Assert.NotEmpty(errors);
        }

        // Helper: wrap XML in a Document element with namespace
        private static string WrapInDocument(string ns, string inner) =>
            $"<Document xmlns=\"{ns}\">{inner}</Document>";
    }
}