Updated tests for new caching approach.

Author: gaffney2010

axelrod/tests/unit/test_deterministic_cache.py

@@ -10,11 +10,11 @@
 class TestDeterministicCache(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.test_key = (TitForTat(), Defector(), 3)
+        cls.test_key = (TitForTat(), Defector())
         cls.test_value = [(C, D), (D, D), (D, D)]
         cls.test_save_file = "test_cache_save.txt"
         cls.test_load_file = "test_cache_load.txt"
-        test_data_to_pickle = {("Tit For Tat", "Defector", 3): [(C, D), (D, D), (D, D)]}
+        test_data_to_pickle = {("Tit For Tat", "Defector"): [(C, D), (D, D), (D, D)]}
         cls.test_pickle = pickle.dumps(test_data_to_pickle)
 
         with open(cls.test_load_file, "wb") as f:
@@ -44,40 +44,30 @@ def test_setitem_invalid_key_not_tuple(self):
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-    def test_setitem_invalid_key_too_short(self):
-        invalid_key = self.test_key + (4,)
-        with self.assertRaises(ValueError):
-            self.cache[invalid_key] = self.test_value
-
-    def test_setitem_invalid_key_too_long(self):
-        invalid_key = self.test_key[:2]
-        with self.assertRaises(ValueError):
-            self.cache[invalid_key] = self.test_value
-
     def test_setitem_invalid_key_first_two_elements_not_player(self):
-        invalid_key = ("test", "test", 2)
+        invalid_key = ("test", "test")
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-        invalid_key = (TitForTat(), "test", 2)
+        invalid_key = (TitForTat(), "test")
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-        invalid_key = ("test", TitForTat(), 2)
+        invalid_key = ("test", TitForTat())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-    def test_setitem_invalid_key_last_element_not_integer(self):
+    def test_setitem_invalid_key_too_many_players(self):
         invalid_key = (TitForTat(), TitForTat(), TitForTat())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
     def test_setitem_invalid_key_stochastic_player(self):
-        invalid_key = (Random(), TitForTat(), 2)
+        invalid_key = (Random(), TitForTat())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 
-        invalid_key = (TitForTat(), Random(), 2)
+        invalid_key = (TitForTat(), Random())
         with self.assertRaises(ValueError):
             self.cache[invalid_key] = self.test_value
 

axelrod/tests/unit/test_match.py

@@ -89,12 +89,8 @@ def test_example_prob_end(self):
             self.assertEqual(len(match.play()), expected_length)
             self.assertEqual(match.noise, 0)
             self.assertEqual(match.game.RPST(), (3, 1, 0, 5))
-        self.assertEqual(len(match._cache), 3)
-
-        for expected_length in expected_lengths:
-            self.assertEqual(
-                match._cache[(p1, p2, expected_length)], [(C, C)] * expected_length
-            )
+        self.assertEqual(len(match._cache), 1)
+        self.assertEqual(match._cache[(p1, p2)], [(C, C)] * 5)
 
     @given(turns=integers(min_value=1, max_value=200), game=games())
     @example(turns=5, game=axelrod.DefaultGame)
@@ -167,14 +163,29 @@ def test_play(self):
         expected_result = [(C, D), (C, D), (C, D)]
         self.assertEqual(match.play(), expected_result)
         self.assertEqual(
-            cache[(axelrod.Cooperator(), axelrod.Defector(), 3)], expected_result
+            cache[(axelrod.Cooperator(), axelrod.Defector())], expected_result
         )
 
         # a deliberately incorrect result so we can tell it came from the cache
-        expected_result = [(C, C), (D, D), (D, C)]
-        cache[(axelrod.Cooperator(), axelrod.Defector(), 3)] = expected_result
+        expected_result = [(C, C), (D, D), (D, C), (C, C), (C, D)]
+        cache[(axelrod.Cooperator(), axelrod.Defector())] = expected_result
         match = axelrod.Match(players, 3, deterministic_cache=cache)
-        self.assertEqual(match.play(), expected_result)
+        self.assertEqual(match.play(), expected_result[:3])
+
+    def test_long_cache(self):
+        cache = DeterministicCache()
+        players = (axelrod.Cooperator(), axelrod.Defector())
+        match = axelrod.Match(players, 5, deterministic_cache=cache)
+        expected_result_5_turn = [(C, D), (C, D), (C, D), (C, D), (C, D)]
+        expected_result_3_turn = [(C, D), (C, D), (C, D)]
+        self.assertEqual(match.play(), expected_result_5_turn)
+        match.turns = 3
+        self.assertEqual(match.play(), expected_result_3_turn)
+        # The cache should still hold the 5.
+        self.assertEqual(
+            cache[(axelrod.Cooperator(), axelrod.Defector())],
+            expected_result_5_turn
+        )
 
     def test_scores(self):
         player1 = axelrod.TitForTat()