Ir al contenido
wannacode

Ejercicio: una clase desordenada, limpiada paso a paso

En resumen: Un ejercicio de refactoring: una clase de alquiler de patinetes se limpia en cinco pasos pequeños (nombres, números mágicos, dinero, consulta separada del comando, planes) mientras los tests siguen en verde.

Problema

Los patinetes que nadie se atreve a tocar

Una empresa que alquila patinetes eléctricos cobra cada viaje con la clase RideMgr. Funciona desde hace tres años. El método Calc calcula el precio según el plan del cliente (pago por uso, estudiante o abono mensual), quita la tarifa de desbloqueo a partir del cuarto viaje del día, añade un recargo nocturno, suma los ingresos y envía un recibo:

public class RideMgr
{
    private readonly Dictionary<string, int> c = new();
    public double S { get; private set; }
    public List<string> Out { get; } = new();


    // El precio: 1 € por desbloquear y 0,15 € por minuto.
    // De noche el precio sube un 50 %.
    public double Calc(string to, string t, int m, bool f)
    {
        c[to] = c.GetValueOrDefault(to) + 1;
        double p = 0;
        if (t == "payg")
        {
            p = 1.0 + m * 0.2;
        }
        else if (t == "student")
        {
            p = (1.0 + m * 0.2) * 0.8;
        }
        else if (t == "monthly")
        {
            if (m > 45)
            {
                p = (m - 45) * 0.2;
            }
        }
        if (c[to] > 3 && t != "monthly")
        {
            p = p - 1.0;
        }
        if (f)
        {
            p = p + 0.5;
        }
        S = S + p;
        Out.Add($"{to}: {m} min, {p:F2} €");
        return p;
    }
}

El mes que viene llegan dos cambios:

  • un plan de empresa: sin tarifa de desbloqueo, 0,18 € por minuto, sin descuento en el cuarto viaje;
  • el precio antes del final: la app muestra lo que costará el viaje mientras todavía está en curso.

El segundo no se puede hacer con esta clase. Esto es lo que pasa si la app llama a Calc para mostrar el precio, y luego otra vez para cobrar:

var rides = new RideMgr();
double shown = rides.Calc("ana@example.com", "payg", 10, false);
Console.WriteLine($"Precio antes del final: {shown:F2} €");
double charged = rides.Calc("ana@example.com", "payg", 10, false);
Console.WriteLine($"Cobrado: {charged:F2} €");
Console.WriteLine($"Recibos: {rides.Out.Count}");
Console.WriteLine($"Ingresos: {rides.S:F2} €");
Salida
Precio antes del final: 3.00 €
Cobrado: 3.00 €
Recibos: 2
Ingresos: 6.00 €

Un viaje, dos recibos y 6 € de ingresos. Calc suena a pregunta, pero cuenta, suma y envía.

En esta lección no hay ninguna idea nueva. Es un ejercicio: la clase pasa por las herramientas del módulo una por una, en pasos pequeños, y después de cada paso ejecutas los tests.

Míralo

Paso 0: la red de seguridad

Primero la red, como en la lección sobre tests. Nueve tests fijan lo que la clase hace hoy: el precio de cada plan, la noche, el cuarto viaje, el recibo y los ingresos.

using Xunit;


public class RideMgrTest
{
    private const string Email = "ana@example.com";
    private readonly RideMgr rides = new();


    private string Ride(string plan, int minutes, bool night)
    {
        return Money(rides.Calc(Email, plan, minutes, night));
    }


    private static string Money(double amount)
    {
        return amount.ToString("F2");
    }


    [Fact]
    public void PayAsYouGoRide()
    {
        Assert.Equal("3.00", Ride("payg", 10, false));
    }


    [Fact]
    public void StudentRide()
    {
        Assert.Equal("2.40", Ride("student", 10, false));
    }


    [Fact]
    public void MonthlyWithinFreeMinutes()
    {
        Assert.Equal("0.00", Ride("monthly", 30, false));
    }


    [Fact]
    public void MonthlyOverFreeMinutes()
    {
        Assert.Equal("3.00", Ride("monthly", 60, false));
    }


    [Fact]
    public void NightSurcharge()
    {
        Assert.Equal("3.50", Ride("payg", 10, true));
    }


