test jugador

package vvs.planets.dominio.jugador;

import com.pholser.junit.quickcheck.Property;
import com.pholser.junit.quickcheck.runner.JUnitQuickcheck;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

import vvs.planets.dominio.Arbitro;
import vvs.planets.util.OperacionInvalida;
import vvs.planets.util.Observable;
import vvs.planets.util.Observador;

@RunWith(JUnitQuickcheck.class)
public class JugadorTest {

    private Jugador jugador;
    private Arbitro arbitroMock;

    @BeforeEach
    public void setUp() {
        arbitroMock = mock(Arbitro.class);
        jugador = new Jugador("JugadorDePrueba");
    }

    @Property
    public void testNombreEsInmutable(String nombre) {
        jugador = new Jugador(nombre);

        // Cambia el estado y verifica que el nombre no cambia
        jugador.establecerEstado(new Preparado());
        assertEquals(nombre, jugador.obtenerNombre(), "El nombre debe ser inmutable.");
    }

    @Property
    public void testObtenerDescripcion(String nombre) {
        jugador = new Jugador(nombre);

        // Se verifica que obtenerDescripcion no cause excepciones ni dé un resultado nulo
        assertNotNull(jugador.obtenerDescripcion(), "La descripción no debería ser nula.");
    }

    @Property
    public void testEnviarOrden(String orden) {
        EstadoJugador estadoMock = mock(EstadoJugador.class);
        jugador.establecerEstado(estadoMock);

        // Enviar órdenes generadas aleatoriamente y verificar que no lance excepciones
        assertDoesNotThrow(() -> jugador.enviarOrden(orden));
    }

    @Property
    public void testJugarTurno(String nombre) {
        jugador = new Jugador(nombre);
        EstadoJugador estadoMock = mock(EstadoJugador.class);
        jugador.establecerEstado(estadoMock);

        // Probar el método jugarTurno
        assertDoesNotThrow(() -> jugador.jugarTurno());
    }

    @Property
    public void testAbortarTurno(String nombre) {
        jugador = new Jugador(nombre);
        EstadoJugador estadoMock = mock(EstadoJugador.class);
        jugador.establecerEstado(estadoMock);

        // Probar abortarTurno sin excepciones
        assertDoesNotThrow(() -> jugador.abortarTurno());
    }

    @Test
    public void testPasarTurnoLanzaOperacionInvalida() {
        // Verificar que se lanza OperacionInvalida al llamar a pasarTurno
        OperacionInvalida exception = assertThrows(OperacionInvalida.class, jugador::pasarTurno);
        assertEquals("No implementado", exception.getMessage());
    }

    @Property
    public void testAbandonarJuego(String nombre) {
        jugador = new Jugador(nombre);
        EstadoJugador estadoMock = mock(EstadoJugador.class);
        jugador.establecerEstado(estadoMock);

        // Verificar que abandonarJuego se llama correctamente en el estado actual
        assertDoesNotThrow(() -> jugador.abandonarJuego());
    }

    @Test
    public void testVolverJuegoLanzaOperacionInvalida() {
        // Verificar que volverJuego lanza la excepción esperada
        OperacionInvalida exception = assertThrows(OperacionInvalida.class, jugador::volverJuego);
        assertEquals("No implementado", exception.getMessage());
    }

    @Property
    public void testActualizarCambioDeTurno(String nombre) {
        jugador = new Jugador(nombre);
        EstadoJugador estadoMock = mock(EstadoJugador.class);
        jugador.establecerEstado(estadoMock);

        when(arbitroMock.obtenerTurno()).thenReturn(2);
        jugador.establecerTurno(1); // Cambiar el turno inicial para forzar la actualización

        // Llamada al método actualizar y verificar que el turno avanza
        jugador.actualizar(arbitroMock);
        verify(estadoMock).avanzarTurno(jugador, 2);
    }

    @Property
    public void testEstablecerEstado(String nombre) {
        jugador = new Jugador(nombre);
        EstadoJugador nuevoEstado = new Jugando();

        // Cambia el estado y verifica que el estado se actualiza correctamente
        jugador.establecerEstado(nuevoEstado);
        assertEquals(nuevoEstado, jugador.obtenerEstado(), "El estado debe actualizarse correctamente.");
    }

    @Property
    public void testEstablecerTurnoPositivo(int turno) {
        assumeTrue(turno > 0);

        jugador.establecerTurno(turno);
        assertTrue(jugador.obtenerTurno() > 0, "El turno debe ser positivo.");
    }
}