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.
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);
}
}