    [Fact]
    public void FourthRideUnlockIsFree()
    {
        Ride("payg", 10, false);
        Ride("payg", 10, false);
        Ride("payg", 10, false);
        Assert.Equal("2.00", Ride("payg", 10, false));
    }


    [Fact]
    public void StudentFourthRide()
    {
        // Así es hoy: el descuento es el 1 € entero, no 0,80 €.
        Ride("student", 10, false);
        Ride("student", 10, false);
        Ride("student", 10, false);
        Assert.Equal("1.40", Ride("student", 10, false));
    }


    [Fact]
    public void Receipt()
    {
        Ride("payg", 10, false);
        Assert.Equal(new[] { "ana@example.com: 10 min, 3.00 €" }, rides.Out);
    }


    [Fact]
    public void Revenue()
    {
        Ride("payg", 10, false);
        Ride("student", 10, false);
        Assert.Equal("5.40", Money(rides.S));
    }
}
Resultado
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0

Los tests llaman a la clase solo a través del auxiliar Ride. Cuando la forma de la clase cambie en los próximos pasos, cambiarán el auxiliar y las llamadas, y nunca los valores esperados.

Uno de los tests es raro. Un estudiante paga el 80 % del precio, así que desbloquear le cuesta 0,80 €. En el cuarto viaje, sin embargo, la clase quita el 1 € entero, y el estudiante paga 1,40 € en vez de 1,60 €. ¿Es un error o un regalo? No lo decides tú, y no lo decides ahora. El test fija lo que pasa hoy, con un comentario, y la pregunta va al product owner. Mientras limpias, el comportamiento no cambia, aunque parezca equivocado.

Más precisamente, para curiosos

Los importes se comparan como texto con dos decimales ("2.40"), tal como los ve el cliente. Comparar números tropezaría con los pequeños errores binarios de double:

Console.WriteLine((1.0 + 10 * 0.2) * 0.8);
Salida
2.4000000000000004

Y en el paso 3 cambiará el tipo de los importes. El texto con dos decimales es el mismo antes y después.

Míralo

Paso 1: los nombres y la bandera

t, m, f, p, c y s pasan a ser palabras (nombres). El nombre más importante es el del método: no calcula, termina el viaje. El nombre honesto es FinishRide, y ahora el efecto secundario se ve en el nombre. La clase pasa a llamarse RideBilling.

public class RideBilling
{
    private readonly Dictionary<string, int> ridesToday = new();
    public double Revenue { get; private set; }
    public List<string> Receipts { get; } = new();


    // El precio: 1 € por desbloquear y 0,15 € por minuto.
    // De noche el precio sube un 50 %.
    public double FinishRide(string email, string plan, int minutes, bool night = false)
    {
        ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
        double price = 0;
        if (plan == "payg")
        {
            price = 1.0 + minutes * 0.2;
        }
        else if (plan == "student")
        {
            price = (1.0 + minutes * 0.2) * 0.8;
        }
        else if (plan == "monthly")
        {
            if (minutes > 45)
            {
                price = (minutes - 45) * 0.2;
            }
        }
        if (ridesToday[email] > 3 && plan != "monthly")
        {
            price = price - 1.0;
        }
        if (night)
        {
            price = price + 0.5;
        }
        Revenue = Revenue + price;
        Receipts.Add($"{email}: {minutes} min, {price:F2} €");
        return price;
    }
}

La bandera se queda por ahora (funciones). Un true en la llamada no dice nada. La noche es un dato del viaje, no la elección de otro trabajo, así que no se convierte en dos funciones. La llamada tiene que decir lo que significa:

C# tiene valores por defecto y argumentos con nombre: el día no lleva argumento, y la noche es night: true.
Antes
private string Ride(string plan, int minutes, bool night)
{
    return Money(rides.Calc(Email, plan, minutes, night));
}


[Fact]
public void NightSurcharge()
{
    Assert.Equal("3.50", Ride("payg", 10, true));
}
Después
private string Ride(string plan, int minutes, bool night = false)
{
    return Money(billing.FinishRide(Email, plan, minutes, night));
}


[Fact]
public void NightSurcharge()
{
    Assert.Equal("3.50", Ride("payg", 10, night: true));
}
Los tests
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0
En Visual Studio, renombrar es Ctrl+R, Ctrl+R (o F2), y en Rider es Shift+F6: cambia también las llamadas de los tests.

Míralo

Paso 2: los números y el comentario que miente

1.0, 0.2, 0.8, 45, 3 y 0.5 pasan a ser constantes con nombre (número mágico → constante).

El comentario sobre el método dice 0,15 € por minuto y un 50 % de recargo nocturno. El código cobra 0,20 € y añade 0,50 €. ¿Qué es verdad? Los tests fijaron lo que hace el código, y los clientes llevan años pagando según él. El comentario miente (comentarios) y se borra. Las constantes dicen lo mismo y no pueden quedarse anticuadas por sí solas.

public class RideBilling
{
    private const double UnlockFee = 1.00;
    private const double PerMinute = 0.20;
    private const double StudentShare = 0.80;
    private const int MonthlyFreeMinutes = 45;
    private const int PaidUnlocksPerDay = 3;
    private const double NightSurcharge = 0.50;


    private readonly Dictionary<string, int> ridesToday = new();
    public double Revenue { get; private set; }
    public List<string> Receipts { get; } = new();


    public double FinishRide(string email, string plan, int minutes, bool night = false)
    {
        ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
        double price = 0;
        if (plan == "payg")
        {
            price = UnlockFee + minutes * PerMinute;
        }
        else if (plan == "student")
        {
            price = (UnlockFee + minutes * PerMinute) * StudentShare;
        }
        else if (plan == "monthly")
        {
            if (minutes > MonthlyFreeMinutes)
            {
                price = (minutes - MonthlyFreeMinutes) * PerMinute;
            }
        }
        if (ridesToday[email] > PaidUnlocksPerDay && plan != "monthly")
        {
            price = price - UnlockFee;
        }
        if (night)
        {
            price = price + NightSurcharge;
        }
        Revenue = Revenue + price;
        Receipts.Add($"{email}: {minutes} min, {price:F2} €");
        return price;
    }
}
Los tests
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0

Los tests no se tocan: ni el nombre ni las llamadas han cambiado.

Pruébalo

Encuentra el error

Un compañero hace el mismo paso, pero se fía del comentario y lo deja:

Elige la línea con el error.

Más precisamente, para curiosos
Los tests
FALLA FourthRideUnlockIsFree
FALLA MonthlyOverFreeMinutes
FALLA NightSurcharge
FALLA PayAsYouGoRide
FALLA Receipt
FALLA Revenue
FALLA StudentFourthRide
FALLA StudentRide
OK    MonthlyWithinFreeMinutes
Pruebas: 9, pasaron: 1, fallaron: 8

Míralo

Paso 3: el dinero

El dinero en un double es primitive obsession (code smells). Hoy no da un céntimo mal en ningún test, porque cada importe se redondea solo al imprimirlo. Por eso el paso es un refactoring: la salida es la misma. Pero los ingresos son una suma de miles de importes así, y ahí es donde se acumulan los errores pequeños.

double pasa a ser decimal, y los literales llevan una m. Las fórmulas se quedan como están, porque decimal tiene los mismos operadores. En el curso, el dinero en C# era decimal desde el principio, pero esta clase es vieja y se escribió con double.
public class RideBilling
{
    private const decimal UnlockFee = 1.00m;
    private const decimal PerMinute = 0.20m;
    private const decimal StudentShare = 0.80m;
    private const int MonthlyFreeMinutes = 45;
    private const int PaidUnlocksPerDay = 3;
    private const decimal NightSurcharge = 0.50m;


    private readonly Dictionary<string, int> ridesToday = new();
    public decimal Revenue { get; private set; }
    public List<string> Receipts { get; } = new();


    public decimal FinishRide(string email, string plan, int minutes, bool night = false)
    {
        ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
        decimal price = 0;
        if (plan == "payg")
        {
            price = UnlockFee + minutes * PerMinute;
        }
        else if (plan == "student")
        {
            price = (UnlockFee + minutes * PerMinute) * StudentShare;
        }
        else if (plan == "monthly")
        {
            if (minutes > MonthlyFreeMinutes)
            {
                price = (minutes - MonthlyFreeMinutes) * PerMinute;
            }
        }
        if (ridesToday[email] > PaidUnlocksPerDay && plan != "monthly")
        {
            price = price - UnlockFee;
        }
        if (night)
        {
            price = price + NightSurcharge;
        }
        Revenue = Revenue + price;
        Receipts.Add($"{email}: {minutes} min, {price:F2} €");
        return price;
    }
}
En los tests solo cambia el auxiliar que convierte el importe en texto:
private static string Money(decimal amount)
{
    return amount.ToString("F2");
}
Los tests
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0

