tests now use versus_test. raise issue- change self.state to bool derived from dict

Author: eric-s-s

axelrod/strategies/grumpy.py

@@ -25,11 +25,12 @@ def __init__(self, starting_state: str ='Nice', grumpy_threshold: int =10,
         """
         Parameters
         ----------
-        starting_state, str: 'Nice' or 'Grumpy'
-        grumpy_threshold, int
+        starting_state: str
+            'Nice' or 'Grumpy'
+        grumpy_threshold: int
             The threshold of opponent defections - cooperations to become
             grumpy
-        nice_threshold, int
+        nice_threshold: int
             The threshold of opponent defections - cooperations to become
             nice
         """

axelrod/tests/strategies/test_grumpy.py

@@ -1,15 +1,15 @@
 """Tests for the Grumpy strategy."""
 
-import axelrod
+import axelrod as axl
 from .test_player import TestPlayer
 
-C, D = axelrod.Actions.C, axelrod.Actions.D
+C, D = axl.Actions.C, axl.Actions.D
 
 
 class TestGrumpy(TestPlayer):
 
     name = "Grumpy: Nice, 10, -10"
-    player = axelrod.Grumpy
+    player = axl.Grumpy
     expected_classifier = {
         'memory_depth': float('inf'),  # Long memory
         'stochastic': False,
@@ -20,33 +20,65 @@ class TestGrumpy(TestPlayer):
         'manipulates_state': False
     }
 
-    def test_strategy(self):
-        # Starts by cooperating.
-        self.first_play_test(C)
-        # Starts by defecting if grumpy initially.
-        self.responses_test(D, init_kwargs={"starting_state": "Grumpy"})
-        # Tests that grumpy will play C until threshold is hit at which point it
-        # will become grumpy. Player will then not become nice until lower nice
-        # threshold is hit.
-
-        self.responses_test([C], [C, D, D, D], [C, C, C, C],
-                            attrs={"state": "Nice"},
-                            init_kwargs={"grumpy_threshold": 3,
-                                         "nice_threshold": 0})
-        self.responses_test([D], [C, C, D, D, D], [D, D, D, D, D],
-                            init_kwargs={"grumpy_threshold": 3,
-                                         "nice_threshold": 0})
-        self.responses_test([D], [C, C, D, D, D, D, D, D],
-                            [D, D, D, D, D, C, C, C],
-                            init_kwargs={"grumpy_threshold": 3,
-                                         "nice_threshold": 0})
-        self.responses_test([C], [C, C, D, D, D, D, D, D, D, D, D],
-                            [D, D, D, D, D, C, C, C, C, C, C],
-                            init_kwargs={"grumpy_threshold": 3,
-                                         "nice_threshold": 0})
+    def test_default_strategy(self):
+
+        opponent = axl.Cooperator()
+        actions = [(C, C)] * 30
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axl.Alternator()
+        actions = [(C, C), (C, D)] * 30
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axl.Defector()
+        actions = [(C, D)] * 11 + [(D, D)] * 20
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent_actions = [D] * 11 + [C] * 22 + [D] * 11
+        opponent = axl.MockPlayer(actions=opponent_actions)
+        actions = ([(C, D)] * 11 + [(D, C)] * 22 + [(C, D)] * 11) * 3
+        self.versus_test(opponent, expected_actions=actions)
+
+    def test_starting_state(self):
+        opponent_actions = [D] * 11 + [C] * 22 + [D] * 11
+        opponent = axl.MockPlayer(actions=opponent_actions)
+
+        actions = ([(C, D)] * 11 + [(D, C)] * 22 + [(C, D)] * 11) * 3
+        init_kwargs = {'starting_state': 'Nice'}
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+        opponent = axl.MockPlayer(actions=opponent_actions)
+        grumpy_starting = [(D, D)] * 11 + [(D, C)] * 22 + [(C, D)] * 11
+        actions = grumpy_starting + actions
+        init_kwargs = {'starting_state': 'Grumpy'}
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_thresholds(self):
+        init_kwargs = {'grumpy_threshold': 3, 'nice_threshold': -2}
+        opponent_actions = [D] * 4 + [C] * 7 + [D] * 3
+        opponent = axl.MockPlayer(actions=opponent_actions)
+        actions = ([(C, D)] * 4 + [(D, C)] * 7 + [(C, D)] * 3) * 3
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+        init_kwargs = {'grumpy_threshold': 0, 'nice_threshold': -2}
+        opponent_actions = [D] * 1 + [C] * 4 + [D] * 3
+        opponent = axl.MockPlayer(actions=opponent_actions)
+        actions = ([(C, D)] * 1 + [(D, C)] * 4 + [(C, D)] * 3) * 3
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+        init_kwargs = {'grumpy_threshold': 3, 'nice_threshold': 0}
+        opponent_actions = [D] * 4 + [C] * 5 + [D] * 1
+        opponent = axl.MockPlayer(actions=opponent_actions)
+        actions = ([(C, D)] * 4 + [(D, C)] * 5 + [(C, D)] * 1) * 3
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
 
     def test_reset_state_with_non_default_init(self):
-        P1 = axelrod.Grumpy(starting_state='Grumpy')
-        P1.state = 'Nice'
-        P1.reset()
-        self.assertEqual(P1.state, 'Grumpy')
+        player = axl.Grumpy(starting_state='Grumpy')
+        player.state = 'Nice'
+        player.reset()
+        self.assertEqual(player.state, 'Grumpy')