test fixture cleanup

remove not-run tests

Author: petrelharp

docs/development.md

@@ -945,6 +945,60 @@ checks for code quality.
 - [CodeCov](https://codecov.io/gh)_ tracks test coverage in Python and C.
 
 
+### Testing methods on a broad range of tree sequences
+
+It's important to test methods on "weird" examples beyond what msprime returns:
+polytomies, samples not all at the same time, samples that are parents to other samples,
+multiple mutations on the same edge and at the same time, etcetera. Small,
+discrete simulations with overlapping generations are a good way to produce these, 
+and these can be produced by the `wf_sim` method in `tests/test_wright_fisher.py`
+(and other tools in `tests/tsutil.py`). The way these are applied across the tests
+is fairly hodge-podge; here are suggestions for best practices moving forward.
+
+(1) Write a "naive" implementation of your method. This should be code that
+obviously does exactly what you want to compute but with no thought at all for
+efficiency. (2) Write a `validate` method that compares the output of the method
+to the naive version. (3) Run this on a few extremely simple edge case examples
+where you can also compare to an answer computed by hand. (4) Also run this on a
+suite of example simulations, including weird ones (see above).
+
+An easy and clean way to run across a suite of example simulations is
+using [pytest's fixtures](https://docs.pytest.org/en/stable/how-to/fixtures.html).
+An example is in `test_tree_stats.py`: `wf_fixture_sims` is a fixture returning
+a dictionary of simulations. It has `scope="session"`, meaning each simulation
+will only be run once and the result cached. Using this is another fixture,
+`wf_fixture`, that has a list of `params` that are the keys to that dictionary.
+Any test that uses `wf_fixture` will then be run many times, once on each simulation,
+for instance simply by
+```
+def test_something(self, wf_fixture_sims):
+    self.validate(wf_fixture_sims)
+```
+If, for instance, a test wants to use only the "unsimplified" and "no_deep_history"
+simulations, then you can do:
+```
+@pytest.mark.parametrize('key', ['unsimplified', 'no_deep_history'])
+def test_something(self, wf_fixture_sims, key):
+    self.validate(wf_fixture_sims[key])
+```
+
+TODO: move the `wf_fixture` to `conftest.py` so it can be used across modules,
+and make sure it includes All the Weirdnesses.
+A list of all currently defined fixtures can be found by running
+`pytest --fixtures tests`.
+
+
+### Running codecov locally
+
+Sometimes it's nice to check for code coverage yourself without waiting for github.
+To do this for the python code, you can run
+```
+python -m pytest -x --cov=tskit --cov-report=html --cov-branch -n4 --durations=20 tests
+```
+The commands used to do this are found in `.github/workflows/test.yml`
+TODO: write down how to get coverage for C.
+
+
 (sec_development_best_practices)=
 
 

python/tests/test_tree_stats.py

@@ -667,24 +667,11 @@ def test_short_sequence_length(self):
         self.verify(ts)
 
     @pytest.mark.slow
-    def test_wright_fisher_unsimplified(self, wf_sim_fixture):
-        self.verify(wf_sim_fixture["unsimplified"])
+    def test_wright_fisher_slow(self, wf_fixture_slow):
+        self.verify(wf_fixture_slow)
 
-    @pytest.mark.slow
-    def test_wright_fisher_initial_generation(self, wf_sim_fixture):
-        self.verify(wf_sim_fixture["initial_generation"])
-
-    def test_wright_fisher_initial_generation_no_deep_history(self, wf_sim_fixture):
-        self.verify(wf_sim_fixture["no_deep_history"])
-
-    def test_wright_fisher_unsimplified_multiple_roots(self, wf_sim_fixture):
-        self.verify(wf_sim_fixture["unsimplified_multi_roots"])
-
-    def test_wright_fisher_simplified(self, wf_sim_fixture):
-        self.verify(wf_sim_fixture["simplified"])
-
-    def test_wright_fisher_simplified_multiple_roots(self, wf_sim_fixture):
-        self.verify(wf_sim_fixture["simplified_multi_roots"])
+    def test_wright_fisher(self, wf_fixture):
+        self.verify(wf_fixture)
 
     def test_empty_ts(self):
         tables = tskit.TableCollection(1.0)
@@ -782,7 +769,7 @@ def _make_ts(length):
 
 # Wright-Fisher simulation fixtures
 @pytest.fixture(scope="session")
-def wf_sim_fixture():
+def wf_fixture_sims():
     """Common Wright-Fisher simulations used across test classes."""
     # Pre-compute all common WF simulations
     simulations = {}
@@ -829,51 +816,37 @@ def wf_sim_fixture():
     return simulations
 
 
-@pytest.fixture(scope="session")
-def wf_mut_sim_fixture():
-    """Wright-Fisher simulations with mutations for MutatedTopologyExamplesMixin."""
-    simulations = {}
-
-    # With mutations for site-based tests
-    tables = wf.wf_sim(
-        4, 5, seed=1, deep_history=True, initial_generation_samples=False, num_loci=10
-    )
-    tables.sort()
-    ts = msprime.mutate(tables.tree_sequence(), rate=0.05, random_seed=234)
-    simulations["unsimplified"] = ts
-
-    tables = wf.wf_sim(
-        6, 5, seed=3, deep_history=True, initial_generation_samples=True, num_loci=2
-    )
-    tables.sort()
-    tables.simplify()
-    ts = msprime.mutate(tables.tree_sequence(), rate=0.08, random_seed=2)
-    simulations["initial_generation"] = ts
-
-    tables = wf.wf_sim(
-        7, 15, seed=202, deep_history=False, initial_generation_samples=True, num_loci=5
+@pytest.fixture(
+    params=[
+        "no_deep_history",
+        "unsimplified_multi_roots",
+        "simplified",
+        "simplified_multi_roots",
+    ],
+    scope="session",
+)
+def wf_fixture(wf_fixture_sims, request):
+    """
+    A collection of small Wright-Fisher simulations.
+    """
+    ts = msprime.sim_mutations(
+        wf_fixture_sims[request.param], rate=0.05, random_seed=1234
     )
-    tables.sort()
-    tables.simplify()
-    ts = msprime.mutate(tables.tree_sequence(), rate=0.1, random_seed=3)
-    simulations["no_deep_history"] = ts
+    assert ts.num_mutations > 0
+    return ts
 
-    tables = wf.wf_sim(
-        8, 15, seed=1, deep_history=False, initial_generation_samples=False, num_loci=20
-    )
-    tables.sort()
-    ts = msprime.mutate(tables.tree_sequence(), rate=0.01, random_seed=2)
-    simulations["unsimplified_multi_roots"] = ts
 
-    tables = wf.wf_sim(
-        9, 10, seed=1, deep_history=True, initial_generation_samples=False, num_loci=5
+@pytest.fixture(params=["unsimplified", "initial_generation"], scope="session")
+def wf_fixture_slow(wf_fixture_sims, request):
+    """
+    A few more small Wright-Fisher simulations. Despite the name, in total
+    they take about the same time for tests together as wf_fixture.
+    """
+    ts = msprime.sim_mutations(
+        wf_fixture_sims[request.param], rate=0.05, random_seed=1234
     )
-    tables.sort()
-    ts = tables.tree_sequence().simplify()
-    ts = tsutil.jukes_cantor(ts, 10, 0.01, seed=1)
-    simulations["simplified"] = ts
-
-    return simulations
+    assert ts.num_mutations > 0
+    return ts
 
 
 @pytest.fixture(scope="session")
@@ -1133,28 +1106,13 @@ def test_many_trees_sequence_length_infinite_sites(
             ts = ts_6_length_factory_fixture(L)
             self.verify(ts)
 
-    def test_wright_fisher_unsimplified(self, wf_mut_sim_fixture):
-        ts = wf_mut_sim_fixture["unsimplified"]
+    def test_wright_fisher(self, wf_fixture):
+        ts = wf_fixture
         assert ts.num_sites > 0
         self.verify(ts)
 
-    def test_wright_fisher_initial_generation(self, wf_mut_sim_fixture):
-        ts = wf_mut_sim_fixture["initial_generation"]
-        assert ts.num_sites > 0
-        self.verify(ts)
-
-    def test_wright_fisher_initial_generation_no_deep_history(self, wf_mut_sim_fixture):
-        ts = wf_mut_sim_fixture["no_deep_history"]
-        assert ts.num_sites > 0
-        self.verify(ts)
-
-    def test_wright_fisher_unsimplified_multiple_roots(self, wf_mut_sim_fixture):
-        ts = wf_mut_sim_fixture["unsimplified_multi_roots"]
-        assert ts.num_sites > 0
-        self.verify(ts)
-
-    def test_wright_fisher_simplified(self, wf_mut_sim_fixture):
-        ts = wf_mut_sim_fixture["simplified"]
+    def test_wright_fisher_slow(self, wf_fixture_slow):
+        ts = wf_fixture_slow
         assert ts.num_sites > 0
         self.verify(ts)
 
@@ -4310,13 +4268,14 @@ def update_result(window_index, u, right):
 
 
 def site_allele_frequency_spectrum(
-    ts, sample_sets, windows, polarised=False, span_normalise=True
+    ts, sample_sets, windows, time_windows=None, polarised=False, span_normalise=True
 ):
     """
     Efficient implementation of the algorithm used as the basis for the
     underlying C version.
     """
     windows = ts.parse_windows(windows)
+    assert time_windows is None
     num_windows = windows.shape[0] - 1
     out_dim = [1 + len(sample_set) for sample_set in sample_sets]
 
@@ -4622,8 +4581,7 @@ class TestSampleSets(StatsTestCase):
     Tests that passing sample sets in various ways gets interpreted correctly.
     """
 
-    def get_example_ts(self, ts_10_mut_recomb_fixture):
-        ts = ts_10_mut_recomb_fixture
+    def get_example_ts(self, ts):
         assert ts.num_mutations > 0
         return ts
 
@@ -7288,18 +7246,18 @@ def f(x):
         x = naive_branch_general_stat(
             ts, W, f, time_windows=[0, 0.5, 2.0], span_normalise=False
         )
-        self.assertArrayAlmostEqual(x, true_x)
+        np.testing.assert_allclose(x, true_x)
 
         x0 = branch_general_stat(ts, W, f, time_windows=None, span_normalise=False)
         x1 = naive_branch_general_stat(
             ts, W, f, time_windows=None, span_normalise=False
         )
-        self.assertArrayAlmostEqual(x0, x1)
+        np.testing.assert_allclose(x0, x1)
         x_tw = branch_general_stat(
             ts, W, f, time_windows=[0, 0.5, 2.0], span_normalise=False
         )
 
-        self.assertArrayAlmostEqual(x, x_tw)
+        np.testing.assert_allclose(x, x_tw)
 
     def test_bad_time_windows(self, four_taxa_test_case):
         ts = four_taxa_test_case
@@ -7372,58 +7330,8 @@ def test_drop_dimension(self, four_taxa_test_case, mode):
 
     def test_four_taxon_example(self, four_taxa_test_case_afs):
         ts, examples = four_taxa_test_case_afs
-        for k, (params, afs) in enumerate(examples):
-            print(k)
+        for params, afs in examples:
             ts_afs = ts.allele_frequency_spectrum(**params)
             py_afs = allele_frequency_spectrum(ts, **params)
             np.testing.assert_allclose(afs, ts_afs)
             np.testing.assert_allclose(afs, py_afs)
-
-    def test_decap_vs_tw(self):
-        ns = 2
-        time_grid = np.append(np.logspace(2, 5, 11), np.inf)[0:1]
-        ts = msprime.sim_ancestry(
-            ns,
-            recombination_rate=1e-8,
-            sequence_length=1e6,
-            population_size=1e4,
-            random_seed=1,
-        )
-        ts = msprime.sim_mutations(ts, rate=1e-8, random_seed=2)
-        sample_sets = [np.arange(ns), np.arange(ns, 2 * ns)]
-
-        time_grid = np.append(0, time_grid)
-        time_grid = np.append(time_grid, np.inf)
-
-        windows = np.array([0, 0.5, 1]) * ts.sequence_length
-        windows = None
-        test1 = ts.allele_frequency_spectrum(
-            sample_sets=sample_sets,
-            time_windows=time_grid,
-            mode="branch",
-            polarised=True,
-            span_normalise=True,
-            windows=windows,
-        ).cumsum(axis=0)
-
-        test2 = branch_allele_frequency_spectrum(
-            ts,
-            windows=windows,
-            sample_sets=sample_sets,
-            time_windows=time_grid,
-            polarised=True,
-            span_normalise=True,
-        ).cumsum(axis=0)
-
-        # manually calculate twAFS
-        twafs0 = np.zeros((time_grid.size, ns + 1, ns + 1))
-        for i, t in enumerate(time_grid):
-            tsd = ts.decapitate(t) if t < np.inf else ts
-            twafs0[i] = tsd.allele_frequency_spectrum(
-                sample_sets=sample_sets,
-                mode="branch",
-                polarised=True,
-                span_normalise=True,
-            ).squeeze()
-        self.assertArrayAlmostEqual(test1, test2)
-        self.assertArrayAlmostEqual(test2, twafs0[1:])