Merge pull request #1100 from UXARRAY/rajeeja/issue_1098

 Convert unittest to pytest

Author: rajeeja

test/test_api.py

@@ -1,11 +1,9 @@
 import os
-from unittest import TestCase
 from pathlib import Path
 import numpy.testing as nt
-
 import uxarray as ux
-import xarray as xr
 import numpy as np
+import pytest
 
 try:
     import constants
@@ -14,126 +12,111 @@
 
 current_path = Path(os.path.dirname(os.path.realpath(__file__)))
 
+geoflow_data_path = current_path / "meshfiles" / "ugrid" / "geoflow-small"
+gridfile_geoflow = current_path / "meshfiles" / "ugrid" / "geoflow-small" / "grid.nc"
+geoflow_data_v1 = geoflow_data_path / "v1.nc"
+geoflow_data_v2 = geoflow_data_path / "v2.nc"
+geoflow_data_v3 = geoflow_data_path / "v3.nc"
 
-class TestAPI(TestCase):
-    geoflow_data_path = current_path / "meshfiles" / "ugrid" / "geoflow-small"
-    gridfile_geoflow = current_path / "meshfiles" / "ugrid" / "geoflow-small" / "grid.nc"
-    geoflow_data_v1 = geoflow_data_path / "v1.nc"
-    geoflow_data_v2 = geoflow_data_path / "v2.nc"
-    geoflow_data_v3 = geoflow_data_path / "v3.nc"
-
-    gridfile_ne30 = current_path / "meshfiles" / "ugrid" / "outCSne30" / "outCSne30.ug"
-    dsfile_var2_ne30 = current_path / "meshfiles" / "ugrid" / "outCSne30" / "outCSne30_var2.nc"
-    dsfiles_mf_ne30 = str(
-        current_path) + "/meshfiles/ugrid/outCSne30/outCSne30_*.nc"
-
-    def test_open_geoflow_dataset(self):
-        """Loads a single dataset with its grid topology file using uxarray's
-        open_dataset call."""
+gridfile_ne30 = current_path / "meshfiles" / "ugrid" / "outCSne30" / "outCSne30.ug"
+dsfile_var2_ne30 = current_path / "meshfiles" / "ugrid" / "outCSne30" / "outCSne30_var2.nc"
+dsfiles_mf_ne30 = str(current_path) + "/meshfiles/ugrid/outCSne30/outCSne30_*.nc"
 
-        # Paths to Data Variable files
-        data_paths = [
-            self.geoflow_data_v1, self.geoflow_data_v2, self.geoflow_data_v3
-        ]
+def test_open_geoflow_dataset():
+    """Loads a single dataset with its grid topology file using uxarray's
+    open_dataset call."""
 
-        uxds_v1 = ux.open_dataset(self.gridfile_geoflow, data_paths[0])
+    # Paths to Data Variable files
+    data_paths = [
+        geoflow_data_v1, geoflow_data_v2, geoflow_data_v3
+    ]
 
-        # Ideally uxds_v1.uxgrid should NOT be None
-        with self.assertRaises(AssertionError):
-            nt.assert_equal(uxds_v1.uxgrid, None)
+    uxds_v1 = ux.open_dataset(gridfile_geoflow, data_paths[0])
 
-    def test_open_dataset(self):
-        """Loads a single dataset with its grid topology file using uxarray's
-        open_dataset call."""
+    # Ideally uxds_v1.uxgrid should NOT be None
+    nt.assert_equal(uxds_v1.uxgrid is not None, True)
 
-        uxds_var2_ne30 = ux.open_dataset(self.gridfile_ne30,
-                                         self.dsfile_var2_ne30)
+def test_open_dataset():
+    """Loads a single dataset with its grid topology file using uxarray's
+    open_dataset call."""
 
-        nt.assert_equal(uxds_var2_ne30.uxgrid.node_lon.size,
-                        constants.NNODES_outCSne30)
-        nt.assert_equal(len(uxds_var2_ne30.uxgrid._ds.data_vars),
-                        constants.DATAVARS_outCSne30)
-        nt.assert_equal(uxds_var2_ne30.source_datasets,
-                        str(self.dsfile_var2_ne30))
+    uxds_var2_ne30 = ux.open_dataset(gridfile_ne30, dsfile_var2_ne30)
 
-    def test_open_mf_dataset(self):
-        """Loads multiple datasets with their grid topology file using
-        uxarray's open_dataset call."""
+    nt.assert_equal(uxds_var2_ne30.uxgrid.node_lon.size, constants.NNODES_outCSne30)
+    nt.assert_equal(len(uxds_var2_ne30.uxgrid._ds.data_vars), constants.DATAVARS_outCSne30)
+    nt.assert_equal(uxds_var2_ne30.source_datasets, str(dsfile_var2_ne30))
 
-        uxds_mf_ne30 = ux.open_mfdataset(self.gridfile_ne30,
-                                         self.dsfiles_mf_ne30)
+def test_open_mf_dataset():
+    """Loads multiple datasets with their grid topology file using
+    uxarray's open_dataset call."""
 
-        nt.assert_equal(uxds_mf_ne30.uxgrid.node_lon.size,
-                        constants.NNODES_outCSne30)
-        nt.assert_equal(len(uxds_mf_ne30.uxgrid._ds.data_vars),
-                        constants.DATAVARS_outCSne30)
+    uxds_mf_ne30 = ux.open_mfdataset(gridfile_ne30, dsfiles_mf_ne30)
 
-        nt.assert_equal(uxds_mf_ne30.source_datasets, self.dsfiles_mf_ne30)
+    nt.assert_equal(uxds_mf_ne30.uxgrid.node_lon.size, constants.NNODES_outCSne30)
+    nt.assert_equal(len(uxds_mf_ne30.uxgrid._ds.data_vars), constants.DATAVARS_outCSne30)
+    nt.assert_equal(uxds_mf_ne30.source_datasets, dsfiles_mf_ne30)
 
-    def test_open_grid(self):
-        """Loads only a grid topology file using uxarray's open_grid call."""
-        uxgrid = ux.open_grid(self.gridfile_geoflow)
+def test_open_grid():
+    """Loads only a grid topology file using uxarray's open_grid call."""
+    uxgrid = ux.open_grid(gridfile_geoflow)
 
-        nt.assert_almost_equal(uxgrid.calculate_total_face_area(),
-                               constants.MESH30_AREA,
-                               decimal=3)
+    nt.assert_almost_equal(uxgrid.calculate_total_face_area(), constants.MESH30_AREA, decimal=3)
 
-    def test_copy_dataset(self):
-        """Loads a single dataset with its grid topology file using uxarray's
-        open_dataset call and make a copy of the object."""
+def test_copy_dataset():
+    """Loads a single dataset with its grid topology file using uxarray's
+    open_dataset call and make a copy of the object."""
 
-        uxds_var2_ne30 = ux.open_dataset(self.gridfile_ne30,
-                                         self.dsfile_var2_ne30)
+    uxds_var2_ne30 = ux.open_dataset(gridfile_ne30, dsfile_var2_ne30)
 
-        # make a shallow and deep copy of the dataset object
-        uxds_var2_ne30_copy_deep = uxds_var2_ne30.copy(deep=True)
-        uxds_var2_ne30_copy = uxds_var2_ne30.copy(deep=False)
+    # make a shallow and deep copy of the dataset object
+    uxds_var2_ne30_copy_deep = uxds_var2_ne30.copy(deep=True)
+    uxds_var2_ne30_copy = uxds_var2_ne30.copy(deep=False)
 
-        # Ideally uxds_var2_ne30_copy.uxgrid should NOT be None
-        with self.assertRaises(AssertionError):
-            nt.assert_equal(uxds_var2_ne30_copy.uxgrid, None)
+    # Ideally uxds_var2_ne30_copy.uxgrid should NOT be None
+    nt.assert_equal(uxds_var2_ne30_copy.uxgrid is not None, True)
 
-        # Check that the copy is a shallow copy
-        assert (uxds_var2_ne30_copy.uxgrid is uxds_var2_ne30.uxgrid)
-        assert (uxds_var2_ne30_copy.uxgrid == uxds_var2_ne30.uxgrid)
+    # Check that the copy is a shallow copy
+    assert uxds_var2_ne30_copy.uxgrid is uxds_var2_ne30.uxgrid
+    assert uxds_var2_ne30_copy.uxgrid == uxds_var2_ne30.uxgrid
 
