Fix deterministic and stochastic tournament tests, improve test structure, and update documentation/configuration

CHANGES.md

@@ -1,3 +1,15 @@
+# v4.13.2, 2025-01-06
+
+Mainly internal changes: fix for `TestOpponent` class and updates to various files.
+
+- Fixed `TestOpponent` class in `axelrod/tests/strategies/test_player.py` to remove the `__init__` constructor and replaced it with a static `strategy` method to resolve PytestCollectionWarning.
+  - The class now defines a `strategy` method that returns `C`, as required for it to be collectable by pytest.
+
+- Renamed `TestMakesUseOfLengthAndGamePlayer` class to `MakesUseOfLengthAndGamePlayer` in axelrod/tests/unit/test_makes_use_of.py to resolve PytestCollectionWarning.
+- Renamed `TestMakesUseOfNothingPlayer` class to `MakesUseOfNothingPlayer` in axelrod/tests/unit/test_makes_use_of.py to resolve PytestCollectionWarning.
+- **Updated docs/Makefile**.
+- **Updated setup.py**.
+
 # v4.13.1, 2024-10-02
 
 Mainly internal changes: move to pyproject.toml.

axelrod/tests/integration/test_tournament.py

@@ -97,9 +97,16 @@ def test_repeat_tournament_deterministic(self):
                 turns=2,
                 repetitions=2,
             )
+            # path = pathlib.Path(
+            #     "test_outputs/stochastic_tournament_{}.csv".format(_)
+            # )
+            # MG: Changed to use right filename "deterministic_tournament_{}.csv"
             path = pathlib.Path(
-                "test_outputs/stochastic_tournament_{}.csv".format(_)
+                f"test_outputs/deterministic_tournament_{_}.csv"
             )
+            # MG: Control for file existence before new execution
+            if path.exists():
+                path.unlink()
             files.append(axl_filename(path))
             tournament.play(
                 progress_bar=False, filename=files[-1], build_results=False

axelrod/tests/strategies/test_player.py

@@ -350,10 +350,22 @@ def test_init_kwargs(self):
         )
 
 
-class TestOpponent(axl.Player):
+# TestPlayer class for testing against a known opponent
+# class TestOpponent(axl.Player):
+#     """A player who only exists so we have something to test against"""
+
+#     name = "TestOpponent"
+#     classifier = _test_classifier
+
+#     @staticmethod
+#     def strategy(opponent):
+#         return C
+
+
+class OpponentTest(axl.Player):
     """A player who only exists so we have something to test against"""
 
-    name = "TestOpponent"
+    name = "OpponentTest"
     classifier = _test_classifier
 
     @staticmethod
@@ -364,7 +376,8 @@ def strategy(opponent):
 class TestPlayer(unittest.TestCase):
     """A Test class from which other player test classes are inherited."""
 
-    player = TestOpponent
+    # The class to be tested OpponentTest
+    player = OpponentTest
     expected_class_classifier = None
 
     def test_initialisation(self):
@@ -632,7 +645,8 @@ def classifier_test(self, expected_class_classifier=None):
             "stochastic" in player.classifier,
             msg="stochastic not in classifier",
         )
