roms-tools 3.1.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

roms_tools/tests/test_setup/{test_datasets.py → test_lat_lon_datasets.py}

@@ -1,6 +1,6 @@
 import logging
 from collections import OrderedDict
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from unittest import mock
 
@@ -9,17 +9,27 @@ import pytest
 import xarray as xr
 
 from roms_tools.download import download_test_data
-from roms_tools.setup.datasets import (
+from roms_tools.setup.lat_lon_datasets import (
+    GLORYS_GLOBAL_GRID_PATH,
     CESMBGCDataset,
-    Dataset,
     ERA5ARCODataset,
     ERA5Correction,
     GLORYSDataset,
     GLORYSDefaultDataset,
-    RiverDataset,
+    LatLonDataset,
     TPXODataset,
+    _concatenate_longitudes,
+    choose_subdomain,
+    get_glorys_bounds,
 )
 from roms_tools.setup.surface_forcing import DEFAULT_ERA5_ARCO_PATH
+from roms_tools.setup.utils import get_target_coords
+from roms_tools.tests.test_setup.utils import download_regional_and_bigger
+
+try:
+    import copernicusmarine  # type: ignore
+except ImportError:
+    copernicusmarine = None
 
 
 @pytest.fixture
@@ -29,9 +39,9 @@ def global_dataset():
     depth = np.linspace(0, 2000, 10)
     time = [
         np.datetime64("2022-01-01T00:00:00"),
-        np.datetime64("2022-02-01T00:00:00"),
-        np.datetime64("2022-03-01T00:00:00"),
-        np.datetime64("2022-04-01T00:00:00"),
+        np.datetime64("2022-01-02T00:00:00"),
+        np.datetime64("2022-01-03T00:00:00"),
+        np.datetime64("2022-01-04T00:00:00"),
     ]
     data = np.random.rand(4, 10, 180, 360)
     ds = xr.Dataset(
@@ -52,9 +62,9 @@ def global_dataset_with_noon_times():
     lat = np.linspace(-90, 90, 180)
     time = [
         np.datetime64("2022-01-01T12:00:00"),
-        np.datetime64("2022-02-01T12:00:00"),
-        np.datetime64("2022-03-01T12:00:00"),
-        np.datetime64("2022-04-01T12:00:00"),
+        np.datetime64("2022-01-02T12:00:00"),
+        np.datetime64("2022-01-03T12:00:00"),
+        np.datetime64("2022-01-04T12:00:00"),
     ]
     data = np.random.rand(4, 180, 360)
     ds = xr.Dataset(
@@ -75,12 +85,12 @@ def global_dataset_with_multiple_times_per_day():
     time = [
         np.datetime64("2022-01-01T00:00:00"),
         np.datetime64("2022-01-01T12:00:00"),
-        np.datetime64("2022-02-01T00:00:00"),
-        np.datetime64("2022-02-01T12:00:00"),
-        np.datetime64("2022-03-01T00:00:00"),
-        np.datetime64("2022-03-01T12:00:00"),
-        np.datetime64("2022-04-01T00:00:00"),
-        np.datetime64("2022-04-01T12:00:00"),
+        np.datetime64("2022-01-02T00:00:00"),
+        np.datetime64("2022-01-02T12:00:00"),
+        np.datetime64("2022-01-03T00:00:00"),
+        np.datetime64("2022-01-03T12:00:00"),
+        np.datetime64("2022-01-04T00:00:00"),
+        np.datetime64("2022-01-04T12:00:00"),
     ]
     data = np.random.rand(8, 180, 360)
     ds = xr.Dataset(
@@ -112,39 +122,42 @@ def non_global_dataset():
         (
             "global_dataset",
             [
-                np.datetime64("2022-02-01T00:00:00"),
-                np.datetime64("2022-03-01T00:00:00"),
+                np.datetime64("2022-01-02T00:00:00"),
+                np.datetime64("2022-01-03T00:00:00"),
+                np.datetime64("2022-01-04T00:00:00"),
             ],
         ),
         (
             "global_dataset_with_noon_times",
             [
                 np.datetime64("2022-01-01T12:00:00"),
-                np.datetime64("2022-02-01T12:00:00"),
-                np.datetime64("2022-03-01T12:00:00"),
+                np.datetime64("2022-01-02T12:00:00"),
+                np.datetime64("2022-01-03T12:00:00"),
+                np.datetime64("2022-01-04T12:00:00"),
             ],
         ),
         (
             "global_dataset_with_multiple_times_per_day",
             [
-                np.datetime64("2022-02-01T00:00:00"),
-                np.datetime64("2022-02-01T12:00:00"),
-                np.datetime64("2022-03-01T00:00:00"),
+                np.datetime64("2022-01-02T00:00:00"),
+                np.datetime64("2022-01-02T12:00:00"),
+                np.datetime64("2022-01-03T00:00:00"),
+                np.datetime64("2022-01-03T12:00:00"),
+                np.datetime64("2022-01-04T00:00:00"),
             ],
         ),
     ],
 )
 def test_select_times(data_fixture, expected_time_values, request, tmp_path, use_dask):
     """Test selecting times with different datasets."""
-    start_time = datetime(2022, 2, 1)
-    end_time = datetime(2022, 3, 1)
+    start_time = datetime(2022, 1, 2)
+    end_time = datetime(2022, 1, 4)
 
-    # Get the fixture dynamically based on the parameter
     dataset = request.getfixturevalue(data_fixture)
 
     filepath = tmp_path / "test.nc"
     dataset.to_netcdf(filepath)
-    dataset = Dataset(
+    dataset = LatLonDataset(
         filename=filepath,
         var_names={"var": "var"},
         start_time=start_time,
@@ -161,16 +174,15 @@ def test_select_times(data_fixture, expected_time_values, request, tmp_path, use
 @pytest.mark.parametrize(
     "data_fixture, expected_time_values",
     [
-        ("global_dataset", [np.datetime64("2022-02-01T00:00:00")]),
-        ("global_dataset_with_noon_times", [np.datetime64("2022-02-01T12:00:00")]),
+        ("global_dataset", [np.datetime64("2022-01-02T00:00:00")]),
+        ("global_dataset_with_noon_times", [np.datetime64("2022-01-02T12:00:00")]),
     ],
 )
 def test_select_times_valid_start_no_end_time(
     data_fixture, expected_time_values, request, tmp_path, use_dask
 ):
     """Test selecting times with only start_time specified."""
-    start_time = datetime(2022, 2, 1)
-
+    start_time = datetime(2022, 1, 2)
     # Get the fixture dynamically based on the parameter
     dataset = request.getfixturevalue(data_fixture)
 
@@ -179,14 +191,16 @@ def test_select_times_valid_start_no_end_time(
     dataset.to_netcdf(filepath)
 
     # Instantiate Dataset object using the temporary file
-    dataset = Dataset(
+    dataset = LatLonDataset(
         filename=filepath,
         var_names={"var": "var"},
         start_time=start_time,
         use_dask=use_dask,
+        allow_flex_time=True,
     )
 
     assert dataset.ds is not None
+    assert "time" in dataset.ds.dims
     assert len(dataset.ds.time) == len(expected_time_values)
     for expected_time in expected_time_values:
         assert expected_time in dataset.ds.time.values
@@ -212,9 +226,9 @@ def test_select_times_invalid_start_no_end_time(
 
     with pytest.raises(
         ValueError,
-        match="The dataset does not contain any time entries between the specified start_time",
+        match="No exact match found ",
     ):
-        dataset = Dataset(
+        dataset = LatLonDataset(
             filename=filepath,
             var_names={"var": "var"},
             start_time=datetime(2022, 5, 1),
@@ -230,14 +244,15 @@ def test_multiple_matching_times(
     """
     filepath = tmp_path / "test.nc"
     global_dataset_with_multiple_times_per_day.to_netcdf(filepath)
-    dataset = Dataset(
+    dataset = LatLonDataset(
         filename=filepath,
         var_names={"var": "var"},
-        start_time=datetime(2022, 1, 31, 22, 0),
+        start_time=datetime(2021, 12, 31, 22, 0),
         use_dask=use_dask,
+        allow_flex_time=True,
     )
 
-    assert dataset.ds["time"].values == np.datetime64(datetime(2022, 2, 1, 0, 0))
+    assert dataset.ds["time"].values == np.datetime64(datetime(2022, 1, 1, 0, 0))
 
 
 def test_warnings_times(global_dataset, tmp_path, caplog, use_dask):
@@ -249,7 +264,7 @@ def test_warnings_times(global_dataset, tmp_path, caplog, use_dask):
         start_time = datetime(2021, 1, 1)
         end_time = datetime(2021, 2, 1)
 
-        Dataset(
+        LatLonDataset(
             filename=filepath,
             var_names={"var": "var"},
             start_time=start_time,
@@ -257,13 +272,13 @@ def test_warnings_times(global_dataset, tmp_path, caplog, use_dask):
             use_dask=use_dask,
         )
     # Verify the warning message in the log
-    assert "No records found at or before the start_time." in caplog.text
+    assert "No records found at or before the start_time" in caplog.text
 
     with caplog.at_level(logging.WARNING):
         start_time = datetime(2024, 1, 1)
         end_time = datetime(2024, 2, 1)
 
-        Dataset(
+        LatLonDataset(
             filename=filepath,
             var_names={"var": "var"},
             start_time=start_time,
@@ -271,17 +286,17 @@ def test_warnings_times(global_dataset, tmp_path, caplog, use_dask):
             use_dask=use_dask,
         )
     # Verify the warning message in the log
-    assert "No records found at or after the end_time." in caplog.text
+    assert "No records found at or after the end_time" in caplog.text
 
 
 def test_from_ds(global_dataset, global_dataset_with_noon_times, use_dask, tmp_path):
-    """Test the from_ds method of the Dataset class."""
+    """Test the from_ds method of the LatLonDataset class."""
     start_time = datetime(2022, 1, 1)
 
     filepath = tmp_path / "test.nc"
     global_dataset.to_netcdf(filepath)
 
-    dataset = Dataset(
+    dataset = LatLonDataset(
         filename=filepath,
         var_names={"var": "var"},
         dim_names={
@@ -292,11 +307,12 @@ def test_from_ds(global_dataset, global_dataset_with_noon_times, use_dask, tmp_p
         },
         start_time=start_time,
         use_dask=use_dask,
+        allow_flex_time=True,
     )
 
-    new_dataset = Dataset.from_ds(dataset, global_dataset_with_noon_times)
+    new_dataset = LatLonDataset.from_ds(dataset, global_dataset_with_noon_times)
 
-    assert isinstance(new_dataset, Dataset)  # Check that the new instance is a Dataset
+    assert isinstance(new_dataset, LatLonDataset)
     assert new_dataset.ds.equals(
         global_dataset_with_noon_times
     )  # Verify the new ds attribute is set correctly
@@ -313,7 +329,7 @@ def test_reverse_latitude_reverse_depth_choose_subdomain(
     global_dataset, tmp_path, use_dask
 ):
     """Test reversing latitude when it is not ascending, the choose_subdomain method,
-    and the convert_to_negative_depth method of the Dataset class.
+    and the convert_to_negative_depth method of the LatLonDataset class.
     """
     start_time = datetime(2022, 1, 1)
 
@@ -322,7 +338,7 @@ def test_reverse_latitude_reverse_depth_choose_subdomain(
     global_dataset["depth"] = global_dataset["depth"][::-1]
     global_dataset.to_netcdf(filepath)
 
-    dataset = Dataset(
+    dataset = LatLonDataset(
         filename=filepath,
         var_names={"var": "var"},
         dim_names={
@@ -333,6 +349,7 @@ def test_reverse_latitude_reverse_depth_choose_subdomain(
         },
         start_time=start_time,
         use_dask=use_dask,
+        allow_flex_time=True,
     )
 
     assert np.all(np.diff(dataset.ds["latitude"]) > 0)
@@ -375,7 +392,9 @@ def test_reverse_latitude_reverse_depth_choose_subdomain(
 def test_check_if_global_with_global_dataset(global_dataset, tmp_path, use_dask):
     filepath = tmp_path / "test.nc"
     global_dataset.to_netcdf(filepath)
-    dataset = Dataset(filename=filepath, var_names={"var": "var"}, use_dask=use_dask)
+    dataset = LatLonDataset(
+        filename=filepath, var_names={"var": "var"}, use_dask=use_dask
+    )
     is_global = dataset.check_if_global(dataset.ds)
     assert is_global
 
@@ -385,7 +404,9 @@ def test_check_if_global_with_non_global_dataset(
 ):
     filepath = tmp_path / "test.nc"
     non_global_dataset.to_netcdf(filepath)
-    dataset = Dataset(filename=filepath, var_names={"var": "var"}, use_dask=use_dask)
+    dataset = LatLonDataset(
+        filename=filepath, var_names={"var": "var"}, use_dask=use_dask
+    )
     is_global = dataset.check_if_global(dataset.ds)
 
     assert not is_global
@@ -403,7 +424,7 @@ def test_check_dataset(global_dataset, tmp_path, use_dask):
     with pytest.raises(
         ValueError, match="Dataset does not contain all required variables."
     ):
-        Dataset(
+        LatLonDataset(
             filename=filepath,
             var_names={"var": "var"},
             start_time=start_time,
@@ -422,7 +443,7 @@ def test_check_dataset(global_dataset, tmp_path, use_dask):
     with pytest.raises(
         ValueError, match="Dataset does not contain all required dimensions."
     ):
-        Dataset(
+        LatLonDataset(
             filename=filepath,
             var_names={"var": "var"},
             start_time=start_time,
@@ -431,12 +452,12 @@ def test_check_dataset(global_dataset, tmp_path, use_dask):
         )
 
 
-def test_era5_correction_choose_subdomain(use_dask):
+def test_era5_correction_match_subdomain(use_dask):
     data = ERA5Correction(use_dask=use_dask)
     lats = data.ds.latitude[10:20]
     lons = data.ds.longitude[10:20]
     target_coords = {"lat": lats, "lon": lons}
-    data.choose_subdomain(target_coords, straddle=False)
+    data.match_subdomain(target_coords)
     assert (data.ds["latitude"] == lats).all()
     assert (data.ds["longitude"] == lons).all()
 
@@ -484,7 +505,7 @@ def test_default_glorys_dataset_loading_dask_not_installed() -> None:
 
     with (
         pytest.raises(RuntimeError),
-        mock.patch("roms_tools.utils._has_dask", return_value=False),
+        mock.patch("roms_tools.utils.has_dask", return_value=False),
     ):
         _ = GLORYSDefaultDataset(
             filename=GLORYSDefaultDataset.dataset_name,
@@ -500,17 +521,51 @@ def test_default_glorys_dataset_loading_dask_not_installed() -> None:
 def test_default_glorys_dataset_loading() -> None:
     """Verify the default GLORYS dataset is loaded correctly."""
     start_time = datetime(2012, 1, 1)
-    end_time = datetime(2013, 1, 1)
 
-    ds = GLORYSDefaultDataset(
-        filename=GLORYSDefaultDataset.dataset_name,
-        start_time=start_time,
-        end_time=end_time,
-        use_dask=True,
-    )
+    for end_time in [start_time, start_time + timedelta(days=0.5)]:
+        data = GLORYSDefaultDataset(
+            filename=GLORYSDefaultDataset.dataset_name,
+            start_time=start_time,
+            end_time=end_time,
+            use_dask=True,
+        )
 
-    expected_vars = {"temp", "salt", "u", "v", "zeta"}
-    assert set(ds.var_names).issuperset(expected_vars)
+        expected_vars = {"temp", "salt", "u", "v", "zeta"}
+        assert set(data.var_names).issuperset(expected_vars)
+
+        expected_vars = {"thetao", "so", "uo", "vo", "zos"}
+        assert "time" in data.ds.dims
+        assert set(data.ds.data_vars).issuperset(expected_vars)
+
+
+@pytest.mark.parametrize(
+    "fname,start_time",
+    [
+        (download_test_data("GLORYS_NA_2012.nc"), datetime(2012, 1, 1, 12)),
+        (download_test_data("GLORYS_NA_20121231.nc"), datetime(2012, 12, 31, 12)),
+        (download_test_data("GLORYS_coarse_test_data.nc"), datetime(2021, 6, 29)),
+    ],
+)
+@pytest.mark.parametrize("allow_flex_time", [True, False])
+def test_non_default_glorys_dataset_loading(
+    fname, start_time, allow_flex_time, use_dask
+) -> None:
+    """Verify the default GLORYS dataset is loaded correctly."""
+    for end_time in [None, start_time, start_time]:
+        data = GLORYSDataset(
+            filename=fname,
+            start_time=start_time,
+            end_time=end_time,
+            use_dask=use_dask,
+            allow_flex_time=allow_flex_time,
+        )
+
+        expected_vars = {"temp", "salt", "u", "v", "zeta"}
+        assert set(data.var_names).issuperset(expected_vars)
+
+        expected_vars = {"thetao", "so", "uo", "vo", "zos"}
+        assert "time" in data.ds.dims
+        assert set(data.ds.data_vars).issuperset(expected_vars)
 
 
 def test_data_concatenation(use_dask):
@@ -708,43 +763,297 @@ class TestTPXODataset:
             global_tpxo_dataset.select_constituents(11, omega)
 
 
-class TestRiverDataset:
-    def test_deduplicate_river_names(self, tmp_path):
-        sample_dim_and_var_names = {
-            "dim_names": {"station": "station", "time": "time"},
-            "var_names": {
-                "latitude": "lat",
-                "longitude": "lon",
-                "flux": "flux",
-                "ratio": "ratio",
-                "name": "name",
-            },
-        }
+# test _concatenate_longitudes
 
-        data = {
-            "lat": (["station"], [10.0, 20.0, 30.0]),
-            "lon": (["station"], [100.0, 110.0, 120.0]),
-            "flux": (["time", "station"], np.random.rand(1, 3)),
-            "ratio": (["time", "station"], np.random.rand(1, 3)),
-            "name": (["station"], ["Amazon", "Nile", "Amazon"]),  # duplicate
-        }
-        coords = {"station": [0, 1, 2], "time": [0]}
-        ds = xr.Dataset(data, coords=coords)
-
-        # Write to temporary NetCDF file
-        file_path = tmp_path / "rivers.nc"
-        ds.to_netcdf(file_path)
-
-        river_dataset = RiverDataset(
-            filename=file_path,
-            start_time=datetime(2000, 1, 1),
-            end_time=datetime(2000, 1, 2),
-            dim_names=sample_dim_and_var_names["dim_names"],
-            var_names=sample_dim_and_var_names["var_names"],
+
+@pytest.fixture
+def sample_ds(use_dask):
+    lon = xr.DataArray(np.array([0, 90, 180]), dims="lon", name="lon")
+    lat = xr.DataArray(np.array([-30, 0, 30]), dims="lat", name="lat")
+
+    var_with_lon = xr.DataArray(
+        np.arange(9).reshape(3, 3),
+        dims=("lat", "lon"),
+        coords={"lat": lat, "lon": lon},
+        name="var_with_lon",
+    )
+
+    var_no_lon = xr.DataArray(
+        np.array([1, 2, 3]),
+        dims="lat",
+        coords={"lat": lat},
+        name="var_no_lon",
+    )
+
+    ds = xr.Dataset({"var_with_lon": var_with_lon, "var_no_lon": var_no_lon})
+
+    if use_dask:
+        ds = ds.chunk({"lat": -1, "lon": -1})
+
+    return ds
+
+
+@pytest.mark.parametrize(
+    "end,expected_lons",
+    [
+        ("lower", [-360, -270, -180, 0, 90, 180]),
+        ("upper", [0, 90, 180, 360, 450, 540]),
+        ("both", [-360, -270, -180, 0, 90, 180, 360, 450, 540]),
+    ],
+)
+def test_concatenate_longitudes(sample_ds, end, expected_lons, use_dask):
+    dim_names = {"longitude": "lon"}
+
+    ds_concat = _concatenate_longitudes(
+        sample_ds, dim_names, end=end, use_dask=use_dask
+    )
+
+    # longitude should be extended as expected
+    np.testing.assert_array_equal(ds_concat.lon.values, expected_lons)
+
+    # variable with longitude should be extended in size
+    assert ds_concat.var_with_lon.shape[-1] == len(expected_lons)
+
+    # variable without longitude should remain untouched
+    np.testing.assert_array_equal(
+        ds_concat.var_no_lon.values,
+        sample_ds.var_no_lon.values,
+    )
+
+    if use_dask:
+        import dask
+
+        # Ensure dask array backing the data
+        assert isinstance(ds_concat.var_with_lon.data, dask.array.Array)
+        # Longitude dimension should be chunked (-1 → one chunk spanning the whole dim)
+        assert ds_concat.var_with_lon.chunks[-1] == (len(expected_lons),)
+    else:
+        # With use_dask=False, data should be a numpy array
+        assert isinstance(ds_concat.var_with_lon.data, np.ndarray)
+
+
+def test_invalid_end_raises(sample_ds):
+    dim_names = {"longitude": "lon"}
+    with pytest.raises(ValueError):
+        _concatenate_longitudes(sample_ds, dim_names, end="invalid")
+
+
+# test choose_subdomain
+
+
+def test_choose_subdomain_basic(global_dataset, use_dask):
+    target_coords = {
+        "lat": xr.DataArray([0, 10]),
+        "lon": xr.DataArray([30, 40]),
+        "straddle": False,
+    }
+    out = choose_subdomain(
+        global_dataset,
+        dim_names={"latitude": "latitude", "longitude": "longitude"},
+        resolution=1.0,
+        is_global=True,
+        target_coords=target_coords,
+        buffer_points=2,
+        use_dask=use_dask,
+    )
+    assert out.latitude.min() <= 0
+    assert out.latitude.max() >= 10
+    assert out.longitude.min() <= 30
+    assert out.longitude.max() >= 40
+
+
+def test_choose_subdomain_raises_on_empty_lon(non_global_dataset, use_dask):
+    target_coords = {
+        "lat": xr.DataArray([-10, 10]),
+        "lon": xr.DataArray([210, 215]),  # outside 0-180
+        "straddle": False,
+    }
+    with pytest.raises(ValueError, match="longitude range"):
+        choose_subdomain(
+            non_global_dataset,
+            dim_names={"latitude": "latitude", "longitude": "longitude"},
+            resolution=1.0,
+            is_global=False,
+            target_coords=target_coords,
+            use_dask=use_dask,
+        )
+
+
+def test_choose_subdomain_raises_on_empty_lat(global_dataset, use_dask):
+    target_coords = {
+        "lat": xr.DataArray([1000, 1010]),  # outside dataset range
+        "lon": xr.DataArray([30, 40]),
+        "straddle": False,
+    }
+    with pytest.raises(ValueError, match="latitude range"):
+        choose_subdomain(
+            global_dataset,
+            dim_names={"latitude": "latitude", "longitude": "longitude"},
+            resolution=1.0,
+            is_global=True,
+            target_coords=target_coords,
+            use_dask=use_dask,
         )
 
-        names = river_dataset.ds["name"].values
-        assert "Amazon_1" in names
-        assert "Amazon_2" in names
-        assert "Nile" in names
-        assert len(set(names)) == len(names)  # all names must be unique
+
+def test_choose_subdomain_straddle(global_dataset, use_dask):
+    target_coords = {
+        "lat": xr.DataArray([-10, 10]),
+        "lon": xr.DataArray([-170, 170]),  # cross the dateline
+        "straddle": True,
+    }
+    out = choose_subdomain(
+        global_dataset,
+        dim_names={"latitude": "latitude", "longitude": "longitude"},
+        resolution=1.0,
+        is_global=True,
+        target_coords=target_coords,
+        buffer_points=5,
+        use_dask=use_dask,
+    )
+    # Ensure output includes both sides of the dateline, mapped into -180 - 180
+    assert (out.longitude.min() < 0) and (out.longitude.max() > 0)
+
+
+def test_choose_subdomain_wraps_negative_lon(global_dataset, use_dask):
+    target_coords = {
+        "lat": xr.DataArray([0, 20]),
+        "lon": xr.DataArray([-20, -10]),  # negative longitudes
+        "straddle": False,
+    }
+    out = choose_subdomain(
+        global_dataset,
+        dim_names={"latitude": "latitude", "longitude": "longitude"},
+        resolution=1.0,
+        is_global=True,
+        target_coords=target_coords,
+        buffer_points=2,
+        use_dask=use_dask,
+    )
+    # Output longitudes should be shifted into [0, 360]
+    assert (out.longitude >= 0).all()
+
+
+def test_choose_subdomain_respects_buffer(global_dataset, use_dask):
+    target_coords = {
+        "lat": xr.DataArray([0, 0]),
+        "lon": xr.DataArray([50, 50]),
+        "straddle": False,
+    }
+    out = choose_subdomain(
+        global_dataset,
+        dim_names={"latitude": "latitude", "longitude": "longitude"},
+        resolution=1.0,
+        is_global=True,
+        target_coords=target_coords,
+        buffer_points=10,
+        use_dask=use_dask,
+    )
+    # Buffer should extend at least 10 degrees beyond target lon
+    assert out.longitude.min() <= 40
+    assert out.longitude.max() >= 60
+
+
+# test get_glorys_bounds
+
+
+@pytest.fixture
+def glorys_grid_0_360(tmp_path):
+    lats = np.linspace(-90, 90, 181)
+    lons = np.linspace(0, 360, 361)
+    ds = xr.Dataset(coords={"latitude": lats, "longitude": lons})
+    path = tmp_path / "GLORYS_0_360.nc"
+    ds.to_netcdf(path)
+    return path
+
+
+@pytest.fixture
+def glorys_grid_neg180_180(tmp_path):
+    lats = np.linspace(-90, 90, 181)
+    lons = np.linspace(-180, 180, 361)
+    ds = xr.Dataset(coords={"latitude": lats, "longitude": lons})
+    path = tmp_path / "GLORYS_neg180_180.nc"
+    ds.to_netcdf(path)
+    return path
+
+
+@pytest.fixture
+def glorys_grid_real():
+    return GLORYS_GLOBAL_GRID_PATH
+
+
+@pytest.mark.parametrize(
+    "grid_fixture",
+    [
+        "grid",
+        "grid_that_straddles_dateline",
+        "grid_that_straddles_180_degree_meridian",
+        "small_grid",
+        "tiny_grid",
+    ],
+)
+@pytest.mark.parametrize(
+    "glorys_grid_fixture",
+    ["glorys_grid_0_360", "glorys_grid_neg180_180", "glorys_grid_real"],
+)
+def test_get_glorys_bounds(tmp_path, grid_fixture, glorys_grid_fixture, request):
+    grid = request.getfixturevalue(grid_fixture)
+    glorys_grid_path = request.getfixturevalue(glorys_grid_fixture)
+
+    bounds = get_glorys_bounds(grid=grid, glorys_grid_path=glorys_grid_path)
+    assert set(bounds) == {
+        "minimum_latitude",
+        "maximum_latitude",
+        "minimum_longitude",
+        "maximum_longitude",
+    }
+
+
+@pytest.mark.use_copernicus
+@pytest.mark.skipif(copernicusmarine is None, reason="copernicusmarine required")
+@pytest.mark.parametrize(
+    "grid_fixture",
+    [
+        "tiny_grid_that_straddles_dateline",
+        "tiny_grid_that_straddles_180_degree_meridian",
+        "tiny_rotated_grid",
+    ],
+)
+def test_invariance_to_get_glorys_bounds(tmp_path, grid_fixture, use_dask, request):
+    start_time = datetime(2012, 1, 1)
+    grid = request.getfixturevalue(grid_fixture)
+    target_coords = get_target_coords(grid)
+
+    regional_file, bigger_regional_file = download_regional_and_bigger(
+        tmp_path, grid, start_time, variables=["thetao", "uo", "zos"]
+    )
+
+    # create datasets from regional and bigger regional data
+    regional_data = GLORYSDataset(
+        var_names={"temp": "thetao", "u": "uo", "zeta": "zos"},
+        filename=regional_file,
+        start_time=start_time,
+        climatology=False,
+        allow_flex_time=False,
+        use_dask=use_dask,
+    )
+    bigger_regional_data = GLORYSDataset(
+        var_names={"temp": "thetao", "u": "uo", "zeta": "zos"},
+        filename=bigger_regional_file,
+        start_time=start_time,
+        climatology=False,
+        allow_flex_time=False,
+        use_dask=use_dask,
+    )
+
+    # subset both datasets and check they are the same
+    regional_data.choose_subdomain(target_coords)
+    bigger_regional_data.choose_subdomain(target_coords)
+
+    # Use assert_allclose instead of equals: necessary for grids that straddle the 180° meridian.
+    # Copernicus returns data on [-180, 180] by default, but if you request a range
+    # like [170, 190], it remaps longitudes. That remapping introduces tiny floating
+    # point differences in the longitude coordinate, so strict equality will fail
+    # even though the data are effectively identical.
+    # For grids that do not straddle the 180° meridian, strict equality still holds.
+    xr.testing.assert_allclose(bigger_regional_data.ds, regional_data.ds)