8501164034

Committed 31 Mar 2024 10:00PM UTC coverage: 87.857% (+0.2%) from 87.669%

Build # 8501164034

Build Type

Pull #53

github

Committed by

web-flow

Commit Message

Merge ad9383aa4 into 03a72041e

Pull Request Pull Request #53: Refactor code style

Run Details

670 of 758 new or added lines in 88 files covered. (88.39%)

332 existing lines in 24 files now uncovered.

9001 of 10245 relevant lines covered (87.86%)

0.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.63

/gpm/tests/test_visualization/test_plot.py

# -----------------------------------------------------------------------------.
# MIT License

# Copyright (c) 2024 GPM-API developers
#
# This file is part of GPM-API.

# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

# -----------------------------------------------------------------------------.
import platform

import cartopy.crs as ccrs
import numpy as np
import pytest
import xarray as xr
from matplotlib import pyplot as plt

import gpm.configs
from gpm.tests.test_visualization.utils import (
    expand_dims,
    get_test_name,
    save_and_check_figure,
    skip_tests_if_no_data,
)
from gpm.visualization import plot

# Fixtures imported from gpm.tests.conftest:
# - orbit_dataarray
# - orbit_antimeridian_dataarray
# - orbit_pole_dataarray
# - orbit_nan_cross_track_dataarray
# - orbit_nan_along_track_dataarray
# - orbit_nan_lon_cross_track_dataarray
# - orbit_nan_lon_along_track_dataarray
# - grid_dataarray
# - grid_nan_lon_dataarray


pytestmark = pytest.mark.skipif(
    platform.system() == "Windows", reason="Minor figure differences on Windows"
)
skip_tests_if_no_data()


def test_is_generator() -> None:
    """Test the _is_generator function"""

    def generator():
        yield 1

    assert plot.is_generator(generator())
    assert plot.is_generator(i for i in range(10))
    assert not plot.is_generator([1, 2, 3])


def test_preprocess_figure_args() -> None:
    """Test the preprocess_figure_args function"""

    nothing = {}
    something = {"": 0}

    # Test with ax None
    _ = plot.preprocess_figure_args(None, fig_kwargs=nothing, subplot_kwargs=nothing)
    _ = plot.preprocess_figure_args(None, fig_kwargs=something, subplot_kwargs=nothing)
    _ = plot.preprocess_figure_args(None, fig_kwargs=nothing, subplot_kwargs=something)

    # Test with ax not None
    ax = plt.subplot()
    _ = plot.preprocess_figure_args(ax, fig_kwargs=nothing, subplot_kwargs=nothing)

    with pytest.raises(ValueError):
        plot.preprocess_figure_args(ax, fig_kwargs=something, subplot_kwargs=nothing)

    with pytest.raises(ValueError):
        plot.preprocess_figure_args(ax, fig_kwargs=nothing, subplot_kwargs=something)


class TestGetDataArrayExtent:
    """Test the get_extent function"""

    def test_orbit(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test getting the extent of orbit data"""

        returned_extent = plot.get_dataarray_extent(orbit_dataarray)
        expected_extent = (-2.77663454, 22.65579744, -3.53830585, 18.64709521)
        np.testing.assert_allclose(returned_extent, expected_extent, rtol=1e-9)

    def test_grid(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test getting the extent of grid data"""

        returned_extent = plot.get_dataarray_extent(grid_dataarray)
        expected_extent = (-5, 20, -5, 15)
        assert returned_extent == expected_extent


def test_get_antimeridian_mask(
    orbit_antimeridian_dataarray: xr.DataArray,
) -> None:
    """Test the get_antimeridian_mask function"""

    lon = orbit_antimeridian_dataarray["lon"].data
    returned_mask = plot.get_antimeridian_mask(lon)
    # fmt: off
    expected_mask = np.array([
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0,],
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0,],
    ], dtype=bool)
    np.testing.assert_array_equal(returned_mask, expected_mask)


