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

roms_tools/tests/test_analysis/test_roms_output.py

@@ -0,0 +1,269 @@
+import pytest
+from pathlib import Path
+import xarray as xr
+import os
+import logging
+from datetime import datetime
+from roms_tools import Grid, ROMSOutput
+from roms_tools.download import download_test_data
+
+
+@pytest.fixture
+def roms_output_from_restart_file(use_dask):
+
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Single file
+    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)
+
+
+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"))
+
+    # 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)
+
+
+def test_load_model_output_file_list(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # 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
+    )
+    assert isinstance(output.ds, xr.Dataset)
+
+
+def test_invalid_type(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,
+        )
+
+
+def test_invalid_path(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Non-existent file
+    with pytest.raises(FileNotFoundError):
+        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,
+        )
+
+
+def test_set_correct_model_reference_date(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    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)
+
+
+def test_model_reference_date_mismatch(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Create a ROMSOutput with a specified model_reference_date
+    model_ref_date = datetime(2020, 1, 1)
+    with pytest.raises(
+        ValueError, match="Mismatch between `self.model_reference_date`"
+    ):
+        ROMSOutput(
+            grid=grid,
+            path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+            type="restart",
+            model_reference_date=model_ref_date,
+            use_dask=use_dask,
+        )
+
+
+def test_model_reference_date_no_metadata(use_dask, tmp_path, caplog):
+    # Helper function to handle the test logic for cases where metadata is missing or invalid
+    def test_no_metadata(faulty_ocean_time_attr, expected_exception, log_message=None):
+        ds = xr.open_dataset(fname)
+        ds["ocean_time"].attrs = faulty_ocean_time_attr
+
+        # Write modified dataset to a new file
+        fname_mod = tmp_path / "eastpac25km_rst.19980106000000_without_metadata.nc"
+        ds.to_netcdf(fname_mod)
+
+        # Test case 1: Expecting a ValueError when metadata is missing or invalid
+        with pytest.raises(
+            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)
+
+        # Test case 2: When a model reference date is explicitly set, verify the warning
+        with caplog.at_level(logging.WARNING):
+            ROMSOutput(
+                grid=grid,
+                path=fname_mod,
+                model_reference_date=datetime(1995, 1, 1),
+                type="restart",
+                use_dask=use_dask,
+            )
+
+            if log_message:
+                # Verify the warning message in the log
+                assert log_message in caplog.text
+
+        fname_mod.unlink()
+
+    # Load grid and test data
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+    fname = download_test_data("eastpac25km_rst.19980106000000.nc")
+
+    # Test 1: Ocean time attribute 'long_name' is missing
+    test_no_metadata({}, ValueError)
+
+    # Test 2: Ocean time attribute 'long_name' contains invalid information
+    test_no_metadata(
+        {"long_name": "some random text"},
+        ValueError,
+        "Could not infer the model reference date from the metadata.",
+    )
+
+
+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"))
+    output = ROMSOutput(
+        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
+    )
+
+    # 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")
+
+    # Check if the depth coordinates were added
+    assert "layer_depth_rho" in output.ds.data_vars
+
+
+def test_check_vertical_coordinate_mismatch(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"))
+    output = ROMSOutput(
+        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
+    )
+
+    # create a mock dataset with inconsistent vertical coordinate parameters
+    ds_mock = output.ds.copy()
+
+    # Modify one of the vertical coordinate attributes to cause a mismatch
+    ds_mock.attrs["theta_s"] = 999
+
+    # Check if ValueError is raised due to mismatch
+    with pytest.raises(ValueError, match="theta_s from grid"):
+        output._check_vertical_coordinate(ds_mock)
+
+    # create a mock dataset with inconsistent vertical coordinate parameters
+    ds_mock = output.ds.copy()
+
+    # Modify one of the vertical coordinate attributes to cause a mismatch
+    ds_mock.attrs["Cs_w"] = ds_mock.attrs["Cs_w"] + 0.01
+
+    # Check if ValueError is raised due to mismatch
+    with pytest.raises(ValueError, match="Cs_w from grid"):
+        output._check_vertical_coordinate(ds_mock)
+
+
+def test_that_coordinates_are_added(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"))
+    output = ROMSOutput(
+        grid=grid, path=fname_restart1, type="restart", 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)
+
+
+def test_plot_errors(roms_output_from_restart_file, use_dask):
+    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="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_tools/tests/{test_setup/test_regrid.py → test_regrid.py}

@@ -1,7 +1,7 @@
 import pytest
 import numpy as np
 import xarray as xr
-from roms_tools.setup.regrid import VerticalRegrid
+from roms_tools.regrid import VerticalRegrid
 
 
 def vertical_regridder(depth_values, layer_depth_rho_values):

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -1,10 +1,11 @@
 import pytest
 from datetime import datetime
 import xarray as xr
+import numpy as np
 from roms_tools import Grid, BoundaryForcing
 import textwrap
-from roms_tools.setup.download import download_test_data
-from conftest import calculate_file_hash
+from roms_tools.download import download_test_data
+from conftest import calculate_data_hash
 from pathlib import Path
 import logging
 
@@ -13,19 +14,23 @@ import logging
     "boundary_forcing_fixture",
     [
         "boundary_forcing",
-        # "boundary_forcing_with_2d_fill",
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
     ],
 )
 def test_boundary_forcing_creation(boundary_forcing_fixture, request):
     """Test the creation of the BoundaryForcing object."""
 
-    fname = Path(download_test_data("GLORYS_coarse_test_data.nc"))
     boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
-    assert boundary_forcing.start_time == datetime(2021, 6, 29)
-    assert boundary_forcing.end_time == datetime(2021, 6, 30)
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+    assert boundary_forcing.start_time == datetime(2012, 1, 1)
+    assert boundary_forcing.end_time == datetime(2012, 12, 31)
     assert boundary_forcing.source == {
         "name": "GLORYS",
-        "path": fname,
+        "path": [fname1, fname2],
         "climatology": False,
     }
     assert boundary_forcing.model_reference_date == datetime(2000, 1, 1)
@@ -44,16 +49,17 @@ def test_boundary_forcing_creation(boundary_forcing_fixture, request):
         assert f"v_{direction}" in boundary_forcing.ds
         assert f"zeta_{direction}" in boundary_forcing.ds
 
-    assert len(boundary_forcing.ds.bry_time) == 1
+    assert len(boundary_forcing.ds.bry_time) == 2
     assert boundary_forcing.ds.coords["bry_time"].attrs["units"] == "days"
     assert not hasattr(boundary_forcing.ds, "climatology")
+    assert hasattr(boundary_forcing.ds, "adjust_depth_for_sea_surface_height")
+    assert hasattr(boundary_forcing.ds, "apply_2d_horizontal_fill")
 
 
 @pytest.mark.parametrize(
     "boundary_forcing_fixture",
     [
         "bgc_boundary_forcing_from_climatology",
-        # "bgc_boundary_forcing_from_climatology_with_2d_fill",
     ],
 )
 def test_boundary_forcing_creation_with_bgc(boundary_forcing_fixture, request):
@@ -155,6 +161,113 @@ def test_boundary_divided_by_land_warning(caplog, use_dask):
     assert "the western boundary is divided by land" in caplog.text
 
 
+def test_info_depth(caplog, use_dask):
+
+    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=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            adjust_depth_for_sea_surface_height=True,
+            use_dask=use_dask,
+        )
+
+    # Verify the warning message in the log
+    assert "Sea surface height will be used to adjust depth coordinates." in caplog.text
+
+    # Clear the log before the next test
+    caplog.clear()
+
+    with caplog.at_level(logging.INFO):
+
+        BoundaryForcing(
+            grid=grid,
+            start_time=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            adjust_depth_for_sea_surface_height=False,
+            use_dask=use_dask,
+        )
+    # Verify the warning message in the log
+    assert (
+        "Sea surface height will NOT be used to adjust depth coordinates."
+        in caplog.text
+    )
+
+
+def test_info_fill(caplog, use_dask):
+
+    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=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            apply_2d_horizontal_fill=True,
+            use_dask=use_dask,
+        )
+
+    # Verify the warning message in the log
+    assert (
+        "Applying 2D horizontal fill to the source data before regridding."
+        in caplog.text
+    )
+
+    # Clear the log before the next test
+    caplog.clear()
+
+    with caplog.at_level(logging.INFO):
+
+        BoundaryForcing(
+            grid=grid,
+            start_time=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            apply_2d_horizontal_fill=False,
+            use_dask=use_dask,
+        )
+    # Verify the warning message in the log
+    assert (
+        "Applying 1D horizontal fill separately to each regridded boundary."
+        in caplog.text
+    )
+
+
 def test_1d_and_2d_fill_coincide_if_no_land(use_dask):
 
     # this grid lies entirely over open ocean
