Fix failing tests and add coveralls CI (#11)

* TEST Switch from unittest to pytest calls in test_deriv
* TEST add coordinates to test DataArrays
* Add .coveragerc for Coveralls CI; test cleanups
* TEST fix faulty inheritance in TestLatUpwindConstP

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+omit = indiff/test/*

indiff/test/__init__.py

@@ -2,6 +2,7 @@
 import unittest
 
 import numpy as np
+import pytest
 import xarray as xr
 
 
@@ -12,15 +13,17 @@ def setUp(self):
         self.dummy_len = 3
         self.dummy_dim = 'dummydim'
 
-        self.ones = xr.DataArray(np.ones((self.dummy_len, self.array_len)),
-                                 dims=[self.dummy_dim, self.dim])
-
-        self.zeros = xr.DataArray(np.zeros(self.ones.shape),
-                                  dims=self.ones.dims)
         self.arange = xr.DataArray(
-            np.arange(self.array_len*self.dummy_len).reshape(self.ones.shape),
-            dims=self.ones.dims
+            np.arange(self.array_len*self.dummy_len).reshape((self.dummy_len,
+                                                              self.array_len)),
+            dims=[self.dummy_dim, self.dim],
+            coords={self.dummy_dim: np.arange(self.dummy_len),
+                    self.dim: np.arange(self.array_len)}
         )
+
+        self.zeros = xr.zeros_like(self.arange)
+        self.ones = xr.ones_like(self.arange)
+
         randstate = np.random.RandomState(12345)
         self.random = xr.DataArray(randstate.rand(*self.ones.shape),
                                    dims=self.ones.dims,
@@ -104,7 +107,8 @@ def assertCoordsIdentical(self, d1, d2):
         assert d1.shape == d2.shape, ('shape mismatch', d1.shape, d2.shape)
 
     def assertNotImplemented(self, func, *args, **kwargs):
-        self.assertRaises(NotImplementedError, func, *args, **kwargs)
+        with pytest.raises(NotImplementedError):
+            func(*args, **kwargs)
 
     def assertAllZeros(self, arr):
         assert not np.any(arr), arr

indiff/test/test_advec_phys.py

@@ -17,10 +17,8 @@
 
 class PhysAdvecSharedTests(object):
     def test_init(self):
-        self.assertIsInstance(self.advec_obj._deriv_bwd_obj,
-                              self._DERIV_BWD_CLS)
-        self.assertIsInstance(self.advec_obj._deriv_fwd_obj,
-                              self._DERIV_FWD_CLS)
+        assert isinstance(self.advec_obj._deriv_bwd_obj, self._DERIV_BWD_CLS)
+        assert isinstance(self.advec_obj._deriv_fwd_obj, self._DERIV_FWD_CLS)
 
     def test_advec(self):
         self.assertNotImplemented(self.advec_obj.advec)
@@ -168,10 +166,10 @@ def setUp(self):
 
 class TestLonUpwindConstP(PhysAdvecSharedTests, LonUpwindConstPTestCase):
     def test_init(self):
-        self.assertEqual(self.advec_obj._DERIV_METHOD, self._DERIV_METHOD)
-        self.assertEqual(self.advec_obj._DERIV_BWD_CLS, self._DERIV_BWD_CLS)
-        self.assertEqual(self.advec_obj._DERIV_FWD_CLS, self._DERIV_FWD_CLS)
-        self.assertEqual(self.advec_obj._DIM, self._DIM)
+        assert self.advec_obj._DERIV_METHOD == self._DERIV_METHOD
+        assert self.advec_obj._DERIV_BWD_CLS == self._DERIV_BWD_CLS
+        assert self.advec_obj._DERIV_FWD_CLS == self._DERIV_FWD_CLS
+        assert self.advec_obj._DIM == self._DIM
 
     def test_advec(self):
         self.advec_obj.advec()
@@ -197,26 +195,22 @@ def test_advec_zero_flow(self):
                                             self.ps).advec())
 
     def test_advec_unity_flow(self):
-        ones = self.flow.copy()
-        ones.values = np.ones(ones.shape)
-        actual = self._ADVEC_CLS(ones, self.arr, self.pk, self.bk,
-                                 self.ps, order=1, cyclic=True,
+        actual = self._ADVEC_CLS(xr.ones_like(self.flow), self.arr, self.pk,
+                                 self.bk, self.ps, order=1, cyclic=True,
                                  fill_edge=False).advec()
         desired = self._DERIV_BWD_CLS(self.arr, self.pk, self.bk, self.ps,
                                       order=1, cyclic_lon=True,
                                       fill_edge_lon=False).d_dx_const_p()
-        self.assertDatasetIdentical(actual, desired)
+        xr.testing.assert_identical(actual, desired)
 
     def test_advec_unity_flow_not_cyclic(self):
-        ones = self.flow.copy()
-        ones.values = np.ones(ones.shape)
-        actual = self._ADVEC_CLS(ones, self.arr, self.pk, self.bk,
-                                 self.ps, order=1, cyclic=False,
+        actual = self._ADVEC_CLS(xr.ones_like(self.flow), self.arr, self.pk,
+                                 self.bk, self.ps, order=1, cyclic=False,
                                  fill_edge=True).advec()
         desired = self._DERIV_BWD_CLS(self.arr, self.pk, self.bk, self.ps,
                                       order=1, cyclic_lon=False,
                                       fill_edge_lon=True).d_dx_const_p()
-        self.assertDatasetIdentical(actual, desired)
+        xr.testing.assert_identical(actual, desired)
 
 
 class LatUpwindConstPTestCase(EtaUpwindTestCase):
@@ -230,15 +224,14 @@ def setUp(self):
         super(LatUpwindConstPTestCase, self).setUp()
 
 
-class TestLatUpwindConstP(TestLonUpwindConstP, LatUpwindConstPTestCase):
+class TestLatUpwindConstP(TestEtaUpwind, LatUpwindConstPTestCase):
     def test_advec_unity_flow(self):
-        ones = self.flow.copy()
-        ones.values = np.ones(ones.shape)
-        actual = self._ADVEC_CLS(ones, self.arr, self.pk, self.bk,
-                                 self.ps, order=1, fill_edge=True).advec()
+        actual = self._ADVEC_CLS(xr.ones_like(self.flow), self.arr, self.pk,
+                                 self.bk, self.ps, order=1,
+                                 fill_edge=True).advec()
         desired = self._DERIV_BWD_CLS(self.arr, self.pk, self.bk, self.ps,
                                       order=1).d_dy_const_p()
-        self.assertDatasetIdentical(actual, desired)
+        xr.testing.assert_identical(actual, desired)
 
 
 class SphereEtaUpwindTestCase(InfiniteDiffTestCase):
@@ -289,5 +282,6 @@ def test_advec_zero_flow(self):
         self.assertAllZeros(self._ADVEC_CLS(self.arr, self.pk, self.bk,
                                             self.ps).advec_x_const_p(zeros))
 
+
 if __name__ == '__main__':
     sys.exit(unittest.main())