Primer servicio inyectado y su prueba unitaria

package es.edu.multagal.domain.model;

import java.math.BigDecimal;
import java.time.LocalDate;

public record Expediente(String numero, EstadoExpediente estado,
                         BigDecimal importe, LocalDate fechaNotificacion) { }

package es.edu.multagal.repository;

import es.edu.multagal.domain.model.EstadoExpediente;
import es.edu.multagal.domain.model.Expediente;
import java.util.List;
import java.util.Optional;

public interface RepositorioExpedientes {
    Expediente guardar(Expediente expediente);
    Optional<Expediente> buscarPorNumero(String numero);
    List<Expediente> buscarTodos();
    List<Expediente> buscarPorEstado(EstadoExpediente estado);
}

package es.edu.multagal.repository;

import es.edu.multagal.domain.model.EstadoExpediente;
import es.edu.multagal.domain.model.Expediente;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.springframework.stereotype.Repository;

@Repository
public class RepositorioExpedientesMemoria implements RepositorioExpedientes {
    private final Map<String, Expediente> datos = new ConcurrentHashMap<>();

    @Override
    public Expediente guardar(Expediente expediente) {
        datos.put(expediente.numero(), expediente);
        return expediente;
    }

    @Override
    public Optional<Expediente> buscarPorNumero(String numero) {
        return Optional.ofNullable(datos.get(numero));
    }

    @Override
    public List<Expediente> buscarTodos() {
        return List.copyOf(datos.values());
    }

    @Override
    public List<Expediente> buscarPorEstado(EstadoExpediente estado) {
        return datos.values().stream()
                .filter(e -> e.estado() == estado)
                .toList();
    }
}

package es.edu.multagal.domain.exception;

public class MultagalException extends RuntimeException {
    public MultagalException(String mensaje) {
        super(mensaje);
    }
}

package es.edu.multagal.domain.exception;

public class ExpedienteNoEncontradoException extends MultagalException {
    public ExpedienteNoEncontradoException(String numero) {
        super("No existe el expediente " + numero);
    }
}

package es.edu.multagal.domain.exception;

public class ExpedienteDuplicadoException extends MultagalException {
    public ExpedienteDuplicadoException(String numero) {
        super("Ya existe el expediente " + numero);
    }
}

package es.edu.multagal.service;

import es.edu.multagal.domain.exception.ExpedienteDuplicadoException;
import es.edu.multagal.domain.exception.ExpedienteNoEncontradoException;
import es.edu.multagal.domain.model.Expediente;
import es.edu.multagal.repository.RepositorioExpedientes;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import org.springframework.stereotype.Service;

@Service
public class ServicioExpedientes {
    private final RepositorioExpedientes repositorio;

    public ServicioExpedientes(RepositorioExpedientes repositorio) {
        this.repositorio = repositorio;
    }

    public Expediente obtener(String numero) {
        return repositorio.buscarPorNumero(numero)
                .orElseThrow(() -> new ExpedienteNoEncontradoException(numero));
    }

    public Expediente registrar(Expediente expediente) {
        if (repositorio.buscarPorNumero(expediente.numero()).isPresent()) {
            throw new ExpedienteDuplicadoException(expediente.numero());
        }
        return repositorio.guardar(expediente);
    }

    public BigDecimal calcularImporteConBonificacion(Expediente expediente,
                                                     LocalDate fechaPago) {
        if (expediente.fechaNotificacion() == null || fechaPago == null) {
            throw new IllegalArgumentException("Se necesitan ambas fechas");
        }
        long dias = ChronoUnit.DAYS.between(expediente.fechaNotificacion(), fechaPago);
        if (dias < 0) {
            throw new IllegalArgumentException("El pago no puede preceder a la notificación");
        }
        // Decisión de esta propuesta: días 1 a 20 incluidos; día 0 sin descuento.
        if (dias >= 1 && dias <= 20) {
            return expediente.importe().multiply(new BigDecimal("0.50"));
        }
        return expediente.importe();
    }
}

package es.edu.multagal.service;

