Rework basic tests and update a number of explicit tests

Author: marcharper

axelrod/strategies/apavlov.py

@@ -14,7 +14,7 @@ class APavlov2006(Player):
     uncooperative opponents.
     """
 
-    name = "Adapative Pavlov 2006"
+    name = "Adaptive Pavlov 2006"
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': False,
@@ -81,7 +81,7 @@ class APavlov2011(Player):
     uncooperative opponents.
     """
 
-    name = "Adapative Pavlov 2011"
+    name = "Adaptive Pavlov 2011"
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': False,

axelrod/strategies/doubler.py

@@ -10,7 +10,7 @@ class Doubler(Player):
 
     Names:
 
-    - doubler: [PRISON1998]_
+    - Doubler: [PRISON1998]_
     """
 
     name = 'Doubler'

axelrod/strategies/grumpy.py

@@ -34,7 +34,6 @@ def __init__(self, starting_state='Nice', grumpy_threshold=10,
             nice
         """
         super().__init__()
-        self.history = []
         self.state = starting_state
         self.starting_state = starting_state
         self.grumpy_threshold = grumpy_threshold
@@ -44,25 +43,27 @@ def strategy(self, opponent):
         """A player that gets grumpier the more the opposition defects,
         and nicer the more they cooperate.
 
-        Starts off Nice, but becomes grumpy once the grumpiness threshold is hit.
-        Won't become nice once that grumpy threshold is hit, but must reach a much lower threshold before it becomes nice again.
+        Starts off Nice, but becomes grumpy once the grumpiness threshold is
+        hit. Won't become nice once that grumpy threshold is hit, but must
+        reach a much lower threshold before it becomes nice again.
         """
 
-        self.grumpiness = opponent.defections - opponent.cooperations
+        grumpiness = opponent.defections - opponent.cooperations
 
         if self.state == 'Nice':
-            if self.grumpiness > self.grumpy_threshold:
+            if grumpiness > self.grumpy_threshold:
                 self.state = 'Grumpy'
                 return D
             return C
 
         if self.state == 'Grumpy':
-            if self.grumpiness < self.nice_threshold:
+            if grumpiness < self.nice_threshold:
                 self.state = 'Nice'
                 return C
             return D
 
     def reset(self):
-        """Resets score, history and state for the next round of the tournement."""
+        """Resets score, history and state for the next round of the
+        tournament."""
         super().reset()
         self.state = self.starting_state

axelrod/strategies/negation.py

@@ -1,9 +1,8 @@
-import random
-from axelrod import Actions, Player, random_choice, flip_action, init_args
-from axelrod.strategy_transformers import TrackHistoryTransformer
+from axelrod import Actions, Player, random_choice, flip_action
 
 C, D = Actions.C, Actions.D
 