class TestPlotMap:
    """Test the plot_map function"""

    def test_orbit(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data"""

        p = plot.plot_map(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_antimeridian(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the antimeridian"""

        p = plot.plot_map(orbit_antimeridian_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_antimeridian_recentered(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the antimeridian with recentering"""

        crs_proj = ccrs.PlateCarree(central_longitude=180)
        p = plot.plot_map(orbit_antimeridian_dataarray, subplot_kwargs={"projection": crs_proj})
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_antimeridian_projection(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the antimeridian on orthographic projection"""

        crs_proj = ccrs.Orthographic(180, 0)
        p = plot.plot_map(orbit_antimeridian_dataarray, subplot_kwargs={"projection": crs_proj})
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_antimeridian_not_masked_recentered(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the antimeridian without masking (recentered)"""

        crs_proj = ccrs.PlateCarree(central_longitude=180)
        with gpm.config.set({"viz_hide_antimeridian_data": False}):
            p = plot.plot_map(orbit_antimeridian_dataarray, subplot_kwargs={"projection": crs_proj})
            save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_pole(
        self,
        orbit_pole_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the south pole"""

        p = plot.plot_map(orbit_pole_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_pole_projection(
        self,
        orbit_pole_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the south pole on orthographic projection"""

        crs_proj = ccrs.Orthographic(0, -90)
        p = plot.plot_map(orbit_pole_dataarray, subplot_kwargs={"projection": crs_proj})
        save_and_check_figure(figure=p.figure, name=get_test_name())

    ## Test data with nan

    def test_orbit_data_nan_cross_track(
        self,
        orbit_data_nan_cross_track_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit with NaN values in the data at cross-track edges"""

        p = plot.plot_map(orbit_data_nan_cross_track_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_data_nan_along_track(
        self,
        orbit_data_nan_along_track_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit with NaN values in the data at along-track edges"""

        p = plot.plot_map(orbit_data_nan_along_track_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_data_nan_values(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit with NaN values in the data at one cell"""

        orbit_dataarray.data[2, 2] = np.nan
        p = plot.plot_map(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    #### Test with NaN coordinates

    def test_orbit_nan_coordinate_at_one_cell(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with NaN coordinates at one cell"""
        # NOTE: here we test linear interpolation of coordinates
        orbit_dataarray["lon"].data[1, 3] = np.nan
        orbit_dataarray["lat"].data[1, 3] = np.nan
        p = plot.plot_map(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    @pytest.mark.skipif(platform.system() == "Windows", reason="Minor figure difference on Windows")
    def test_orbit_nan_coordinate_at_corners(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with NaN coordinates at the swath corners."""
        # NOTE: here we test nearest neighbour interpolation of coordinates
        orbit_dataarray["lon"].data[0:2, 0:2] = np.nan
        orbit_dataarray["lat"].data[0:2, 0:2] = np.nan
        p = plot.plot_map(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_nan_coordinate_at_cross_track_center(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with NaN coordinates at one cell on the cross-track centerline"""
        # NOTE: centerline used to identify contiguoues slices. So here assumed not contiguous.
        orbit_dataarray["lon"].data[2, 3] = np.nan
        orbit_dataarray["lat"].data[2, 3] = np.nan
        p = plot.plot_map(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_nan_outer_cross_track(
        self,
        orbit_nan_outer_cross_track_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with some NaN coordinates on the outer cross-track cells"""

        p = plot.plot_map(orbit_nan_outer_cross_track_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_nan_inner_cross_track(
        self,
        orbit_nan_inner_cross_track_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with all NaN coordinates on the outer cross-track cells"""

        p = plot.plot_map(orbit_nan_inner_cross_track_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_nan_slice_along_track(
        self,
        orbit_nan_slice_along_track_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with some NaN latitudes along-track"""

        p = plot.plot_map(orbit_nan_slice_along_track_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    #### Test colorbar kwargs

    def test_orbit_cbar_kwargs(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with colorbar keyword arguments"""
        cbar_kwargs = {"ticks": [0.1, 0.2, 0.4, 0.6, 0.8], "ticklabels": [42.5, 43, 44, 45, 46]}

        p = plot.plot_map(orbit_dataarray, cbar_kwargs=cbar_kwargs)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_horizontal_colorbar(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with a horizontal colorbar"""

        cbar_kwargs = {"orientation": "horizontal"}
        p = plot.plot_map(orbit_dataarray, cbar_kwargs=cbar_kwargs)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_rgb(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit RGB data"""

        orbit_dataarray = expand_dims(orbit_dataarray, 3, dim="rgb", axis=2)
        p = plot.plot_map(orbit_dataarray, rgb=True)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_rgba(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit RGBA data"""

        orbit_dataarray = expand_dims(orbit_dataarray, 4, dim="rgb", axis=2)
        p = plot.plot_map(orbit_dataarray, rgb=True)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_rgb_antimeridian_recentered(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit RGB data going over the antimeridian without masking (recentered)"""

        orbit_dataarray = expand_dims(orbit_antimeridian_dataarray, 3, dim="rgb", axis=2)
        crs_proj = ccrs.PlateCarree(central_longitude=180)
        p = plot.plot_map(orbit_dataarray, subplot_kwargs={"projection": crs_proj}, rgb=True)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_rgb_antimeridian_not_masked_recentered(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit RGB data going over the antimeridian without masking (recentered)"""

        orbit_dataarray = expand_dims(orbit_antimeridian_dataarray, 3, dim="rgb", axis=2)
        crs_proj = ccrs.PlateCarree(central_longitude=180)
        with gpm.config.set({"viz_hide_antimeridian_data": False}):
            p = plot.plot_map(orbit_dataarray, subplot_kwargs={"projection": crs_proj}, rgb=True)
            save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_rgb_invalid(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with RGB flag on non RGB data"""

        with pytest.raises(ValueError):
            plot.plot_map(orbit_dataarray, rgb=True)

    def test_orbit_invalid_values(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with some invalid values"""

        orbit_dataarray.data[1:4, 1:4] = np.nan
        p = plot.plot_map(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data"""

        p = plot.plot_map(grid_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid_nan_lon(
        self,
        grid_nan_lon_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data with NaN longitudes"""

        p = plot.plot_map(grid_nan_lon_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid_time_dim(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data with time dimension"""

        grid_dataarray = expand_dims(grid_dataarray, 4, "time")
        with pytest.raises(ValueError):  # Expecting a 2D GPM field
            plot.plot_map(grid_dataarray)

    def test_invalid(
        self,
    ) -> None:
        """Test invalid data"""

        da = xr.DataArray()
        with pytest.raises(ValueError):
            plot.plot_map(da)


class TestPlotImage:
    """Test the plot_image function"""

    def test_orbit(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data"""

        p = plot.plot_image(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_cbar_kwargs(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with colorbar keyword arguments"""
        cbar_kwargs = {"ticks": [0.1, 0.2, 0.4, 0.6, 0.8], "ticklabels": [42.5, 43, 44, 45, 46]}

        p = plot.plot_image(orbit_dataarray, cbar_kwargs=cbar_kwargs)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_horizontal_colorbar(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with a horizontal colorbar"""

        cbar_kwargs = {"orientation": "horizontal"}
        p = plot.plot_image(orbit_dataarray, cbar_kwargs=cbar_kwargs)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_no_cbar(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data without colorbar"""

        p = plot.plot_image(orbit_dataarray, add_colorbar=False)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data"""

        p = plot.plot_image(grid_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_invalid(
        self,
    ) -> None:
        """Test invalid data"""

        da = xr.DataArray()
        with pytest.raises(ValueError):
            plot.plot_image(da)


class TestPlotMapMesh:
    """Test the plot_map_mesh function"""

    def test_orbit(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data"""

        p = plot.plot_map_mesh(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    # def test_orbit_antimeridian(  # Does not work, issue in cartopy
    #     self,
    #     orbit_antimeridian_dataarray: xr.DataArray,
    # ) -> None:
    #     """Test plotting orbit data going over the antimeridian"""

    #     p = plot.plot_map_mesh(orbit_antimeridian_dataarray)
    #     save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_antimeridian_projection(
        self,
        orbit_antimeridian_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the antimeridian on orthographic projection"""

        crs_proj = ccrs.Orthographic(180, 0)
        p = plot.plot_map_mesh(
            orbit_antimeridian_dataarray, subplot_kwargs={"projection": crs_proj}
        )
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_pole(
        self,
        orbit_pole_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the south pole"""

        p = plot.plot_map_mesh(orbit_pole_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_pole_projection(
        self,
        orbit_pole_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data going over the south pole on orthographic projection"""

        crs_proj = ccrs.Orthographic(0, -90)
        p = plot.plot_map_mesh(orbit_pole_dataarray, subplot_kwargs={"projection": crs_proj})
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data"""

        p = plot.plot_map_mesh(grid_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid_nan_lon(
        self,
        grid_nan_lon_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data with NaN longitudes"""

        p = plot.plot_map_mesh(grid_nan_lon_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())


class TestPlotMapMeshCentroids:
    """Test the plot_map_mesh_centroids function"""

    def test_orbit(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data"""

        p = plot.plot_map_mesh_centroids(orbit_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data"""

        p = plot.plot_map_mesh_centroids(grid_dataarray)
        save_and_check_figure(figure=p.figure, name=get_test_name())


class TestPlotLabels:
    """Test the plot_labels function"""

    label_name = "label"

    @pytest.fixture()
    def orbit_labels_dataarray(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> xr.DataArray:
        """Create an orbit data array with label coordinates"""

        labels = np.random.randint(0, 10, orbit_dataarray.shape)
        return orbit_dataarray.assign_coords(
            {self.label_name: (("cross_track", "along_track"), labels)}
        )

    @pytest.fixture()
    def grid_labels_dataarray(
        self,
        grid_dataarray: xr.DataArray,
    ) -> xr.DataArray:
        """Create a grid data array with label coordinates"""

        labels = np.random.randint(0, 10, grid_dataarray.shape)
        return grid_dataarray.assign_coords({self.label_name: (("lat", "lon"), labels)})

    def test_orbit(
        self,
        orbit_labels_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data"""

        p = plot.plot_labels(orbit_labels_dataarray, label_name=self.label_name)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_dataset(
        self,
        orbit_labels_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data from a dataset"""

        ds = xr.Dataset({self.label_name: orbit_labels_dataarray[self.label_name]})
        p = plot.plot_labels(ds, label_name=self.label_name)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_labels_dataarray(
        self,
        orbit_labels_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data from labels data array directly"""

        p = plot.plot_labels(orbit_labels_dataarray[self.label_name])
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_orbit_exceed_labels(
        self,
        orbit_labels_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data with too many labels for colorbar"""

        p = plot.plot_labels(orbit_labels_dataarray, label_name=self.label_name, max_n_labels=5)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    def test_grid(
        self,
        grid_labels_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data"""

        p = plot.plot_labels(grid_labels_dataarray, label_name=self.label_name)
        save_and_check_figure(figure=p.figure, name=get_test_name())

    @pytest.mark.usefixtures("_prevent_pyplot_show")
    def test_generator(
        self,
        orbit_labels_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data form a generator"""

        da_list = [
            (0, orbit_labels_dataarray),
            (1, orbit_labels_dataarray),
        ]
        generator = (t for t in da_list)

        p = plot.plot_labels(generator, label_name=self.label_name)  # only last plot is returned
        save_and_check_figure(figure=p.figure, name=get_test_name())


class TestPlotPatches:
    """Test the plot_patches function"""

    @pytest.mark.usefixtures("_prevent_pyplot_show")
    def test_orbit(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data"""

        da_list = [
            (0, orbit_dataarray),
            (1, orbit_dataarray),
        ]
        generator = (t for t in da_list)
        plot.plot_patches(generator)  # does not return plotter
        save_and_check_figure(name=get_test_name())

    @pytest.mark.usefixtures("_prevent_pyplot_show")
    def test_orbit_dataset(
        self,
        orbit_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting orbit data from a dataset"""

        variable_name = "variable"
        ds = xr.Dataset({variable_name: orbit_dataarray})
        ds_list = [
            (0, ds),
            (1, ds),
        ]
        generator = (t for t in ds_list)

        # Test with missing variable
        with pytest.raises(ValueError):
            plot.plot_patches(generator)

        plot.plot_patches(generator, variable=variable_name)  # does not return plotter
        save_and_check_figure(name=get_test_name())

    @pytest.mark.usefixtures("_prevent_pyplot_show")
    def test_grid(
        self,
        grid_dataarray: xr.DataArray,
    ) -> None:
        """Test plotting grid data"""

        da_list = [
            (0, grid_dataarray),
            (1, grid_dataarray),
        ]
        generator = (t for t in da_list)
        plot.plot_patches(generator)  # does not return plotter
        save_and_check_figure(name=get_test_name())

    def test_invalid(
        self,
    ) -> None:
        """Test invalid data"""

        invalid_list = [
            (0, xr.DataArray()),
            (1, xr.DataArray()),
        ]
        generator = (t for t in invalid_list)
        plot.plot_patches(generator)  # passes without error

ghiggi / gpm_api / 8501164034

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous