Merge branch 'kzscisoft/fix-folder-deletion-inconsistencies' into kzscisoft/test-fixes

Author: kzscisoft

poetry.lock

@@ -412,6 +412,10 @@ def get(
                     f"Expected key 'data' for retrieval of {_class_instance.__class__.__name__.lower()}s"
                 )
 
+            # If data is an empty list
+            if not _data:
+                return
+
             for entry in _data:
                 _id = entry["id"]
                 yield _id, cls(_read_only=True, identifier=_id, _local=True, **entry)

simvue/api/objects/base.py

@@ -32,7 +32,16 @@
 from .models import FOLDER_REGEX, NAME_REGEX
 from .config.user import SimvueConfiguration
 from .api.request import get_json_from_response
-from .api.objects import Run, Folder, Tag, Artifact, Alert, FileArtifact, ObjectArtifact
+from .api.objects import (
+    Run,
+    Folder,
+    Tag,
+    Artifact,
+    Alert,
+    FileArtifact,
+    ObjectArtifact,
+    get_folder_from_path,
+)
 
 
 CONCURRENT_DOWNLOADS = 10
@@ -429,6 +438,9 @@ def delete_folder(
             delete_runs=remove_runs, recursive=recursive, runs_only=False
         )
 
+        if folder_path not in _response.get("folders", []):
+            raise RuntimeError("Deletion of folder failed, server returned mismatch.")
+
         return _response.get("runs", [])
 
     @prettify_pydantic
@@ -665,17 +677,12 @@ def get_folder(
         RuntimeError
             if there was a failure when retrieving information from the server
         """
-        _folders: typing.Generator[tuple[str, Folder], None, None] = Folder.get(
-            filters=json.dumps([f"path == {folder_path}"])
-        )  # type: ignore
-
         try:
-            _, _folder = next(_folders)
-            if not read_only:
-                _folder.read_only(read_only)
-            return _folder
-        except StopIteration:
+            _folder = get_folder_from_path(path=folder_path)
+        except ObjectNotFoundError:
             return None
+        _folder.read_only(is_read_only=read_only)
+        return _folder
 
     @pydantic.validate_call
     def get_folders(

simvue/client.py

@@ -756,7 +756,7 @@ def init(
 
         if self._user_config.run.mode == "online":
             click.secho(
-                f"[simvue] Run {self._sv_obj.name} created",
+                f"[simvue] Run {self.name} created",
                 bold=self._term_color,
                 fg="green" if self._term_color else None,
             )

simvue/run.py

@@ -186,7 +186,7 @@ def create_plain_run_offline(request,prevent_script_exit,monkeypatch) -> typing.
     clear_out_files()
 
 
-@pytest.fixture
+@pytest.fixture(scope="function")
 def create_run_object(mocker: pytest_mock.MockFixture) -> sv_api_obj.Run:
     def testing_exit(status: int) -> None:
         raise SystemExit(status)

tests/conftest.py

@@ -15,6 +15,7 @@
 import simvue.api.objects as sv_api_obj
 from simvue.api.objects.alert.base import AlertBase
 
+
 @pytest.mark.dependency
 @pytest.mark.client
 def test_get_events(create_test_run: tuple[sv_run.Run, dict]) -> None:
@@ -24,12 +25,8 @@ def test_get_events(create_test_run: tuple[sv_run.Run, dict]) -> None:
 
 @pytest.mark.dependency
 @pytest.mark.client
-@pytest.mark.parametrize(
-    "from_run", (True, False), ids=("from_run", "all_runs")
-)
-@pytest.mark.parametrize(
-    "names_only", (True, False), ids=("names_only", "all_details")
-)
+@pytest.mark.parametrize("from_run", (True, False), ids=("from_run", "all_runs"))
+@pytest.mark.parametrize("names_only", (True, False), ids=("names_only", "all_details"))
 @pytest.mark.parametrize(
     "critical_only", (True, False), ids=("critical_only", "all_states")
 )
@@ -43,42 +40,44 @@ def test_get_alerts(
     run_id = run.id
     unique_id = f"{uuid.uuid4()}".split("-")[0]
     _id_1 = run.create_user_alert(
-        name=f"user_alert_1_{unique_id}", 
+        name=f"user_alert_1_{unique_id}",
     )
     run.create_user_alert(
-        name=f"user_alert_2_{unique_id}", 
-    )
-    run.create_user_alert(
-        name=f"user_alert_3_{unique_id}",
-        attach_to_run=False
+        name=f"user_alert_2_{unique_id}",
     )
+    run.create_user_alert(name=f"user_alert_3_{unique_id}", attach_to_run=False)
     run.log_alert(identifier=_id_1, state="critical")
     time.sleep(2)
     run.close()
-    
+
     client = svc.Client()
 
     if critical_only and not from_run:
         with pytest.raises(RuntimeError) as e:
-            _alerts = client.get_alerts(critical_only=critical_only, names_only=names_only)
-        assert "critical_only is ambiguous when returning alerts with no run ID specified." in str(e.value)
+            _alerts = client.get_alerts(
+                critical_only=critical_only, names_only=names_only
+            )
+        assert (
+            "critical_only is ambiguous when returning alerts with no run ID specified."
+            in str(e.value)
+        )
     else:
         sorting = None if run_id else [("name", True), ("created", True)]
         _alerts = client.get_alerts(
             run_id=run_id if from_run else None,
             critical_only=critical_only,
             names_only=names_only,
-            sort_by_columns=sorting
+            sort_by_columns=sorting,
         )
-    
+
         if names_only:
             assert all(isinstance(item, str) for item in _alerts)
         else:
-            assert all(isinstance(item, AlertBase) for item in _alerts)            
+            assert all(isinstance(item, AlertBase) for item in _alerts)
             _alerts = [alert.name for alert in _alerts]
-            
+
         assert f"user_alert_1_{unique_id}" in _alerts
-            
+
         if not from_run:
             assert len(_alerts) > 2
             assert f"user_alert_3_{unique_id}" in _alerts
@@ -90,6 +89,7 @@ def test_get_alerts(
                 assert len(_alerts) == 2
                 assert f"user_alert_2_{unique_id}" in _alerts
 
+
 @pytest.mark.dependency
 @pytest.mark.client
 def test_get_run_id_from_name(create_test_run: tuple[sv_run.Run, dict]) -> None:
@@ -104,12 +104,8 @@ def test_get_run_id_from_name(create_test_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.client
 @pytest.mark.parametrize(
     "aggregate,use_name_labels",
-    [
-        (True, False),
-        (False, False),
-        (False, True)
-    ],
-    ids=("aggregate", "complete_ids", "complete_labels")
+    [(True, False), (False, False), (False, True)],
+    ids=("aggregate", "complete_ids", "complete_labels"),
 )
 def test_get_metric_values(
     create_test_run: tuple[sv_run.Run, dict], aggregate: bool, use_name_labels: bool
@@ -130,9 +126,9 @@ def test_get_metric_values(
     assert create_test_run[1]["metrics"][0] in _metrics_dict.keys()
     if aggregate:
         _value_types = {i[1] for i in _first_entry}
-        assert all(
-            i in _value_types for i in ("average", "min", "max")
-        ), f"Expected ('average', 'min', 'max') in {_value_types}"
+        assert all(i in _value_types for i in ("average", "min", "max")), (
+            f"Expected ('average', 'min', 'max') in {_value_types}"
+        )
     elif not use_name_labels:
         _runs = {i[1] for i in _first_entry}
         assert create_test_run[1]["run_id"] in _runs
@@ -157,12 +153,17 @@ def test_plot_metrics(create_test_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.dependency
 @pytest.mark.client
 @pytest.mark.parametrize(
-    "sorting", ([("metadata.test_identifier", True)], [("name", True), ("created", True)], None),
-    ids=("sorted-metadata", "sorted-name-created", None)
+    "sorting",
+    ([("metadata.test_identifier", True)], [("name", True), ("created", True)], None),
+    ids=("sorted-metadata", "sorted-name-created", None),
 )
-def test_get_artifacts_entries(create_test_run: tuple[sv_run.Run, dict], sorting: list[tuple[str, bool]] | None) -> None:
+def test_get_artifacts_entries(
+    create_test_run: tuple[sv_run.Run, dict], sorting: list[tuple[str, bool]] | None
+) -> None:
     client = svc.Client()
-    assert dict(client.list_artifacts(create_test_run[1]["run_id"], sort_by_columns=sorting))
+    assert dict(
+        client.list_artifacts(create_test_run[1]["run_id"], sort_by_columns=sorting)
+    )
     assert client.get_artifact(create_test_run[1]["run_id"], name="test_attributes")
 
 
@@ -180,7 +181,9 @@ def test_get_artifact_as_file(
             name=_file_name,
             output_dir=tempd,
         )
-        assert pathlib.Path(tempd).joinpath(_file_name).exists(), f"Failed to download '{_file_name}'"
+        assert pathlib.Path(tempd).joinpath(_file_name).exists(), (
+            f"Failed to download '{_file_name}'"
+        )
 
 
 @pytest.mark.dependency
@@ -196,7 +199,7 @@ def test_get_artifacts_as_files(
             create_test_run[1]["run_id"], category=category, output_dir=tempd
         )
         files = [os.path.basename(i) for i in glob.glob(os.path.join(tempd, "*"))]
-        
+
         if not category:
             expected_files = ["file_1", "file_2", "file_3"]
         elif category == "input":
@@ -205,7 +208,7 @@ def test_get_artifacts_as_files(
             expected_files = ["file_2"]
         elif category == "code":
             expected_files = ["file_3"]
-            
+
         for file in ["file_1", "file_2", "file_3"]:
             if file in expected_files:
                 assert create_test_run[1][file] in files
@@ -222,12 +225,18 @@ def test_get_artifacts_as_files(
         ("dataframe", [("created", True), ("started", True)]),
         ("objects", [("metadata.test_identifier", True)]),
     ],
-    ids=("dict-unsorted", "dataframe-datesorted", "objects-metasorted")
+    ids=("dict-unsorted", "dataframe-datesorted", "objects-metasorted"),
 )
-def test_get_runs(create_test_run: tuple[sv_run.Run, dict], output_format: str, sorting: list[tuple[str, bool]] | None) -> None:
+def test_get_runs(
+    create_test_run: tuple[sv_run.Run, dict],
+    output_format: str,
+    sorting: list[tuple[str, bool]] | None,
+) -> None:
     client = svc.Client()
 
-    _result = client.get_runs(filters=[], output_format=output_format, count_limit=10, sort_by_columns=sorting)
+    _result = client.get_runs(
+        filters=[], output_format=output_format, count_limit=10, sort_by_columns=sorting
+    )
 
     if output_format == "dataframe":
         assert not _result.empty
@@ -245,10 +254,13 @@ def test_get_run(create_test_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.dependency
 @pytest.mark.client
 @pytest.mark.parametrize(
-    "sorting", (None, [("metadata.test_identifier", True), ("path", True)], [("modified", False)]),
-    ids=("no-sort", "sort-path-metadata", "sort-modified")
+    "sorting",
+    (None, [("metadata.test_identifier", True), ("path", True)], [("modified", False)]),
+    ids=("no-sort", "sort-path-metadata", "sort-modified"),
 )
-def test_get_folders(create_test_run: tuple[sv_run.Run, dict], sorting: list[tuple[str, bool]] | None) -> None:
+def test_get_folders(
+    create_test_run: tuple[sv_run.Run, dict], sorting: list[tuple[str, bool]] | None
+) -> None:
     client = svc.Client()
     assert (folders := client.get_folders(sort_by_columns=sorting))
     _id, _folder = next(folders)
@@ -277,7 +289,12 @@ def test_get_tag(create_plain_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.client
 def test_run_deletion() -> None:
     run = sv_run.Run()
-    run.init(name="test_run_deletion", folder="/simvue_unit_testing", tags=["test_run_deletion"], retention_period="1 min")
+    run.init(
+        name="test_run_deletion",
+        folder="/simvue_unit_testing",
+        tags=["test_run_deletion"],
+        retention_period="1 min",
+    )
     run.log_metrics({"x": 2})
     run.close()
     client = svc.Client()
@@ -291,13 +308,18 @@ def test_run_deletion() -> None:
 def test_runs_deletion() -> None:
     _runs = [sv_run.Run() for _ in range(5)]
     for i, run in enumerate(_runs):
-        run.init(name="test_runs_deletion", folder="/simvue_unit_testing/runs_batch", tags=["test_runs_deletion"], retention_period="1 min")
+        run.init(
+            name="test_runs_deletion",
+            folder="/simvue_unit_testing/runs_batch",
+            tags=["test_runs_deletion"],
+            retention_period="1 min",
+        )
         run.log_metrics({"x": i})
     client = svc.Client()
     assert len(client.delete_runs("/simvue_unit_testing/runs_batch")) > 0
     for run in _runs:
         with pytest.raises(ObjectNotFoundError):
-            client.get_run(run.id) 
+            client.get_run(run.id)
 
 
 @pytest.mark.dependency
@@ -316,11 +338,24 @@ def test_get_tags(create_plain_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.client
 def test_folder_deletion() -> None:
     run = sv_run.Run()
-    run.init(name="test_folder_deletion", folder="/simvue_unit_testing/delete_me", tags=["test_folder_deletion"], retention_period="1 min")
+    _temp_folder_id: str = f"{uuid.uuid4()}".split()[0]
+    run.init(
+        name="test_folder_deletion",
+        folder=f"/simvue_unit_testing/{_temp_folder_id}",
+        tags=["test_folder_deletion"],
+        retention_period="1 min",
+    )
     run.close()
     client = svc.Client()
     # This test is called last, one run created so expect length 1
-    assert len(client.delete_folder("/simvue_unit_testing/delete_me", remove_runs=True)) == 1
+    assert (
+        len(
+            client.delete_folder(
+                f"/simvue_unit_testing/{_temp_folder_id}", remove_runs=True
+            )
+        )
+        == 1
+    )
     time.sleep(10)
     with pytest.raises(ObjectNotFoundError):
         client.get_folder("/simvue_unit_testing/delete_me")
@@ -332,19 +367,24 @@ def test_folder_deletion() -> None:
 def test_run_folder_metadata_find(create_plain_run: tuple[sv_run.Run, dict]) -> None:
     run, run_data = create_plain_run
     rand_val = random.randint(0, 1000)
-    run.set_folder_details(metadata={'atest': rand_val})
+    run.set_folder_details(metadata={"atest": rand_val})
     run.close()
     time.sleep(1.0)
     client = svc.Client()
-    data = client.get_folders(filters=[f'metadata.atest == {rand_val}'])
+    data = client.get_folders(filters=[f"metadata.atest == {rand_val}"])
 
     assert run_data["folder"] in [i.path for _, i in data]
 
 
 @pytest.mark.client
 def test_tag_deletion() -> None:
     run = sv_run.Run()
-    run.init(name="test_folder_deletion", folder="/simvue_unit_testing/delete_me", tags=["test_tag_deletion"], retention_period="1 min")
+    run.init(
+        name="test_folder_deletion",
+        folder="/simvue_unit_testing",
+        tags=["test_tag_deletion"],
+        retention_period="1 min",
+    )
     run.close()
     unique_id = f"{uuid.uuid4()}".split("-")[0]
     run.update_tags([(tag_str := f"delete_me_{unique_id}")])
@@ -398,7 +438,9 @@ def test_multiple_metric_retrieval(
 
 @pytest.mark.client
 def test_alert_deletion() -> None:
-    _alert = sv_api_obj.UserAlert.new(name="test_alert", notification="none", description=None)
+    _alert = sv_api_obj.UserAlert.new(
+        name="test_alert", notification="none", description=None
+    )
     _alert.commit()
     _client = svc.Client()
     _client.delete_alert(alert_id=_alert.id)
@@ -422,5 +464,3 @@ def test_abort_run(speedy_heartbeat, create_plain_run: tuple[sv_run.Run, dict])
     except AssertionError:
         time.sleep(2)
         assert run._status == "terminated"
-
-