Merge pull request #454 from Axelrod-Python/198

198 - Implements some hypothesis testing

Author: meatballs

.gitattributes

@@ -0,0 +1 @@
+.hypothesis/examples.db merge=hypothesisdb

.gitignore

@@ -6,3 +6,4 @@ _build/
 dist/
 MANIFEST
 Axelrod.egg-info
+.hypothesis/eval_source/

.hypothesis/examples.db

@@ -1,4 +1,6 @@
 import unittest
+from hypothesis import given
+from hypothesis.strategies import integers, tuples
 
 import axelrod
 
@@ -25,3 +27,26 @@ def test_score(self):
         self.assertEqual(self.game.score((D, D)), (1, 1))
         self.assertEqual(self.game.score((C, D)), (0, 5))
         self.assertEqual(self.game.score((D, C)), (5, 0))
+
+    @given(r=integers(), p=integers(), s=integers(), t=integers())
+    def test_property_init(self, r, p, s, t):
+        """Use the hypothesis library to test init"""
+        expected_scores = {(C, D): (s, t), (D, C): (t, s),
+                           (D, D): (p, p), (C, C): (r, r)}
+        game = axelrod.Game(r, s, t, p)
+        self.assertEqual(game.scores, expected_scores)
+
+    @given(r=integers(), p=integers(), s=integers(), t=integers())
+    def test_property_RPST(self, r, p, s, t):
+        """Use the hypothesis library to test RPST"""
+        game = axelrod.Game(r, s, t, p)
+        self.assertEqual(game.RPST(), (r, p, s, t))
+
+    @given(r=integers(), p=integers(), s=integers(), t=integers())
+    def test_property_score(self, r, p, s, t):
+        """Use the hypothesis library to test score"""
+        game = axelrod.Game(r, s, t, p)
+        self.assertEqual(game.score((C, C)), (r, r))
+        self.assertEqual(game.score((D, D)), (p, p))
+        self.assertEqual(game.score((C, D)), (s, t))
+        self.assertEqual(game.score((D, C)), (t, s))

axelrod/tests/unit/test_game.py

@@ -1,9 +1,15 @@
 """Tests for the main tournament class."""
 
-import unittest
 import axelrod
 import logging
 import multiprocessing
+import unittest
+import random
+
+from hypothesis import given, example
+from hypothesis.strategies import (integers, lists,
+                                   sampled_from, random_module,
+                                   Settings)
 
 try:
     # Python 3
@@ -12,21 +18,24 @@
     # Python 2
     from mock import MagicMock
 
+test_strategies = [axelrod.Cooperator,
+                   axelrod.TitForTat,
+                   axelrod.Defector,
+                   axelrod.Grudger,
+                   axelrod.GoByMajority]
+test_repetitions = 5
+test_turns = 100
+
 
 class TestTournament(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         cls.game = axelrod.Game()
-        cls.players = [
-            axelrod.Cooperator(),
-            axelrod.TitForTat(),
-            axelrod.Defector(),
-            axelrod.Grudger(),
-            axelrod.GoByMajority()]
+        cls.players = [s() for s in test_strategies]
         cls.test_name = 'test'
-        cls.test_repetitions = 5
-        cls.test_turns = 100
+        cls.test_repetitions = test_repetitions
+        cls.test_turns = test_turns
 
         cls.expected_payoff = [
             [600, 600, 0, 600, 600],
@@ -99,6 +108,33 @@ def test_serial_play(self):
             {'cooperation': [], 'payoff': []})
         self.assertFalse(tournament._run_parallel_repetitions.called)
 
+    @given(s=lists(sampled_from(axelrod.strategies),
+                   min_size=2,  # Errors are returned if less than 2 strategies
+                   max_size=5, unique=True),
+           turns=integers(min_value=2, max_value=50),
+           repetitions=integers(min_value=2, max_value=4),
+           settings=Settings(max_examples=50,
+                             timeout=0),
+           rm=random_module())
+    @example(s=test_strategies, turns=test_turns, repetitions=test_repetitions,
+             rm=random.seed(0))
+    def test_property_serial_play(self, s, turns, repetitions, rm):
+        """Test serial play using hypothesis"""
+        # Test that we get an instance of ResultSet
+        players = [strat() for strat in s]
+
+        tournament = axelrod.Tournament(
+            name=self.test_name,
+            players=players,
+            game=self.game,
+            turns=turns,
+            repetitions=repetitions)
+        results = tournament.play()
+        self.assertIsInstance(results, axelrod.ResultSet)
+        self.assertEqual(len(results.cooperation), len(players))
+        self.assertEqual(results.nplayers, len(players))
+        self.assertEqual(results.players, players)
+
     def test_parallel_play(self):
         # Test that we get an instance of ResultSet
         tournament = axelrod.Tournament(

axelrod/tests/unit/test_tournament.py

@@ -1,3 +1,4 @@
 numpy>=1.9.2
 matplotlib>=1.4.2
 cloudpickle==0.1.1
+hypothesis==1.18