Se agregan tests sobre los comandos, cubriendo totalmente esos casos

src/main/java/jwarrior/piezas/unidades/Unidad.java

@@ -84,7 +84,7 @@ public void recibirGolpe(final Integer fuerza) {
 		}
 	}
 
-	public final void curar(final Integer cantidadARestaurar) {
+	public void curar(final Integer cantidadARestaurar) {
 		this.saludActual = Math.min(
 				this.saludActual + cantidadARestaurar,
 				this.saludMaxima);
@@ -109,7 +109,7 @@ public boolean estaSaludable() {
 		return this.saludActual == this.saludMaxima;
 	}
 
-	public final boolean estaVivo() {
+	public boolean estaVivo() {
 		return this.saludActual > 0;
 	}
 

src/test/java/jwarrior/comandos/AtacarTests.java

@@ -0,0 +1,24 @@
+package jwarrior.comandos;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import jwarrior.piezas.unidades.Unidad;
+import jwarrior.piezas.unidades.mocks.UnidadEspia;
+import jwarrior.piezas.unidades.mocks.UnidadStubBuilder;
+
+import org.junit.Test;
+
+public class AtacarTests {
+
+	@Test
+	public void queUnidadAtacadaRecibeGolpe() {
+
+		Unidad atacante = UnidadStubBuilder.construirStubGuerrero();
+		UnidadEspia atacada = UnidadStubBuilder.construirStubEspia();
+		Atacar comando = ConstructorDeEscenarios.escenarioParaAtacar(atacante, atacada);
+		comando.ejecutarComando();
+		assertThat(atacada.invocoRecibirGolpe(), is(true));
+	}
+
+	// TODO: falta testear, pero es responsabilidad de otra clase, cuánto se lastima.
+}

src/test/java/jwarrior/comandos/ConstructorDeEscenarios.java

@@ -0,0 +1,116 @@
+package jwarrior.comandos;
+
+import jwarrior.piezas.PosicionEspia;
+import jwarrior.piezas.Salida;
+import jwarrior.piezas.unidades.Unidad;
+import jwarrior.piezas.unidades.mocks.UnidadEspia;
+import jwarrior.piezas.unidades.mocks.UnidadStubBuilder;
+import jwarrior.posiciones.Posicion;
+import jwarrior.posiciones.PosicionInexistente;
+import jwarrior.referencias.Direccion;
+import jwarrior.referencias.Espacio;
+
+public class ConstructorDeEscenarios {
+
+	public static NoHacerNada escenarioParaNoHacerNada(Unidad unidad) {
+		return new NoHacerNada(unidad);
+	}
+
+	public static Descansar escenarioParaDescansar(Unidad unidad) {
+		return new Descansar(unidad);
+	}
+
+	public static Atacar escenarioParaAtacar(Unidad atacante,
+			UnidadEspia atacada) {
+
+		Posicion posicionAtacada = new Posicion();
+		posicionAtacada.establecerPieza(atacada);
+
+		atacante.establecerPosicion(posicionJuntoAPosicion(posicionAtacada));
+		return new Atacar(Direccion.ADELANTE, atacante);
+	}
+
+	private static Posicion posicionJuntoAPosicion(Posicion posicionAtacada) {
+		return new PosicionJuntoAOtra(posicionAtacada);
+	}
+
+	public static EscenarioParaDesplazarse escenarioParaDesplazarsePorVacia() {
+
+		Posicion posicionDestino = new Posicion();
+		PosicionEspia posicionActual = posicionEspiaJuntoAPosicion(posicionDestino);
+		Unidad unidad = UnidadStubBuilder.construirStubGuerrero();
+		unidad.establecerPosicion(posicionActual);
+
+		return new EscenarioParaDesplazarse(unidad, posicionActual);
+	}
+
+	public static EscenarioParaDesplazarse escenarioParaDesplazarsePorSalida() {
+
+		Posicion posicionDestino = new Salida();
+		PosicionEspia posicionActual = posicionEspiaJuntoAPosicion(posicionDestino);
+		Unidad unidad = UnidadStubBuilder.construirStubGuerrero();
+		unidad.establecerPosicion(posicionActual);
+
+		return new EscenarioParaDesplazarse(unidad, posicionActual);
+	}
+
+	public static EscenarioParaDesplazarse escenarioParaNoDesplazarsePorInexistente() {
+
+		Posicion posicionDestino = new PosicionInexistente();
+		PosicionEspia posicionActual = posicionEspiaJuntoAPosicion(posicionDestino);
+		Unidad unidad = UnidadStubBuilder.construirStubGuerrero();
+		unidad.establecerPosicion(posicionActual);
+
+		return new EscenarioParaDesplazarse(unidad, posicionActual);
+	}
+
+	public static EscenarioParaDesplazarse escenarioParaNoDesplazarsePorOcupada() {
+
+		Posicion posicionDestino = new PosicionOcupada();
+		PosicionEspia posicionActual = posicionEspiaJuntoAPosicion(posicionDestino);
+		Unidad unidad = UnidadStubBuilder.construirStubGuerrero();
+		unidad.establecerPosicion(posicionActual);
+
+		return new EscenarioParaDesplazarse(unidad, posicionActual);
+	}
+
+	private static PosicionEspia posicionEspiaJuntoAPosicion(Posicion posicionAtacada) {
+		return new PosicionEspiaJuntoAOtra(posicionAtacada);
+	}
+}
+
+class PosicionOcupada extends Posicion {
+	@Override
+	public boolean hay(Espacio espacio) {
+		return Espacio.ENEMIGO == espacio;
+	}
+}
+
+class PosicionJuntoAOtra extends Posicion {
+
+	private Posicion contigua;
+
+	public PosicionJuntoAOtra(Posicion otraPosicion) {
+		this.contigua = otraPosicion;
+	}
+
+	@Override
+	public Posicion obtenerContigua(Direccion direccion) {
+		return this.contigua;
+	}
+}
+
+class PosicionEspiaJuntoAOtra extends PosicionEspia {
+
+	private Posicion contigua;
+
+	public PosicionEspiaJuntoAOtra(Posicion otraPosicion) {
+		this.contigua = otraPosicion;
+	}
+
+	@Override
+	public Posicion obtenerContigua(Direccion direccion) {
+		return this.contigua;
+	}
+
+}

src/test/java/jwarrior/comandos/DescansarTests.java

@@ -0,0 +1,32 @@
+package jwarrior.comandos;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import jwarrior.piezas.unidades.mocks.UnidadHeridaEspia;
+import jwarrior.piezas.unidades.mocks.UnidadSaludable;
+import jwarrior.piezas.unidades.mocks.UnidadStubBuilder;
+
+import org.junit.Test;
+
+public class DescansarTests {
+
+	@Test
+	public void queUnidadSaludableNoSeCura() {
+
+		UnidadSaludable unidadEspia = UnidadStubBuilder.construirStubSaludable(20);
+		Descansar comando = ConstructorDeEscenarios.escenarioParaDescansar(unidadEspia);
+		comando.ejecutarComando();
+		assertThat(unidadEspia.invocoCurar(), is(false));
+	}
+
+	@Test
+	public void queUnidadNoSaludableSeCura() {
+
+		UnidadHeridaEspia unidadEspia = UnidadStubBuilder.construirStubHeridoEspia(20);
+		Descansar comando = ConstructorDeEscenarios.escenarioParaDescansar(unidadEspia);
+		comando.ejecutarComando();
+		assertThat(unidadEspia.invocoCurar(), is(true));
+	}
+
+	// TODO: falta testear, pero es responsabilidad de otra clase, cuánto se cura.
+}

src/test/java/jwarrior/comandos/DesplazarseTests.java

@@ -0,0 +1,49 @@
+package jwarrior.comandos;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Test;
+
+public class DesplazarseTests {
+
+	@Test
+	public void queUnidadSiHayContiguaSeMueve() {
+
+		EscenarioParaDesplazarse escenario = ConstructorDeEscenarios.escenarioParaDesplazarsePorVacia();
+		Desplazarse comando = escenario.obtenerComando();
+
+		comando.ejecutarComando();
+		assertThat(escenario.obtenerPosicionOrigen().invocoMoverUnidadHacia(), is(true));
+	}
+
+	@Test
+	public void queUnidadSiHaySalidaSeMueve() {
+
+		EscenarioParaDesplazarse escenario = ConstructorDeEscenarios.escenarioParaDesplazarsePorSalida();
+		Desplazarse comando = escenario.obtenerComando();
+
+		comando.ejecutarComando();
+		assertThat(escenario.obtenerPosicionOrigen().invocoMoverUnidadHacia(), is(true));
+	}
+
+	@Test
+	public void queUnidadSiNoHayContiguaNoSeMueve() {
+
+		EscenarioParaDesplazarse escenario = ConstructorDeEscenarios.escenarioParaNoDesplazarsePorInexistente();
+		Desplazarse comando = escenario.obtenerComando();
+
+		comando.ejecutarComando();
+		assertThat(escenario.obtenerPosicionOrigen().invocoMoverUnidadHacia(), is(false));
+	}
+
+	@Test
+	public void queUnidadSiHayContiguaOcupadaNoSeMueve() {
+
+		EscenarioParaDesplazarse escenario = ConstructorDeEscenarios.escenarioParaNoDesplazarsePorOcupada();
+		Desplazarse comando = escenario.obtenerComando();
+
+		comando.ejecutarComando();
+		assertThat(escenario.obtenerPosicionOrigen().invocoMoverUnidadHacia(), is(false));
+	}
+}

src/test/java/jwarrior/comandos/EscenarioParaDesplazarse.java

@@ -0,0 +1,26 @@
+package jwarrior.comandos;
+
+import jwarrior.piezas.PosicionEspia;
+import jwarrior.piezas.unidades.Unidad;
+import jwarrior.referencias.Direccion;
+
+public class EscenarioParaDesplazarse {
+
+	private PosicionEspia posicionActual;
+	private Unidad unidad;
+
+	public EscenarioParaDesplazarse(Unidad unidad,
+			PosicionEspia posicionActual) {
+		this.unidad = unidad;
+		this.posicionActual = posicionActual;
+	}
+
+	public PosicionEspia obtenerPosicionOrigen() {
+		return this.posicionActual;
+	}
+
+	public Desplazarse obtenerComando() {
+		return new Desplazarse(Direccion.ADELANTE, this.unidad);
+	}
+
+}

src/test/java/jwarrior/comandos/NoHacerNadaTests.java

@@ -0,0 +1,31 @@
+package jwarrior.comandos;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import jwarrior.piezas.unidades.mocks.UnidadEspia;
+import jwarrior.piezas.unidades.mocks.UnidadMuerta;
+import jwarrior.piezas.unidades.mocks.UnidadStubBuilder;
+
+import org.junit.Test;
+
+public class NoHacerNadaTests {
+
+	@Test
+	public void queNoHaceNada() {
+
+		UnidadEspia unidadEspia = UnidadStubBuilder.construirStubEspia();
+		NoHacerNada comando = ConstructorDeEscenarios.escenarioParaNoHacerNada(unidadEspia);
+		comando.ejecutarComando();
+		assertThat(unidadEspia.invocoDecir(), is(true));
+	}
+
+	@Test
+	public void queSiEstaMuertaNoEjecuta() {
+
+		UnidadMuerta unidadMuerta = UnidadStubBuilder.construirStubMuerto();
+		NoHacerNada comando = ConstructorDeEscenarios.escenarioParaNoHacerNada(unidadMuerta);
+		comando.ejecutarComando();
+		assertThat(unidadMuerta.invocoDecir(), is(false));
+	}
+
+}

src/test/java/jwarrior/juego/puntuacion/ControlDePuntajeTests.java

@@ -19,18 +19,18 @@ public class ControlDePuntajeTests {
 
 	@Test
 	public void informaPuntuacionInicial() {
-		
+
 		ControlDePuntaje controlDePuntaje = new ControlDePuntaje();
 		assertThat(controlDePuntaje.obtenerPuntaje(), is(10));
 	}
-	
+
 	@Test
 	public void alInformarPasoDeTurnoNotificaConPuntajeNegativo() {
 
 		ControlDePuntaje controlDePuntaje = new ControlDePuntaje();
 		PuntajeEspia puntajeEspia = new PuntajeEspia();
 		controlDePuntaje.establecerPuntaje(puntajeEspia);
-		
+
 		controlDePuntaje.notificarTurno(new JuegoStub());
 		assertThat(puntajeEspia.invocoComputarConNegativo(), is(true));
 	}
@@ -41,7 +41,7 @@ public void alInformarMuerteEnemigoComputa() {
 		ControlDePuntaje controlDePuntaje = new ControlDePuntaje();
 		PuntajeEspia puntajeEspia = new PuntajeEspia();
 		controlDePuntaje.establecerPuntaje(puntajeEspia);
-		
+
 		controlDePuntaje.notificarMuerte(UnidadStubBuilder.construirStub());
 		assertThat(puntajeEspia.invocoComputar(), is(true));
 	}
@@ -52,7 +52,7 @@ public void alInformarMuerteGuerreroNoComputa() {
 		ControlDePuntaje controlDePuntaje = new ControlDePuntaje();
 		PuntajeEspia puntajeEspia = new PuntajeEspia();
 		controlDePuntaje.establecerPuntaje(puntajeEspia);
-		
+
 		controlDePuntaje.notificarMuerte(UnidadStubBuilder.construirStubGuerrero());
 		assertThat(puntajeEspia.invocoComputar(), is(false));
 	}
@@ -63,7 +63,7 @@ public void alInformarFinalizacionPartidaComputa() {
 		ControlDePuntaje controlDePuntaje = new ControlDePuntaje();
 		PuntajeEspia puntajeEspia = new PuntajeEspia();
 		controlDePuntaje.establecerPuntaje(puntajeEspia);
-		
+
 		controlDePuntaje.notificarFinal(new JuegoStub());
 		assertThat(puntajeEspia.invocoComputar(), is(true));
 	}
@@ -74,7 +74,7 @@ class JuegoStub extends Juego {
 	public JuegoStub() {
 		super(new NivelDummy());
 	}
-	
+
 	@Override
 	public Unidad obtenerGuerrero() {
 		return UnidadStubBuilder.construirStubGuerrero();
@@ -103,11 +103,11 @@ public void computar(Integer puntos) {
 			this.computoConNegativo = true;
 		}
 	}
-	
+
 	public Boolean invocoComputarConNegativo() {
 		return this.computoConNegativo;
 	}
-	
+
 	public Boolean invocoComputar() {
 		return this.computo;
 	}

src/test/java/jwarrior/piezas/PosicionEspia.java

@@ -5,6 +5,7 @@
 public class PosicionEspia extends Posicion {
 
 	private boolean seLibero = false;
+	private boolean invocoMoverUnidadHacia = false;
 
 	@Override
 	public void liberar() {
@@ -15,4 +16,13 @@ public boolean verificarQueSeLibero() {
 		return this.seLibero;
 	}
 
+	@Override
+	public void moverUnidadHacia(Posicion posicionDestino) {
+		this.invocoMoverUnidadHacia = true;
+	}
+
+	public boolean invocoMoverUnidadHacia() {
+		return this.invocoMoverUnidadHacia ;
+	}
+
 }