roms-tools 2.4.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

roms_tools/tests/test_analysis/test_roms_output.py

@@ -7,6 +7,11 @@ from datetime import datetime
 from roms_tools import Grid, ROMSOutput
 from roms_tools.download import download_test_data
 
+try:
+    import xesmf  # type: ignore
+except ImportError:
+    xesmf = None
+
 
 @pytest.fixture
 def roms_output_from_restart_file(use_dask):
@@ -18,28 +23,36 @@ def roms_output_from_restart_file(use_dask):
     return ROMSOutput(
         grid=grid,
         path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
-        type="restart",
         use_dask=use_dask,
     )
 
 
-def test_load_model_output_file(roms_output_from_restart_file, use_dask):
-
-    assert isinstance(roms_output_from_restart_file.ds, xr.Dataset)
-
+@pytest.fixture
+def roms_output_from_restart_file_adjusted_for_zeta(use_dask):
 
-def test_load_model_output_directory(use_dask):
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
 
-    # Download at least two files, so these will be found within the pooch directory
-    _ = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
-    _ = Path(download_test_data("eastpac25km_rst.19980126000000.nc"))
+    # Single file
+    return ROMSOutput(
+        grid=grid,
+        path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+        adjust_depth_for_sea_surface_height=True,
+        use_dask=use_dask,
+    )
 
-    # Directory
-    directory = os.path.dirname(download_test_data("eastpac25km_rst.19980106000000.nc"))
-    output = ROMSOutput(grid=grid, path=directory, type="restart", use_dask=use_dask)
-    assert isinstance(output.ds, xr.Dataset)
+
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+    ],
+)
+def test_load_model_output_file(roms_output_fixture, use_dask, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
+
+    assert isinstance(roms_output.ds, xr.Dataset)
 
 
 def test_load_model_output_file_list(use_dask):
@@ -49,24 +62,23 @@ def test_load_model_output_file_list(use_dask):
     # List of files
     file1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
     file2 = Path(download_test_data("eastpac25km_rst.19980126000000.nc"))
-    output = ROMSOutput(
-        grid=grid, path=[file1, file2], type="restart", use_dask=use_dask
-    )
+    output = ROMSOutput(grid=grid, path=[file1, file2], use_dask=use_dask)
     assert isinstance(output.ds, xr.Dataset)
 
 
-def test_invalid_type(use_dask):
+def test_load_model_output_with_wildcard(use_dask):
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
 
-    # Invalid type
-    with pytest.raises(ValueError, match="Invalid type 'invalid_type'"):
-        ROMSOutput(
-            grid=grid,
-            path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
-            type="invalid_type",
-            use_dask=use_dask,
-        )
+    # Download at least two files, so these will be found within the pooch directory
+    Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    Path(download_test_data("eastpac25km_rst.19980126000000.nc"))
+    directory = Path(
+        os.path.dirname(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    )
+
+    output = ROMSOutput(grid=grid, path=directory / "*rst*.nc", use_dask=use_dask)
+    assert isinstance(output.ds, xr.Dataset)
 
 
 def test_invalid_path(use_dask):
@@ -78,16 +90,6 @@ def test_invalid_path(use_dask):
         ROMSOutput(
             grid=grid,
             path=Path("/path/to/nonexistent/file.nc"),
-            type="restart",
-            use_dask=use_dask,
-        )
-
-    # Non-existent directory
-    with pytest.raises(FileNotFoundError):
-        ROMSOutput(
-            grid=grid,
-            path=Path("/path/to/nonexistent/directory"),
-            type="restart",
             use_dask=use_dask,
         )
 
@@ -99,7 +101,6 @@ def test_set_correct_model_reference_date(use_dask):
     output = ROMSOutput(
         grid=grid,
         path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
-        type="restart",
         use_dask=use_dask,
     )
     assert output.model_reference_date == datetime(1995, 1, 1)
@@ -117,7 +118,6 @@ def test_model_reference_date_mismatch(use_dask):
         ROMSOutput(
             grid=grid,
             path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
-            type="restart",
             model_reference_date=model_ref_date,
             use_dask=use_dask,
         )
@@ -138,7 +138,7 @@ def test_model_reference_date_no_metadata(use_dask, tmp_path, caplog):
             expected_exception,
             match="Model reference date could not be inferred from the metadata",
         ):
-            ROMSOutput(grid=grid, path=fname_mod, type="restart", use_dask=use_dask)
+            ROMSOutput(grid=grid, path=fname_mod, use_dask=use_dask)
 
         # Test case 2: When a model reference date is explicitly set, verify the warning
         with caplog.at_level(logging.WARNING):
@@ -146,7 +146,6 @@ def test_model_reference_date_no_metadata(use_dask, tmp_path, caplog):
                 grid=grid,
                 path=fname_mod,
                 model_reference_date=datetime(1995, 1, 1),
-                type="restart",
                 use_dask=use_dask,
             )
 
