test fixes

Author: wpbonelli

autotest/test_models.py

@@ -22,7 +22,6 @@
 PROJ_ROOT = Path(__file__).parents[1]
 MODELS_PATH = PROJ_ROOT / "modflow_devtools" / "registry" / "models.toml"
 MODELS = tomli.load(MODELS_PATH.open("rb"))
-REGISTRY = models.DEFAULT_REGISTRY
 
 # V2 test configuration (dynamic registry)
 # Loaded from .env file via pytest-dotenv plugin
@@ -37,42 +36,58 @@
 # ============================================================================
 
 
-def test_files():
-    files = models.get_files()
+@pytest.fixture(scope="module")
+def bundled_registry():
+    """
+    Create a fresh PoochRegistry from bundled files (ignoring cache).
+
+    This ensures v1 tests use the actual bundled registry, not the v2 cache.
+    """
+    # Temporarily clear cache to force loading from bundled files
+    cache.clear_registry_cache()
+
+    # Create fresh registry with default base_url - it will load from bundled files
+    # Use same base_url as DEFAULT_REGISTRY
+    base_url = (
+        "https://github.com/MODFLOW-ORG/modflow6-examples/releases/download/current/"
+    )
+    registry = models.PoochRegistry(base_url=base_url)
+
+    # Cache may be populated during test runs, that's OK
+    return registry
+
+
+def test_files(bundled_registry):
+    files = bundled_registry.files
     assert files is not None, "Files not loaded"
-    assert files is REGISTRY.files
     assert any(files), "Registry is empty"
 
 
 @pytest.mark.parametrize("model_name, files", MODELS.items(), ids=list(MODELS.keys()))
-def test_models(model_name, files):
-    model_names = list(models.get_models().keys())
+def test_models(bundled_registry, model_name, files):
+    model_names = list(bundled_registry.models.keys())
     assert model_name in model_names, f"Model {model_name} not found in model map"
