Código

Basado en el Reloj de Cobranza que diseñé en Totalplay

Motor de enrutamiento de cobranza

Un millón de cuentas por ciclo, en paralelo y escalado horizontalmente.

C# 96%MSBuild 4%14 archivos710 líneas de código 12/12 pruebas
using System.Text.Json;
using CollectionRouter.Domain;
using CollectionRouter.Infrastructure;
using CollectionRouter.Pipeline;
using CollectionRouter.Rules;

// Runner mínimo: cada prueba es una función; si lanza excepción, falla.
var tests = new (string Name, Func<Task> Run)[]
{
    ("Cuenta en disputa nunca se gestiona", () =>
    {
        var d = RoutingRules.Route(Sample() with { IsDisputed = true, DaysPastDue = 120 }, "C1");
        Assert.Equal(Stage.Hold, d.Stage);
        Assert.Equal(ContactChannel.None, d.Channel);
        return Task.CompletedTask;
    }),
    ("Promesa de pago vigente detiene la gestión", () =>
    {
        var d = RoutingRules.Route(Sample() with { HasActivePaymentPromise = true }, "C1");
        Assert.Equal(Stage.Hold, d.Stage);
        return Task.CompletedTask;
    }),
    ("Más de 90 días va a agente especializado", () =>
    {
        var d = RoutingRules.Route(Sample() with { DaysPastDue = 91 }, "C1");
        Assert.Equal(Stage.PreLegal, d.Stage);
        Assert.Equal(ContactChannel.SpecializedAgent, d.Channel);
        return Task.CompletedTask;
    }),
    ("Etapa temprana escala de SMS a IVR y a agente", () =>
    {
        Assert.Equal(ContactChannel.Sms, RoutingRules.Route(Sample() with { DaysPastDue = 10, FailedContactsThisCycle = 0 }, "C1").Channel);
        Assert.Equal(ContactChannel.Ivr, RoutingRules.Route(Sample() with { DaysPastDue = 10, FailedContactsThisCycle = 3 }, "C1").Channel);
        Assert.Equal(ContactChannel.Agent, RoutingRules.Route(Sample() with { DaysPastDue = 10, FailedContactsThisCycle = 5 }, "C1").Channel);
        return Task.CompletedTask;
    }),
    ("La prioridad siempre está entre 0 y 100", () =>
    {
        var d = RoutingRules.Route(Sample() with { PastDueAmount = 9_999_999m, DaysPastDue = 999, Segment = Segment.Enterprise }, "C1");
        Assert.True(d.Priority is >= 0 and <= 100, $"Prioridad fuera de rango: {d.Priority}");
        return Task.CompletedTask;
    }),
    ("Las reglas son deterministas", () =>
    {
        var a = Sample();
        Assert.Equal(RoutingRules.Route(a, "C1"), RoutingRules.Route(a, "C1"));
        return Task.CompletedTask;
    }),
    ("Cada cuenta pertenece a exactamente una instancia", () =>
    {
        var instances = Enumerable.Range(0, 4).Select(i => new Partitioner(i, 4)).ToArray();
        for (long id = 1; id <= 50_000; id++)
            Assert.Equal(1, instances.Count(p => p.Owns(id)));
        return Task.CompletedTask;
    }),
    ("El particionado reparte de forma balanceada (±2%)", () =>
    {
        const int parts = 8, n = 400_000;
        var counts = new int[parts];
        for (long id = 10_000_001; id <= 10_000_000 + n; id++) counts[Partitioner.PartitionOf(id, parts)]++;
        var expected = n / (double)parts;
        foreach (var c in counts)
            Assert.True(Math.Abs(c - expected) / expected < 0.02, $"Partición desbalanceada: {c} vs {expected}");
        return Task.CompletedTask;
    }),
    ("El destino en memoria es idempotente", async () =>
    {
        var sink = new InMemoryDecisionSink();
        var batch = new[] { RoutingRules.Route(Sample(), "C1"), RoutingRules.Route(Sample() with { Id = 2 }, "C1") };
        await sink.WriteBatchAsync(batch, default);
        await sink.WriteBatchAsync(batch, default);
        Assert.Equal(2, sink.Count);
        Assert.Equal(2, sink.Duplicates);
    }),
    ("Paralelo y secuencial producen las mismas decisiones", async () =>
    {
        var s = new InMemoryDecisionSink();
        var p = new InMemoryDecisionSink();
        await new SequentialRouter(new SyntheticAccountSource(5_000), new SimulatedLatencyEnricher(TimeSpan.Zero), s, "C1").RunAsync();
        await new ParallelRouter(new SyntheticAccountSource(5_000), new SimulatedLatencyEnricher(TimeSpan.Zero), p,
            new Partitioner(0, 1), new RouterOptions("C1", DegreeOfParallelism: 16, BatchSize: 97)).RunAsync();
        Assert.Equal(5_000, p.Count);
        Assert.True(s.Decisions.OrderBy(d => d.AccountId).SequenceEqual(p.Decisions.OrderBy(d => d.AccountId)), "Las decisiones difieren");
    }),
    ("Cuatro instancias cubren todas las cuentas sin duplicar", async () =>
    {
        var shared = new InMemoryDecisionSink();
        var runs = Enumerable.Range(0, 4).Select(i => new ParallelRouter(
            new SyntheticAccountSource(8_000), new SimulatedLatencyEnricher(TimeSpan.Zero), shared,
            new Partitioner(i, 4), new RouterOptions("C1", DegreeOfParallelism: 8)).RunAsync());
        var results = await Task.WhenAll(runs);
        Assert.Equal(8_000, shared.Count);
        Assert.Equal(0, shared.Duplicates);
        Assert.Equal(8_000L, results.Sum(r => r.Owned));
    }),
    ("El cuerpo _bulk usa la clave de idempotencia como _id", () =>
    {
        var d = RoutingRules.Route(Sample(), "CICLO-1");
        var lines = ElasticsearchBulkSink.BuildBulkBody("idx", new[] { d }).TrimEnd('\n').Split('\n');
        Assert.Equal(2, lines.Length);
        using var action = JsonDocument.Parse(lines[0]);
        Assert.Equal("CICLO-1:42", action.RootElement.GetProperty("index").GetProperty("_id").GetString());
        return Task.CompletedTask;
    }),
};

var failed = 0;
foreach (var (name, run) in tests)
{
    try
    {
        await run();
        Console.WriteLine($"  ✓ {name}");
    }
    catch (Exception ex)
    {
        failed++;
        Console.WriteLine($"  ✗ {name}\n      {ex.Message}");
    }
}
Console.WriteLine($"\n{tests.Length - failed}/{tests.Length} pruebas pasaron.");
return failed == 0 ? 0 : 1;

static Account Sample() => new(42, Segment.Residential, 1_500m, 15, 0, false, false);

static class Assert
{
    public static void Equal<T>(T expected, T actual)
    {
        if (!EqualityComparer<T>.Default.Equals(expected, actual))
            throw new Exception($"Se esperaba «{expected}» y se obtuvo «{actual}».");
    }

    public static void True(bool condition, string message)
    {
        if (!condition) throw new Exception(message);
    }
}