@@ -175,20 +174,53 @@ def test_model_reference_date_no_metadata(use_dask, tmp_path, caplog):
 def test_compute_depth_coordinates(use_dask):
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
+    fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+
+    for adjust_depth_for_sea_surface_height in [True, False]:
+        output = ROMSOutput(
+            grid=grid,
+            path=fname_restart1,
+            use_dask=use_dask,
+            adjust_depth_for_sea_surface_height=adjust_depth_for_sea_surface_height,
+        )
 
+        # Before calling get_vertical_coordinates, check if the dataset doesn't already have depth coordinates
+        assert "layer_depth_rho" not in output.ds_depth_coords.data_vars
+
+        # Call the method to get vertical coordinates
+        output._get_depth_coordinates(depth_type="layer")
+
+        # Check if the depth coordinates were added
+        assert "layer_depth_rho" in output.ds_depth_coords.data_vars
+
+
+def test_missing_zeta_gets_raised(use_dask):
+    """Test that a ValueError is raised when `zeta` is missing from the dataset and
+    `adjust_depth_for_sea_surface_height` is enabled."""
+    # Load the grid
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Load the ROMS output
     fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
-    output = ROMSOutput(
-        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
+    roms_output = ROMSOutput(
+        grid=grid,
+        path=fname_restart1,
+        use_dask=use_dask,
+        adjust_depth_for_sea_surface_height=True,
     )
 
-    # Before calling get_vertical_coordinates, check if the dataset doesn't already have depth coordinates
-    assert "layer_depth_rho" not in output.ds.data_vars
-
-    # Call the method to get vertical coordinates
-    output.compute_depth_coordinates(depth_type="layer")
+    # Remove `zeta` from the dataset
+    object.__setattr__(
+        roms_output, "ds", roms_output.ds.drop_vars("zeta", errors="ignore")
+    )
 
-    # Check if the depth coordinates were added
-    assert "layer_depth_rho" in output.ds.data_vars
+    # Expect ValueError when calling `_get_depth_coordinates`
+    with pytest.raises(
+        ValueError,
+        match="`zeta` is required in provided ROMS output when `adjust_depth_for_sea_surface_height` is enabled.",
+    ):
+        roms_output._get_depth_coordinates()
 
 
 def test_check_vertical_coordinate_mismatch(use_dask):
@@ -196,9 +228,7 @@ def test_check_vertical_coordinate_mismatch(use_dask):
     grid = Grid.from_file(fname_grid)
 
     fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
-    output = ROMSOutput(
-        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
-    )
+    output = ROMSOutput(grid=grid, path=fname_restart1, use_dask=use_dask)
 
     # create a mock dataset with inconsistent vertical coordinate parameters
     ds_mock = output.ds.copy()
@@ -226,44 +256,233 @@ def test_that_coordinates_are_added(use_dask):
     grid = Grid.from_file(fname_grid)
 
     fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
-    output = ROMSOutput(
-        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
-    )
+    output = ROMSOutput(grid=grid, path=fname_restart1, use_dask=use_dask)
 
     assert "abs_time" in output.ds.coords
     assert "lat_rho" in output.ds.coords
     assert "lon_rho" in output.ds.coords
 
 
-def test_plot(roms_output_from_restart_file, use_dask):
-
-    kwargs = {}
-    for var_name in ["temp", "u", "v"]:
-        roms_output_from_restart_file.plot(var_name, time=0, s=-1, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, eta=0, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, xi=0, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, eta=0, xi=0, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, s=-1, eta=0, **kwargs)
-
-    kwargs = {"depth_contours": True, "layer_contours": True}
-    for var_name in ["temp", "u", "v"]:
-        roms_output_from_restart_file.plot(var_name, time=0, s=-1, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, eta=0, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, xi=0, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, eta=0, xi=0, **kwargs)
-        roms_output_from_restart_file.plot(var_name, time=0, s=-1, eta=0, **kwargs)
-
-    roms_output_from_restart_file.plot("zeta", time=0, **kwargs)
-    roms_output_from_restart_file.plot("zeta", time=0, eta=0, **kwargs)
-    roms_output_from_restart_file.plot("zeta", time=0, xi=0, **kwargs)
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+    ],
+)
+def test_plot_on_native_model_grid(roms_output_fixture, use_dask, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
+
+    for include_boundary in [False, True]:
+        for depth_contours in [False, True]:
+
+            # 3D fields
+            for var_name in ["temp", "u", "v"]:
+                kwargs = {
+                    "include_boundary": include_boundary,
+                    "depth_contours": depth_contours,
+                }
+
+                roms_output.plot(var_name, time=1, s=-1, **kwargs)
+                roms_output.plot(var_name, time=1, depth=1000, **kwargs)
+
+                roms_output.plot(var_name, time=1, eta=1, **kwargs)
+                roms_output.plot(var_name, time=1, xi=1, **kwargs)
+
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    eta=1,
+                    xi=1,
+                    **kwargs,
+                )
+
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    s=-1,
+                    eta=1,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    depth=1000,
+                    eta=1,
+                    **kwargs,
+                )
+
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    s=-1,
+                    xi=1,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    depth=1000,
+                    xi=1,
+                    **kwargs,
+                )
+
+            # 2D fields
+            roms_output.plot("zeta", time=1, **kwargs)
+            roms_output.plot("zeta", time=1, eta=1, **kwargs)
+            roms_output.plot("zeta", time=1, xi=1, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+    ],
+)
+@pytest.mark.skipif(xesmf is None, reason="xesmf required")
+def test_plot_on_lat_lon(roms_output_fixture, use_dask, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
+
+    for include_boundary in [False, True]:
+        for depth_contours in [False, True]:
+
+            # 3D fields
+            for var_name in ["temp", "u", "v"]:
+                kwargs = {
+                    "include_boundary": include_boundary,
+                    "depth_contours": depth_contours,
+                }
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lat=9,
+                    lon=-128,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lat=9,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lat=9,
+                    s=-1,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lat=9,
+                    depth=1000,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lon=-128,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lon=-128,
+                    s=-1,
+                    **kwargs,
+                )
+                roms_output.plot(
+                    var_name,
+                    time=1,
+                    lon=-128,
+                    depth=1000,
+                    **kwargs,
+                )
+
+            # 2D fields
+            roms_output.plot("zeta", time=1, lat=9, **kwargs)
+            roms_output.plot("zeta", time=1, lon=-128, **kwargs)
 
 
 def test_plot_errors(roms_output_from_restart_file, use_dask):
