Merge pull request #1033 from Axelrod-Python/884-hunter

Refactor tests for hunter.

Author: marcharper

axelrod/tests/strategies/test_axelrod_first.py

@@ -253,8 +253,6 @@ def test_strategy(self):
         # Test TFT-type initial play
         self.first_play_test(C)
 
-        # self.responses_test([D], [C, D], [D, C])
-
         # Test trailing post-round 3 play
 
         actions = [(C, C)] * 9

axelrod/tests/strategies/test_hunter.py

@@ -47,10 +47,13 @@ class TestDefectorHunter(TestPlayer):
 
     def test_strategy(self):
         self.first_play_test(C)
-        for i in range(3):
-            self.responses_test([C], [C] * i, [D] * i)
-        self.responses_test([D], [C] * 4, [D] * 4)
 
+        actions = [(C, D)] * 4 + [(D, D)] * 10
+        self.versus_test(opponent=axelrod.Defector(), expected_actions=actions)
+
+        actions = [(C, C)] * 14
+        self.versus_test(opponent=axelrod.Cooperator(),
+                         expected_actions=actions)
 
 class TestCooperatorHunter(TestPlayer):
 
@@ -67,10 +70,13 @@ class TestCooperatorHunter(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
-        for i in range(3):
-            self.responses_test([C], [C] * i, [C] * i)
-        self.responses_test([D], [C] * 4, [C] * 4)
+        actions = [(C, C)] * 4 + [(D, C)] * 10
+        self.versus_test(opponent=axelrod.Cooperator(),
+                         expected_actions=actions)
+
+        actions = [(C, D)] * 14
+        self.versus_test(opponent=axelrod.Defector(),
+                         expected_actions=actions)
 
 
 class TestAlternatorHunter(TestPlayer):
@@ -89,14 +95,13 @@ class TestAlternatorHunter(TestPlayer):
 
     def test_strategy(self):
         self.first_play_test(C)
-        self.responses_test([C], [C] * 2, [C, D], attrs={'is_alt': False})
-        self.responses_test([C], [C] * 3, [C, D, C], attrs={'is_alt': False})
-        self.responses_test([C], [C] * 4, [C, D] * 2, attrs={'is_alt': False})
-        self.responses_test([C], [C] * 5, [C, D] * 2 + [C],
-                            attrs={'is_alt': False})
-        self.responses_test([D], [C] * 6, [C, D] * 3, attrs={'is_alt': True})
-        self.responses_test([D], [C] * 7, [C, D] * 3 + [C],
-                            attrs={'is_alt': True})
+        actions = [(C, C), (C, D)] * 3 + [(D, C), (D, D)] * 5
+        self.versus_test(opponent=axelrod.Alternator(),
+                         expected_actions=actions, attrs={'is_alt': True})
+
+        actions = [(C, D)] * 14
+        self.versus_test(opponent=axelrod.Defector(),
+                         expected_actions=actions, attrs={'is_alt': False})
 
     def test_reset_attr(self):
         p = self.player()
@@ -200,7 +205,9 @@ class TestMathConstantHunter(TestPlayer):
     }
 
     def test_strategy(self):
-        self.responses_test([D], [C] * 8, [C] * 7 + [D])
+        opponent = axelrod.MockPlayer([C] * 7 + [D] * 3)
+        actions = [(C, C)] * 7 + [(C, D)]
+        self.versus_test(opponent=opponent, expected_actions=actions)
 
 
 class TestRandomHunter(TestPlayer):
@@ -220,16 +227,15 @@ class TestRandomHunter(TestPlayer):
     def test_strategy(self):
 
         # We should catch the alternator here.
-        self.responses_test([D], [C] * 12, [C, D] * 6)
-
-        # It is still possible for this test to fail, but very unlikely.
-        history1 = [C] * 100
-        history2 = [random.choice([C, D]) for i in range(100)]
-        self.responses_test(D, history1, history2)
-
-        history1 = [D] * 100
-        history2 = [random.choice([C, D]) for i in range(100)]
-        self.responses_test(D, history1, history2)
+        actions = [(C, C), (C, D)] * 5 + [(C, C), (D, D), (D, C)]
+        self.versus_test(opponent=axelrod.Alternator(),
+                         expected_actions=actions, attrs={"countCC": 5,
+                                                          "countDD": 0})
+
+        actions = [(C, D)] * 14
+        self.versus_test(opponent=axelrod.Defector(),
+                         expected_actions=actions, attrs={"countCC": 0,
+                                                          "countDD": 0})
 
     def test_reset(self):
         player = self.player()

axelrod/tests/strategies/test_player.py

@@ -337,7 +337,7 @@ def test_init_kwargs(self):
 
 
 def test_responses(test_class, player1, player2, responses, history1=None,
-                   history2=None, seed=None, attrs=None):
+                   history2=None, seed=None):
     """
     Test responses to arbitrary histories. Used for the following tests
     in TestPlayer: first_play_test, second_play_test, and responses_test.
@@ -359,9 +359,6 @@ def test_responses(test_class, player1, player2, responses, history1=None,
     for response in responses:
         s1, s2 = simulate_play(player1, player2)
         test_class.assertEqual(s1, response)
-    if attrs:
-        for attr, value in attrs.items():
-            test_class.assertEqual(getattr(player1, attr), value)
 
 
 class TestOpponent(Player):
@@ -541,7 +538,6 @@ def versus_test(self, opponent, expected_actions,
 
     def responses_test(self, responses, player_history=None,
                        opponent_history=None, seed=None, length=200,
-                       attrs=None,
                        init_args=None, init_kwargs=None):
         """Test responses to arbitrary histories. A match is played where the
         histories are enforced and the sequence of plays in responses is
@@ -576,19 +572,19 @@ def responses_test(self, responses, player_history=None,
         player2 = MockPlayer()
         player2.set_match_attributes(length=length)
         test_responses(self, player1, player2, responses, player_history,
-                       opponent_history, seed=seed, attrs=attrs)
+                       opponent_history, seed=seed)
 
         # Test that we get the same sequence after a reset
         player1.reset()
         player2.reset()
         test_responses(self, player1, player2, responses, player_history,
-                       opponent_history, seed=seed, attrs=attrs)
+                       opponent_history, seed=seed)
 
         # Test that we get the same sequence after a clone
         player1 = player1.clone()
         player2 = player2.clone()
         test_responses(self, player1, player2, responses, player_history,
-                       opponent_history, seed=seed, attrs=attrs)
+                       opponent_history, seed=seed)
 
     def classifier_test(self, expected_class_classifier=None):
         """Test that the keys in the expected_classifier dictionary give the