+
 class Negation(Player):
     """
     A player starts by cooperating or defecting randomly if it's their first move,
@@ -28,8 +27,7 @@ class Negation(Player):
     def strategy(self, opponent):
         # Random first move
         if not self.history:
-            return random_choice();
-        
+            return random_choice()
         # Act opposite of opponent otherwise
         return flip_action(opponent.history[-1])
-		
+

axelrod/tests/unit/test_actions.py

@@ -1,19 +1,22 @@
 import unittest
 from axelrod import Actions, flip_action
 
+
+C, D = Actions.C, Actions.D
+
+
 class TestAction(unittest.TestCase):
 
     def test_action_values(self):
-        self.assertEqual(Actions.C, 'C')
-        self.assertEqual(Actions.D, 'D')
-        self.assertNotEqual(Actions.D, 'd')
-        self.assertNotEqual(Actions.C, 'c')
-        self.assertNotEqual(Actions.C, Actions.D)
-
+        self.assertEqual(C, 'C')
+        self.assertEqual(D, 'D')
+        self.assertNotEqual(D, 'd')
+        self.assertNotEqual(C, 'c')
+        self.assertNotEqual(C, D)
 
     def test_flip_action(self):
-        self.assertEqual(flip_action(Actions.D), Actions.C)
-        self.assertEqual(flip_action(Actions.C), Actions.D)
+        self.assertEqual(flip_action(D), C)
+        self.assertEqual(flip_action(C), D)
 
         with self.assertRaises(ValueError):
-            flip_action('R')
+            flip_action('R')

axelrod/tests/unit/test_adaptive.py

@@ -1,7 +1,6 @@
-"""Test for the Adaptive strategy."""
+"""Tests for the Adaptive strategy."""
 
 import axelrod
-
 from .test_player import TestHeadsUp, TestPlayer
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
@@ -23,7 +22,7 @@ class TestAdaptive(TestPlayer):
 
     def test_strategy(self):
         # Test initial play sequence
-        self.responses_test([], [], [C] * 6 + [D] * 5)
+        self.responses_test([C] * 6 + [D] * 5, [], [])
 
     def test_scoring(self):
         player = axelrod.Adaptive()

axelrod/tests/unit/test_alternator.py

@@ -1,7 +1,6 @@
-"""Test for the alternator strategy."""
+"""Tests for the Alternator strategy."""
 
 import axelrod
-
 from .test_player import TestPlayer
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
@@ -22,13 +21,11 @@ class TestAlternator(TestPlayer):
     }
 
     def test_strategy(self):
-        """Starts by cooperating."""
+        # Starts by cooperating.
         self.first_play_test(C)
-
-    def test_effect_of_strategy(self):
-        """Simply does the opposite to what the strategy did last time."""
-        self.markov_test([D, D, C, C])
+        # Simply does the opposite to what the strategy did last time.
+        self.second_play_test(D, D, C, C)
         for i in range(10):
-            self.responses_test([], [], [C, D] * i)
-        self.responses_test([C, D, D, D], [C, C, C, C], [C])
-        self.responses_test([C, C, D, D, C], [C, D, C, C, C], [D])
+            self.responses_test([C, D] * i)
+        self.responses_test([C], [C, D, D, D], [C, C, C, C])
+        self.responses_test([D], [C, C, D, D, C], [C, D, C, C, C])

axelrod/tests/unit/test_ann.py

@@ -1,9 +1,10 @@
-"""Test for the Adaptive strategy."""
+"""Tests for the Adaptive strategy."""
 import unittest
 
 import axelrod
-from .test_player import TestHeadsUp, TestPlayer
 from axelrod.strategies.ann import split_weights
+from .test_player import TestHeadsUp, TestPlayer
+
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
 
@@ -74,7 +75,6 @@ def test_strategy(self):
         self.first_play_test(C)
 
 
-
 class TestEvolvedANNvsCooperator(TestHeadsUp):
     def test_rounds(self):
         self.versus_test(axelrod.EvolvedANN(), axelrod.Cooperator(),

axelrod/tests/unit/test_apavlov.py

@@ -7,7 +7,7 @@
 
 
 class TestAPavlov2006(TestPlayer):
-    name = "Adapative Pavlov 2006"
+    name = "Adaptive Pavlov 2006"
     player = axelrod.APavlov2006
 
     expected_classifier = {
@@ -22,19 +22,19 @@ class TestAPavlov2006(TestPlayer):
 
     def test_strategy(self):
         self.first_play_test(C)
-        self.responses_test([C] * 6, [C] * 6, [C],
+        self.responses_test([C], [C] * 6, [C] * 6,
                             attrs={"opponent_class": "Cooperative"})
-        self.responses_test([C, D, D, D, D, D], [D] * 6, [D],
+        self.responses_test([D], [C, D, D, D, D, D], [D] * 6,
                             attrs={"opponent_class": "ALLD"})
-        self.responses_test([C, D, C, D, C, D], [D, C, D, C, D, C], [C, C],
+        self.responses_test([C, C], [C, D, C, D, C, D], [D, C, D, C, D, C],
                             attrs={"opponent_class": "STFT"})
-        self.responses_test([C, D, D, C, D, D], [D, D, C, D, D, C], [D],
+        self.responses_test([D], [C, D, D, C, D, D], [D, D, C, D, D, C],
                             attrs={"opponent_class": "PavlovD"})
-        self.responses_test([C, D, D, C, D, D, C], [D, D, C, D, D, C, D], [C],
+        self.responses_test([C], [C, D, D, C, D, D, C], [D, D, C, D, D, C, D],
                             attrs={"opponent_class": "PavlovD"})
-        self.responses_test([C, D, D, C, D, D], [C, C, C, D, D, D], [D],
+        self.responses_test([D], [C, D, D, C, D, D], [C, C, C, D, D, D],
                             attrs={"opponent_class": "Random"})
-        self.responses_test([C, D, D, D, C, C], [D, D, D, C, C, C], [D],
+        self.responses_test([D], [C, D, D, D, C, C], [D, D, D, C, C, C],
                             attrs={"opponent_class": "Random"})
 
     def test_reset(self):
@@ -44,8 +44,9 @@ def test_reset(self):
         player.reset()
         self.assertEqual(player.opponent_class, None)
 
+
 class TestAPavlov2011(TestPlayer):
-    name = "Adapative Pavlov 2011"
+    name = "Adaptive Pavlov 2011"
     player = axelrod.APavlov2011
 
     expected_classifier = {
@@ -60,24 +61,24 @@ class TestAPavlov2011(TestPlayer):
 
     def test_strategy(self):
         self.first_play_test(C)
-        self.responses_test([C] * 6, [C] * 6, [C],
+        self.responses_test([C], [C] * 6, [C] * 6,
                             attrs={"opponent_class": "Cooperative"})
-        self.responses_test([C, D, D, D, D, D], [D] * 6, [D],
+        self.responses_test([D], [C, D, D, D, D, D], [D] * 6,
                             attrs={"opponent_class": "ALLD"})
-        self.responses_test([C, C, D, D, D, D], [C] + [D] * 5, [D],
+        self.responses_test([D], [C, C, D, D, D, D], [C] + [D] * 5,
                             attrs={"opponent_class": "ALLD"})
-        self.responses_test([C, C, C, D, D, D], [C, C] + [D] * 4, [D],
+        self.responses_test([D], [C, C, C, D, D, D], [C, C] + [D] * 4,
                             attrs={"opponent_class": "ALLD"})
-        self.responses_test([C, C, D, D, C, D], [C, D, D, C, D, D], [D],
+        self.responses_test([D], [C, C, D, D, C, D], [C, D, D, C, D, D],
                             attrs={"opponent_class": "ALLD"})
 
-        self.responses_test([C, C, D, D, D, C], [C, D, D, C, C, D], [C],
+        self.responses_test([C], [C, C, D, D, D, C], [C, D, D, C, C, D],
                             attrs={"opponent_class": "STFT"})
-        self.responses_test([C, C, D, C, D, C], [C, D, C, D, C, D], [C],
+        self.responses_test([C], [C, C, D, C, D, C], [C, D, C, D, C, D],
                             attrs={"opponent_class": "STFT"})
-        self.responses_test([C, D, D, D, C, C], [D, D, D, C, C, C], [C],
+        self.responses_test([C], [C, D, D, D, C, C], [D, D, D, C, C, C],
                             attrs={"opponent_class": "STFT"})
-        self.responses_test([C, D, D, D, C, C], [D, D, D, C, C, C], [C],
+        self.responses_test([C], [C, D, D, D, C, C], [D, D, D, C, C, C],
                             attrs={"opponent_class": "STFT"})
 
         # Specific case for STFT when responding with TFT
@@ -90,9 +91,9 @@ def test_strategy(self):
         opponent.history.append(C)
         self.assertEqual(player.strategy(opponent), C)
 
-        self.responses_test([C, C, C, C, C, D], [C, C, C, C, D, D], [D],
+        self.responses_test([D], [C, C, C, C, C, D], [C, C, C, C, D, D],
                             attrs={"opponent_class": "Random"})
-        self.responses_test([C, D, D, C, C, C], [D, D, C, C, C, C], [D],
+        self.responses_test([D], [C, D, D, C, C, C], [D, D, C, C, C, C],
                             attrs={"opponent_class": "Random"})
 
     def test_reset(self):

axelrod/tests/unit/test_appeaser.py

@@ -1,7 +1,6 @@
-"""Test for the appeaser strategy."""
+"""Tests for the Appeaser strategy."""
 
 import axelrod
-
 from .test_player import TestPlayer
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
@@ -22,16 +21,10 @@ class TestAppeaser(TestPlayer):
     }
 
     def test_strategy(self):
-        """Starts by cooperating."""
+        # Starts by cooperating.
         self.first_play_test(C)
-
-    def test_effect_of_strategy(self):
-        P1 = axelrod.Appeaser()
-        P2 = axelrod.Cooperator()
-        self.assertEqual(P1.strategy(P2), C)
-
-        self.responses_test([C], [C], [C, C, C])
-        self.responses_test([C, D, C, D], [C, C, D], [D])
-        self.responses_test([C, D, C, D, C], [C, C, D, D], [C])
-        self.responses_test([C, D, C, D, C, D], [C, C, D, D, D], [D])
+        self.responses_test([C, C, C], [C], [C])
+        self.responses_test([D], [C, D, C, D], [C, C, D])
+        self.responses_test([C], [C, D, C, D, C], [C, C, D, D])
+        self.responses_test([D], [C, D, C, D, C, D], [C, C, D, D, D])
 

axelrod/tests/unit/test_averagecopier.py

@@ -1,7 +1,6 @@
-"""Test for the average_copier strategy."""
+"""Tests for the AverageCopier strategies."""
 
 import axelrod
-
 from .test_player import TestPlayer
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
@@ -22,19 +21,13 @@ class TestAverageCopier(TestPlayer):
     }
 
     def test_strategy(self):
-        """Test that the first strategy is picked randomly."""
-        self.responses_test([], [], [C], random_seed=1)
-        self.responses_test([], [], [D], random_seed=2)
-
-    def test_when_oppenent_all_Cs(self):
-        """Tests that if opponent has played all C then player chooses C."""
-        self.responses_test([C, C, C, C], [C, C, C, C], [C, C, C],
-                            random_seed=5)
-
-    def test_when_opponent_all_Ds(self):
-        """Tests that if opponent has played all D then player chooses D."""
-        self.responses_test([C, C, C, C], [D, D, D, D], [D, D, D],
-                            random_seed=5)
+        # Test that the first strategy is picked randomly.
+        self.responses_test([C], seed=1)
+        self.responses_test([D], seed=2)
+        # Tests that if opponent has played all C then player chooses C.
+        self.responses_test([C, C, C], [C, C, C, C], [C, C, C, C], seed=5)
+        # Tests that if opponent has played all D then player chooses D.
+        self.responses_test([D, D, D], [C, C, C, C], [D, D, D, D], seed=5)
 
 
 class TestNiceAverageCopier(TestPlayer):
@@ -52,19 +45,9 @@ class TestNiceAverageCopier(TestPlayer):
     }
 
     def test_strategy(self):
-        """Test that the first strategy is cooperation."""
+        # Cooperates initially.
         self.first_play_test(C)
-
-    def test_when_oppenent_all_Cs(self):
-        """
-        Tests that if opponent has played all C then player chooses C
-        """
-        self.responses_test([C, C, C, C], [C, C, C, C], [C, C, C],
-                            random_seed=5)
-
-    def test_when_opponent_all_Ds(self):
-        """
-        Tests that if opponent has played all D then player chooses D
-        """
-        self.responses_test([D, D, D, D], [D, D, D, D], [D, D, D],
-                            random_seed=5)
+        # If opponent has played all C then player chooses C.
+        self.responses_test([C, C, C], [C, C, C, C], [C, C, C, C], seed=5)
+        # If opponent has played all D then player chooses D.
+        self.responses_test([D, D, D], [D, D, D, D], [D, D, D, D], seed=5)