+    """Test error conditions for the ROMSOutput.plot() method."""
+
+    # Invalid time index
     with pytest.raises(ValueError, match="Invalid time index"):
         roms_output_from_restart_file.plot("temp", time=10, s=-1)
-    with pytest.raises(ValueError, match="Invalid input"):
-        roms_output_from_restart_file.plot("temp", time=0)
+
+    with pytest.raises(
+        ValueError,
+        match="Conflicting input: You cannot specify both 's' and 'depth' at the same time.",
+    ):
+        roms_output_from_restart_file.plot("temp", time=0, s=-1, depth=10)
+
+    # Ambiguous input: Too many dimensions specified for 3D fields
     with pytest.raises(ValueError, match="Ambiguous input"):
-        roms_output_from_restart_file.plot("temp", time=0, s=-1, eta=0, xi=0)
-    with pytest.raises(ValueError, match="Conflicting input"):
-        roms_output_from_restart_file.plot("zeta", time=0, eta=0, xi=0)
+        roms_output_from_restart_file.plot("temp", time=1, s=-1, eta=0, xi=0)
+
+    # Vertical dimension specified for 2D fields
+    with pytest.raises(
+        ValueError, match="Vertical dimension 's' should be None for 2D fields"
+    ):
+        roms_output_from_restart_file.plot("zeta", time=1, s=-1)
+    with pytest.raises(
+        ValueError, match="Vertical dimension 'depth' should be None for 2D fields"
+    ):
+        roms_output_from_restart_file.plot("zeta", time=1, depth=100)
+
+    # Conflicting input: Both eta and xi specified for 2D fields
+    with pytest.raises(
+        ValueError,
+        match="Conflicting input: For 2D fields, specify only one dimension, either 'eta' or 'xi', not both.",
+    ):
+        roms_output_from_restart_file.plot("zeta", time=1, eta=0, xi=0)
+    # Conflicting input: Both lat and lon specified for 2D fields
+    with pytest.raises(
+        ValueError,
+        match="Conflicting input: For 2D fields, specify only one dimension, either 'lat' or 'lon', not both.",
+    ):
+        roms_output_from_restart_file.plot("zeta", time=1, lat=0, lon=0)
+
+    # Conflicting input: lat or lon provided with eta or xi
+    with pytest.raises(
+        ValueError,
+        match="Conflicting input: You cannot specify 'lat' or 'lon' simultaneously with 'eta' or 'xi'.",
+    ):
+        roms_output_from_restart_file.plot("temp", time=1, lat=10, lon=20, eta=5)
+
+    # Invalid eta index out of bounds
+    with pytest.raises(ValueError, match="Invalid eta index"):
+        roms_output_from_restart_file.plot("temp", time=1, eta=999)
+
+    # Invalid xi index out of bounds
+    with pytest.raises(ValueError, match="Invalid eta index"):
+        roms_output_from_restart_file.plot("temp", time=1, xi=999)
+
+    # Boundary exclusion error for eta
+    with pytest.raises(ValueError, match="Invalid eta index.*boundary.*excluded"):
+        roms_output_from_restart_file.plot(
+            "temp", time=1, eta=0, include_boundary=False
+        )
+
+    # Boundary exclusion error for xi
+    with pytest.raises(ValueError, match="Invalid xi index.*boundary.*excluded"):
+        roms_output_from_restart_file.plot("temp", time=1, xi=0, include_boundary=False)
+
+    # No dimension specified for 3D field
+    with pytest.raises(
+        ValueError,
+        match="Invalid input: For 3D fields, you must specify at least one of the dimensions",
+    ):
+        roms_output_from_restart_file.plot("temp", time=1)
+
+
+def test_figure_gets_saved(roms_output_from_restart_file, tmp_path):
+
+    filename = tmp_path / "figure.png"
+    roms_output_from_restart_file.plot("temp", time=0, depth=1000, save_path=filename)
+
+    assert filename.exists()
+    filename.unlink()

