Modificaciones realizadas y nuevas excepciones

src/main/java/es/ujaen/dae/carpoolingdae/entidades/Usuario.java

@@ -23,6 +23,7 @@ import lombok.NoArgsConstructor;
 
 /**
  * Usuario a la app de carpooling
+ * 
  * @author maria
  */
 @Data
@@ -30,6 +31,12 @@ import lombok.NoArgsConstructor;
 @Entity
 public class Usuario {
 
+    // Lista de viajes como conductor
+    private List<Viaje> viajesComoConductor;
+     
+    // Lista de viajes como pasajero
+    private List<Viaje> viajesComoPasajero;
+
     @NotBlank
     @Id
     @Size(min = 9, max = 9)
@@ -64,6 +71,9 @@ public class Usuario {
         this.email = email;
         this.clave = CodificadorMd5.codificar(clave);
         // reservas = new ArrayList<>();
+        viajesComoConductor = new ArrayList<>();
+        viajesComoPasajero = new ArrayList<>();
+
     }
 
     public String getDni() {
@@ -90,47 +100,16 @@ public class Usuario {
         return email;
     }
 
-    // Lista de viajes actuales disponibles
-     List<Viaje> viajesActuales;
-    private int totalViajes = 0;
-
-    public void crearViaje(Viaje viaje) {
-          viajesActuales.add(viaje);
-          totalViajes++;
-         
-    }
-
-    //Lista de viajes como pasajero
-     List<Viaje> viajesComoPasajero = new ArrayList<>();
+    public List<Viaje> getviajesComoConductor() {
+        return viajesComoConductor;
+    }  
 
-     /**
-     * Enviar solicitud para ser pasajero de un viaje
-     * @param viaje al que se envía la solicitud
-     */
-    public void enviarSolicitudViaje(Viaje viaje) {
-        if (viaje != null && !viajesComoPasajero.contains(viaje)) {
-            //viajesComoPasajero.add(viaje);
-            viaje.usuariosSolicitantes.add(this); // Agregar este usuario a la lista de solicitantes en el Viaje
-        }
-    }
- /**
-     * Aceptar pasajero en un viaje
-     * @param viaje
-     * @param pasajero que es aceptado en el viaje
-     */
-
-    public void aceptarPasajero(Viaje viaje, Usuario pasajero) {
-        if (viaje != null && viaje.usuariosSolicitantes.contains(pasajero)) {
-            viaje.usuariosSolicitantes.remove(pasajero);
-            viaje.usuariosConfirmados.add(pasajero);
-            pasajero.getViajesComoPasajero().add(viaje);
-        }
-    }
 
-       /**
+    /**
      * Compara la clave con la del usuario, codificándola en Md5
+     * 
      * @param clave
-     * @return 
+     * @return
      */
 
     public boolean claveValida(String clave) {

src/main/java/es/ujaen/dae/carpoolingdae/entidades/Viaje.java

@@ -7,18 +7,27 @@ import java.util.List;
 import javax.persistence.GeneratedValue;
 import javax.persistence.GenerationType;
 import javax.persistence.Id;
+import javax.persistence.ManyToOne;
 import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.Past;
 
+import es.ujaen.dae.carpoolingdae.excepciones.PlazaNoDisponible;
+
 
 
 public class Viaje  {
 
     //Lista de usuarios que solicitan unirse a un viaje
-     List<Usuario> usuariosSolicitantes = new ArrayList<>();
+     private List<Usuario> usuariosSolicitantes = new ArrayList<>();
+     
    //Lista de usuarios que son confirmados en un viaje
-     List<Usuario> usuariosConfirmados = new ArrayList<>();
+     private List<Usuario> usuariosConfirmados = new ArrayList<>();
+     
+
+     @ManyToOne
+    private Usuario conductor;
 
+   
 
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
@@ -39,7 +48,7 @@ int id;
     @NotBlank
      Double precioAsiento;
 
-    public Viaje(int id, String destino, String origen, LocalDateTime fecha_hora, int plazasDisponibles, Double precioAsiento){
+    public Viaje(int id,String destino, String origen, LocalDateTime fecha_hora, int plazasDisponibles, Double precioAsiento){
         this.id = id;
         this.origen = origen;
         this.destino = destino;
@@ -49,9 +58,12 @@ int id;
         //reservas = new ArrayList<>();
     }
 
+     
+
     public int getId(){
         return id;
     }
+   
      public String getDestino(){
         return destino;
     }
@@ -67,6 +79,25 @@ int id;
      public Double getPrecio(){
         return precioAsiento;
     }
+    public List<Usuario> getUsuariosSolicitantes() {
+        return usuariosSolicitantes;
+    }
+    public List<Usuario> getusuariosConfirmados() {
+        return usuariosConfirmados;
+    }
+    public void setConductor(Usuario conductor) {
+        this.conductor = conductor;
+    }
     
+
+    public void addPasajero(Usuario pasajero){
+        if (plazasDisponibles > 0) {
+            usuariosConfirmados.add(pasajero);
+            plazasDisponibles--;
+        } else {
+            throw new PlazaNoDisponible();
+        } 
+        
+    }
     
 }

src/main/java/es/ujaen/dae/carpoolingdae/excepciones/PlazaNoDisponible.java

+package es.ujaen.dae.carpoolingdae.excepciones;
+
+public class PlazaNoDisponible extends RuntimeException{
+    public PlazaNoDisponible() {
+    }
+}

src/main/java/es/ujaen/dae/carpoolingdae/excepciones/UsuarioNoRegistrado.java

+package es.ujaen.dae.carpoolingdae.excepciones;
+
+public class UsuarioNoRegistrado extends RuntimeException{
+    public UsuarioNoRegistrado() {
+    }
+}

src/main/java/es/ujaen/dae/carpoolingdae/excepciones/ViajeNoExistente.java

+package es.ujaen.dae.carpoolingdae.excepciones;
+
+public class ViajeNoExistente extends RuntimeException {
+    public ViajeNoExistente(){
+        
+    }
+}

src/main/java/es/ujaen/dae/carpoolingdae/servicios/SistemaCarpooling.java

@@ -17,74 +17,118 @@ import org.springframework.validation.annotation.Validated;
 
 import es.ujaen.dae.carpoolingdae.entidades.Usuario;
 import es.ujaen.dae.carpoolingdae.entidades.Viaje;
+import es.ujaen.dae.carpoolingdae.excepciones.UsuarioNoRegistrado;
 import es.ujaen.dae.carpoolingdae.excepciones.UsuarioYaRegistrado;
+import es.ujaen.dae.carpoolingdae.excepciones.ViajeNoExistente;
 
 @Service
 @Validated
 public class SistemaCarpooling {
 
-     /** Mapa con la lista de Usuarios */
+    /** Mapa con la lista de Usuarios */
     Map<String, Usuario> usuarios;
-     /** Mapa con la lista de Viajes */
+    /** Mapa con la lista de Viajes */
     Map<String, Viaje> viajes;
 
-    public SistemaCarpooling(){
+    public SistemaCarpooling() {
         usuarios = new TreeMap<>();
         viajes = new TreeMap<>();
     }
 
-     /**
-     * Dar de alta usuario 
+    /**
+     * Dar de alta usuario
+     * 
      * @param usuario el usuario a dar de alta
      */
 
-     public void altaUsuario(@NotNull @Valid Usuario usuario) {
+    public void altaUsuario(@NotNull @Valid Usuario usuario) {
         if (usuarios.containsKey(usuario.getDni())) {
             throw new UsuarioYaRegistrado();
         }
-        
+
         // Registrar usuario
         usuarios.put(usuario.getDni(), usuario);
 
-    
-}
+    }
 
- /**
+    /**
      * Realiza un login de un usuario
+     * 
      * @param email email del usuario
      * @param clave la clave de acceso
      * @return el objeto de la clase Viaje asociado
      */
     public Optional<Usuario> loginUsuario(@NotBlank String email, @NotBlank String clave) {
-        return Optional.ofNullable(usuarios.get(email)).filter((cliente)->cliente.claveValida(clave));
+        return Optional.ofNullable(usuarios.get(email)).filter((cliente) -> cliente.claveValida(clave));
     }
 
-     /**
+    /**
      * Buscar viaje
-     * @param origen donde empieza el viaje
+     * 
+     * @param origen  donde empieza el viaje
      * @param destino donde acaba el viaje
-     * @param fecha fecha del viaje
+     * @param fecha   fecha del viaje
      * @return viajes encontrados con esos datos
      */
-   
+
     public List<Viaje> buscarViajes(String origen, String destino, LocalDate fecha) {
         List<Viaje> viajesEncontrados = new ArrayList<>();
         for (Viaje viaje : viajes.values()) { // Iterar sobre la colección de viajes
-            if (viaje.getOrigen().equals(origen) && viaje.getDestino().equals(destino) && viaje.getFecha_hora().toLocalDate().equals(fecha)) {
+            if (viaje.getOrigen().equals(origen) && viaje.getDestino().equals(destino)
+                    && viaje.getFecha_hora().toLocalDate().equals(fecha)) {
                 viajesEncontrados.add(viaje);
+            }else{
+                throw new ViajeNoExistente();
             }
         }
         return viajesEncontrados;
+        
     }
 
-       /**
-     * Agregar viaje
-     * @param nuevoViaje viaje creado
-     */
+   
+    public void agregarViaje(@NotBlank String dni, @NotNull @Valid Viaje viaje) {
+        // Verificar si el usuario conductor existe en la base de datos
+        Usuario conductor = usuarios.get(dni);
+        if (conductor == null) {
+            throw new UsuarioNoRegistrado();
+        }
+    
+        // Asignar el conductor al viaje
+        viaje.setConductor(conductor);
+    
+        // Agregar el viaje a la lista de viajes del conductor (si es necesario)
+        conductor.getviajesComoConductor().add(viaje);
+    
+        // Agregar el viaje al mapa de viajes
+        viajes.put(String.valueOf(viaje.getId()), viaje);
+    }
 
-    public void agregarViaje(@NotNull @Valid Viaje nuevoViaje) {
-        viajes.put(String.valueOf(nuevoViaje.getId()), nuevoViaje);
+    
+    /**
+     * Enviar solicitud para ser pasajero de un viaje
+     * 
+     * @param viaje al que se envía la solicitud
+     */
+    public void enviarSolicitudViaje(Viaje viaje, Usuario pasajero) {
+        if (viaje != null && ! viaje.getUsuariosSolicitantes().contains(pasajero)) {
+            viaje.getUsuariosSolicitantes().add(pasajero);// Agregar este usuario a la lista de solicitantes en el Viaje
+        }
     }
 
+    /**
+     * Aceptar pasajero en un viaje
+     * 
+     * @param viaje
+     * @param pasajero que es aceptado en el viaje
+     */
+
+    public void aceptarPasajero(@NotNull @Valid Viaje viaje, Usuario pasajero) {
+        if (viaje != null && viaje.getUsuariosSolicitantes().contains(pasajero) && pasajero.getviajesComoConductor().contains(viaje)) { //AQUI EN VER QUE SOLO PUEDE ACEPTAR EL CONDUCTOR
+            viaje.getUsuariosSolicitantes().remove(pasajero);
+            viaje.getusuariosConfirmados().add(pasajero);
+        } else {
+            throw new IllegalArgumentException("No se puede aceptar al pasajero.");
+        }
+    }
 
 }
\ No newline at end of file

src/test/java/es/ujaen/dae/carpoolingdae/entidades/UsuarioTest.java

 package es.ujaen.dae.carpoolingdae.entidades;
+
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -13,90 +14,61 @@ import org.assertj.core.api.Assertions;
 
 import java.util.Set;
 
-
 public class UsuarioTest {
 
-    public UsuarioTest() {}
+    public UsuarioTest() {
+    }
 
     @Test
     void testValidacionUsuario() {
-        String clave  = "mariahm";
-        
+        String clave = "mariahm";
+
         Usuario usuario = new Usuario(
-            "22334455H",
-            "María",
-            "Hidalgo Morcillo",
-            LocalDate.of(1990, 11, 1),
-            "189273810",
-            "mhm@red.ujaen.es",
-            clave);
-        
+                "22334455H",
+                "María",
+                "Hidalgo Morcillo",
+                LocalDate.of(1990, 11, 1),
+                "189273810",
+                "mhm@red.ujaen.es",
+                clave);
+
         Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
         Set<ConstraintViolation<Usuario>> violations = validator.validate(usuario);
-                
+
         Assertions.assertThat(violations).isEmpty();
     }
 
-        @Test
-    void testCrearViaje() {
-        String clave = "mariahm";
-        
-       Usuario usuario = new Usuario(
-            "22334455H",
-            "María",
-            "Hidalgo Morcillo",
-            LocalDate.of(1990, 11, 1),
-            "189273810",
-            "mhm@red.ujaen.es",
-            clave);
-        
-        Viaje viaje = new Viaje(1,  "Origen", "Destino", LocalDateTime.of(2023, 9, 30, 8, 0), 4, 50.0);
-        usuario.crearViaje(viaje);
-        
-    }  
-        
-
-    @Test
-    public void testEnviarSolicitudViaje() {
-        Viaje viaje = new Viaje(1,  "Origen", "Destino", LocalDateTime.of(2023, 9, 30, 8, 0), 4, 50.0);
-        Usuario usuario = new Usuario("987654321", "OtroNombre", "OtroApellido", LocalDate.of(1995, 2, 2), "987654321", "otrocorreo@example.com", "clave");
-
-        usuario.enviarSolicitudViaje(viaje);
-        assertTrue(viaje.usuariosSolicitantes.contains(usuario));
-
-        // Asegúrate de que otroUsuario no esté en la lista de solicitantes
-        assertFalse(viaje.usuariosSolicitantes.contains(usuario));
-    }
+    
 
     @Test
     public void testAceptarPasajero() {
-        Viaje viaje = new Viaje(1,  "Origen", "Destino", LocalDateTime.of(2023, 9, 30, 8, 0), 4, 50.0);
-        Usuario pasajero = new Usuario("987654321", "OtroNombre", "OtroApellido", LocalDate.of(1995, 2, 2), "987654321", "otrocorreo@example.com", "clave");
+        Viaje viaje = new Viaje(1, "Destino", "Origen", LocalDateTime.of(2023, 9, 30, 8, 0, 0), 4, 50.0);
+        Usuario pasajero = new Usuario("987654321", "OtroNombre", "OtroApellido", LocalDate.of(1995, 2, 2), "987654321",
+                "otrocorreo@example.com", "clave");
 
-        viaje.usuariosSolicitantes.add(pasajero);
+        viaje.getusuariosSolicitantes().add(pasajero);
         pasajero.aceptarPasajero(viaje, pasajero);
 
+        // Me aseguro de que el pasajero y el conductor no puedan ser la misma persona
         assertFalse(viaje.usuariosSolicitantes.contains(pasajero));
         assertTrue(viaje.usuariosConfirmados.contains(pasajero));
-        assertTrue(pasajero.getViajesComoPasajero().contains(viaje));
-    }
 
+    }
 
     @Test
     void testComprobacionClave() {
         String clave = "mariahm";
-        
-       Usuario usuario = new Usuario(
-            "22334455H",
-            "María",
-            "Hidalgo Morcillo",
-            LocalDate.of(1990, 11, 1),
-            "189273810",
-            "mhm@red.ujaen.es",
-            clave);
-        
+
+        Usuario usuario = new Usuario(
+                "22334455H",
+                "María",
+                "Hidalgo Morcillo",
+                LocalDate.of(1990, 11, 1),
+                "189273810",
+                "mhm@red.ujaen.es",
+                clave);
+
         Assertions.assertThat(usuario.claveValida(clave)).isTrue();
     }
-    
-  
+
 }

src/test/java/es/ujaen/dae/carpoolingdae/servicios/SistemaCarpoolingTest.java

 package es.ujaen.dae.carpoolingdae.servicios;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 
 import javax.validation.ConstraintViolationException;
 
 import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.annotation.DirtiesContext.MethodMode;
+import org.springframework.test.context.ActiveProfiles;
 
 import es.ujaen.dae.carpoolingdae.entidades.Usuario;
 //import es.ujaen.dae.carpoolingdae.utils.CodificadorMd5;
@@ -20,11 +32,19 @@ import es.ujaen.dae.carpoolingdae.entidades.Viaje;
 
 //@Disabled
 @SpringBootTest(classes = es.ujaen.dae.carpoolingdae.app.CarpoolingDaeApplication.class)
+@ActiveProfiles(profiles = {"test"})
 public class SistemaCarpoolingTest {
 
     @Autowired
     SistemaCarpooling sistemaCarpooling;
 
+     //Accedemos al sistema
+     @Test
+     public void testAccesoServicioHotel() {
+         Assertions.assertThat(sistemaCarpooling).isNotNull();
+     }
+
+
     @Test
     public void testAccesoSistemaCarpooling() {
         Assertions.assertThat(sistemaCarpooling).isNotNull();
@@ -33,25 +53,27 @@ public class SistemaCarpoolingTest {
     @Test
     @DirtiesContext(methodMode = MethodMode.AFTER_METHOD)
     public void testAltaUsuarioInvalido() {
-        // Usuario con e-mail incorrecto!!!
-        // String clave = "mariahm";
+         String clave = "mariahm";
         Usuario usuario = new Usuario(
                 "22334455H",
                 "María",
                 "Hidalgo Morcillo",
                 LocalDate.of(1990, 11, 1),
                 "189273810",
-                "mhm@red..es",
-                "clave");
+                "mhm@red.ujaen.es",
+                clave);
 
         Assertions.assertThatThrownBy(() -> {
             sistemaCarpooling.altaUsuario(usuario);
         }).isInstanceOf(ConstraintViolationException.class);
     }
 
+    //Damos de alta el usuario
+
     @Test
     @DirtiesContext(methodMode = MethodMode.AFTER_METHOD)
-    public void testAltaYLoginUsuarioCuenta() {
+    public void testAltaYLoginUsuario() {
+        String clave = "mariahm";
         Usuario usuario = new Usuario(
                 "22334455H",
                 "María",
@@ -59,7 +81,7 @@ public class SistemaCarpoolingTest {
                 LocalDate.of(1990, 11, 1),
                 "189273810",
                 "mhm@red.ujaen.es",
-                "clave");
+                clave);
 
         // Cuenta cuenta = servicioUjaCoin.altaCliente(cliente);
         Optional<Usuario> usuarioLogin = sistemaCarpooling.loginUsuario(usuario.getEmail(), "clave");
@@ -68,10 +90,19 @@ public class SistemaCarpoolingTest {
         Assertions.assertThat(usuarioLogin.get()).isEqualTo(usuario);
     }
 
-    @Test
+  
     @DirtiesContext(methodMode = MethodMode.AFTER_METHOD)
-    public void testIngreso() {
-        // Registrar cliente y realizar login
+    public void testAgregarViaje() {
+        // Crear un objeto Viaje válido
+        Viaje nuevoViaje = new Viaje(
+                12345, // ID del viaje
+                "Origen",
+                "Destino",
+                LocalDateTime.of(2023, 9, 30, 8, 0),
+                2,
+                50.0);
+
+                String clave = "mariahm";
         Usuario usuario = new Usuario(
                 "22334455H",
                 "María",
@@ -79,74 +110,164 @@ public class SistemaCarpoolingTest {
                 LocalDate.of(1990, 11, 1),
                 "189273810",
                 "mhm@red.ujaen.es",
-                "clave");
+                clave);
 
-        // Cuenta cuenta = servicioUjaCoin.altaCliente(cliente);
-        Usuario usuarioLogin = sistemaCarpooling.loginUsuario(usuario.getEmail(), "clave").get();
+        // Agregar el viaje al sistema
+        sistemaCarpooling.agregarViaje(usuario.getDni(), nuevoViaje);
+
+        // Buscar el viaje paraver si ha sido añadido
+        String origenBusqueda = "Origen";
+        String destinoBusqueda = "Destino";
+        LocalDate fechaBusqueda = LocalDate.of(2023, 9, 30);
 
-        // Añadir una tarjeta
+        List<Viaje> viajesEncontrados = sistemaCarpooling.buscarViajes(origenBusqueda, destinoBusqueda, fechaBusqueda);
 
-    }
+        // Verificar que se encuentren los viajes esperados
+        Assertions.assertThat(viajesEncontrados).contains(nuevoViaje);
+
+    } 
 
     @Test
     @DirtiesContext(methodMode = MethodMode.AFTER_METHOD)
     public void testBuscarViajes() {
 
         Viaje viaje = new Viaje(
-        12345, // ID del viaje
-        "Origen",
-        "Destino",
-        LocalDateTime.of(2023, 9, 30, 8, 0),
-        2,
-        50.0);
-
-
-        // Crear algunos viajes de prueba
-
-        // Agregar los viajes al sistema
-        sistemaCarpooling.agregarViaje(viaje);
+                12345, // ID del viaje
+                "Origen",
+                "Destino",
+                LocalDateTime.of(2023, 9, 30, 8, 0),
+                2,
+                50.0);
 
         // Realizar la búsqueda de viajes
         String origenBusqueda = "Origen";
         String destinoBusqueda = "Destino";
         LocalDate fechaBusqueda = LocalDate.of(2023, 9, 30);
 
+
+        Viaje viaje2 = new Viaje(
+                54321, // ID del viaje
+                "Origen2",
+                "Destino2",
+                LocalDateTime.of(2023, 9, 30, 8, 0),
+                3,
+                30.0);
+
+        // Realizar la búsqueda de viajes
+        String origenBusqueda2 = "Origen2";
+        String destinoBusqueda2 = "Destino2";
+        LocalDate fechaBusqueda2 = LocalDate.of(2023, 9, 30);
+
         List<Viaje> viajesEncontrados = sistemaCarpooling.buscarViajes(origenBusqueda, destinoBusqueda, fechaBusqueda);
+        //List<Viaje> viajesEncontrados = sistemaCarpooling.buscarViajes(origenBusqueda2, destinoBusqueda2, fechaBusqueda2);
 
         // Verificar que se encuentren los viajes esperados
         Assertions.assertThat(viajesEncontrados).containsExactly(viaje);
+        Assertions.assertThat(viajesEncontrados).containsExactly(viaje2);
 
-        // Limpiar los viajes creados durante la prueba
-        // sistemaCarpooling.eliminarViaje(viaje);
 
-    }
 
+    }
+    
+    
     @Test
     @DirtiesContext(methodMode = MethodMode.AFTER_METHOD)
-    public void testAgregarViaje() {
-        // Crear un objeto Viaje válido
-        Viaje nuevoViaje = new Viaje(
-        12345, // ID del viaje
-        "Origen",
-        "Destino",
-        LocalDateTime.of(2023, 9, 30, 8, 0),
-        2,
-        50.0);
+    public void testEnviarSolicitudViaje() {
+        // Crear un usuario conductor
+        Usuario conductor = new Usuario(
+                "12345678A",
+                "Conductor",
+                "Apellido",
+                LocalDate.of(1990, 1, 1),
+                "123456789",
+                "conductor@example.com",
+                "clave");
 
-         // Agregar el viaje al sistema
-         sistemaCarpooling.agregarViaje(nuevoViaje);
+        // Crear un usuario pasajero
+        Usuario pasajero = new Usuario(
+                "87654321B",
+                "Pasajero",
+                "Apellido",
+                LocalDate.of(1995, 5, 5),
+                "987654321",
+                "pasajero@example.com",
+                "clave");
+                // Crear un viaje
+        Viaje viaje = new Viaje(
+            12345,
+            "Origen",
+            "Destino",
+            LocalDateTime.of(2023, 9, 30, 8, 0),
+            2,
+            50.0);
+    viaje.setConductor(conductor);
+
+    // Agregar el viaje al sistema
+    sistemaCarpooling.agregarViaje(conductor.getDni(), viaje);
+
+    // Enviar solicitud de viaje
+    sistemaCarpooling.enviarSolicitudViaje(viaje, pasajero);
+
+    // Verificar que el pasajero está en la lista de solicitantes del viaje
+    assertTrue(viaje.getUsuariosSolicitantes().contains(pasajero));
+}
+
+@Test
+@DirtiesContext(methodMode = MethodMode.AFTER_METHOD)
+public void testAceptarPasajero() {
+    // Crear un usuario conductor
+    Usuario conductor = new Usuario(
+            "12345678A",
+            "Conductor",
+            "Apellido",
+            LocalDate.of(1990, 1, 1),
+            "123456789",
+            "conductor@example.com",
+            "clave");
+
+    // Crear un usuario pasajero
+    Usuario pasajero = new Usuario(
+            "87654321B",
+            "Pasajero",
+            "Apellido",
+            LocalDate.of(1995, 5, 5),
+            "987654321",
+            "pasajero@example.com",
+            "clave");
+
+            // Crear un viaje
+        Viaje viaje = new Viaje(
+            12345,
+            "Origen",
+            "Destino",
+            LocalDateTime.of(2023, 9, 30, 8, 0),
+            2,
+            50.0);
+    viaje.setConductor(conductor);
+
+    // Agregar el viaje al sistema
+    sistemaCarpooling.agregarViaje(conductor.getDni(), viaje);
+
+    // Enviar solicitud de viaje
+    sistemaCarpooling.enviarSolicitudViaje(viaje, pasajero);
+
+    // Aceptar al pasajero en el viaje
+    sistemaCarpooling.aceptarPasajero(viaje, pasajero);
+
+    // Verificar que el pasajero está en la lista de usuarios confirmados en el viaje
+    assertTrue(viaje.getusuariosConfirmados().contains(pasajero));
+    // Verificar que el pasajero ya no está en la lista de solicitantes del viaje
+    assertFalse(viaje.getUsuariosSolicitantes().contains(pasajero));
+}
 
-      // Buscar el viaje paraver si ha sido añadido
-        String origenBusqueda = "Origen";
-        String destinoBusqueda = "Destino";
-        LocalDate fechaBusqueda = LocalDate.of(2023, 9, 30);
 
-        List<Viaje> viajesEncontrados = sistemaCarpooling.buscarViajes(origenBusqueda, destinoBusqueda, fechaBusqueda);
 
-        // Verificar que se encuentren los viajes esperados
-        Assertions.assertThat(viajesEncontrados).contains(nuevoViaje);
 
-    }
-}
 
 
+
+
+
+
+
+}