Merge pull request #640 from Axelrod-Python/604

Removing the random module for hypothesis

Author: marcharper

axelrod/tests/property.py

@@ -2,7 +2,8 @@
 A module for creating hypothesis based strategies for property based testing
 """
 import axelrod
-from hypothesis.strategies import composite, tuples, sampled_from, integers, floats, random_module, lists
+from hypothesis.strategies import (composite, sampled_from, integers,
+                                   floats, lists)
 
 
 @composite
@@ -45,15 +46,15 @@ def matches(draw, strategies=axelrod.strategies,
 
     Returns
     -------
-    tuple : a random match as well as a random seed
+    match : a random match
     """
-    seed = draw(random_module())
     strategies = draw(strategy_lists(min_size=2, max_size=2))
     players = [s() for s in strategies]
     turns = draw(integers(min_value=min_turns, max_value=max_turns))
     noise = draw(floats(min_value=min_noise, max_value=max_noise))
     match = axelrod.Match(players, turns=turns, noise=noise)
-    return match, seed
+    return match
+
 
 @composite
 def tournaments(draw, strategies=axelrod.strategies,
@@ -85,7 +86,6 @@ def tournaments(draw, strategies=axelrod.strategies,
     max_repetitions : integer
         The maximum number of repetitions
     """
-    seed = draw(random_module())
     strategies = draw(strategy_lists(strategies=strategies,
                                      min_size=min_size,
                                      max_size=max_size))
@@ -97,7 +97,7 @@ def tournaments(draw, strategies=axelrod.strategies,
 
     tournament = axelrod.Tournament(players, turns=turns,
                                     repetitions=repetitions, noise=noise)
-    return tournament, seed
+    return tournament
 
 
 @composite
@@ -130,7 +130,6 @@ def prob_end_tournaments(draw, strategies=axelrod.strategies,
     max_repetitions : integer
         The maximum number of repetitions
     """
-    seed = draw(random_module())
     strategies = draw(strategy_lists(strategies=strategies,
                                      min_size=min_size,
                                      max_size=max_size))
@@ -142,7 +141,7 @@ def prob_end_tournaments(draw, strategies=axelrod.strategies,
 
     tournament = axelrod.ProbEndTournament(players, prob_end=prob_end,
                                            repetitions=repetitions, noise=noise)
-    return tournament, seed
+    return tournament
 
 
 @composite

axelrod/tests/unit/test_match.py

@@ -5,7 +5,7 @@
 from axelrod.deterministic_cache import DeterministicCache
 
 from hypothesis import given, example
-from hypothesis.strategies import integers, floats, random_module, assume
+from hypothesis.strategies import integers, floats, assume
 
 from axelrod.tests.property import games
 
@@ -52,9 +52,8 @@ def test_len(self, turns):
         match = axelrod.Match((p1, p2), turns)
         self.assertEqual(len(match), turns)
 
-    @given(p=floats(min_value=0, max_value=1),
-           rm=random_module())
-    def test_stochastic(self, p, rm):
+    @given(p=floats(min_value=0, max_value=1))
+    def test_stochastic(self, p):
 
         assume(0 < p < 1)
 
@@ -69,9 +68,8 @@ def test_stochastic(self, p, rm):
         match = axelrod.Match((p1, p2), 5)
         self.assertTrue(match._stochastic)
 
-    @given(p=floats(min_value=0, max_value=1),
-           rm=random_module())
-    def test_cache_update_required(self, p, rm):
+    @given(p=floats(min_value=0, max_value=1))
+    def test_cache_update_required(self, p):
 
         assume(0 < p < 1)
 

axelrod/tests/unit/test_match_generator.py

@@ -2,7 +2,7 @@
 import unittest
 
 from hypothesis import given, example
-from hypothesis.strategies import floats, random_module, integers
+from hypothesis.strategies import floats, integers
 
 import axelrod
 
@@ -123,9 +123,9 @@ def setUpClass(cls):
         cls.players = [s() for s in test_strategies]
 
     @given(repetitions=integers(min_value=1, max_value=test_repetitions),
-           prob_end=floats(min_value=0, max_value=1), rm=random_module())
-    @example(repetitions=test_repetitions, prob_end=.5, rm=random_module())
-    def test_build_match_chunks(self, repetitions, prob_end, rm):
+           prob_end=floats(min_value=0, max_value=1))
+    @example(repetitions=test_repetitions, prob_end=.5)
+    def test_build_match_chunks(self, repetitions, prob_end):
         rr = axelrod.ProbEndRoundRobinMatches(
             self.players, prob_end, test_game, repetitions)
         chunks = list(rr.build_match_chunks())
@@ -134,8 +134,8 @@ def test_build_match_chunks(self, repetitions, prob_end, rm):
 
         self.assertEqual(sorted(match_definitions), sorted(expected_match_definitions))
 
-    @given(prob_end=floats(min_value=0.1, max_value=0.5), rm=random_module())
-    def test_build_matches_different_length(self, prob_end, rm):
+    @given(prob_end=floats(min_value=0.1, max_value=0.5))
+    def test_build_matches_different_length(self, prob_end):
         """
         If prob end is not 0 or 1 then the matches should all have different
         length
@@ -149,8 +149,8 @@ def test_build_matches_different_length(self, prob_end, rm):
         match_lengths = [match_params[0] for (index_pair, match_params, repetitions) in chunks]
         self.assertNotEqual(min(match_lengths), max(match_lengths))
 
-    @given(prob_end=floats(min_value=0, max_value=1), rm=random_module())
-    def test_sample_length(self, prob_end, rm):
+    @given(prob_end=floats(min_value=0, max_value=1))
+    def test_sample_length(self, prob_end):
         rr = axelrod.ProbEndRoundRobinMatches(
             self.players, prob_end, test_game, test_repetitions)
         self.assertGreaterEqual(rr.sample_length(prob_end), 1)
@@ -159,8 +159,8 @@ def test_sample_length(self, prob_end, rm):
         except AssertionError:
             self.assertEqual(rr.sample_length(prob_end), float("inf"))
 
-    @given(prob_end=floats(min_value=.1, max_value=1), rm=random_module())
-    def test_build_single_match_params(self, prob_end, rm):
+    @given(prob_end=floats(min_value=.1, max_value=1))
+    def test_build_single_match_params(self, prob_end):
         rr = axelrod.ProbEndRoundRobinMatches(
             self.players, prob_end, test_game, test_repetitions)
         match_params = rr.build_single_match_params()
@@ -200,8 +200,8 @@ def test_build_single_match_params(self, prob_end, rm):
         self.assertLess(len(match), float('inf'))
         self.assertGreater(len(match), 0)
 
-    @given(prob_end=floats(min_value=.1, max_value=1), rm=random_module())
-    def test_len(self, prob_end, rm):
+    @given(prob_end=floats(min_value=.1, max_value=1))
+    def test_len(self, prob_end):
         repetitions = 10
         rr = axelrod.ProbEndRoundRobinMatches(
             self.players, prob_end, game=None, repetitions=repetitions)

axelrod/tests/unit/test_moran.py

@@ -7,7 +7,6 @@
 from axelrod.moran import fitness_proportionate_selection
 
 from hypothesis import given, example, settings
-from hypothesis.strategies import random_module
 
 from axelrod.tests.property import strategy_lists
 
@@ -69,16 +68,13 @@ def test_four_players(self):
         self.assertEqual(populations, mp.populations)
         self.assertEqual(mp.winning_strategy_name, str(axelrod.Defector()))
 
-    @given(strategies=strategy_lists(min_size=2, max_size=5),
-           rm=random_module())
+    @given(strategies=strategy_lists(min_size=2, max_size=5))
     @settings(max_examples=5, timeout=0)  # Very low number of examples
 
     # Two specific examples relating to cloning of strategies
-    @example(strategies=[axelrod.BackStabber, axelrod.MindReader],
-             rm=random.seed(0))
-    @example(strategies=[axelrod.ThueMorse, axelrod.MindReader],
-             rm=random.seed(0))
-    def test_property_players(self, strategies, rm):
+    @example(strategies=[axelrod.BackStabber, axelrod.MindReader])
+    @example(strategies=[axelrod.ThueMorse, axelrod.MindReader])
+    def test_property_players(self, strategies):
         """Hypothesis test that randomly checks players"""
         players = [s() for s in strategies]
         mp = MoranProcess(players)

axelrod/tests/unit/test_property.py

@@ -6,7 +6,6 @@
                                     prob_end_tournaments, games)
 
 from hypothesis import given, settings
-from hypothesis.strategies import random_module
 
 stochastic_strategies = [s for s in axelrod.strategies if
                          s().classifier['stochastic']]
@@ -20,31 +19,28 @@ def test_call(self):
         for p in strategies:
             self.assertIsInstance(p(), axelrod.Player)
 
-    @given(strategies=strategy_lists(min_size=1, max_size=50),
-           rm=random_module())
+    @given(strategies=strategy_lists(min_size=1, max_size=50))
     @settings(max_examples=10, timeout=0)
-    def test_decorator(self, strategies, rm):
+    def test_decorator(self, strategies):
         self.assertIsInstance(strategies, list)
         self.assertGreaterEqual(len(strategies), 1)
         self.assertLessEqual(len(strategies), 50)
         for strategy in strategies:
             self.assertIsInstance(strategy(), axelrod.Player)
 
-    @given(strategies=strategy_lists(strategies=axelrod.basic_strategies),
-           rm=random_module())
+    @given(strategies=strategy_lists(strategies=axelrod.basic_strategies))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_given_strategies(self, strategies, rm):
+    def test_decorator_with_given_strategies(self, strategies):
         self.assertIsInstance(strategies, list)
         basic_player_names = [str(s()) for s in axelrod.basic_strategies]
         for strategy in strategies:
             player = strategy()
             self.assertIsInstance(player, axelrod.Player)
             self.assertIn(str(player), basic_player_names)
 
-    @given(strategies=strategy_lists(strategies=stochastic_strategies),
-           rm=random_module())
+    @given(strategies=strategy_lists(strategies=stochastic_strategies))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_stochastic_strategies(self, strategies, rm):
+    def test_decorator_with_stochastic_strategies(self, strategies):
         self.assertIsInstance(strategies, list)
         stochastic_player_names = [str(s()) for s in stochastic_strategies]
         for strategy in strategies:
@@ -59,29 +55,24 @@ class TestMatch(unittest.TestCase):
     """
 
     def test_call(self):
-        match, seed = matches().example()
-        self.assertTrue(str(seed).startswith('random.seed'))
+        match = matches().example()
         self.assertIsInstance(match, axelrod.Match)
 
-    @given(match_and_seed=matches(min_turns=10, max_turns=50,
-                                  min_noise=0, max_noise=1))
+    @given(match=matches(min_turns=10, max_turns=50,
+                         min_noise=0, max_noise=1))
     @settings(max_examples=10, timeout=0)
-    def test_decorator(self, match_and_seed):
-        match, seed = match_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
+    def test_decorator(self, match):
 
         self.assertIsInstance(match, axelrod.Match)
         self.assertGreaterEqual(len(match), 10)
         self.assertLessEqual(len(match), 50)
         self.assertGreaterEqual(match.noise, 0)
         self.assertLessEqual(match.noise, 1)
 
-    @given(match_and_seed=matches(min_turns=10, max_turns=50,
-                                  min_noise=0, max_noise=0))
+    @given(match=matches(min_turns=10, max_turns=50,
+                         min_noise=0, max_noise=0))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_no_noise(self, match_and_seed):
-        match, seed = match_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
+    def test_decorator_with_no_noise(self, match):
 
         self.assertIsInstance(match, axelrod.Match)
         self.assertGreaterEqual(len(match), 10)
@@ -92,19 +83,15 @@ def test_decorator_with_no_noise(self, match_and_seed):
 class TestTournament(unittest.TestCase):
 
     def test_call(self):
-        tournament, seed = tournaments().example()
-        self.assertTrue(str(seed).startswith('random.seed'))
+        tournament = tournaments().example()
         self.assertIsInstance(tournament, axelrod.Tournament)
 
-    @given(tournament_and_seed=tournaments(min_turns=2, max_turns=50, min_noise=0,
-                                           max_noise=1, min_repetitions=2,
-                                           max_repetitions=50,
-                                           max_size=3))
+    @given(tournament=tournaments(min_turns=2, max_turns=50, min_noise=0,
+                                  max_noise=1, min_repetitions=2,
+                                  max_repetitions=50,
+                                  max_size=3))
     @settings(max_examples=10, timeout=0)
-    def test_decorator(self, tournament_and_seed):
-        tournament, seed = tournament_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
-
+    def test_decorator(self, tournament):
         self.assertIsInstance(tournament, axelrod.Tournament)
         self.assertLessEqual(tournament.turns, 50)
         self.assertGreaterEqual(tournament.turns, 2)
@@ -113,25 +100,19 @@ def test_decorator(self, tournament_and_seed):
         self.assertLessEqual(tournament.repetitions, 50)
         self.assertGreaterEqual(tournament.repetitions, 2)
 
-    @given(tournament_and_seed=tournaments(strategies=axelrod.basic_strategies,
-                                           max_size=3))
+    @given(tournament=tournaments(strategies=axelrod.basic_strategies,
+                                  max_size=3))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_given_strategies(self, tournament_and_seed):
-        tournament, seed = tournament_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
-
+    def test_decorator_with_given_strategies(self, tournament):
         self.assertIsInstance(tournament, axelrod.Tournament)
         basic_player_names = [str(s()) for s in axelrod.basic_strategies]
         for p in tournament.players:
             self.assertIn(str(p), basic_player_names)
 
-    @given(tournament_and_seed=tournaments(strategies=stochastic_strategies,
-                                           max_size=3))
+    @given(tournament=tournaments(strategies=stochastic_strategies,
+                                  max_size=3))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_stochastic_strategies(self, tournament_and_seed):
-        tournament, seed = tournament_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
-
+    def test_decorator_with_stochastic_strategies(self, tournament):
         self.assertIsInstance(tournament, axelrod.Tournament)
         stochastic_player_names = [str(s()) for s in stochastic_strategies]
         for p in tournament.players:
@@ -141,21 +122,17 @@ def test_decorator_with_stochastic_strategies(self, tournament_and_seed):
 class TestProbEndTournament(unittest.TestCase):
 
     def test_call(self):
-        tournament, seed = prob_end_tournaments().example()
-        self.assertTrue(str(seed).startswith('random.seed'))
+        tournament = tournaments().example()
         self.assertIsInstance(tournament, axelrod.Tournament)
 
-    @given(tournament_and_seed=prob_end_tournaments(min_prob_end=0,
-                                                    max_prob_end=1,
-                                                    min_noise=0, max_noise=1,
-                                                    min_repetitions=2,
-                                                    max_repetitions=50,
-                                                    max_size=3))
+    @given(tournament=prob_end_tournaments(min_prob_end=0,
+                                           max_prob_end=1,
+                                           min_noise=0, max_noise=1,
+                                           min_repetitions=2,
+                                           max_repetitions=50,
+                                           max_size=3))
     @settings(max_examples=10, timeout=0)
-    def test_decorator(self, tournament_and_seed):
-        tournament, seed = tournament_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
-
+    def test_decorator(self, tournament):
         self.assertIsInstance(tournament, axelrod.ProbEndTournament)
         self.assertLessEqual(tournament.prob_end, 1)
         self.assertGreaterEqual(tournament.prob_end, 0)
@@ -164,25 +141,19 @@ def test_decorator(self, tournament_and_seed):
         self.assertLessEqual(tournament.repetitions, 50)
         self.assertGreaterEqual(tournament.repetitions, 2)
 
-    @given(tournament_and_seed=prob_end_tournaments(
-        strategies=axelrod.basic_strategies, max_size=3))
+    @given(tournament=prob_end_tournaments(strategies=axelrod.basic_strategies,
+                                           max_size=3))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_given_strategies(self, tournament_and_seed):
-        tournament, seed = tournament_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
-
+    def test_decorator_with_given_strategies(self, tournament):
         self.assertIsInstance(tournament, axelrod.ProbEndTournament)
         basic_player_names = [str(s()) for s in axelrod.basic_strategies]
         for p in tournament.players:
             self.assertIn(str(p), basic_player_names)
 
-    @given(tournament_and_seed=prob_end_tournaments(
-        strategies=stochastic_strategies, max_size=3))
+    @given(tournament=prob_end_tournaments(strategies=stochastic_strategies,
+                                           max_size=3))
     @settings(max_examples=10, timeout=0)
-    def test_decorator_with_stochastic_strategies(self, tournament_and_seed):
-        tournament, seed = tournament_and_seed
-        self.assertTrue(str(seed).startswith('random.seed'))
-
+    def test_decorator_with_stochastic_strategies(self, tournament):
         self.assertIsInstance(tournament, axelrod.ProbEndTournament)
         stochastic_player_names = [str(s()) for s in stochastic_strategies]
         for p in tournament.players: