Updated WRW game enums

Added a dedicated function to get fight results.

Author: shorodilov

src/wrw_game/enums.py

@@ -31,24 +31,49 @@ def __str__(self) -> str:
 
         return self.name
 
-    def __sub__(self, other) -> FightResult:
-        """Return a fight result"""
-
-        if not isinstance(other, FightChoice):
-            raise TypeError(
-                f"unsupported operand type(s) for -: "
-                f"{self.__class__.__name__} and {other.__class__.__name__}"
-            )
-
-        if self == other:
-            return FightResult.DRAW
-
-        success_attacks = (
-            FightChoice.WARRIOR.value - FightChoice.ROBBER.value,
-            FightChoice.ROBBER.value - FightChoice.WIZARD.value,
-            FightChoice.WIZARD.value - FightChoice.WARRIOR.value,
+
+def get_fight_result(attack: FightChoice, defence: FightChoice) -> FightResult:
+    """Return a fight result based on attack and defence choices
+
+    This function performs argument types validation first and raises
+    TypeError in case of failure. After that the attack choice is compared
+    with the defence choice. The comparison rules are:
+
+    - if attack and defence are the same - draw result is returned
+    - if attack and defence pair is in successful attacks preset, the attack
+      is considered to be successful
+    - otherwise attack is considered to be failed
+
+    :param attack: attack choice
+    :type attack: :class: `FightChoice`
+    :param defence: defence choice
+    :type defence: :class: `FightChoice`
+
+    :return:
+    :rtype: :class: `FightResult`
+
+    :raise: TypeError
+
+    """
+
+    # perform type validation
+    if not isinstance(attack, FightChoice) or \
+       not isinstance(defence, FightChoice):
+        raise TypeError(
+            f"unsupported argument type(s): "
+            f"'{attack.__class__.__name__}' and '{defence.__class__.__name__}'"
         )
-        if self.value - other.value in success_attacks:
-            return FightResult.SUCCESS
 
-        return FightResult.FAILURE
+    # calculate result
+    if attack == defence:
+        return FightResult.DRAW
+
+    successful_attacks = (
+        (FightChoice.WARRIOR, FightChoice.ROBBER),
+        (FightChoice.ROBBER, FightChoice.WIZARD),
+        (FightChoice.WIZARD, FightChoice.WARRIOR),
+    )
+    if (attack, defence) in successful_attacks:
+        return FightResult.SUCCESS
+
+    return FightResult.FAILURE

src/wrw_game/models.py

@@ -8,7 +8,7 @@
 from abc import ABC, abstractmethod
 
 from wrw_game import settings
-from wrw_game.enums import FightChoice, FightResult
+from wrw_game.enums import FightChoice, FightResult, get_fight_result
 from wrw_game.exceptions import EnemyDown, GameOver
 from wrw_game.loggers import stream_handler
 
@@ -148,9 +148,9 @@ def select_defence(self) -> FightChoice:  # pragma: no cover
 
     @staticmethod
     def fight(attack: FightChoice, defence: FightChoice) -> FightResult:
-        """Return a fight result"""
+        """Implements a fight result calculation interface"""
 
-        return attack - defence
+        return get_fight_result(attack, defence)
 
     def add_score_points(self, score_points: int) -> None:
         """Add score points"""

tests/wrw_game/unit/test_fight.py

@@ -1,6 +1,6 @@
 import unittest
 
-from wrw_game.enums import FightChoice, FightResult
+from wrw_game.enums import FightChoice, FightResult, get_fight_result
 
 
 class TestFightChoice(unittest.TestCase):
@@ -32,45 +32,46 @@ def test_draw_str(self):
 
 class TestFights(unittest.TestCase):
     def test_draw_warrior(self):
-        fight_result = FightChoice.WARRIOR - FightChoice.WARRIOR
+        fight_result = get_fight_result(FightChoice.WARRIOR,
+                                        FightChoice.WARRIOR)
         self.assertEqual(FightResult.DRAW, fight_result)
 
     def test_draw_robber(self):
-        fight_result = FightChoice.ROBBER - FightChoice.ROBBER
+        fight_result = get_fight_result(FightChoice.ROBBER, FightChoice.ROBBER)
         self.assertEqual(FightResult.DRAW, fight_result)
 
     def test_draw_wizard(self):
-        fight_result = FightChoice.WIZARD - FightChoice.WIZARD
+        fight_result = get_fight_result(FightChoice.WIZARD, FightChoice.WIZARD)
         self.assertEqual(FightResult.DRAW, fight_result)
 
     def test_success_warrior(self):
-        fight_result = FightChoice.WARRIOR - FightChoice.ROBBER
+        fight_result = get_fight_result(FightChoice.WARRIOR, FightChoice.ROBBER)
         self.assertEqual(FightResult.SUCCESS, fight_result)
 
     def test_success_robber(self):
-        fight_result = FightChoice.ROBBER - FightChoice.WIZARD
+        fight_result = get_fight_result(FightChoice.ROBBER, FightChoice.WIZARD)
         self.assertEqual(FightResult.SUCCESS, fight_result)
 
     def test_success_wizard(self):
-        fight_result = FightChoice.WIZARD - FightChoice.WARRIOR
+        fight_result = get_fight_result(FightChoice.WIZARD, FightChoice.WARRIOR)
         self.assertEqual(FightResult.SUCCESS, fight_result)
 
     def test_failure_warrior(self):
-        fight_result = FightChoice.WARRIOR - FightChoice.WIZARD
+        fight_result = get_fight_result(FightChoice.WARRIOR, FightChoice.WIZARD)
         self.assertEqual(FightResult.FAILURE, fight_result)
 
     def test_failure_robber(self):
-        fight_result = FightChoice.ROBBER - FightChoice.WARRIOR
+        fight_result = get_fight_result(FightChoice.ROBBER, FightChoice.WARRIOR)
         self.assertEqual(FightResult.FAILURE, fight_result)
 
     def test_failure_wizard(self):
-        fight_result = FightChoice.WIZARD - FightChoice.ROBBER
+        fight_result = get_fight_result(FightChoice.WIZARD, FightChoice.ROBBER)
         self.assertEqual(FightResult.FAILURE, fight_result)
 
     def test_exception(self):
-        self.assertRaises(TypeError, FightChoice.WARRIOR.__sub__, 1)
-        self.assertRaises(TypeError, FightChoice.WARRIOR.__sub__, "1")
-        self.assertRaises(TypeError, FightChoice.WARRIOR.__sub__, None)
+        self.assertRaises(TypeError, get_fight_result, None, None)
+        self.assertRaises(TypeError, get_fight_result, FightChoice.WARRIOR, 1)
+        self.assertRaises(TypeError, get_fight_result, 1, FightChoice.WARRIOR)
 
 
 if __name__ == "__main__":