@@ -182,23 +295,95 @@ def test_1d_and_2d_fill_coincide_if_no_land(use_dask):
     xr.testing.assert_allclose(bf_1d_fill.ds, bf_2d_fill.ds, rtol=1.0e-4)
 
 
-def test_boundary_forcing_plot(boundary_forcing):
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
+    ],
+)
+def test_correct_depth_coords_adjusted_for_zeta(
+    boundary_forcing_fixture, request, use_dask
+):
+
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
+
+    for direction in ["south", "east", "north", "west"]:
+
+        # Test that uppermost interface coincides with sea surface height
+        assert np.allclose(
+            boundary_forcing.ds_depth_coords[f"interface_depth_rho_{direction}"]
+            .isel(s_w=-1)
+            .values,
+            -boundary_forcing.ds[f"zeta_{direction}"].values,
+            atol=1e-6,
+        )
+
+
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing",
+        "boundary_forcing_with_2d_fill",
+    ],
+)
+def test_correct_depth_coords_zero_zeta(boundary_forcing_fixture, request, use_dask):
+
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
+
+    for direction in ["south", "east", "north", "west"]:
+
+        # Test that uppermost interface coincides with sea surface height
+        assert np.allclose(
+            boundary_forcing.ds_depth_coords[f"interface_depth_rho_{direction}"]
+            .isel(s_w=-1)
+            .values,
+            0 * boundary_forcing.ds[f"zeta_{direction}"].values,
+            atol=1e-6,
+        )
+
+
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing",
+        "boundary_forcing_with_2d_fill",
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
+    ],
+)
+def test_boundary_forcing_plot(boundary_forcing_fixture, request):
     """Test plot."""
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
-    boundary_forcing.plot(var_name="temp_south", layer_contours=True)
-    boundary_forcing.plot(var_name="temp_east", layer_contours=True)
-    boundary_forcing.plot(var_name="temp_north", layer_contours=True)
-    boundary_forcing.plot(var_name="temp_west", layer_contours=True)
-    boundary_forcing.plot(var_name="zeta_south")
-    boundary_forcing.plot(var_name="zeta_east")
-    boundary_forcing.plot(var_name="zeta_north")
-    boundary_forcing.plot(var_name="zeta_west")
-    boundary_forcing.plot(var_name="vbar_north")
-    boundary_forcing.plot(var_name="ubar_west")
+    for direction in ["south", "east", "north", "west"]:
+        for layer_contours in [False, True]:
+            boundary_forcing.plot(
+                var_name=f"temp_{direction}", layer_contours=layer_contours
+            )
+            boundary_forcing.plot(
+                var_name=f"u_{direction}", layer_contours=layer_contours
+            )
+            boundary_forcing.plot(
+                var_name=f"v_{direction}", layer_contours=layer_contours
+            )
+        boundary_forcing.plot(var_name=f"zeta_{direction}")
+        boundary_forcing.plot(var_name=f"vbar_{direction}")
+        boundary_forcing.plot(var_name=f"ubar_{direction}")
 
 
-def test_boundary_forcing_save(boundary_forcing, tmp_path):
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing",
+        "boundary_forcing_with_2d_fill",
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
+    ],
+)
+def test_boundary_forcing_save(boundary_forcing_fixture, request, tmp_path):
     """Test save method."""
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     for file_str in ["test_bf", "test_bf.nc"]:
         # Create a temporary filepath using the tmp_path fixture
@@ -207,8 +392,8 @@ def test_boundary_forcing_save(boundary_forcing, tmp_path):
             str(tmp_path / file_str),
         ]:  # test for Path object and str
 
-            # Test saving without partitioning and grouping
-            saved_filenames = boundary_forcing.save(filepath)
+            # Test saving without grouping
+            saved_filenames = boundary_forcing.save(filepath, group=False)
 
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
@@ -217,28 +402,16 @@ def test_boundary_forcing_save(boundary_forcing, tmp_path):
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving without partitioning but with grouping
+            # Test saving with grouping
             saved_filenames = boundary_forcing.save(filepath, group=True)
 
             filepath_str = str(Path(filepath).with_suffix(""))
-            expected_filepath = Path(f"{filepath_str}_202106.nc")
+            expected_filepath = Path(f"{filepath_str}_2012.nc")
 
             assert saved_filenames == [expected_filepath]
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning and grouping
-            saved_filenames = boundary_forcing.save(filepath, np_eta=2, group=True)
-            expected_filepath_list = [
-                Path(filepath_str + f"_202106.{index}.nc") for index in range(2)
-            ]
-
-            assert saved_filenames == expected_filepath_list
-
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 def test_bgc_boundary_forcing_plot(bgc_boundary_forcing_from_climatology):
     """Test plot method."""