Pruébalo

Completa

El precio por minuto en el tipo para dinero del lenguaje:

private const decimal PerMinute = ;

Míralo

Paso 4: la consulta separada del comando

Ahora el cambio que esperaba: el precio antes del final tiene que ser una consulta que no cambia nada (comando o consulta). El cálculo se extrae a un método Price (Extract Method de la lección de refactoring). FinishRide sigue siendo un comando: pide el precio, y luego cuenta, suma y envía.

Un compañero lo hace así. El contador se mueve detrás del precio, porque un viaje cuenta cuando ha terminado:

¿Qué dicen los nueve tests?

public decimal Price(string email, string plan, int minutes, bool night = false)
{
    decimal price = 0;
    if (plan == "payg")
    {
        price = UnlockFee + minutes * PerMinute;
    }
    else if (plan == "student")
    {
        price = (UnlockFee + minutes * PerMinute) * StudentShare;
    }
    else if (plan == "monthly")
    {
        if (minutes > MonthlyFreeMinutes)
        {
            price = (minutes - MonthlyFreeMinutes) * PerMinute;
        }
    }
    if (ridesToday.GetValueOrDefault(email) > PaidUnlocksPerDay && plan != "monthly")
    {
        price = price - UnlockFee;
    }
    if (night)
    {
        price = price + NightSurcharge;
    }
    return price;
}


public decimal FinishRide(string email, string plan, int minutes, bool night = false)
{
    decimal price = Price(email, plan, minutes, night);
    ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
    Revenue = Revenue + price;
    Receipts.Add($"{email}: {minutes} min, {price:F2} €");
    return price;
}
Respuesta
Más precisamente, para curiosos
Los tests
FALLA FourthRideUnlockIsFree
      Assert.Equal() Failure: Strings differ
                 ↓ (pos 0)
      Expected: "2.00"
      Actual:   "3.00"
                 ↑ (pos 0)
FALLA StudentFourthRide
      Assert.Equal() Failure: Strings differ
                 ↓ (pos 0)
      Expected: "1.40"
      Actual:   "2.40"
                 ↑ (pos 0)
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentRide
Pruebas: 9, pasaron: 7, fallaron: 2

Míralo

Paso 4, segundo intento

El rojo apunta al último paso. No buscas el error en toda la clase: deshaces el paso y lo repites. El orden de los efectos secundarios era una parte oculta del comportamiento, y solo los tests lo sabían.

Price calcula qué viaje del día será este:

public decimal Price(string email, string plan, int minutes, bool night = false)
{
    int rideOfDay = ridesToday.GetValueOrDefault(email) + 1;
    decimal price = 0;
    if (plan == "payg")
    {
        price = UnlockFee + minutes * PerMinute;
    }
    else if (plan == "student")
    {
        price = (UnlockFee + minutes * PerMinute) * StudentShare;
    }
    else if (plan == "monthly")
    {
        if (minutes > MonthlyFreeMinutes)
        {
            price = (minutes - MonthlyFreeMinutes) * PerMinute;
        }
    }
    if (rideOfDay > PaidUnlocksPerDay && plan != "monthly")
    {
        price = price - UnlockFee;
    }
    if (night)
    {
        price = price + NightSurcharge;
    }
    return price;
}


public decimal FinishRide(string email, string plan, int minutes, bool night = false)
{
    decimal price = Price(email, plan, minutes, night);
    ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
    Revenue = Revenue + price;
    Receipts.Add($"{email}: {minutes} min, {price:F2} €");
    return price;
}
Los tests
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0

Los tests no se vuelven a tocar: llaman a FinishRide, y este hace lo mismo que antes.

La clase entera después del paso 4
public class RideBilling
{
    private const decimal UnlockFee = 1.00m;
    private const decimal PerMinute = 0.20m;
    private const decimal StudentShare = 0.80m;
    private const int MonthlyFreeMinutes = 45;
    private const int PaidUnlocksPerDay = 3;
    private const decimal NightSurcharge = 0.50m;


    private readonly Dictionary<string, int> ridesToday = new();
    public decimal Revenue { get; private set; }
    public List<string> Receipts { get; } = new();


