Merge pull request #588 from Axelrod-Python/581

581 - Improving test coverage

Author: meatballs

axelrod/_strategy_utils.py

@@ -96,25 +96,20 @@ def __init__(self, func):
         self.cache = {}
 
     def __call__(self, *args):
-        if not isinstance(args, collections.Hashable):
-            # uncacheable. a list, for instance.
-            # better to not cache than blow up.
+        try:
+            try:
+                return self.cache[args]
+            except KeyError:
+                value = self.func(*args)
+                self.cache[args] = value
+                return value
+        except TypeError:
             return self.func(*args)
-        if args in self.cache:
-            return self.cache[args]
-        else:
-            value = self.func(*args)
-            self.cache[args] = value
-            return value
 
     def __repr__(self):
         """Return the function's docstring."""
         return self.func.__doc__
 
-    def __get__(self, obj, objtype):
-        """Support instance methods."""
-        return functools.partial(self.__call__, obj)
-
 
 @Memoized
 def recursive_thue_morse(n):

axelrod/deterministic_cache.py

@@ -50,7 +50,7 @@ def __setitem__(self, key, value):
         """Overrides the UserDict.__setitem__ method in order to validate
         the key/value and also to set the turns attribute"""
         if not self.mutable:
-            raise ValueError('Cannot update cache unles mutable is True.')
+            raise ValueError('Cannot update cache unless mutable is True.')
 
         if not self._is_valid_key(key):
             raise ValueError(

axelrod/match_generator.py

@@ -7,8 +7,6 @@
 
 class MatchGenerator(object):
 
-    clone_opponents = True
-
     def __init__(self, players, turns, game, repetitions):
         """
         A class to generate matches. This is used by the Tournament class which
@@ -37,12 +35,9 @@ def opponents(self):
 
     @opponents.setter
     def opponents(self, players):
-        if self.clone_opponents:
-            opponents = []
-            for player in players:
-                opponents.append(player.clone())
-        else:
-            opponents = players
+        opponents = []
+        for player in players:
+            opponents.append(player.clone())
         self._opponents = opponents
 
     def __len__(self):
@@ -57,8 +52,6 @@ def build_single_match_params(self):
 
 class RoundRobinMatches(MatchGenerator):
 
-    clone_opponents = True
-
     def build_match_chunks(self, noise=0):
         """
         A generator that returns player index pairs and match parameters for a
@@ -110,8 +103,6 @@ def estimated_size(self):
 
 class ProbEndRoundRobinMatches(RoundRobinMatches):
 
-    clone_opponents = True
-
     def __init__(self, players, prob_end, game, repetitions):
         """
         A class that generates matches for which the players do not

axelrod/moran.py

@@ -40,7 +40,7 @@ def __init__(self, players, turns=100, noise=0, deterministic_cache=None):
         self.set_players()
         self.score_history = []
         self.winning_strategy_name = None
-        if deterministic_cache:
+        if deterministic_cache is not None:
             self.deterministic_cache = deterministic_cache
         else:
             self.deterministic_cache = DeterministicCache()

axelrod/plot.py

@@ -1,4 +1,3 @@
-from numpy.linalg import LinAlgError
 from numpy import arange, median, nan_to_num
 from warnings import warn
 
@@ -27,23 +26,6 @@ def __init__(self, result_set):
         self.result_set = result_set
         self.matplotlib_installed = matplotlib_installed
 
-    # Abstract Box and Violin plots
-
-    def _boxplot(self, data, names, title=None):
-        """For making boxplots."""
-        if not self.matplotlib_installed:
-            return None
-        nplayers = self.result_set.nplayers
-        width = max(nplayers / 3, 12)
-        height = width / 2
-        figure = plt.figure(figsize=(width, height))
-        plt.boxplot(data)
-        plt.xticks(self._boxplot_xticks_locations, names, rotation=90)
-        plt.tick_params(axis='both', which='both', labelsize=8)
-        if title:
-            plt.title(title)
-        return figure
-
     def _violinplot(self, data, names, title=None):
         """For making violinplots."""
         if not self.matplotlib_installed:
@@ -83,14 +65,7 @@ def boxplot(self, title=None):
         """For the specific mean score boxplot."""
         data = self._boxplot_dataset
         names = self._boxplot_xticks_labels
-        try:
-            figure = self._violinplot(data, names, title=title)
-        except LinAlgError:
-            # Matplotlib doesn't handle single point distributions well
-            # in violin plots. Should be fixed in next release:
-            # https://github.com/matplotlib/matplotlib/pull/4816
-            # Fall back to boxplot
-            figure = self._boxplot(data, names, title=title)
+        figure = self._violinplot(data, names, title=title)
         return figure
 
     @property
@@ -112,14 +87,7 @@ def winplot(self, title=None):
             return None
 
         data, names = self._winplot_dataset
-        try:
-            figure = self._violinplot(data, names, title)
-        except LinAlgError:
-            # Matplotlib doesn't handle single point distributions well
-            # in violin plots. Should be fixed in next release:
-            # https://github.com/matplotlib/matplotlib/pull/4816
-            # Fall back to boxplot
-            figure = self._boxplot(data, names, title)
+        figure = self._violinplot(data, names, title)
         # Expand ylim a bit
         maximum = max(max(w) for w in data)
         plt.ylim(-0.5, 0.5 + maximum)
@@ -165,14 +133,7 @@ def lengthplot(self, title=None):
         """For the specific match length boxplot."""
         data = self._lengthplot_dataset
         names = self._boxplot_xticks_labels
-        try:
-            figure = self._violinplot(data, names, title=title)
-        except LinAlgError:
-            # Matplotlib doesn't handle single point distributions well
-            # in violin plots. Should be fixed in next release:
-            # https://github.com/matplotlib/matplotlib/pull/4816
-            # Fall back to boxplot
-            figure = self._boxplot(data, names, title=title)
+        figure = self._violinplot(data, names, title=title)
         return figure
 
     # Payoff heatmaps
@@ -242,11 +203,7 @@ def stackplot(self, eco, title=None):
         if not self.matplotlib_installed:
             return None
 
-        if type(eco) is list:
-            warn("""Passing the population sizes as an argument is deprecated and will be removed, please pass the Ecosystem directly""")
-            populations = eco
-        else:
-            populations = eco.population_sizes
+        populations = eco.population_sizes
 
         figure, ax = plt.subplots()
         turns = range(len(populations))

axelrod/strategies/apavlov.py

@@ -52,15 +52,17 @@ def strategy(self, opponent):
             if len(self.history) % 6 in [0, 1]:
                 return C
             #TFT
-            return D if opponent.history[-1:] == [D] else C
+            if opponent.history[-1:] == [D]:
+                return D
         if self.opponent_class == "PavlovD":
             # Return D then C for the period
             if len(self.history) % 6 == 0:
                 return D
-            return C
         if self.opponent_class == "Cooperative":
             #TFT
-            return D if opponent.history[-1:] == [D] else C
+            if opponent.history[-1:] == [D]:
+                return D
+        return C
 
     def reset(self):
         Player.reset(self)

axelrod/strategies/qlearner.py

@@ -37,7 +37,7 @@ def __init__(self):
         self.prev_action = random_choice()
         self.history = []
         self.score = 0
-        self.Qs = OrderedDict({'':  OrderedDict(zip([C, D], [0, 0])) })
+        self.Qs = OrderedDict({'':  OrderedDict(zip([C, D], [0, 0]))})
         self.Vs = OrderedDict({'': 0})
         self.prev_state = ''
 
@@ -53,10 +53,7 @@ def strategy(self, opponent):
             self.Qs[state] = OrderedDict(zip([C, D], [0, 0]))
             self.Vs[state] = 0
         self.perform_q_learning(self.prev_state, state, self.prev_action, reward)
-        if state not in self.Qs:
-            action = random_choice()
-        else:
-            action = self.select_action(state)
+        action = self.select_action(state)
         self.prev_state = state
         self.prev_action = action
         return action
@@ -73,7 +70,8 @@ def select_action(self, state):
 
     def find_state(self, opponent):
         """
-        Finds the my_state (the opponents last n moves +  its previous proportion of playing C) as a hashable state
+        Finds the my_state (the opponents last n moves +
+        its previous proportion of playing C) as a hashable state
         """
         prob = '{:.1f}'.format(opponent.cooperations)
         return ''.join(opponent.history[-self.memory_length:]) + prob

axelrod/tests/unit/test_apavlov.py

@@ -75,6 +75,19 @@ def test_strategy(self):
                             attrs={"opponent_class": "STFT"})
         self.responses_test([C, D, D, D, C, C], [D, D, D, C, C, C], [C],
                             attrs={"opponent_class": "STFT"})
+        self.responses_test([C, D, D, D, C, C], [D, D, D, C, C, C], [C],
+                            attrs={"opponent_class": "STFT"})
+
+        # Specific case for STFT when responding with TFT
+        opponent = axelrod.Player()
+        player = axelrod.APavlov2006()
+        player.history = [D] * 8
+        opponent.history = [D] * 8
+        player.opponent_class = "STFT"
+        self.assertEqual(player.strategy(opponent), D)
+        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],
                             attrs={"opponent_class": "Random"})

axelrod/tests/unit/test_axelrod_first.py

@@ -72,6 +72,7 @@ def test_strategy(self):
         self.responses_test([C, C, C], [D, C, D], [C])
         self.responses_test([C, C, D, D], [C, D, D, D], [D])
         self.responses_test([C, C, C, C], [D, C, D, C], [C])
+        self.responses_test([C, D, C, C, D, D], [C, C, C, C, D, D], [C])
 
     def test_not_revised(self):
         # Test not revised

axelrod/tests/unit/test_deterministic_cache.py

@@ -3,6 +3,9 @@
 import sys
 from axelrod import DeterministicCache, TitForTat, Defector, Random
 
+import pickle
+import tempfile
+
 
 class TestDeterministicCache(unittest.TestCase):
 
@@ -39,6 +42,17 @@ def test_setitem(self):
         cache[self.test_key] = self.test_value
         self.assertEqual(cache[self.test_key], self.test_value)
 
+    def test_setitem_invalid_key(self):
+        cache = DeterministicCache()
+        invalid_key = (1, 2, 3, 4)
+        with self.assertRaises(ValueError):
+            cache[invalid_key] = 3
+
+    def test_setitem_invalid_value(self):
+        cache = DeterministicCache()
+        with self.assertRaises(ValueError):
+            cache[self.test_key] = 5
+
     def test_set_immutable_cache(self):
         cache = DeterministicCache()
         cache.mutable = False
@@ -57,6 +71,7 @@ def test_is_valid_key(self):
         self.assertFalse(cache._is_valid_key(('test', 'test', 'test')))
         self.assertFalse(cache._is_valid_key((TitForTat, 'test', 2)))
         self.assertFalse(cache._is_valid_key(('test', TitForTat, 2)))
+        self.assertFalse(cache._is_valid_key((TitForTat, TitForTat, TitForTat)))
         # Should return false if either player class is stochastic
         self.assertFalse(cache._is_valid_key((Random, TitForTat, 2)))
         self.assertFalse(cache._is_valid_key((TitForTat, Random, 2)))
@@ -79,3 +94,13 @@ def test_load(self):
         cache = DeterministicCache()
         cache.load(self.test_load_file)
         self.assertEqual(cache[self.test_key], self.test_value)
+
+    def test_load_error_for_inccorect_format(self):
+        tmp_file = tempfile.NamedTemporaryFile()
+        with open(tmp_file.name, 'wb') as io:
+            pickle.dump(range(5), io)
+
+        with self.assertRaises(ValueError):
+            cache = DeterministicCache()
+            cache.load(tmp_file.name)
+