-        # Check that the deep copy is a deep copy
-        assert (uxds_var2_ne30_copy_deep.uxgrid == uxds_var2_ne30.uxgrid)
-        assert (uxds_var2_ne30_copy_deep.uxgrid is not uxds_var2_ne30.uxgrid)
+    # Check that the deep copy is a deep copy
+    assert uxds_var2_ne30_copy_deep.uxgrid == uxds_var2_ne30.uxgrid
+    assert uxds_var2_ne30_copy_deep.uxgrid is not uxds_var2_ne30.uxgrid
 
-    def test_copy_dataarray(self):
-        """Loads an unstructured grid and data using uxarray's open_dataset
-        call and make a copy of the dataarray object."""
+def test_copy_dataarray():
+    """Loads an unstructured grid and data using uxarray's open_dataset
+    call and make a copy of the dataarray object."""
 
-        # Paths to Data Variable files
-        data_paths = [
-            self.geoflow_data_v1, self.geoflow_data_v2, self.geoflow_data_v3
-        ]
+    # Paths to Data Variable files
+    data_paths = [
+        geoflow_data_v1, geoflow_data_v2, geoflow_data_v3
+    ]
 
-        uxds_v1 = ux.open_dataset(self.gridfile_geoflow, data_paths[0])
+    uxds_v1 = ux.open_dataset(gridfile_geoflow, data_paths[0])
 
-        # get the uxdataarray object
-        v1_uxdata_array = uxds_v1['v1']
+    # get the uxdataarray object
+    v1_uxdata_array = uxds_v1['v1']
 
-        # make a shallow and deep copy of the dataarray object
-        v1_uxdata_array_copy_deep = v1_uxdata_array.copy(deep=True)
-        v1_uxdata_array_copy = v1_uxdata_array.copy(deep=False)
+    # make a shallow and deep copy of the dataarray object
+    v1_uxdata_array_copy_deep = v1_uxdata_array.copy(deep=True)
+    v1_uxdata_array_copy = v1_uxdata_array.copy(deep=False)
 
-        # Check that the copy is a shallow copy
-        assert (v1_uxdata_array_copy.uxgrid is v1_uxdata_array.uxgrid)
-        assert (v1_uxdata_array_copy.uxgrid == v1_uxdata_array.uxgrid)
+    # Check that the copy is a shallow copy
+    assert v1_uxdata_array_copy.uxgrid is v1_uxdata_array.uxgrid
+    assert v1_uxdata_array_copy.uxgrid == v1_uxdata_array.uxgrid
 
-        # Check that the deep copy is a deep copy
-        assert (v1_uxdata_array_copy_deep.uxgrid == v1_uxdata_array.uxgrid)
-        assert (v1_uxdata_array_copy_deep.uxgrid is not v1_uxdata_array.uxgrid)
+    # Check that the deep copy is a deep copy
+    assert v1_uxdata_array_copy_deep.uxgrid == v1_uxdata_array.uxgrid
+    assert v1_uxdata_array_copy_deep.uxgrid is not v1_uxdata_array.uxgrid
 
-    def test_open_dataset_grid_kwargs(self):
-        """Drops ``Mesh2_face_nodes`` from the inputted grid file using
-        ``grid_kwargs``"""
+def test_open_dataset_grid_kwargs():
+    """Drops ``Mesh2_face_nodes`` from the inputted grid file using
+    ``grid_kwargs``"""
 
-        with self.assertRaises(ValueError):
-            # attempt to open a dataset after dropping face nodes should raise a KeyError
-            uxds = ux.open_dataset(
-                self.gridfile_ne30,
-                self.dsfile_var2_ne30,
-                grid_kwargs={"drop_variables": "Mesh2_face_nodes"})
+    with pytest.raises(ValueError):
+        # attempt to open a dataset after dropping face nodes should raise a KeyError
+        uxds = ux.open_dataset(
+            gridfile_ne30,
+            dsfile_var2_ne30,
+            grid_kwargs={"drop_variables": "Mesh2_face_nodes"}
+        )

test/test_arcs.py

@@ -1,14 +1,9 @@
 import os
 import numpy as np
 import numpy.testing as nt