    public decimal Price(string email, string plan, int minutes, bool night = false)
    {
        int rideOfDay = ridesToday.GetValueOrDefault(email) + 1;
        decimal price = 0;
        if (plan == "payg")
        {
            price = UnlockFee + minutes * PerMinute;
        }
        else if (plan == "student")
        {
            price = (UnlockFee + minutes * PerMinute) * StudentShare;
        }
        else if (plan == "monthly")
        {
            if (minutes > MonthlyFreeMinutes)
            {
                price = (minutes - MonthlyFreeMinutes) * PerMinute;
            }
        }
        if (rideOfDay > PaidUnlocksPerDay && plan != "monthly")
        {
            price = price - UnlockFee;
        }
        if (night)
        {
            price = price + NightSurcharge;
        }
        return price;
    }


    public decimal FinishRide(string email, string plan, int minutes, bool night = false)
    {
        decimal price = Price(email, plan, minutes, night);
        ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
        Revenue = Revenue + price;
        Receipts.Add($"{email}: {minutes} min, {price:F2} €");
        return price;
    }
}

Míralo

Paso 5: los planes

Lo que queda es la cadena de if sobre el texto del plan (cadena larga de if). Cada plan nuevo es una rama nueva, y "monthly" se comprueba en dos sitios. Cada plan pasa a ser una clase que conoce su precio y su descuento del cuarto viaje. Esto es Replace Conditional with Polymorphism de la lección de refactoring:

public interface IPlan
{
    decimal Price(int minutes);


    decimal LoyaltyDiscount();
}


public class PayAsYouGo : IPlan
{
    public decimal Price(int minutes)
    {
        return RideBilling.UnlockFee + minutes * RideBilling.PerMinute;
    }


    public decimal LoyaltyDiscount()
    {
        return RideBilling.UnlockFee;
    }
}


public class Student : IPlan
{
    private const decimal StudentShare = 0.80m;


    public decimal Price(int minutes)
    {
        return new PayAsYouGo().Price(minutes) * StudentShare;
    }


    public decimal LoyaltyDiscount()
    {
        // Así es hoy: el 1 € entero, aunque desbloquear le cuesta 0,80 € a un estudiante.
        return RideBilling.UnlockFee;
    }
}


public class Monthly : IPlan
{
    private const int FreeMinutes = 45;


    public decimal Price(int minutes)
    {
        return Math.Max(0, minutes - FreeMinutes) * RideBilling.PerMinute;
    }


    public decimal LoyaltyDiscount()
    {
        return 0;
    }
}

La comprobación del abono mensual desaparece: simplemente devuelve un descuento de 0. El comportamiento raro del estudiante queda ahora en una línea, con un comentario que dice por qué es así (el buen comentario de la lección sobre comentarios).

public class RideBilling
{
    public const decimal UnlockFee = 1.00m;
    public const decimal PerMinute = 0.20m;
    private const int PaidUnlocksPerDay = 3;
    private const decimal NightSurcharge = 0.50m;


    private readonly Dictionary<string, int> ridesToday = new();
    public decimal Revenue { get; private set; }
    public List<string> Receipts { get; } = new();


    public decimal Price(string email, IPlan plan, int minutes, bool night = false)
    {
        int rideOfDay = ridesToday.GetValueOrDefault(email) + 1;
        decimal price = plan.Price(minutes);
        if (rideOfDay > PaidUnlocksPerDay)
        {
            price = price - plan.LoyaltyDiscount();
        }
        if (night)
        {
            price = price + NightSurcharge;
        }
        return price;
    }


    public decimal FinishRide(string email, IPlan plan, int minutes, bool night = false)
    {
        decimal price = Price(email, plan, minutes, night);
        ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
        Revenue = Revenue + price;
        Receipts.Add($"{email}: {minutes} min, {price:F2} €");
        return price;
    }
}
La parte del estudiante y los minutos gratis pasan al plan que los usa. La tarifa de desbloqueo y el precio por minuto los comparten varios planes, así que se quedan en la clase de cobro y dejan de ser private.

En los tests las llamadas pasan un objeto en vez de texto:

Assert.Equal("3.50", Ride("payg", 10, night: true));
Assert.Equal("3.50", Ride(new PayAsYouGo(), 10, night: true));
Los tests
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0

Esto es Strategy del módulo de patrones de diseño: la regla es un objeto aparte, y el cobro solo pregunta.

Míralo

Los dos cambios ahora

El plan de empresa es una clase nueva. La clase de cobro no se toca (abierto a la extensión):

public class Business : IPlan
{
    private const decimal PerMinute = 0.18m;


    public decimal Price(int minutes)
    {
        return minutes * PerMinute;
    }


    public decimal LoyaltyDiscount()
    {
        return 0;
    }
}

El precio antes del final es la consulta Price. Las veces que la llames, no se cuenta nada y no sale ningún recibo:

var billing = new RideBilling();
var payg = new PayAsYouGo();
billing.FinishRide("ana@example.com", payg, 10);
billing.FinishRide("ana@example.com", payg, 5);
billing.FinishRide("ana@example.com", payg, 12, night: true);
Console.WriteLine($"Precio antes del final: {billing.Price("ana@example.com", payg, 8):F2} €");
Console.WriteLine($"Precio antes del final: {billing.Price("ana@example.com", payg, 8):F2} €");
Console.WriteLine($"Cobrado: {billing.FinishRide("ana@example.com", payg, 8):F2} €");
Console.WriteLine($"Empresa, 12 min: {billing.FinishRide("office@example.com", new Business(), 12):F2} €");
Console.WriteLine($"Recibos: {billing.Receipts.Count}");
Salida
Precio antes del final: 1.60 €
Precio antes del final: 1.60 €
Cobrado: 1.60 €
Empresa, 12 min: 2.16 €
Recibos: 5

Cinco recibos: tres viajes antes de la vista previa, el cuarto y el de la empresa. Las dos vistas previas no dejan rastro, y muestran exactamente lo que se cobra después.

La idea

Antes y después

Smell Paso Lección
nada protege el comportamiento 0: tests que fijan el comportamiento de hoy la red de seguridad
nombres de una letra, calc que no dice que envía 1: Rename nombres
true en la llamada 1: un argumento que dice lo que significa funciones
números mágicos 2: constantes con nombre nombres
un comentario que miente 2: borrado comentarios
dinero en un double 3: un tipo para dinero code smells
una consulta con un efecto secundario oculto, un método largo 4: Extract Method, comando y consulta funciones, refactoring
una cadena de if sobre el plan como texto 5: Replace Conditional with Polymorphism code smells, refactoring, SOLID

La clase se hizo más larga, no más corta. Pero cada regla está en un solo lugar y tiene nombre, y cada cambio del principio es una clase.

El día de viajes, ejecutado con la clase de antes del paso 1 y con la clase de después del paso 5, imprime lo mismo línea por línea. Aquí los dos programas se ejecutan en cada comprobación del sitio.

Antes
var rides = new RideMgr();
rides.Calc("ana@example.com", "payg", 10, false);
rides.Calc("ivan@example.com", "student", 25, false);
rides.Calc("ana@example.com", "payg", 5, false);
rides.Calc("maria@example.com", "monthly", 60, true);
rides.Calc("ana@example.com", "payg", 12, true);
rides.Calc("ana@example.com", "payg", 8, false);


foreach (string receipt in rides.Out)
{
    Console.WriteLine(receipt);
}
Console.WriteLine($"Ingresos: {rides.S:F2} €");
Después
var billing = new RideBilling();
var payg = new PayAsYouGo();
billing.FinishRide("ana@example.com", payg, 10);
billing.FinishRide("ivan@example.com", new Student(), 25);
billing.FinishRide("ana@example.com", payg, 5);
billing.FinishRide("maria@example.com", new Monthly(), 60, night: true);
billing.FinishRide("ana@example.com", payg, 12, night: true);
billing.FinishRide("ana@example.com", payg, 8);


foreach (string receipt in billing.Receipts)
{
    Console.WriteLine(receipt);
}
Console.WriteLine($"Ingresos: {billing.Revenue:F2} €");
Salida
ana@example.com: 10 min, 3.00 €
ivan@example.com: 25 min, 4.80 €
ana@example.com: 5 min, 2.00 €
maria@example.com: 60 min, 3.50 €
ana@example.com: 12 min, 3.90 €
ana@example.com: 8 min, 1.60 €
Ingresos: 18.80 €

La idea

Dónde parar

Te detienes cuando los cambios que vienen se vuelven fáciles. Aquí los dos cambios son una clase y una línea. Por eso algunos pasos se dejan sin hacer a propósito:

  • el recibo en su propia clase. El texto del recibo es una segunda razón para cambiar la clase (una sola razón para cambiar). Hoy no cambia. En cuanto marketing empiece a editarlo cada mes, pasa a ser una clase aparte (tarea 1);
  • el envío detrás de una interfaz. Los recibos son una lista, no un correo de verdad. Cuando llegue el correo real, el test no debe enviarlo, y entonces llega la abstracción (depender de una abstracción);
  • el comportamiento del estudiante. Es un cambio de comportamiento, no una limpieza. Se hace aparte, con su propio test, cuando el producto decida.

Y la regla de la lección de refactoring: cambias la forma o el comportamiento, nunca los dos en un mismo paso.

Ejercicio

Sigue tú solo

Resuelve las tareas en tu editor, partiendo de la clase después del paso 5. Después de cada paso, ejecuta los nueve tests.

1. El recibo en su propia clase. Mueve el texto del recibo y la lista de recibos enviados a una clase ReceiptBook. La clase de cobro solo le dice "send". Los tests no se tocan.

Una solución posible
public class ReceiptBook
{
    public List<string> Sent { get; } = new();


    public void Send(string email, int minutes, decimal price)
    {
        Sent.Add($"{email}: {minutes} min, {price:F2} €");
    }
}
public class RideBilling
{
    public const decimal UnlockFee = 1.00m;
    public const decimal PerMinute = 0.20m;
    private const int PaidUnlocksPerDay = 3;
    private const decimal NightSurcharge = 0.50m;


    private readonly Dictionary<string, int> ridesToday = new();
    public decimal Revenue { get; private set; }
    private readonly ReceiptBook receipts = new();
    public List<string> Receipts => receipts.Sent;


    public decimal Price(string email, IPlan plan, int minutes, bool night = false)
    {
        int rideOfDay = ridesToday.GetValueOrDefault(email) + 1;
        decimal price = plan.Price(minutes);
        if (rideOfDay > PaidUnlocksPerDay)
        {
            price = price - plan.LoyaltyDiscount();
        }
        if (night)
        {
            price = price + NightSurcharge;
        }
        return price;
    }


    public decimal FinishRide(string email, IPlan plan, int minutes, bool night = false)
    {
        decimal price = Price(email, plan, minutes, night);
        ridesToday[email] = ridesToday.GetValueOrDefault(email) + 1;
        Revenue = Revenue + price;
        receipts.Send(email, minutes, price);
        return price;
    }
}
Los tests
OK    FourthRideUnlockIsFree
OK    MonthlyOverFreeMinutes
OK    MonthlyWithinFreeMinutes
OK    NightSurcharge
OK    PayAsYouGoRide
OK    Receipt
OK    Revenue
OK    StudentFourthRide
OK    StudentRide
Pruebas: 9, pasaron: 9, fallaron: 0

El programa del día de la tarjeta "Antes y después" imprime la misma salida con esta clase.

2. El plan desde texto. El plan llega de la base de datos como texto ("payg"). Escribe la tabla que lo convierte en un objeto. ¿Qué hacía la clase vieja con un plan desconocido? Fíjalo con un test sobre la clase vieja antes de decidir qué debe hacer la nueva.

3. La noche desde la hora. La app ya no sabe cuándo es de noche; pasa la hora de inicio. La regla "de las 22:00 a las 6:00" tiene que vivir en un solo lugar. Escribe primero los tests para las 21:59, 22:00, 5:59 y 6:00.

4. El estudiante. El producto ha decidido: en el cuarto viaje un estudiante recibe 0,80 €, no 1 €. Es un cambio de comportamiento: primero cambia el valor esperado en el test y míralo en rojo, y luego cambia una línea del plan.

Test

Ponte a prueba

1. El test de un estudiante en el cuarto viaje espera 1,40 €, y la respuesta "correcta" parece ser 1,60 €. ¿Qué haces mientras limpias la clase?
2. El comentario dice 0,15 € por minuto, y el código cobra 0,20 €. ¿A cuál le haces caso?
3. ¿Por qué los tests llaman a la clase a través de un método auxiliar y no directamente?
4. El primer intento del paso 4 puso dos tests en rojo. ¿Qué haces?
5. Después de la limpieza, el plan de empresa es una clase nueva, y la clase de cobro no se toca. ¿Qué principio es este?

Creado por Ivo Gergov como parte de la campaña de Evo Tech por una educación accesible en programación ·