class Fauno(Atacable, Atacante):
def __init__(self, resistencia=100):
self._resistencia = resistencia
self.__escudo = Escudo()
self.__arma = Arma()
def atacar(self, objetivo):
self.__arma.atacar(objetivo)
def recibir_ataque(self, potencia):
self._validar_resistencia()
try:
self.__escudo.recibir_ataque()
except ValueError:
if self._resistencia - potencia > 0:
self._resistencia -= potencia
else:
self._resistencia = 0
class IntegracionArmaTestCase(unittest.TestCase):
def setUp(self):
self.arma = Arma()
self.escudo = Escudo()
self.fauno = Fauno()
def test_arma_ataca_escudo_y_reduce_resistencia(self):
self.arma.atacar(self.escudo)
self.assertEqual(4, self.escudo.resistencia)
def test_arma_ataca_escudo_sin_resistencia(self):
self.arma.atacar(self.escudo)
self.arma.atacar(self.escudo)
self.arma.atacar(self.escudo)
self.arma.atacar(self.escudo)
self.arma.atacar(self.escudo)
with self.assertRaises(ValueError) as contexto:
self.arma.atacar(self.escudo)
self.assertEqual("¡El objetivo ya no puede recibir ataques!", str(contexto.exception))
self.assertEqual(0, self.escudo.resistencia)
def test_arma_ataca_fauno_con_escudo_y_no_reduce_resistencia(self):
resistencia_inicial = self.fauno.resistencia
self.arma.atacar(self.fauno)
self.assertEqual(resistencia_inicial, self.fauno.resistencia)
def test_arma_ataca_fauno_con_escudo_vencido_y_reduce_resistencia(self):
for _ in range(5):
self.arma.atacar(self.fauno)
self.arma.atacar(self.fauno)
self.assertEqual(90, self.fauno.resistencia)
def test_arma_ataca_fauno_sin_resistencia(self):
for _ in range(15):
self.arma.atacar(self.fauno)
with self.assertRaises(ValueError) as contexto:
self.arma.atacar(self.fauno)
self.assertEqual("¡El objetivo ya no puede recibir ataques!", str(contexto.exception))
class ArmaTestCase(unittest.TestCase):
"""
==========================================================================
Casos de prueba detectados
==========================================================================
Escenario: un arma es atacante
Dado que existe un arma
Cuando un arma ataca a un objetivo que puede recibir un ataque
Entonces no hay error
--------------------------------------------------------------------------
Escenario: un arma tiene una potencia predeterminada de 10
Dado que existe un arma
Cuando se crea un arma
Entonces el arma tiene una potencia de 10
--------------------------------------------------------------------------
Escenario: un arma tiene una potencia específica de 50
Dado que existe un arma
Cuando se crea un arma con potencia 50
Entonces el arma tiene una potencia de 50
--------------------------------------------------------------------------
Escenario: un arma con potencia predeterminada ataca a un objetivo
Dado que existe un arma
Cuando el arma ataca a un objetivo puntual con una potencia de 10
Entonces el objetivo recibe un ataque con potencia 10
--------------------------------------------------------------------------
Escenario: un arma con potencia específica ataca a un objetivo
Dado que existe un arma
Cuando el arma ataca a un objetivo puntual con una potencia específica de 50
Entonces el objetivo recibe un ataque con potencia específica de 50
--------------------------------------------------------------------------
Escenario: un arma no puede atacar a aquel objetivo que no puede recibir ataques
Dado que existe un arma
Cuando el arma ataca a un objetivo que no puede recibir ataques
Entonces se obtiene un NotImplementedError
"""
def setUp(self):
self.arma = Arma()
def test_arma_es_atacante(self):
self.arma.atacar(Mock())
def test_arma_inicia_con_potencia_predeterminada(self):
self.assertEqual(10, self.arma.potencia)
def test_arma_inicia_con_potencia_especificada(self):
potencia_especificada = 50
self.arma = Arma(potencia_especificada)
self.assertEqual(potencia_especificada, self.arma.potencia)
def test_arma_ataca_objetivo_que_puede_recibir_ataque(self):
objetivo = Mock()
self.arma.atacar(objetivo)
objetivo.recibir_ataque.assert_called_with(self.arma.potencia)
def test_arma_potencia_custom_ataca_objetivo_que_puede_recibir_ataque(
self):
potencia_custom = 50
self.arma = Arma(potencia_custom)
objetivo = Mock()
self.arma.atacar(objetivo)
objetivo.recibir_ataque.assert_called_with(potencia_custom)
def test_arma_ataca_objetivo_que_no_puede_recibir_ataque(self):
with self.assertRaises(NotImplementedError):
self.arma.atacar(123)