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:
class RideMgr: def __init__(self): self.c = {} self.s = 0 self.out = []
# El precio: 1 € por desbloquear y 0,15 € por minuto. # De noche el precio sube un 50 %. def calc(self, to, t, m, f): self.c[to] = self.c.get(to, 0) + 1 p = 0 if t == "payg": p = 1.0 + m * 0.2 elif t == "student": p = (1.0 + m * 0.2) * 0.8 elif t == "monthly": if m > 45: p = (m - 45) * 0.2 if self.c[to] > 3 and t != "monthly": p = p - 1.0 if f: p = p + 0.5 self.s = self.s + p self.out.append(f"{to}: {m} min, {p:.2f} €") return pEl 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:
rides = RideMgr()shown = rides.calc("ana@example.com", "payg", 10, False)print(f"Precio antes del final: {shown:.2f} €")charged = rides.calc("ana@example.com", "payg", 10, False)print(f"Cobrado: {charged:.2f} €")print(f"Recibos: {len(rides.out)}")print(f"Ingresos: {rides.s:.2f} €")Precio antes del final: 3.00 €Cobrado: 3.00 €Recibos: 2Ingresos: 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.
import unittest
from rides import RideMgr
EMAIL = "ana@example.com"
def money(amount): return f"{amount:.2f}"
class RideMgrTest(unittest.TestCase): def setUp(self): self.rides = RideMgr()
def ride(self, plan, minutes, night): return money(self.rides.calc(EMAIL, plan, minutes, night))
def test_pay_as_you_go_ride(self): self.assertEqual(self.ride("payg", 10, False), "3.00")
def test_student_ride(self): self.assertEqual(self.ride("student", 10, False), "2.40")
def test_monthly_within_free_minutes(self): self.assertEqual(self.ride("monthly", 30, False), "0.00")
def test_monthly_over_free_minutes(self): self.assertEqual(self.ride("monthly", 60, False), "3.00")
def test_night_surcharge(self): self.assertEqual(self.ride("payg", 10, True), "3.50")
def test_fourth_ride_unlock_is_free(self): self.ride("payg", 10, False) self.ride("payg", 10, False) self.ride("payg", 10, False) self.assertEqual(self.ride("payg", 10, False), "2.00")
def test_student_fourth_ride(self): # Así es hoy: el descuento es el 1 € entero, no 0,80 €. self.ride("student", 10, False) self.ride("student", 10, False) self.ride("student", 10, False) self.assertEqual(self.ride("student", 10, False), "1.40")
def test_receipt(self): self.ride("payg", 10, False) self.assertEqual(self.rides.out, ["ana@example.com: 10 min, 3.00 €"])
def test_revenue(self): self.ride("payg", 10, False) self.ride("student", 10, False) self.assertEqual(money(self.rides.s), "5.40")OK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0Los 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 float:
print((1.0 + 10 * 0.2) * 0.8)2.4000000000000004Y 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 finish_ride, y ahora el efecto secundario se ve en el nombre. La clase pasa a llamarse RideBilling.
class RideBilling: def __init__(self): self.rides_today = {} self.revenue = 0 self.receipts = []
# El precio: 1 € por desbloquear y 0,15 € por minuto. # De noche el precio sube un 50 %. def finish_ride(self, email, plan, minutes, *, night=False): self.rides_today[email] = self.rides_today.get(email, 0) + 1 price = 0 if plan == "payg": price = 1.0 + minutes * 0.2 elif plan == "student": price = (1.0 + minutes * 0.2) * 0.8 elif plan == "monthly": if minutes > 45: price = (minutes - 45) * 0.2 if self.rides_today[email] > 3 and plan != "monthly": price = price - 1.0 if night: price = price + 0.5 self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return priceLa 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:
night pasa a ser un argumento solo por nombre (después de *) con un valor por defecto: el día no lleva argumento, y la noche es night=True.def ride(self, plan, minutes, night): return money(self.rides.calc(EMAIL, plan, minutes, night))
def test_night_surcharge(self): self.assertEqual(self.ride("payg", 10, True), "3.50")def ride(self, plan, minutes, *, night=False): return money(self.billing.finish_ride(EMAIL, plan, minutes, night=night))
def test_night_surcharge(self): self.assertEqual(self.ride("payg", 10, night=True), "3.50")OK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0self.s) en todas partes, así que aquí los tests te dicen más que en Java o C#.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.
UNLOCK_FEE = 1.00PER_MINUTE = 0.20STUDENT_SHARE = 0.80MONTHLY_FREE_MINUTES = 45PAID_UNLOCKS_PER_DAY = 3NIGHT_SURCHARGE = 0.50
class RideBilling: def __init__(self): self.rides_today = {} self.revenue = 0 self.receipts = []
def finish_ride(self, email, plan, minutes, *, night=False): self.rides_today[email] = self.rides_today.get(email, 0) + 1 price = 0 if plan == "payg": price = UNLOCK_FEE + minutes * PER_MINUTE elif plan == "student": price = (UNLOCK_FEE + minutes * PER_MINUTE) * STUDENT_SHARE elif plan == "monthly": if minutes > MONTHLY_FREE_MINUTES: price = (minutes - MONTHLY_FREE_MINUTES) * PER_MINUTE if self.rides_today[email] > PAID_UNLOCKS_PER_DAY and plan != "monthly": price = price - UNLOCK_FEE if night: price = price + NIGHT_SURCHARGE self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return priceOK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0Los tests no se tocan: ni el nombre ni las llamadas han cambiado.
Las constantes están a nivel de módulo, encima de la clase: así las ve cualquier otro código del archivo, y en el paso 5 también los planes.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.
El precio por minuto sale del comentario: 0,15 € en vez de 0,20 €. Así el refactoring baja en silencio el precio de cada viaje. Ocho de los nueve tests fallan; solo pasa el abono mensual de hasta 45 minutos, donde los minutos no se pagan. El comentario había que borrarlo, y el número había que tomarlo del código que los tests ya vigilan.
Más precisamente, para curiosos
FALLA test_fourth_ride_unlock_is_freeFALLA test_monthly_over_free_minutesFALLA test_night_surchargeFALLA test_pay_as_you_go_rideFALLA test_receiptFALLA test_revenueFALLA test_student_fourth_rideFALLA test_student_rideOK test_monthly_within_free_minutesPruebas: 9, pasaron: 1, fallaron: 8Míralo
Paso 3: el dinero
El dinero en un float 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.
Los números pasan a serDecimal, creados a partir de un string. Las fórmulas se quedan como están, porque Decimal funciona con + y *, y con números enteros.from decimal import Decimal
UNLOCK_FEE = Decimal("1.00")PER_MINUTE = Decimal("0.20")STUDENT_SHARE = Decimal("0.80")MONTHLY_FREE_MINUTES = 45PAID_UNLOCKS_PER_DAY = 3NIGHT_SURCHARGE = Decimal("0.50")
class RideBilling: def __init__(self): self.rides_today = {} self.revenue = Decimal("0") self.receipts = []
def finish_ride(self, email, plan, minutes, *, night=False): self.rides_today[email] = self.rides_today.get(email, 0) + 1 price = Decimal("0") if plan == "payg": price = UNLOCK_FEE + minutes * PER_MINUTE elif plan == "student": price = (UNLOCK_FEE + minutes * PER_MINUTE) * STUDENT_SHARE elif plan == "monthly": if minutes > MONTHLY_FREE_MINUTES: price = (minutes - MONTHLY_FREE_MINUTES) * PER_MINUTE if self.rides_today[email] > PAID_UNLOCKS_PER_DAY and plan != "monthly": price = price - UNLOCK_FEE if night: price = price + NIGHT_SURCHARGE self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return pricef"{amount:.2f}" funciona también con Decimal.def money(amount): return f"{amount:.2f}"OK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0Pruébalo
Completa
El precio por minuto en el tipo para dinero del lenguaje:
PER_MINUTE = Decimal()Decimal("0.20"). Desde un float (Decimal(0.20)) el error de la forma binaria ya está dentro.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). finish_ride 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?
def price(self, email, plan, minutes, *, night=False): price = Decimal("0") if plan == "payg": price = UNLOCK_FEE + minutes * PER_MINUTE elif plan == "student": price = (UNLOCK_FEE + minutes * PER_MINUTE) * STUDENT_SHARE elif plan == "monthly": if minutes > MONTHLY_FREE_MINUTES: price = (minutes - MONTHLY_FREE_MINUTES) * PER_MINUTE if self.rides_today.get(email, 0) > PAID_UNLOCKS_PER_DAY and plan != "monthly": price = price - UNLOCK_FEE if night: price = price + NIGHT_SURCHARGE return price
def finish_ride(self, email, plan, minutes, *, night=False): price = self.price(email, plan, minutes, night=night) self.rides_today[email] = self.rides_today.get(email, 0) + 1 self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return priceEn el antiguo calc el contador subía antes de la comprobación, así que "más de 3" significaba "este es el cuarto viaje". Ahora price pregunta antes de contar, y el contador es uno menos. El cuarto viaje pasa por el tercero y paga la tarifa de desbloqueo. Los demás tests pasan, porque nunca llegan a un cuarto viaje.
Más precisamente, para curiosos
FALLA test_fourth_ride_unlock_is_free: '3.00' != '2.00'- 3.00? ^+ 2.00? ^
FALLA test_student_fourth_ride: '2.40' != '1.40'- 2.40? ^+ 1.40? ^
OK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_ridePruebas: 9, pasaron: 7, fallaron: 2Mí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:
def price(self, email, plan, minutes, *, night=False): ride_of_day = self.rides_today.get(email, 0) + 1 price = Decimal("0") if plan == "payg": price = UNLOCK_FEE + minutes * PER_MINUTE elif plan == "student": price = (UNLOCK_FEE + minutes * PER_MINUTE) * STUDENT_SHARE elif plan == "monthly": if minutes > MONTHLY_FREE_MINUTES: price = (minutes - MONTHLY_FREE_MINUTES) * PER_MINUTE if ride_of_day > PAID_UNLOCKS_PER_DAY and plan != "monthly": price = price - UNLOCK_FEE if night: price = price + NIGHT_SURCHARGE return price
def finish_ride(self, email, plan, minutes, *, night=False): price = self.price(email, plan, minutes, night=night) self.rides_today[email] = self.rides_today.get(email, 0) + 1 self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return priceOK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0Los tests no se vuelven a tocar: llaman a finish_ride, y este hace lo mismo que antes.
La clase entera después del paso 4
from decimal import Decimal
UNLOCK_FEE = Decimal("1.00")PER_MINUTE = Decimal("0.20")STUDENT_SHARE = Decimal("0.80")MONTHLY_FREE_MINUTES = 45PAID_UNLOCKS_PER_DAY = 3NIGHT_SURCHARGE = Decimal("0.50")
class RideBilling: def __init__(self): self.rides_today = {} self.revenue = Decimal("0") self.receipts = []
def price(self, email, plan, minutes, *, night=False): ride_of_day = self.rides_today.get(email, 0) + 1 price = Decimal("0") if plan == "payg": price = UNLOCK_FEE + minutes * PER_MINUTE elif plan == "student": price = (UNLOCK_FEE + minutes * PER_MINUTE) * STUDENT_SHARE elif plan == "monthly": if minutes > MONTHLY_FREE_MINUTES: price = (minutes - MONTHLY_FREE_MINUTES) * PER_MINUTE if ride_of_day > PAID_UNLOCKS_PER_DAY and plan != "monthly": price = price - UNLOCK_FEE if night: price = price + NIGHT_SURCHARGE return price
def finish_ride(self, email, plan, minutes, *, night=False): price = self.price(email, plan, minutes, night=night) self.rides_today[email] = self.rides_today.get(email, 0) + 1 self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return priceMí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:
class PayAsYouGo: def price(self, minutes): return UNLOCK_FEE + minutes * PER_MINUTE
def loyalty_discount(self): return UNLOCK_FEE
class Student: def price(self, minutes): return PayAsYouGo().price(minutes) * STUDENT_SHARE
def loyalty_discount(self): # Así es hoy: el 1 € entero, aunque desbloquear le cuesta 0,80 € a un estudiante. return UNLOCK_FEE
class Monthly: def price(self, minutes): return max(0, minutes - MONTHLY_FREE_MINUTES) * PER_MINUTE
def loyalty_discount(self): return Decimal("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).
from decimal import Decimal
UNLOCK_FEE = Decimal("1.00")PER_MINUTE = Decimal("0.20")STUDENT_SHARE = Decimal("0.80")MONTHLY_FREE_MINUTES = 45PAID_UNLOCKS_PER_DAY = 3NIGHT_SURCHARGE = Decimal("0.50")
class RideBilling: def __init__(self): self.rides_today = {} self.revenue = Decimal("0") self.receipts = []
def price(self, email, plan, minutes, *, night=False): ride_of_day = self.rides_today.get(email, 0) + 1 price = plan.price(minutes) if ride_of_day > PAID_UNLOCKS_PER_DAY: price = price - plan.loyalty_discount() if night: price = price + NIGHT_SURCHARGE return price
def finish_ride(self, email, plan, minutes, *, night=False): price = self.price(email, plan, minutes, night=night) self.rides_today[email] = self.rides_today.get(email, 0) + 1 self.revenue = self.revenue + price self.receipts.append(f"{email}: {minutes} min, {price:.2f} €") return priceEn los tests las llamadas pasan un objeto en vez de texto:
self.assertEqual(self.ride("payg", 10, night=True), "3.50")self.assertEqual(self.ride(PayAsYouGo(), 10, night=True), "3.50")OK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0Esto 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):
BUSINESS_PER_MINUTE = Decimal("0.18")
class Business: def price(self, minutes): return minutes * BUSINESS_PER_MINUTE
def loyalty_discount(self): return Decimal("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:
billing = RideBilling()payg = PayAsYouGo()billing.finish_ride("ana@example.com", payg, 10)billing.finish_ride("ana@example.com", payg, 5)billing.finish_ride("ana@example.com", payg, 12, night=True)print(f"Precio antes del final: {billing.price("ana@example.com", payg, 8):.2f} €")print(f"Precio antes del final: {billing.price("ana@example.com", payg, 8):.2f} €")print(f"Cobrado: {billing.finish_ride("ana@example.com", payg, 8):.2f} €")print(f"Empresa, 12 min: {billing.finish_ride("office@example.com", Business(), 12):.2f} €")print(f"Recibos: {len(billing.receipts)}")Precio antes del final: 1.60 €Precio antes del final: 1.60 €Cobrado: 1.60 €Empresa, 12 min: 2.16 €Recibos: 5Cinco 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 float | 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.
rides = 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)
for receipt in rides.out: print(receipt)print(f"Ingresos: {rides.s:.2f} €")billing = RideBilling()payg = PayAsYouGo()billing.finish_ride("ana@example.com", payg, 10)billing.finish_ride("ivan@example.com", Student(), 25)billing.finish_ride("ana@example.com", payg, 5)billing.finish_ride("maria@example.com", Monthly(), 60, night=True)billing.finish_ride("ana@example.com", payg, 12, night=True)billing.finish_ride("ana@example.com", payg, 8)
for receipt in billing.receipts: print(receipt)print(f"Ingresos: {billing.revenue:.2f} €")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
class ReceiptBook: def __init__(self): self.sent = []
def send(self, email, minutes, price): self.sent.append(f"{email}: {minutes} min, {price:.2f} €")from decimal import Decimal
UNLOCK_FEE = Decimal("1.00")PER_MINUTE = Decimal("0.20")STUDENT_SHARE = Decimal("0.80")MONTHLY_FREE_MINUTES = 45PAID_UNLOCKS_PER_DAY = 3NIGHT_SURCHARGE = Decimal("0.50")
class RideBilling: def __init__(self): self.rides_today = {} self.revenue = Decimal("0") self.receipt_book = ReceiptBook()
def price(self, email, plan, minutes, *, night=False): ride_of_day = self.rides_today.get(email, 0) + 1 price = plan.price(minutes) if ride_of_day > PAID_UNLOCKS_PER_DAY: price = price - plan.loyalty_discount() if night: price = price + NIGHT_SURCHARGE return price
def finish_ride(self, email, plan, minutes, *, night=False): price = self.price(email, plan, minutes, night=night) self.rides_today[email] = self.rides_today.get(email, 0) + 1 self.revenue = self.revenue + price self.receipt_book.send(email, minutes, price) return price
@property def receipts(self): return self.receipt_book.sentOK test_fourth_ride_unlock_is_freeOK test_monthly_over_free_minutesOK test_monthly_within_free_minutesOK test_night_surchargeOK test_pay_as_you_go_rideOK test_receiptOK test_revenueOK test_student_fourth_rideOK test_student_ridePruebas: 9, pasaron: 9, fallaron: 0El 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