-        for key in TestOpponent.classifier:
+        # OpponentTest
+        for key in OpponentTest.classifier:
             self.assertEqual(
                 axl.Classifiers[key](player),
                 self.expected_classifier[key],

axelrod/tests/strategies/test_sequence_player.py

@@ -6,7 +6,7 @@
 from axelrod._strategy_utils import recursive_thue_morse
 from axelrod.strategies.sequence_player import SequencePlayer
 
-from .test_player import TestOpponent, TestPlayer
+from .test_player import OpponentTest, TestPlayer
 
 C, D = axl.Action.C, axl.Action.D
 
@@ -26,7 +26,7 @@ def cooperate_gen():
             yield 1
 
         player = SequencePlayer(generator_function=cooperate_gen)
-        opponent = TestOpponent()
+        opponent = OpponentTest()
         self.assertEqual(C, player.strategy(opponent))
 
 

axelrod/tests/unit/test_game.py

@@ -113,7 +113,7 @@ def test_invalid_matrices(self, A, B):
         self.assertEqual(error_raised, (A.shape != B.transpose().shape))
 
     @given(asymgame=asymmetric_games())
-    @settings(max_examples=5)
+    @settings(max_examples=5, deadline=3000)
     def test_random_repr(self, asymgame):
         """Test repr with random scores."""
         expected_repr = "Axelrod game with matrices: {}".format(

axelrod/tests/unit/test_makes_use_of.py

@@ -12,7 +12,8 @@
 from axelrod.strategy_transformers import final_sequence
 
 
-class TestMakesUseOfLengthAndGamePlayer(axl.Player):
+# class TestMakesUseOfLengthAndGamePlayer(axl.Player):
+class MakesUseOfLengthAndGamePlayer(axl.Player):
     """
     Should have some function that uses length
     """
@@ -45,7 +46,7 @@ def only_function(self):  # pragma: no cover
 class TestMakesUseOf(unittest.TestCase):
     def test_makes_use_of_length_and_game(self):
         self.assertEqual(
-            makes_use_of(TestMakesUseOfLengthAndGamePlayer()),
+            makes_use_of(MakesUseOfLengthAndGamePlayer()),
             {"length", "game"},
         )
 

axelrod/tests/unit/test_property.py

@@ -19,14 +19,16 @@
 
 
 class TestStrategyList(unittest.TestCase):
-    def test_call(self):
-        strategies = strategy_lists().example()
+    # MG: Replaced .example() with @given for generating strategies
+    @given(strategies=strategy_lists())
+    @settings(max_examples=3)
+    def test_call(self, strategies):
         self.assertIsInstance(strategies, list)
         for p in strategies:
             self.assertIsInstance(p(), axl.Player)
 
     @given(strategies=strategy_lists(min_size=1, max_size=50))
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, strategies):
         self.assertIsInstance(strategies, list)
         self.assertGreaterEqual(len(strategies), 1)
@@ -35,7 +37,7 @@ def test_decorator(self, strategies):
             self.assertIsInstance(strategy(), axl.Player)
 
     @given(strategies=strategy_lists(strategies=axl.basic_strategies))
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_with_given_strategies(self, strategies):
         self.assertIsInstance(strategies, list)
         basic_player_names = [str(s()) for s in axl.basic_strategies]
@@ -50,12 +52,14 @@ class TestMatch(unittest.TestCase):
     Test that the composite method works
     """
 
-    def test_call(self):
-        match = matches().example()
+    # MG: Replaced .example() with @given for match generation
+    @given(match=matches())
+    @settings(max_examples=3)
+    def test_call(self, match):
         self.assertIsInstance(match, axl.Match)
 
     @given(match=matches(min_turns=10, max_turns=50, min_noise=0, max_noise=1))
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, match):
         self.assertIsInstance(match, axl.Match)
         self.assertGreaterEqual(len(match), 10)
@@ -64,7 +68,7 @@ def test_decorator(self, match):
         self.assertLessEqual(match.noise, 1)
 
     @given(match=matches(min_turns=10, max_turns=50, min_noise=0, max_noise=0))
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_with_no_noise(self, match):
         self.assertIsInstance(match, axl.Match)
         self.assertGreaterEqual(len(match), 10)
@@ -73,8 +77,10 @@ def test_decorator_with_no_noise(self, match):
 
 
 class TestTournament(unittest.TestCase):
-    def test_call(self):
-        tournament = tournaments().example()
+    # MG: Replaced .example() with @given for tournament generation
+    @given(tournament=tournaments())
+    @settings(max_examples=3)
+    def test_call(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
 
     @given(
@@ -88,7 +94,7 @@ def test_call(self):
             max_size=3,
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         self.assertLessEqual(tournament.turns, 50)
@@ -99,7 +105,7 @@ def test_decorator(self, tournament):
         self.assertGreaterEqual(tournament.repetitions, 2)
 
     @given(tournament=tournaments(strategies=axl.basic_strategies, max_size=3))
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_with_given_strategies(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         basic_player_names = [str(s()) for s in axl.basic_strategies]
@@ -108,8 +114,9 @@ def test_decorator_with_given_strategies(self, tournament):
 
 
 class TestProbEndTournament(unittest.TestCase):
-    def test_call(self):
-        tournament = tournaments().example()
+    @given(tournament=prob_end_tournaments())
+    @settings(max_examples=3)
+    def test_call(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
 
     @given(
@@ -123,7 +130,7 @@ def test_call(self):
             max_size=3,
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         self.assertLessEqual(tournament.prob_end, 1)
@@ -138,7 +145,7 @@ def test_decorator(self, tournament):
             strategies=axl.basic_strategies, max_size=3
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_with_given_strategies(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         basic_player_names = [str(s()) for s in axl.basic_strategies]
@@ -147,8 +154,9 @@ def test_decorator_with_given_strategies(self, tournament):
 
 
 class TestSpatialTournament(unittest.TestCase):
-    def test_call(self):
-        tournament = spatial_tournaments().example()
+    @given(tournament=spatial_tournaments())
+    @settings(max_examples=3)
+    def test_call(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
 
     @given(
@@ -162,7 +170,7 @@ def test_call(self):
             max_size=3,
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         self.assertLessEqual(tournament.turns, 50)
@@ -177,7 +185,7 @@ def test_decorator(self, tournament):
             strategies=axl.basic_strategies, max_size=3
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_with_given_strategies(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         basic_player_names = [str(s()) for s in axl.basic_strategies]
@@ -186,8 +194,9 @@ def test_decorator_with_given_strategies(self, tournament):
 
 
 class TestProbEndSpatialTournament(unittest.TestCase):
-    def test_call(self):
-        tournament = prob_end_spatial_tournaments().example()
+    @given(tournament=prob_end_spatial_tournaments())
+    @settings(max_examples=3)
+    def test_call(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
 
     @given(
@@ -201,7 +210,7 @@ def test_call(self):
             max_size=3,
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         self.assertLessEqual(tournament.prob_end, 1)
@@ -216,7 +225,7 @@ def test_decorator(self, tournament):
             strategies=axl.basic_strategies, max_size=3
         )
     )
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_with_given_strategies(self, tournament):
         self.assertIsInstance(tournament, axl.Tournament)
         basic_player_names = [str(s()) for s in axl.basic_strategies]
@@ -225,18 +234,19 @@ def test_decorator_with_given_strategies(self, tournament):
 
 
 class TestGame(unittest.TestCase):
-    def test_call(self):
-        game = games().example()
+    @given(game=games())
+    @settings(max_examples=3)
+    def test_call(self, game):
         self.assertIsInstance(game, axl.Game)
 
     @given(game=games())
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator(self, game):
         self.assertIsInstance(game, axl.Game)
         r, p, s, t = game.RPST()
         self.assertTrue((2 * r) > (t + s) and (t > r > p > s))
 
     @given(game=games(prisoners_dilemma=False))
-    @settings(max_examples=5)
+    @settings(max_examples=3)
     def test_decorator_unconstrained(self, game):
         self.assertIsInstance(game, axl.Game)