Merge branch 'main' into fix/missing_test_files

Author: mikemhenry

gufe/tests/test_ligandatommapping.py

@@ -2,7 +2,6 @@
 # For details, see https://github.com/OpenFreeEnergy/gufe
 import importlib
 import json
-import pathlib
 
 import numpy as np
 import pytest
@@ -228,19 +227,18 @@ def test_atommapping_hash(simple_mapping, other_mapping):
     assert simple_mapping is not other_mapping
 
 
-def test_draw_mapping_cairo(tmpdir, simple_mapping):
-    with tmpdir.as_cwd():
-        simple_mapping.draw_to_file("test.png")
-        filed = pathlib.Path("test.png")
-        assert filed.exists()
+def test_draw_mapping_cairo(tmp_path, simple_mapping):
+    fpath = tmp_path / "test.png"
 
+    simple_mapping.draw_to_file(fpath)
+    assert fpath.exists()
 
-def test_draw_mapping_svg(tmpdir, other_mapping):
-    with tmpdir.as_cwd():
-        d2d = Chem.Draw.rdMolDraw2D.MolDraw2DSVG(600, 300, 300, 300)
-        other_mapping.draw_to_file("test.svg", d2d=d2d)
-        filed = pathlib.Path("test.svg")
-        assert filed.exists()
+
+def test_draw_mapping_svg(tmp_path, other_mapping):
+    fpath = tmp_path / "test.svg"
+    d2d = Chem.Draw.rdMolDraw2D.MolDraw2DSVG(600, 300, 300, 300)
+    other_mapping.draw_to_file(fpath, d2d=d2d)
+    assert fpath.exists()
 
 
 class TestLigandAtomMappingSerialization:
@@ -249,23 +247,23 @@ def test_deserialize_roundtrip(self, benzene_phenol_mapping, benzene_anisole_map
 
         assert roundtrip == benzene_phenol_mapping
 
-        # We don't check coordinates since that's already done in guefe for
+        # We don't check coordinates since that's already done in gufe for
         # SmallMoleculeComponent
 
         assert roundtrip != benzene_anisole_mapping
 
-    def test_file_roundtrip(self, benzene_phenol_mapping, tmpdir):
-        with tmpdir.as_cwd():
-            with open("tmpfile.json", "w") as f:
-                f.write(json.dumps(benzene_phenol_mapping.to_dict()))
+    def test_file_roundtrip(self, benzene_phenol_mapping, tmp_path):
+        fpath = tmp_path / "tmpfile.json"
+        with open(fpath, "w") as f:
+            f.write(json.dumps(benzene_phenol_mapping.to_dict()))
 
-            with open("tmpfile.json") as f:
-                d = json.load(f)
+        with open(fpath) as f:
+            d = json.load(f)
 
-            assert isinstance(d, dict)
-            roundtrip = LigandAtomMapping.from_dict(d)
+        assert isinstance(d, dict)
+        roundtrip = LigandAtomMapping.from_dict(d)
 
-            assert roundtrip == benzene_phenol_mapping
+        assert roundtrip == benzene_phenol_mapping
 
 
 def test_annotated_atommapping_hash_eq(simple_mapping, annotated_simple_mapping):

gufe/tests/test_protocol.py

@@ -210,63 +210,62 @@ def instance(self):
         return DummyProtocol(settings=DummyProtocol.default_settings())
 
     @pytest.fixture
-    def protocol_dag(self, solvated_ligand, vacuum_ligand, tmpdir):
+    def protocol_dag(self, solvated_ligand, vacuum_ligand, tmp_path):
         protocol = DummyProtocol(settings=DummyProtocol.default_settings())
         dag = protocol.create(
             stateA=solvated_ligand,
             stateB=vacuum_ligand,
             name="a dummy run",
             mapping=None,
         )
-        with tmpdir.as_cwd():
-            shared = pathlib.Path("shared")
-            shared.mkdir(parents=True)
 
-            scratch = pathlib.Path("scratch")
-            scratch.mkdir(parents=True)
+        shared = pathlib.Path(tmp_path / "shared")
+        shared.mkdir(parents=True)
 
-            stderr = pathlib.Path("stderr")
-            stderr.mkdir(parents=True)
+        scratch = pathlib.Path(tmp_path / "scratch")
+        scratch.mkdir(parents=True)
 
-            stdout = pathlib.Path("stdout")
-            stdout.mkdir(parents=True)
+        stderr = pathlib.Path(tmp_path / "stderr")
+        stderr.mkdir(parents=True)
 
-            dagresult: ProtocolDAGResult = execute_DAG(
-                dag, shared_basedir=shared, scratch_basedir=scratch, stderr_basedir=stderr, stdout_basedir=stdout
-            )
+        stdout = pathlib.Path(tmp_path / "stdout")
+        stdout.mkdir(parents=True)
+
+        dagresult: ProtocolDAGResult = execute_DAG(
+            dag, shared_basedir=shared, scratch_basedir=scratch, stderr_basedir=stderr, stdout_basedir=stdout
+        )
 
         return protocol, dag, dagresult
 
     @pytest.fixture
-    def protocol_dag_broken(self, solvated_ligand, vacuum_ligand, tmpdir):
+    def protocol_dag_broken(self, solvated_ligand, vacuum_ligand, tmp_path):
         protocol = BrokenProtocol(settings=BrokenProtocol.default_settings())
         dag = protocol.create(
             stateA=solvated_ligand,
             stateB=vacuum_ligand,
             name="a broken dummy run",
             mapping=None,
         )
-        with tmpdir.as_cwd():
-            shared = pathlib.Path("shared")
-            shared.mkdir(parents=True)
+        shared = pathlib.Path(tmp_path / "shared")
+        shared.mkdir(parents=True)
 
-            scratch = pathlib.Path("scratch")
-            scratch.mkdir(parents=True)
+        scratch = pathlib.Path(tmp_path / "scratch")
+        scratch.mkdir(parents=True)
 
-            stderr = pathlib.Path("stderr")
-            stderr.mkdir(parents=True)
+        stderr = pathlib.Path(tmp_path / "stderr")
+        stderr.mkdir(parents=True)
 
-            stdout = pathlib.Path("stdout")
-            stdout.mkdir(parents=True)
+        stdout = pathlib.Path(tmp_path / "stdout")
+        stdout.mkdir(parents=True)
 
-            dagfailure: ProtocolDAGResult = execute_DAG(
-                dag,
-                shared_basedir=shared,
-                scratch_basedir=scratch,
-                stderr_basedir=stderr,
-                stdout_basedir=stdout,
-                raise_error=False,
-            )
+        dagfailure: ProtocolDAGResult = execute_DAG(
+            dag,
+            shared_basedir=shared,
+            scratch_basedir=scratch,
+            stderr_basedir=stderr,
+            stdout_basedir=stdout,
+            raise_error=False,
+        )
 
         return protocol, dag, dagfailure
 
@@ -381,28 +380,27 @@ def test_dag_execute_failure(self, protocol_dag_broken):
 
         assert len(succeeded_units) > 0
 
-    def test_dag_execute_failure_raise_error(self, solvated_ligand, vacuum_ligand, tmpdir):
+    def test_dag_execute_failure_raise_error(self, solvated_ligand, vacuum_ligand, tmp_path):
         protocol = BrokenProtocol(settings=BrokenProtocol.default_settings())
         dag = protocol.create(
             stateA=solvated_ligand,
             stateB=vacuum_ligand,
             name="a broken dummy run",
             mapping=None,
         )
-        with tmpdir.as_cwd():
-            shared = pathlib.Path("shared")
-            shared.mkdir(parents=True)
-
-            scratch = pathlib.Path("scratch")
-            scratch.mkdir(parents=True)
-
-            with pytest.raises(ValueError, match="I have failed my mission"):
-                execute_DAG(
-                    dag,
-                    shared_basedir=shared,
-                    scratch_basedir=scratch,
-                    raise_error=True,
-                )
+        shared = pathlib.Path(tmp_path / "shared")
+        shared.mkdir(parents=True)
+
+        scratch = pathlib.Path(tmp_path / "scratch")
+        scratch.mkdir(parents=True)
+
+        with pytest.raises(ValueError, match="I have failed my mission"):
+            execute_DAG(
+                dag,
+                shared_basedir=shared,
+                scratch_basedir=scratch,
+                raise_error=True,
+            )
 
     def test_create_execute_gather(self, protocol_dag):
         protocol, dag, dagresult = protocol_dag
@@ -651,15 +649,14 @@ def dag(self, protocol):
     def test_create(self, dag):
         assert len(dag.protocol_units) == 3
 
-    def test_gather(self, protocol, dag, tmpdir):
-        with tmpdir.as_cwd():
-            shared = pathlib.Path("shared")
-            shared.mkdir(parents=True)
+    def test_gather(self, protocol, dag, tmp_path):
+        shared = pathlib.Path(tmp_path / "shared")
+        shared.mkdir(parents=True)
 
-            scratch = pathlib.Path("scratch")
-            scratch.mkdir(parents=True)
+        scratch = pathlib.Path(tmp_path / "scratch")
+        scratch.mkdir(parents=True)
 
-            dag_result = execute_DAG(dag, shared_basedir=shared, scratch_basedir=scratch)
+        dag_result = execute_DAG(dag, shared_basedir=shared, scratch_basedir=scratch)
 
         assert dag_result.ok()
 
@@ -668,16 +665,15 @@ def test_gather(self, protocol, dag, tmpdir):
         assert result.get_estimate() == 0 + 1 + 4
         assert result.get_uncertainty() == 3
 
-    def test_terminal_units(self, protocol, dag, tmpdir):
-        with tmpdir.as_cwd():
-            shared = pathlib.Path("shared")
-            shared.mkdir(parents=True)
+    def test_terminal_units(self, protocol, dag, tmp_path):
+        shared = pathlib.Path(tmp_path / "shared")
+        shared.mkdir(parents=True)
 
-            scratch = pathlib.Path("scratch")
-            scratch.mkdir(parents=True)
+        scratch = pathlib.Path(tmp_path / "scratch")
+        scratch.mkdir(parents=True)
 
-            # we have no dependencies, so this should be all three Unit results
-            dag_result = execute_DAG(dag, shared_basedir=shared, scratch_basedir=scratch)
+        # we have no dependencies, so this should be all three Unit results
+        dag_result = execute_DAG(dag, shared_basedir=shared, scratch_basedir=scratch)
 
         terminal_results = dag_result.terminal_protocol_unit_results
 
@@ -798,67 +794,65 @@ def test_foreign_objects(self, units, successes):
             dagresult.result_to_unit(successes[2])
 
 
-def test_execute_DAG_retries(solvated_ligand, vacuum_ligand, tmpdir):
+def test_execute_DAG_retries(solvated_ligand, vacuum_ligand, tmp_path):
     protocol = BrokenProtocol(settings=BrokenProtocol.default_settings())
     dag = protocol.create(
         stateA=solvated_ligand,
         stateB=vacuum_ligand,
         mapping=None,
     )
 
-    with tmpdir.as_cwd():
-        shared = pathlib.Path("shared")
-        shared.mkdir(parents=True)
-        scratch = pathlib.Path("scratch")
-        scratch.mkdir(parents=True)
-
-        r = execute_DAG(
-            dag,
-            shared_basedir=shared,
-            scratch_basedir=scratch,
-            keep_shared=True,
-            keep_scratch=True,
-            raise_error=False,
-            n_retries=3,
-        )
+    shared = pathlib.Path(tmp_path / "shared")
+    shared.mkdir(parents=True)
+    scratch = pathlib.Path(tmp_path / "scratch")
+    scratch.mkdir(parents=True)
+
+    r = execute_DAG(
+        dag,
+        shared_basedir=shared,
+        scratch_basedir=scratch,
+        keep_shared=True,
+        keep_scratch=True,
+        raise_error=False,
+        n_retries=3,
+    )
 
-        assert not r.ok()
+    assert not r.ok()
 
-        number_unit_failures = len(r.protocol_unit_failures)
-        number_unit_results = len(r.protocol_unit_results)
-        number_dirs = len(list(shared.iterdir()))
+    number_unit_failures = len(r.protocol_unit_failures)
+    number_unit_results = len(r.protocol_unit_results)
+    number_dirs = len(list(shared.iterdir()))
 
-        # failed first attempt of BrokenSimulationUnit, failed 3 retries
-        assert number_unit_failures == 4
-        # InitializeUnit and 21 SimulationUnits run before guaranteed
-        # final failure
-        assert number_unit_results == number_dirs == 26
+    # failed first attempt of BrokenSimulationUnit, failed 3 retries
+    assert number_unit_failures == 4
+    # InitializeUnit and 21 SimulationUnits run before guaranteed
+    # final failure
+    assert number_unit_results == number_dirs == 26
 
 
-def test_execute_DAG_bad_nretries(solvated_ligand, vacuum_ligand, tmpdir):
+def test_execute_DAG_bad_nretries(solvated_ligand, vacuum_ligand, tmp_path):
     protocol = BrokenProtocol(settings=BrokenProtocol.default_settings())
     dag = protocol.create(
         stateA=solvated_ligand,
         stateB=vacuum_ligand,
         mapping=None,
     )
 
-    with tmpdir.as_cwd():
-        shared = pathlib.Path("shared")
-        shared.mkdir(parents=True)
-        scratch = pathlib.Path("scratch")
-        scratch.mkdir(parents=True)
+    shared = pathlib.Path(tmp_path / "shared")
+    shared.mkdir(parents=True)
+    scratch = pathlib.Path(tmp_path / "scratch")
+    scratch.mkdir(parents=True)
 
-        with pytest.raises(ValueError):
-            r = execute_DAG(
-                dag,
-                shared_basedir=shared,
-                scratch_basedir=scratch,
-                keep_shared=True,
-                keep_scratch=True,
-                raise_error=False,
-                n_retries=-1,
-            )
+    with pytest.raises(ValueError):
+        r = execute_DAG(
+            dag,
+            shared_basedir=shared,
+            scratch_basedir=scratch,
+            keep_shared=True,
+            keep_scratch=True,
+            raise_error=False,
+            n_retries=-1,
+        )
 
 
 def test_settings_readonly():