Cálculo de Descuentos con Pruebas Unitarias en Java

¿Cómo crear un sistema de cálculo de descuentos usando TDD?

Crear un sistema de cálculo de descuentos puede parecer complicado al principio, pero con el uso de Test-Driven Development (TDD), el proceso se convierte en algo más accesible y estructurado. TDD nos permite desarrollar software de manera incremental y sistemática, haciendo que el código sea más confiable y fácil de mantener. Aquí, veremos cómo construir un "price calculator" o calculador de precios, siguiendo un ejemplo detallado basado en el marco de un desarrollo típico en Java.

¿Qué es TDD y cómo se aplica en este proyecto?

TDD es una práctica de desarrollo de software que enfatiza la creación de tests antes de implementar la funcionalidad real, permitiendo verificar que el código cumple sus requisitos. En este proyecto, comenzamos por definir las características que debe tener nuestro calculador de precios:

1. Inicialmente, el total debe ser cero: Si no se añaden precios al calculador, el total debe ser cero.
2. El total debe ser la suma de los precios añadidos: Cuando se añaden precios, el cálculo total debe reflejar la suma de esos precios.
3. Aplicar descuentos a los precios totales: El sistema debe ser capaz de aplicar descuentos porcentuales al total de los precios.

¿Cómo se implementa el calculador de precios?

Comenzamos creando una clase PriceCalculator en un paquete llamado discounts. Luego, escribimos un test inicial para asegurar que el total sea cero cuando no se han añadido precios:

import org.junit.Assert;
import org.junit.Test;

public class PriceCalculatorTest {

    @Test
    public void testZeroTotalWhenNoPrices() {
        PriceCalculator calculator = new PriceCalculator();
        Assert.assertEquals(0, calculator.getTotal(), 0.0);
    }
}

En este test, utilizamos assertEquals para verificar que el total es cero. Creamos el método getTotal() en la clase PriceCalculator:

public class PriceCalculator {
    public double getTotal() {
        return 0.0;
    }
}

¿Cómo se suman los precios introducidos?

El siguiente paso es modificar la clase para que sume los precios introducidos antes de calcular el total:

public class PriceCalculator {
    private List<Double> prices = new ArrayList<>();

    public void addPrice(double price) {
        prices.add(price);
    }

    public double getTotal() {
        double total = 0;
        for (double price : prices) {
            total += price;
        }
        return total;
    }
}

Hemos añadido el método addPrice(double price) que permite introducir precios al calculador, y el método getTotal() ha sido modificado para sumar todos los precios añadidos.

¿Cómo se aplica un descuento?

Finalmente, implementamos la funcionalidad de aplicar un descuento. Para esto, extendemos la clase PriceCalculator para incluir esta capacidad:

public class PriceCalculator {
    private List<Double> prices = new ArrayList<>();
    private double discount = 0.0;

    public void addPrice(double price) {
        prices.add(price);
    }

    public void setDiscount(double discount) {
        this.discount = discount;
    }

    public double getTotal() {
        double total = 0;
        for (double price : prices) {
            total += price;
        }
        return total - (total * discount / 100);
    }
}

En esta extensión, hemos añadido un método setDiscount(double discount) que acepta un porcentaje de descuento. Luego, al calcular el total, aplicamos el descuento correspondiente.

¿Cómo se validan los casos de prueba?

Con el objetivo de asegurarnos de que todos los métodos están implementados correctamente, escribimos tests para cada característica:

@Test
public void testApplyDiscountToTotal() {
    PriceCalculator calculator = new PriceCalculator();
    calculator.addPrice(100);
    calculator.addPrice(50);
    calculator.setDiscount(25);
    Assert.assertEquals(112.5, calculator.getTotal(), 0.0);
}

Este test verifica que un descuento del 25% se aplica correctamente a un precio total de 150, resultando en un total de 112.5.

TDD es un enfoque que nos guía paso a paso a través de la implementación, asegurando que cada parte del código cumple su propósito antes de pasar a desarrollos más complejos. Con cada iteración y caso de prueba, el programa crece de manera elemental pero segura, hasta lograr la funcionalidad deseada. ¡Adelante, sigue practicando y mejorando tus habilidades en TDD y desarrollo de software!