-import random
-import xarray as xr
-
-from unittest import TestCase
 from pathlib import Path
-
 import uxarray as ux
-
+import pytest
 from uxarray.grid.coordinates import _lonlat_rad_to_xyz
 from uxarray.grid.arcs import point_within_gca
 
@@ -25,72 +20,65 @@
 gridfile_geoflowsmall_grid = current_path / 'meshfiles' / "ugrid" / "geoflow-small" / 'grid.nc'
 gridfile_geoflowsmall_var = current_path / 'meshfiles' / "ugrid" / "geoflow-small" / 'v1.nc'
 
-
-class TestIntersectionPoint(TestCase):
-
-    def test_pt_within_gcr(self):
-        # The GCR that's eexactly 180 degrees will have Value Error raised
-
-        gcr_180degree_cart = np.asarray([
-            _lonlat_rad_to_xyz(0.0, np.pi / 2.0),
-            _lonlat_rad_to_xyz(0.0, -np.pi / 2.0)
-        ])
-        pt_same_lon_in = np.asarray(_lonlat_rad_to_xyz(0.0, 0.0))
-
-        with self.assertRaises(ValueError):
-            point_within_gca(pt_same_lon_in, gcr_180degree_cart[0],gcr_180degree_cart[1] )
-        #
-        # Test when the point and the GCA all have the same longitude
-        gcr_same_lon_cart = np.asarray([
-            _lonlat_rad_to_xyz(0.0, 1.5),
-            _lonlat_rad_to_xyz(0.0, -1.5)
-        ])
-        pt_same_lon_in = np.asarray(_lonlat_rad_to_xyz(0.0, 0.0))
-        self.assertTrue(point_within_gca(pt_same_lon_in, gcr_same_lon_cart[0], gcr_same_lon_cart[1]))
-
-        pt_same_lon_out = np.asarray(_lonlat_rad_to_xyz(0.0, 1.5000001))
-        res = point_within_gca(pt_same_lon_out, gcr_same_lon_cart[0], gcr_same_lon_cart[1])
-        self.assertFalse(res)
-
-        pt_same_lon_out_2 = np.asarray(_lonlat_rad_to_xyz(0.1, 1.0))
-        res = point_within_gca(pt_same_lon_out_2, gcr_same_lon_cart[0], gcr_same_lon_cart[1])
-        self.assertFalse(res)
-
-    def test_pt_within_gcr_antimeridian(self):
-        # GCR vertex0 in radian : [5.163808182822441, 0.6351384888657234],
-        # GCR vertex1 in radian : [0.8280410325693055, 0.42237025187091526]
-        # Point in radian : [0.12574759138415173, 0.770098701904903]
-        gcr_cart = np.array([[0.351, -0.724, 0.593], [0.617, 0.672, 0.410]])
-        pt_cart = np.array(
-            [0.9438777657502077, 0.1193199333436068, 0.922714737029319])
-        self.assertTrue(
-            point_within_gca(pt_cart, gcr_cart[0], gcr_cart[1]))
-
-        gcr_cart_flip = np.array([[0.617, 0.672, 0.410], [0.351, -0.724,
-                                                          0.593]])
-        # If we flip the gcr in the undirected mode, it should still work
-        self.assertTrue(
-            point_within_gca(pt_cart, gcr_cart_flip[0], gcr_cart_flip[1]))
-
-        # 2nd anti-meridian case
-        # GCR vertex0 in radian : [4.104711496596806, 0.5352983676533828],
-        # GCR vertex1 in radian : [2.4269979227622533, -0.007003212877856825]
-        # Point in radian : [0.43400375562899113, -0.49554509841586936]
-        gcr_cart_1 = np.array([[-0.491, -0.706, 0.510], [-0.755, 0.655,
-                                                         -0.007]])
-        pt_cart_within = np.array(
-            [0.6136726305712109, 0.28442243941920053, -0.365605190899831])
-        self.assertFalse(
-            point_within_gca(pt_cart_within, gcr_cart_1[0], gcr_cart_1[1]))
-
-
-
-    def test_pt_within_gcr_cross_pole(self):
-        gcr_cart = np.array([[0.351, 0.0, 0.3], [-0.351, 0.0, 0.3]])
-        pt_cart = np.array(
-            [0.10, 0.0, 0.8])
-
-        # Normalize the point abd the GCA
-        pt_cart = pt_cart / np.linalg.norm(pt_cart)
-        gcr_cart = np.array([x / np.linalg.norm(x) for x in gcr_cart])
-        self.assertTrue(point_within_gca(pt_cart, gcr_cart[0], gcr_cart[1]))
+def test_pt_within_gcr():
+    # The GCR that's exactly 180 degrees will raise a ValueError
+    gcr_180degree_cart = np.asarray([
+        _lonlat_rad_to_xyz(0.0, np.pi / 2.0),
+        _lonlat_rad_to_xyz(0.0, -np.pi / 2.0)
+    ])
+    pt_same_lon_in = np.asarray(_lonlat_rad_to_xyz(0.0, 0.0))
+
+    with pytest.raises(ValueError):
+        point_within_gca(pt_same_lon_in, gcr_180degree_cart[0],gcr_180degree_cart[1] )
+    #
+    # Test when the point and the GCA all have the same longitude
+    gcr_same_lon_cart = np.asarray([
+        _lonlat_rad_to_xyz(0.0, 1.5),
+        _lonlat_rad_to_xyz(0.0, -1.5)
+    ])
+    pt_same_lon_in = np.asarray(_lonlat_rad_to_xyz(0.0, 0.0))
+    assert(point_within_gca(pt_same_lon_in, gcr_same_lon_cart[0], gcr_same_lon_cart[1]))
+
+    pt_same_lon_out = np.asarray(_lonlat_rad_to_xyz(0.0, 1.5000001))
+    res = point_within_gca(pt_same_lon_out, gcr_same_lon_cart[0], gcr_same_lon_cart[1])
+    assert not res
+
+    pt_same_lon_out_2 = np.asarray(_lonlat_rad_to_xyz(0.1, 1.0))
+    res = point_within_gca(pt_same_lon_out_2, gcr_same_lon_cart[0], gcr_same_lon_cart[1])
+    assert not res
+
+def test_pt_within_gcr_antimeridian():
+    # GCR vertex0 in radian : [5.163808182822441, 0.6351384888657234],
+    # GCR vertex1 in radian : [0.8280410325693055, 0.42237025187091526]
+    # Point in radian : [0.12574759138415173, 0.770098701904903]
+    gcr_cart = np.array([[0.351, -0.724, 0.593], [0.617, 0.672, 0.410]])
+    pt_cart = np.array(
+        [0.9438777657502077, 0.1193199333436068, 0.922714737029319])
+    assert(
+        point_within_gca(pt_cart, gcr_cart[0], gcr_cart[1]))
+
+    gcr_cart_flip = np.array([[0.617, 0.672, 0.410], [0.351, -0.724,
+                                                        0.593]])
+    # If we flip the gcr in the undirected mode, it should still work
+    assert(
+        point_within_gca(pt_cart, gcr_cart_flip[0], gcr_cart_flip[1]))
+
+    # 2nd anti-meridian case
+    # GCR vertex0 in radian : [4.104711496596806, 0.5352983676533828],
+    # GCR vertex1 in radian : [2.4269979227622533, -0.007003212877856825]
+    # Point in radian : [0.43400375562899113, -0.49554509841586936]
+    gcr_cart_1 = np.array([[-0.491, -0.706, 0.510], [-0.755, 0.655,
+                                                        -0.007]])
+    pt_cart_within = np.array(
+        [0.6136726305712109, 0.28442243941920053, -0.365605190899831])
+    assert( not
+        point_within_gca(pt_cart_within, gcr_cart_1[0], gcr_cart_1[1]))
+
+def test_pt_within_gcr_cross_pole():
+    gcr_cart = np.array([[0.351, 0.0, 0.3], [-0.351, 0.0, 0.3]])
+    pt_cart = np.array([0.10, 0.0, 0.8])
+
+    # Normalize the point abd the GCA
+    pt_cart = pt_cart / np.linalg.norm(pt_cart)
+    gcr_cart = np.array([x / np.linalg.norm(x) for x in gcr_cart])
+    assert(point_within_gca(pt_cart, gcr_cart[0], gcr_cart[1]))