Merge pull request #1039 from Axelrod-Python/1038

Remove unneeded tests

Author: meatballs

axelrod/__init__.py

@@ -13,7 +13,7 @@
 from .player import (
     get_state_distribution_from_history, is_basic, obey_axelrod,
     update_history, update_state_distribution, Player)
-from .mock_player import MockPlayer, simulate_play
+from .mock_player import MockPlayer
 from .match import Match
 from .moran import MoranProcess, MoranProcessGraph, ApproximateMoranProcess
 from .strategies import *

axelrod/mock_player.py

@@ -10,24 +10,14 @@
 
 
 class MockPlayer(Player):
-    """Creates a mock player that copies a history and state distribution to
-    simulate a history of play, and then plays a given sequence of actions. If
-    no actions are given, plays like Cooperator.
+    """Creates a mock player that plays a given sequence of actions. If
+    no actions are given, plays like Cooperator. Used for testing.
     """
 
     name = "Mock Player"
 
-    def __init__(self, actions: List[Action] =None, history: List[Action] =None, state_dist: defaultdict =None) -> None:
-        # Need to retain history for opponents that examine opponents history
-        # Do a deep copy just to be safe
+    def __init__(self, actions: List[Action] = None) -> None:
         super().__init__()
-        if history:
-            # Make sure we both copy the history and get the right counts
-            # for cooperations and defections.
-            for action in history:
-                update_history(self, action)
-        if state_dist:
-            self.state_distribution = dict(state_dist)
         if actions:
             self.actions = cycle(actions)
         else:
@@ -40,40 +30,3 @@ def strategy(self, opponent: Player) -> Action:
             return action
         except StopIteration:
             return C
-
-
-def simulate_play(player1: Player, player2: Player, action1: Action =None, action2: Action =None) -> Tuple[Action, Action]:
-    """
-    Simulates play with or without forced history. If action1 and action2 are given, these
-    actions are enforced in the players strategy. This generally should not be
-    necessary, but various tests may force impossible or unlikely histories.
-    """
-
-    if action1 and action2:
-        mock_player1 = MockPlayer(actions=[action1], history=player1.history)
-        mock_player2 = MockPlayer(actions=[action2], history=player2.history)
-        # Force plays
-        s1 = player1.strategy(mock_player2)
-        s2 = player2.strategy(mock_player1)
-        if (s1 != action1) or (s2 != action2):
-            warnings.warn(
-            "Simulated play mismatch with expected history: Round was "
-            "({}, {}) but ({}, {}) was expected for player: {}".format(
-                s1, s2, action1, action2, str(player1))
-            )
-        # Record intended history
-        # Update Cooperation / Defection counts
-        update_history(player1, action1)
-        update_history(player2, action2)
-        update_state_distribution(player1, action1, action2)
-        update_state_distribution(player2, action2, action1)
-        return (s1, s2)
-    else:
-        s1 = player1.strategy(player2)
-        s2 = player2.strategy(player1)
-        # Record history
-        update_history(player1, s1)
-        update_history(player2, s2)
-        update_state_distribution(player1, s1, s2)
-        update_state_distribution(player2, s2, s1)
-        return (s1, s2)

axelrod/tests/strategies/test_alternator.py

@@ -21,9 +21,6 @@ class TestAlternator(TestPlayer):
     }
 
     def test_strategy(self):
-        # Starts by cooperating.
-        self.first_play_test(C)
-
         actions = [(C, C), (D, C)] * 5
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 

axelrod/tests/strategies/test_ann.py

@@ -33,9 +33,6 @@ class TestEvolvedANN(TestPlayer):
     }
 
     def test_strategy(self):
-        # Test initial play sequence
-        self.first_play_test(C)
-
         actions = [(C, C)] * 5
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 
@@ -61,9 +58,6 @@ class TestEvolvedANN5(TestPlayer):
     }
 
     def test_strategy(self):
-        # Test initial play sequence
-        self.first_play_test(C)
-
         actions = [(C, C)] * 5
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 
@@ -86,9 +80,6 @@ class TestEvolvedANNNoise05(TestPlayer):
     }
 
     def test_strategy(self):
-        # Test initial play sequence
-        self.first_play_test(C)
-
         actions = [(C, C)] * 5
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 

axelrod/tests/strategies/test_apavlov.py

@@ -21,8 +21,6 @@ class TestAPavlov2006(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         actions = [(C, C)] * 7
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,
                          attrs={"opponent_class": "Cooperative"})
@@ -80,7 +78,6 @@ class TestAPavlov2011(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
 
         actions = [(C, C)] * 8
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,

axelrod/tests/strategies/test_appeaser.py

@@ -21,9 +21,6 @@ class TestAppeaser(TestPlayer):
     }
 
     def test_strategy(self):
-        # Starts by cooperating.
-        self.first_play_test(C)
-
         actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 

axelrod/tests/strategies/test_averagecopier.py

@@ -21,10 +21,6 @@ class TestAverageCopier(TestPlayer):
     }
 
     def test_strategy(self):
-        # Test that the first strategy is picked randomly.
-        self.first_play_test(C, seed=1)
-        self.first_play_test(D, seed=2)
-
         # Tests that if opponent has played all C then player chooses C.
         actions = [(C, C)] * 10
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,
@@ -81,10 +77,6 @@ class TestNiceAverageCopier(TestPlayer):
     }
 
     def test_strategy(self):
-        # Cooperates initially (not stochastic)
-        self.first_play_test(C, seed=1)
-        self.first_play_test(C, seed=2)
-
         # Tests that if opponent has played all C then player chooses C.
         actions = [(C, C)] * 10
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,

axelrod/tests/strategies/test_axelrod_first.py

@@ -23,7 +23,6 @@ class TestDavis(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
         # Cooperates for the first ten rounds
         actions = [(C, C)] * 10
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
@@ -60,8 +59,6 @@ class TestRevisedDowning(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         actions = [(C, C), (C, C), (C, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 
@@ -136,8 +133,6 @@ def test_decay(self):
                              player._end_coop_prob)
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         actions = [(C, C)] * 41 + [(D, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,
                          seed=1)
@@ -165,8 +160,6 @@ class TestGrofman(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         actions = [(C, C)] * 7
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 
@@ -201,8 +194,6 @@ def test_four_vector(self):
         test_four_vector(self, expected_dictionary)
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         actions = [(C, C), (C, C), (C, C), (C, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions, seed=1)
 
@@ -251,8 +242,6 @@ def test_score_history(self):
 
     def test_strategy(self):
         # Test TFT-type initial play
-        self.first_play_test(C)
-
         # Test trailing post-round 3 play
 
         actions = [(C, C)] * 9
@@ -287,11 +276,6 @@ class TestShubik(TestPlayer):
     }
 
     def test_strategy(self):
-        # Starts by Cooperating
-        self.first_play_test(C)
-        # Looks like Tit-For-Tat at first
-        self.second_play_test(C, D, C, D)
-
         actions = [(C, C), (C, C), (C, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 
@@ -332,8 +316,6 @@ class TestTullock(TestPlayer):
 
     def test_strategy(self):
         """Cooperates for first ten rounds"""
-        self.first_play_test(C)
-
         actions = [(C, C), (C, D)] * 5
         self.versus_test(axelrod.Alternator(), expected_actions=actions)
 
@@ -377,8 +359,6 @@ class TestUnnamedStrategy(TestPlayer):
     }
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         actions = [(D, C), (C, C), (C, C), (D, C), (C, C), (C, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions, seed=1)
 
@@ -411,8 +391,6 @@ def test_init(self):
         self.assertIsNone(player.opponent_is_random)
 
     def test_strategy(self):
-        self.first_play_test(C)
-
         # Our Player (SteinAndRapoport) vs Cooperator
         # After 15th round (pvalue < alpha) still plays titfortat
         # Note it always defects on the last two rounds
@@ -461,4 +439,3 @@ def test_strategy(self):
         self.versus_test(opponent, expected_actions=actions,
                          match_attributes={"length": -1},
                          attrs={"opponent_is_random": False})
-

axelrod/tests/strategies/test_axelrod_second.py

@@ -22,9 +22,6 @@ class TestChampion(TestPlayer):
     }
 
     def test_strategy(self):
-        # Initially cooperates
-        self.first_play_test(C)
-
         # Cooperates for num_rounds / 20 (10 by default)
 
         actions = [(C, C), (C, D)] * 5  # Cooperate for ten rounds
@@ -66,8 +63,6 @@ class TestEatherley(TestPlayer):
     }
 
     def test_strategy(self):
-        # Initially cooperates
-        self.first_play_test(C)
         # Test cooperate after opponent cooperates
         actions = [(C, C)] * 5
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
@@ -107,10 +102,6 @@ class TestTester(TestPlayer):
     }
 
     def test_strategy(self):
-        """Starts by defecting."""
-        self.first_play_test(D)
-
-
         # Alternate after 3rd round if opponent only cooperates
         actions = [(D, C)] + [(C, C), (C, C)] +  [(D, C), (C, C)] * 4
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,

axelrod/tests/strategies/test_backstabber.py

@@ -24,7 +24,6 @@ class TestBackStabber(TestPlayer):
     }
 
     def test_defects_after_four_defections(self):
-        self.first_play_test(C)
         # Forgives three defections
         defector_actions = [(C, D), (C, D), (C, D), (C, D), (D, D), (D, D)]
         self.versus_test(axelrod.Defector(), expected_actions=defector_actions, match_attributes={"length": 200})