roms_tools/tests/test_regrid.py

@@ -1,9 +1,92 @@
 import pytest
 import numpy as np
 import xarray as xr
-from roms_tools.regrid import VerticalRegrid
+from roms_tools.regrid import VerticalRegridToROMS
 
+try:
+    import xesmf  # type: ignore
+except ImportError:
+    xesmf = None
 
+from roms_tools.regrid import LateralRegridFromROMS
+
+# Lateral regridding
+@pytest.mark.skipif(xesmf is None, reason="xesmf required")
+def test_lateral_regrid_with_curvilinear_grid():
+    """Test that LateralRegridFromROMS regrids data correctly from a curvilinear ROMS
+    grid."""
+
+    # Define ROMS curvilinear grid dimensions
+    eta_rho, xi_rho = 10, 20
+
+    # Create a mock ROMS grid with curvilinear coordinates
+    lat_rho = np.linspace(-10, 10, eta_rho).reshape(-1, 1) * np.ones((1, xi_rho))
+    lon_rho = np.linspace(120, 140, xi_rho).reshape(1, -1) * np.ones((eta_rho, 1))
+
+    ds_in = xr.Dataset(
+        {
+            "temp": (("eta_rho", "xi_rho"), np.random.rand(eta_rho, xi_rho)),
+        },
+        coords={
+            "lat": (("eta_rho", "xi_rho"), lat_rho),
+            "lon": (("eta_rho", "xi_rho"), lon_rho),
+        },
+    )
+
+    # Define target latitude and longitude coordinates
+    target_coords = {
+        "lat": np.linspace(-5, 5, 5),
+        "lon": np.linspace(125, 135, 10),
+    }
+
+    # Instantiate the regridder
+    regridder = LateralRegridFromROMS(ds_in, target_coords, method="bilinear")
+
+    # Apply the regridding to the input data
+    regridded_da = regridder.apply(ds_in["temp"])
+
+    # Assertions to verify that the output is as expected
+    assert isinstance(regridded_da, xr.DataArray)
+    assert regridded_da.shape == (5, 10)
+    assert np.allclose(regridded_da.coords["lat"], target_coords["lat"])
+    assert np.allclose(regridded_da.coords["lon"], target_coords["lon"])
+
+
+@pytest.mark.skipif(xesmf is not None, reason="xesmf has to be missing")
+def test_lateral_regrid_import_error():
+    """Test that LateralRegridFromROMS raises ImportError when xesmf is missing."""
+
+    # Define mock ROMS curvilinear grid dimensions
+    eta_rho, xi_rho = 10, 20
+
+    # Create a mock ROMS grid with curvilinear coordinates
+    lat_rho = np.linspace(-10, 10, eta_rho).reshape(-1, 1) * np.ones((1, xi_rho))
+    lon_rho = np.linspace(120, 140, xi_rho).reshape(1, -1) * np.ones((eta_rho, 1))
+
+    ds_in = xr.Dataset(
+        {
+            "temp": (("eta_rho", "xi_rho"), np.random.rand(eta_rho, xi_rho)),
+        },
+        coords={
+            "lat": (("eta_rho", "xi_rho"), lat_rho),
+            "lon": (("eta_rho", "xi_rho"), lon_rho),
+        },
+    )
+
+    # Define target latitude and longitude coordinates
+    target_coords = {
+        "lat": np.linspace(-5, 5, 5),
+        "lon": np.linspace(125, 135, 10),
+    }
+
+    # Check that ImportError is raised when xesmf is missing
+    with pytest.raises(
+        ImportError, match="xesmf is required for this regridding task.*"
+    ):
+        LateralRegridFromROMS(ds_in, target_coords, method="bilinear")
+
+
+# Vertical regridding
 def vertical_regridder(depth_values, layer_depth_rho_values):
     class DataContainer:
         """Mock class for holding data and dimension names."""
