Merge pull request #1 from marcharper/314pe

Updates to tests and minor strategy refactor

Author: 314pe

axelrod/strategies/naiveprober.py

@@ -1,10 +1,8 @@
 from axelrod import Actions, Player, init_args, random_choice
-from axelrod.strategy_transformers import RetaliateUntilApologyTransformer
 
 C, D = Actions.C, Actions.D
 
 
-@RetaliateUntilApologyTransformer
 class NaiveProber(Player):
     """
     Like tit-for-tat, but it occasionally defects with a small probability.
@@ -26,13 +24,22 @@ def __init__(self, p=0.1):
         Parameters
         ----------
         p, float
-            The probability to defect without provoking
+            The probability to defect randomly
         """
         Player.__init__(self)
         self.p = p
+        if (self.p == 0) or (self.p == 1):
+            self.classifier['stochastic'] = False
 
     def strategy(self, opponent):
-        choice = random_choice(1-self.p)
+        # First move
+        if len(self.history) == 0:
+            return C
+        # React to the opponent's last move
+        if opponent.history[-1] == D:
+            return D
+        # Otherwise cooperate, defect with a small probability
+        choice = random_choice(1 - self.p)
         return choice
 
     def __repr__(self):

axelrod/tests/unit/test_naiveprober.py

@@ -1,14 +1,14 @@
 """Test for the Naive Prober strategy."""
 
 import axelrod
-from .test_player import TestPlayer
+from .test_player import TestPlayer, test_responses
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
 
 
 class TestNaiveProber(TestPlayer):
 
-    name = "RUA Naive Prober: 0.1"
+    name = "Naive Prober: 0.1"
     player = axelrod.NaiveProber
     expected_classifier = {
         'memory_depth': 1,
@@ -21,9 +21,20 @@ class TestNaiveProber(TestPlayer):
 
     def test_strategy(self):
         "Randomly defects and always retaliates like tit for tat."
-        self.first_play_test(C, random_seed=1)
-        self.first_play_test(D, random_seed=2)
-        # Random defection
-        self.responses_test([C] * 10, [C] * 10, [D], random_seed=3)
+        self.first_play_test(C)
         # Always retaliate a defection
         self.responses_test([C] * 2, [C, D], [D])
+
+    def test_random_defection(self):
+        # Random defection
+        player = self.player(0.4)
+        opponent = axelrod.Random()
+        test_responses(self, player, opponent, [C], [C], [D], random_seed=1)
+
+    def test_reduction_to_TFT(self):
+        player = self.player(0)
+        opponent = axelrod.Random()
+        test_responses(self, player, opponent, [C], [C], [C], random_seed=1)
+        test_responses(self, player, opponent, [C], [D], [D])
+        test_responses(self, player, opponent, [C, D], [D, C], [C])
+        test_responses(self, player, opponent, [C, D], [D, D], [D])

docs/reference/overview_of_strategies.rst

@@ -1012,11 +1012,11 @@ Here is how NaiveProber is implemented in the library::
 
     >>> import axelrod
     >>> p1 = axelrod.NaiveProber()  # Create a Prober3 player
-    >>> p2 = axelrod.Random()  # Create a player that always cooperates
+    >>> p2 = axelrod.Defector()  # Create a player that always defects
     >>> for round in range(5):
     ...     p1.play(p2)
 
     >>> p1.history
-    ['C', 'C', 'C', 'C', 'D']
+    ['C', 'D', 'D', 'D', 'D']
     >>> p2.history
-    ['C', 'C', 'C', 'C', 'D']
+    ['D', 'D', 'D', 'D', 'D']