Only assert the filter criteria when at least one game returned

Author: edwardchalstrey1

tests/test_catalog.py

@@ -54,101 +54,110 @@ def test_catalog_games_filter_n_actions(all_games):
     filtered_games = gbt.catalog.games(n_actions=2)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.actions) == 2
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.actions) == 2
 
 
 def test_catalog_games_filter_n_contingencies(all_games):
     """Test games() function can filter on length of gbt.Game attribute 'contingencies'"""
     filtered_games = gbt.catalog.games(n_contingencies=2)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.contingencies) == 2
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.contingencies) == 2
 
 
 def test_catalog_games_filter_n_infosets(all_games):
     """Test games() function can filter on length of gbt.Game attribute 'infosets'"""
     filtered_games = gbt.catalog.games(n_infosets=2)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.infosets) == 2
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.infosets) == 2
 
 
 def test_catalog_games_filter_is_const_sum(all_games):
     """Test games() function can filter on boolean gbt.Game attribute 'is_const_sum'"""
     filtered_games = gbt.catalog.games(is_const_sum=True)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert g.is_const_sum
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert g.is_const_sum
 
 
-# TODO: Re-introduce this test when there are examples in the catalog without perfect recall
-# def test_catalog_games_filter_is_perfect_recall(all_games):
-#     """Test games() function can filter on boolean gbt.Game attribute 'is_perfect_recall'"""
-#     filtered_games = gbt.catalog.games(is_perfect_recall=True)
-#     assert isinstance(filtered_games, pd.DataFrame)
-#     assert len(filtered_games) < len(all_games)
-#     g = gbt.catalog.load(filtered_games.Game.iloc[0])
-#     assert g.is_perfect_recall
+def test_catalog_games_filter_is_not_perfect_recall(all_games):
+    """Test games() function can filter on boolean gbt.Game attribute 'is_perfect_recall'"""
+    filtered_games = gbt.catalog.games(is_perfect_recall=False)
+    assert isinstance(filtered_games, pd.DataFrame)
+    assert len(filtered_games) < len(all_games)
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert not g.is_perfect_recall
 
 
-# TODO: Re-introduce this test when there are examples in the catalog of normal form games
-# def test_catalog_games_filter_is_tree(all_games):
-#     """Test games() function can filter on boolean gbt.Game attribute 'is_tree'"""
-#     filtered_games = gbt.catalog.games(is_tree=True)
-#     assert isinstance(filtered_games, pd.DataFrame)
-#     assert len(filtered_games) < len(all_games)
-#     g = gbt.catalog.load(filtered_games.Game.iloc[0])
-#     assert g.is_tree
+def test_catalog_games_filter_is_not_tree(all_games):
+    """Test games() function can filter on boolean gbt.Game attribute 'is_tree'"""
+    filtered_games = gbt.catalog.games(is_tree=False)
+    assert isinstance(filtered_games, pd.DataFrame)
+    assert len(filtered_games) < len(all_games)
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert not g.is_tree
 
 
 def test_catalog_games_filter_min_payoff_and_max_payoff(all_games):
     """Test games() function can filter on min and max payoff values"""
     filtered_games = gbt.catalog.games(min_payoff=0, max_payoff=10)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert g.min_payoff >= 0
-    assert g.max_payoff <= 10
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert g.min_payoff >= 0
+        assert g.max_payoff <= 10
 
 
 def test_catalog_games_filter_n_nodes(all_games):
     """Test games() function can filter on length of gbt.Game attribute 'nodes'"""
     filtered_games = gbt.catalog.games(n_nodes=5)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.nodes) == 5
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.nodes) == 5
 
 
 def test_catalog_games_filter_n_outcomes(all_games):
     """Test games() function can filter on length of gbt.Game attribute 'outcomes'"""
     filtered_games = gbt.catalog.games(n_outcomes=3)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.outcomes) == 3
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.outcomes) == 3
 
 
 def test_catalog_games_filter_n_players(all_games):
     """Test games() function can filter on length of gbt.Game attribute 'players'"""
     filtered_games = gbt.catalog.games(n_players=2)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.players) == 2
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.players) == 2
 
 
 def test_catalog_games_filter_n_strategies(all_games):
     """Test games() function can filter on length of gbt.Game attribute 'strategies'"""
     filtered_games = gbt.catalog.games(n_strategies=4)
     assert isinstance(filtered_games, pd.DataFrame)
     assert len(filtered_games) < len(all_games)
-    g = gbt.catalog.load(filtered_games.Game.iloc[0])
-    assert len(g.strategies) == 4
+    if len(filtered_games) > 0:
+        g = gbt.catalog.load(filtered_games.Game.iloc[0])
+        assert len(g.strategies) == 4
 
 
 def test_catalog_games_filter_bad_filter():