-    assert files == REGISTRY.models[model_name], (
+    assert files == bundled_registry.models[model_name], (
         f"Files for model {model_name} do not match"
     )
     if "mf6" in model_name:
         assert any(Path(f).name == "mfsim.nam" for f in files)
 
 
-@pytest.mark.parametrize(
-    "example_name, model_names",
-    models.get_examples().items(),
-    ids=list(models.get_examples().keys()),
-)
-def test_examples(example_name, model_names):
-    assert example_name in models.get_examples()
-    for model_name in model_names:
-        assert model_name in REGISTRY.models
+def test_examples(bundled_registry):
+    """Test that examples are loaded from bundled registry."""
+    # Note: bundled registry uses models.toml which doesn't have examples section
+    # This test just verifies the examples dict exists
+    assert bundled_registry.examples is not None
 
 
 @pytest.mark.parametrize(
     "model_name, files",
     list(islice(MODELS.items(), TAKE)),
     ids=list(MODELS.keys())[:TAKE],
 )
-def test_copy_to(model_name, files, tmp_path):
-    workspace = models.copy_to(tmp_path, model_name, verbose=True)
+def test_copy_to(bundled_registry, model_name, files, tmp_path):
+    workspace = bundled_registry.copy_to(tmp_path, model_name, verbose=True)
     assert workspace.exists(), f"Model {model_name} was not copied to {tmp_path}"
     assert workspace.is_dir(), f"Model {model_name} is not a directory"
     found = [p for p in workspace.rglob("*") if p.is_file()]
@@ -293,14 +308,20 @@ class TestCache:
     def test_get_cache_root(self):
         """Test getting cache root directory."""
         cache_root = cache.get_cache_root()
-        assert cache_root.name == "modflow-devtools"
+        # Should contain modflow-devtools somewhere in the path
+        assert "modflow-devtools" in str(cache_root)
         # Should be in user's cache directory (platform-specific)
         assert "cache" in str(cache_root).lower() or "caches" in str(cache_root).lower()
 
     def test_get_registry_cache_dir(self):
         """Test getting registry cache directory for a source/ref."""
         cache_dir = cache.get_registry_cache_dir(TEST_SOURCE_NAME, TEST_REF)
-        assert TEST_SOURCE_NAME.replace("/", "-") in str(cache_dir)
+        # Normalize path separators for comparison (Windows uses \, Unix uses /)
+        cache_dir_str = str(cache_dir).replace("\\", "/")
+        assert (
+            TEST_SOURCE_NAME in cache_dir_str
+            or TEST_SOURCE_NAME.replace("/", "-") in cache_dir_str
+        )
         assert TEST_REF in str(cache_dir)
         assert "registries" in str(cache_dir)
 

modflow_devtools/models/schema.py

@@ -69,9 +69,9 @@ def sync(
         from .sync import sync_registry
 
         return sync_registry(
-            source=self.name,
+            source=self,
             ref=ref,
-            repo=repo or self.repo,
+            repo=repo,
             force=force,
             verbose=verbose,
         )

modflow_devtools/models/sync.py

@@ -6,6 +6,7 @@
 
 from .cache import cache_registry, is_registry_cached, list_cached_registries
 from .discovery import RegistryDiscoveryError, discover_registry, load_bootstrap
+from .schema import BootstrapSource
 
 
 class SyncResult:
@@ -25,7 +26,7 @@ def __repr__(self) -> str:
 
 
 def sync_registry(
-    source: str | None = None,
+    source: str | BootstrapSource | None = None,
     ref: str | None = None,
     repo: str | None = None,
     force: bool = False,
@@ -37,8 +38,9 @@ def sync_registry(
 
     Parameters
     ----------
-    source : str | None
-        Specific source to sync. If None, syncs all sources from bootstrap.
+    source : str | BootstrapSource | None
+        Specific source to sync. Can be a source name (string) to look up in bootstrap,
+        or a BootstrapSource object directly. If None, syncs all sources from bootstrap.
     ref : str | None
         Specific ref to sync. If None, syncs all refs from bootstrap for the source(s).
     repo : str | None
@@ -82,20 +84,30 @@ def sync_registry(
         raise ValueError("Cannot specify 'repo' without specifying 'source'")
 
     result = SyncResult()
-    bootstrap = load_bootstrap(bootstrap_path)
 
     # Determine which sources to sync
     if source:
-        if source not in bootstrap.sources:
-            raise ValueError(f"Source '{source}' not found in bootstrap")
-        source_meta = bootstrap.sources[source]
-
-        # Override repo if provided
-        if repo:
-            source_meta = source_meta.model_copy(update={"repo": repo})
-
-        sources_to_sync = {source: source_meta}
+        # Handle BootstrapSource object directly
+        if isinstance(source, BootstrapSource):
+            source_meta = source
+            # Override repo if provided
+            if repo:
+                source_meta = source_meta.model_copy(update={"repo": repo})
+            # Use a dummy key for the dict (will use source_meta.name later)
+            sources_to_sync = {source_meta.name: source_meta}
+        # Handle source name (string) - look up in bootstrap
+        else:
+            bootstrap = load_bootstrap(bootstrap_path)
+            if source not in bootstrap.sources:
+                raise ValueError(f"Source '{source}' not found in bootstrap")
+            source_meta = bootstrap.sources[source]
+            # Override repo if provided
+            if repo:
+                source_meta = source_meta.model_copy(update={"repo": repo})
+            sources_to_sync = {source: source_meta}
     else:
+        # No source specified - sync all sources from bootstrap
+        bootstrap = load_bootstrap(bootstrap_path)
         sources_to_sync = bootstrap.sources
 
     # Sync each source/ref combination
@@ -138,17 +150,19 @@ def sync_registry(
                 cache_registry(discovered.registry, source_name, ref_name)
 
                 if verbose:
-                    print(f"  ✓ Synced {source_name}@{ref_name}")
+                    print(f"  [+] Synced {source_name}@{ref_name}")
 
                 result.synced.append((source_name, ref_name))
 
             except RegistryDiscoveryError as e:
                 if verbose:
-                    print(f"  ✗ Failed to sync {source_name}@{ref_name}: {e}")
+                    print(f"  [-] Failed to sync {source_name}@{ref_name}: {e}")
                 result.failed.append((source_name, ref_name, str(e)))
             except Exception as e:
                 if verbose:
-                    print(f"  ✗ Unexpected error syncing {source_name}@{ref_name}: {e}")
+                    print(
+                        f"  [-] Unexpected error syncing {source_name}@{ref_name}: {e}"
+                    )
                 result.failed.append((source_name, ref_name, str(e)))
 
     return result