fix: adapt tests to API changes (#19)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Refactor**
* Pinning and asset caching operations are now asynchronous. Plugin
implementations and callers must use await for these actions.
  * Unified caching/pinning terminology replaces prior archiving usage.

* **Tests**
  * Updated tests to exercise asynchronous pinning and caching flows.
  * Added a dedicated pinning test.
* Simplified environment setup in tests with explicit keyword arguments
for settings, shell executable, temp directories, and prefixes.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: johanneskoester

snakemake_interface_software_deployment_plugins/__init__.py

@@ -247,7 +247,7 @@ class PinnableEnvBase(ABC):
     def pinfile_extension(cls) -> str: ...
 
     @abstractmethod
-    def pin(self) -> None:
+    async def pin(self) -> None:
         """Pin the environment to potentially more concrete versions than defined.
         Only implement this base class if pinning makes sense for your kind of
         environment. Pinfile has to be written to self.pinfile.
@@ -269,7 +269,7 @@ class CacheableEnvBase(ABC):
     async def get_cache_assets(self) -> Iterable[str]: ...
 
     @abstractmethod
-    def cache_assets(self) -> None:
+    async def cache_assets(self) -> None:
         """Determine environment assets and store any associated information or data to
         self.cache_path.
         """

snakemake_interface_software_deployment_plugins/tests.py

@@ -1,18 +1,18 @@
 from abc import ABC, abstractmethod
 import asyncio
 from copy import deepcopy
-import tempfile
 from typing import Optional, Type
 import subprocess as sp
 
 import pytest
 
 from snakemake_interface_software_deployment_plugins import (
-    ArchiveableEnvBase,
+    CacheableEnvBase,
     DeployableEnvBase,
     EnvBase,
     EnvSpecBase,
     EnvSpecSourceFile,
+    PinnableEnvBase,
     SoftwareReport,
 )
 from snakemake_interface_software_deployment_plugins.settings import (
@@ -52,10 +52,22 @@ def get_test_cmd(self) -> str:
         ...
 
     @abstractmethod
-    def get_software_deployment_provider_settings(
+    def get_settings(
         self,
     ) -> Optional[SoftwareDeploymentSettingsBase]: ...
 
+    @abstractmethod
+    def get_settings_cls(self) -> Optional[Type[SoftwareDeploymentSettingsBase]]: ...
+
+    def test_envspec_str(self):
+        print("env spec", str(self.get_env_spec()))
+
+    def test_default_settings(self):
+        settings_cls = self.get_settings_cls()
+        if settings_cls is None:
+            pytest.skip("No settings class defined.")
+        settings_cls()
+
     def test_shellcmd(self, tmp_path):
         env = self._get_env(tmp_path)
 
@@ -80,13 +92,24 @@ def test_deploy(self, tmp_path):
 
     def test_archive(self, tmp_path):
         env = self._get_env(tmp_path)
-        if not isinstance(env, ArchiveableEnvBase):
-            pytest.skip("Environment either not deployable or not archiveable.")
+        if not isinstance(env, CacheableEnvBase):
+            pytest.skip("Environment either not deployable or not cacheable.")
+
+        asyncio.run(env.cache_assets())
 
         self._deploy(env, tmp_path)
 
-        asyncio.run(env.archive())
-        assert any((tmp_path / "archives").iterdir())
+        assert any(env.cache_path.iterdir())
+
+    def test_pin(self, tmp_path):
+        env = self._get_env(tmp_path)
+        if not isinstance(env, PinnableEnvBase):
+            pytest.skip("Environment is not pinnable.")
+
+        asyncio.run(env.pin())
+        assert env.pinfile.exists()
+        print("Pinfile content:", env.pinfile.read_text(), sep="\n")
+        self._deploy(env, tmp_path)
 
     def test_report_software(self, tmp_path):
         env = self._get_env(tmp_path)
@@ -119,16 +142,25 @@ def _get_cached_env_spec(self):
     def _get_env(self, tmp_path) -> EnvBase:
         env_cls = self.get_env_cls()
         spec = self._get_cached_env_spec()
-        args = {
-            "settings": self.get_software_deployment_provider_settings(),
-            "tempdir": tempfile.gettempdir(),
-        }
-        if issubclass(env_cls, DeployableEnvBase):
-            args["deployment_prefix"] = tmp_path / "deployments"
-        if issubclass(env_cls, ArchiveableEnvBase):
-            args["archive_prefix"] = tmp_path / "archives"
+
+        tempdir = tmp_path / "temp"
+        deployment_prefix = tmp_path / "deployments"
+        cache_prefix = tmp_path / "cache"
+        pinfile_prefix = tmp_path / "pinfiles"
+        tempdir.mkdir(parents=True, exist_ok=True)
+        deployment_prefix.mkdir(parents=True, exist_ok=True)
+        cache_prefix.mkdir(parents=True, exist_ok=True)
+        pinfile_prefix.mkdir(parents=True, exist_ok=True)
+
         return env_cls(
-            spec=spec, within=None, shell_executable=self.shell_executable, **args
+            spec=spec,
+            within=None,
+            settings=self.get_settings(),
+            shell_executable=self.shell_executable,
+            tempdir=tempdir,
+            deployment_prefix=deployment_prefix,
+            cache_prefix=cache_prefix,
+            pinfile_prefix=pinfile_prefix,
         )
 
     def _deploy(self, env: DeployableEnvBase, tmp_path):