import es.edu.multagal.domain.exception.ExpedienteDuplicadoException;
import es.edu.multagal.domain.exception.ExpedienteNoEncontradoException;
import es.edu.multagal.domain.model.EstadoExpediente;
import es.edu.multagal.domain.model.Expediente;
import es.edu.multagal.repository.RepositorioExpedientes;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.Optional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.*;

class ServicioExpedientesTest {
    private RepositorioExpedientes repo;
    private ServicioExpedientes servicio;
    private final LocalDate notificacion = LocalDate.of(2026, 1, 1);

    @BeforeEach
    void preparar() {
        repo = mock(RepositorioExpedientes.class);
        servicio = new ServicioExpedientes(repo);
    }

    // Adapta SOLO esta construcción a los campos de tu modelo de A.03.
    private Expediente expediente(LocalDate fecha) {
        return new Expediente("X-1", EstadoExpediente.ABIERTO,
                new BigDecimal("100.00"), fecha);
    }

    @Test
    void devuelveElExpedienteCuandoExiste() {
        Expediente esperado = expediente(notificacion);
        when(repo.buscarPorNumero("X-1")).thenReturn(Optional.of(esperado));

        Expediente resultado = servicio.obtener("X-1");

        assertThat(resultado).isEqualTo(esperado);
    }

    @Test
    void registraUnNumeroNuevo() {
        Expediente nuevo = expediente(notificacion);
        when(repo.buscarPorNumero("X-1")).thenReturn(Optional.empty());
        when(repo.guardar(nuevo)).thenReturn(nuevo);

        Expediente resultado = servicio.registrar(nuevo);

        assertThat(resultado).isEqualTo(nuevo);
        verify(repo).guardar(nuevo);
    }

    @Test
    void lanzaExcepcionSiNoExiste() {
        when(repo.buscarPorNumero("X-1")).thenReturn(Optional.empty());

        assertThatThrownBy(() -> servicio.obtener("X-1"))
                .isInstanceOf(ExpedienteNoEncontradoException.class);
    }

    @Test
    void rechazaDuplicadoSinGuardar() {
        Expediente existente = expediente(notificacion);
        when(repo.buscarPorNumero("X-1")).thenReturn(Optional.of(existente));

        assertThatThrownBy(() -> servicio.registrar(existente))
                .isInstanceOf(ExpedienteDuplicadoException.class);
        verify(repo, never()).guardar(any(Expediente.class));
    }

    private void comprobarImporte(int dias, String esperado) {
        BigDecimal importe = servicio.calcularImporteConBonificacion(
                expediente(notificacion), notificacion.plusDays(dias));
        assertThat(importe).isEqualByComparingTo(esperado);
        verifyNoInteractions(repo);
    }

    @Test
    void bonificaUnDiaInteriorDelPlazo() {
        comprobarImporte(10, "50.00");
    }

    @Test
    void bonificaElDia20() {
        comprobarImporte(20, "50.00");
    }

    @Test
    void cobraCompletoElDia21() {
        comprobarImporte(21, "100.00");
    }

    // Casos adicionales para las decisiones de esta propuesta.
    @Test
    void bonificaElPrimerDiaSiguiente() {
        comprobarImporte(1, "50.00");
    }

    @Test
    void noBonificaElMismoDia() {
        comprobarImporte(0, "100.00");
    }

    @Test
    void rechazaPagoAnterior() {
        assertThatThrownBy(() -> servicio.calcularImporteConBonificacion(
                expediente(notificacion), notificacion.minusDays(1)))
                .isInstanceOf(IllegalArgumentException.class);
    }

    @Test
    void rechazaCalculoSinNotificacion() {
        assertThatThrownBy(() -> servicio.calcularImporteConBonificacion(
                expediente(null), notificacion.plusDays(1)))
                .isInstanceOf(IllegalArgumentException.class);
    }

    @Test
    void rechazaCalculoSinFechaDePago() {
        assertThatThrownBy(() -> servicio.calcularImporteConBonificacion(
                expediente(notificacion), null))
                .isInstanceOf(IllegalArgumentException.class);
    }
}