@@ -21,7 +104,7 @@ def vertical_regridder(depth_values, layer_depth_rho_values):
     target_depth = xr.DataArray(data=layer_depth_rho_values, dims=["s_rho"])
     source_depth = xr.DataArray(data=depth_values, dims=["depth"])
 
-    return VerticalRegrid(target_depth, source_depth)
+    return VerticalRegridToROMS(target_depth, source_depth)
 
 
 @pytest.mark.parametrize(

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -139,6 +139,69 @@ def test_unsuccessful_boundary_forcing_creation_with_1d_fill(use_dask):
         )
 
 
+def test_start_time_end_time_error(use_dask):
+    """Test error when start_time and end_time are not both provided or both None."""
+    # Case 1: Only start_time provided
+    with pytest.raises(
+        ValueError, match="Both `start_time` and `end_time` must be provided together"
+    ):
+        BoundaryForcing(
+            grid=None,
+            start_time=datetime(2022, 1, 1),
+            end_time=None,  # end_time is None, should raise an error
+            source={"name": "GLORYS", "path": "glorys_data.nc"},
+            use_dask=use_dask,
+        )
+
+    # Case 2: Only end_time provided
+    with pytest.raises(
+        ValueError, match="Both `start_time` and `end_time` must be provided together"
+    ):
+        BoundaryForcing(
+            grid=None,
+            start_time=None,  # start_time is None, should raise an error
+            end_time=datetime(2022, 1, 2),
+            source={"name": "GLORYS", "path": "glorys_data.nc"},
+            use_dask=use_dask,
+        )
+
+
+def test_start_time_end_time_warning(use_dask, caplog):
+    """Test that a warning is triggered when both start_time and end_time are None."""
+    # Catching the warning during test
+    grid = Grid(
+        nx=3,
+        ny=3,
+        size_x=400,
+        size_y=400,
+        center_lon=-8,
+        center_lat=58,
+        rot=0,
+        N=3,  # number of vertical levels
+        theta_s=5.0,  # surface control parameter
+        theta_b=2.0,  # bottom control parameter
+        hc=250.0,  # critical depth
+    )
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    with caplog.at_level(logging.INFO):
+        BoundaryForcing(
+            grid=grid,
+            start_time=None,
+            end_time=None,
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            use_dask=use_dask,
+        )
+
+    # Verify the warning message in the log
+    assert (
+        "Both `start_time` and `end_time` are None. No time filtering will be applied to the source data."
+        in caplog.text
+    )
+
+
 def test_boundary_divided_by_land_warning(caplog, use_dask):
 
     # Iceland intersects the western boundary of the following grid

