Geradores/UnitTest/KnownValuesTests.cs

using GeradoresService;

namespace UnitTest;

/// <summary>Valores conhecidos (exemplos oficiais / números de teste públicos).</summary>
public class KnownValuesTests
{
    private static readonly GeneratorRegistry Registry = new();

    private static void AssertValid(string id, string value) =>
        Assert.True(Registry.Find(id)!.Validate(value).IsValid, $"{id}: '{value}' devia ser válido.");

    private static void AssertInvalid(string id, string value) =>
        Assert.False(Registry.Find(id)!.Validate(value).IsValid, $"{id}: '{value}' devia ser inválido.");

    [Theory]
    [InlineData("123456789")]
    [InlineData("PT 123 456 789")]
    [InlineData("100000010")] // resto 0 → dígito 0 (falhava na versão antiga)
    [InlineData("500000000")] // resto 1 → dígito 0
    [InlineData("451234561")] // prefixo 45
    public void Nif_valid(string nif) => AssertValid("nif", nif);

    [Theory]
    [InlineData("123456780")]
    [InlineData("100000011")]
    [InlineData("12345678")]
    [InlineData("412345678")] // prefixo 4 só é válido como 45
    [InlineData("abcdefghi")]
    public void Nif_invalid(string nif) => AssertInvalid("nif", nif);

    [Fact]
    public void Nipc_rejects_individual_nif()
    {
        AssertValid("nipc", "500000000");
        AssertInvalid("nipc", "123456789");
    }

    [Fact]
    public void Nif_reports_expected_check_digit()
    {
        var result = Registry.Find("nif")!.Validate("123456780");
        Assert.True(result.FormatMatch);
        Assert.Contains("esperado 9", result.Message);
    }

    [Theory]
    [InlineData("12345678902")]
    [InlineData("20000000001")]
    public void Niss_valid(string niss) => AssertValid("niss", niss);

    [Theory]
    [InlineData("12345678903")]
    [InlineData("32345678902")]
    [InlineData("1234567890")]
    public void Niss_invalid(string niss) => AssertInvalid("niss", niss);

    [Theory]
    [InlineData("00000000 0 ZZ4")] // exemplo da especificação da AMA
    [InlineData("000000000zz4")]
    public void Cc_valid(string cc) => AssertValid("cc", cc);

    [Theory]
    [InlineData("00000000 0 ZZ5")]
    [InlineData("00000000 0 ZZ")]
    public void Cc_invalid(string cc) => AssertInvalid("cc", cc);

    [Theory]
    [InlineData("PT50000201231234567890154")] // exemplo do Banco de Portugal
    [InlineData("PT50 0002 0123 1234 5678 9015 4")]
    [InlineData("GB82 WEST 1234 5698 7654 32")]
    [InlineData("DE89370400440532013000")]
    public void Iban_valid(string iban) => AssertValid("iban", iban);

    [Theory]
    [InlineData("PT50000201231234567890155")]
    [InlineData("PT51000201231234567890154")]
    [InlineData("PT5000020123123456789015")]
    [InlineData("GB82WEST12345698765433")]
    public void Iban_invalid(string iban) => AssertInvalid("iban", iban);

    [Fact]
    public void Nib_valid() => AssertValid("nib", "0002 0123 12345678901 54");

    [Theory]
    [InlineData("4111 1111 1111 1111")]
    [InlineData("5555555555554444")]
    [InlineData("2223003122003222")]
    [InlineData("378282246310005")]
    public void Card_valid(string card) => AssertValid("cartao-credito", card);

    [Theory]
    [InlineData("4111111111111112")]
    [InlineData("411111")]
    public void Card_invalid(string card) => AssertInvalid("cartao-credito", card);

    [Theory]
    [InlineData("4006381333931")]
    [InlineData("96385074")]
    public void Ean_valid(string ean) => AssertValid("ean", ean);

    [Fact]
    public void Ean_invalid() => AssertInvalid("ean", "4006381333932");

    [Theory]
    [InlineData("AA-00-AA")]
    [InlineData("00 AB 00")]
    [InlineData("12-34-XZ")]
    [InlineData("ab0012")]
    public void Matricula_valid(string m) => AssertValid("matricula", m);

    [Theory]
    [InlineData("AK-00-AA")]
    [InlineData("A1-00-AA")]
    [InlineData("AA-00-AA-00")]
    public void Matricula_invalid(string m) => AssertInvalid("matricula", m);

    [Theory]
    [InlineData("+351 912 345 678")]
    [InlineData("00351213456789")]
    [InlineData("800 123 456")]
    public void Telefone_valid(string t) => AssertValid("telefone", t);

    [Theory]
    [InlineData("942 345 678")]
    [InlineData("91234567")]
    public void Telefone_invalid(string t) => AssertInvalid("telefone", t);

    [Theory]
    [InlineData("1000-001")]
    [InlineData("4000 123")]
    public void CodigoPostal_valid(string cp) => AssertValid("codigo-postal", cp);

    [Theory]
    [InlineData("0100-001")]
    [InlineData("1000-01")]
    public void CodigoPostal_invalid(string cp) => AssertInvalid("codigo-postal", cp);

    [Theory]
    [InlineData("joao.silva@example.com")]
    public void Email_valid(string e) => AssertValid("email", e);

    [Theory]
    [InlineData("joao.silva")]
    [InlineData("joao@silva")]
    [InlineData("jo ao@example.com")]
    public void Email_invalid(string e) => AssertInvalid("email", e);

    [Fact]
    public void Multibanco_roundtrip_detects_tampering()
    {
        var mb = Registry.Find("multibanco")!;
        var value = mb.Generate(new GeradoresService.Core.GeneratorContext(new Random(1), new Dictionary<string, string?>())).Value;
        Assert.True(mb.Validate(value).IsValid);

        var parts = value.Split(' ');
        var amount = decimal.Parse(parts[^1], System.Globalization.CultureInfo.InvariantCulture) + 1;
        var tampered = string.Join(' ', parts[..^1]) + " " + amount.ToString("0.00", System.Globalization.CultureInfo.InvariantCulture);
        Assert.False(mb.Validate(tampered).IsValid);
    }

    [Fact]
    public void Uuid_versions()
    {
        Assert.Contains("versão 4", Registry.Find("uuid")!.Validate("f47ac10b-58cc-4372-a567-0e02b2c3d479").Message);
        AssertInvalid("uuid", "not-a-uuid");
    }
}