@@ -264,7 +437,9 @@ def test_bgc_boundary_forcing_save(bgc_boundary_forcing_from_climatology, tmp_pa
         ]:  # test for Path object and str
 
             # Test saving without partitioning and grouping
-            saved_filenames = bgc_boundary_forcing_from_climatology.save(filepath)
+            saved_filenames = bgc_boundary_forcing_from_climatology.save(
+                filepath, group=False
+            )
 
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
@@ -283,20 +458,6 @@ def test_bgc_boundary_forcing_save(bgc_boundary_forcing_from_climatology, tmp_pa
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning
-            saved_filenames = bgc_boundary_forcing_from_climatology.save(
-                filepath, np_xi=2, group=True
-            )
-
-            expected_filepath_list = [
-                Path(filepath_str + f"_clim.{index}.nc") for index in range(2)
-            ]
-            assert saved_filenames == expected_filepath_list
-
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 @pytest.mark.parametrize(
     "bdry_forcing_fixture",
@@ -341,11 +502,12 @@ def test_files_have_same_hash(boundary_forcing, tmp_path, use_dask):
 
     filepath_str1 = str(Path(filepath1).with_suffix(""))
     filepath_str2 = str(Path(filepath2).with_suffix(""))
-    expected_filepath1 = f"{filepath_str1}_202106.nc"
-    expected_filepath2 = f"{filepath_str2}_202106.nc"
+    expected_filepath1 = f"{filepath_str1}_2012.nc"
+    expected_filepath2 = f"{filepath_str2}_2012.nc"
 
-    hash1 = calculate_file_hash(expected_filepath1)
-    hash2 = calculate_file_hash(expected_filepath2)
+    # Only compare hash of datasets because metadata is non-deterministic with dask
+    hash1 = calculate_data_hash(expected_filepath1)
+    hash2 = calculate_data_hash(expected_filepath2)
 
     assert hash1 == hash2, f"Hashes do not match: {hash1} != {hash2}"
 
@@ -372,8 +534,9 @@ def test_files_have_same_hash_clim(
     expected_filepath1 = f"{filepath_str1}_clim.nc"
     expected_filepath2 = f"{filepath_str2}_clim.nc"
 
-    hash1 = calculate_file_hash(expected_filepath1)
-    hash2 = calculate_file_hash(expected_filepath2)
+    # Only compare hash of datasets because metadata is non-deterministic with dask
+    hash1 = calculate_data_hash(expected_filepath1)
+    hash2 = calculate_data_hash(expected_filepath2)
 
     assert hash1 == hash2, f"Hashes do not match: {hash1} != {hash2}"
 

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

@@ -1,10 +1,12 @@
 {
-    "end_time": "2021-06-30 00:00:00",
+    "adjust_depth_for_sea_surface_height": "False",
+    "apply_2d_horizontal_fill": "False",
+    "end_time": "2012-12-31 00:00:00",
     "hc": 250.0,
     "model_reference_date": "2000-01-01 00:00:00",
-    "roms_tools_version": "0.1.dev157+dirty",
+    "roms_tools_version": "0.1.dev177",
     "source": "GLORYS",
-    "start_time": "2021-06-29 00:00:00",
+    "start_time": "2012-01-01 00:00:00",
     "theta_b": 2.0,
     "theta_s": 5.0,
     "title": "ROMS boundary forcing file created by ROMS-Tools"