roms_tools/tests/test_setup/test_data/bgc_boundary_forcing_from_climatology.zarr/.zattrs

@@ -1,9 +1,11 @@
 {
+    "adjust_depth_for_sea_surface_height": "False",
+    "apply_2d_horizontal_fill": "True",
     "climatology": "True",
     "end_time": "2021-06-30 00:00:00",
     "hc": 250.0,
     "model_reference_date": "2000-01-01 00:00:00",
-    "roms_tools_version": "0.1.dev169+dirty",
+    "roms_tools_version": "2.1.1.dev3+gef240eb.d20250116",
     "source": "CESM_REGRIDDED",
     "start_time": "2021-06-29 00:00:00",
     "theta_b": 2.0,

roms_tools/tests/test_setup/test_data/bgc_boundary_forcing_from_climatology.zarr/.zmetadata

@@ -1,11 +1,13 @@
 {
     "metadata": {
         ".zattrs": {
+            "adjust_depth_for_sea_surface_height": "False",
+            "apply_2d_horizontal_fill": "True",
             "climatology": "True",
             "end_time": "2021-06-30 00:00:00",
             "hc": 250.0,
             "model_reference_date": "2000-01-01 00:00:00",
-            "roms_tools_version": "0.1.dev169+dirty",
+            "roms_tools_version": "2.1.1.dev3+gef240eb.d20250116",
             "source": "CESM_REGRIDDED",
             "start_time": "2021-06-29 00:00:00",
             "theta_b": 2.0,