switch to pytest from nosetests

Author: phobson

probscale/tests/test_formatters.py

@@ -1,6 +1,6 @@
 import numpy
 
-import nose.tools as nt
+import pytest
 import numpy.testing as nptest
 
 from probscale import formatters
@@ -11,62 +11,59 @@ def teardown(self):
         pass
 
     def test_baseline(self):
-        nt.assert_equal(self.fmt._sig_figs(self.x, 3), self.known_3)
-        nt.assert_equal(self.fmt._sig_figs(self.x, 4), self.known_4)
+        assert self.fmt._sig_figs(self.x, 3) == self.known_3
+        assert self.fmt._sig_figs(self.x, 4) == self.known_4
 
     def test_string(self):
-        nt.assert_equal(self.fmt._sig_figs('1.23', 3), '1.23')
+        assert self.fmt._sig_figs('1.23', 3) == '1.23'
 
     def test_na_inf(self):
-        nt.assert_equal(self.fmt._sig_figs(numpy.nan, 3), 'NA')
-        nt.assert_equal(self.fmt._sig_figs(numpy.inf, 3), 'NA')
+        assert self.fmt._sig_figs(numpy.nan, 3) == 'NA'
+        assert self.fmt._sig_figs(numpy.inf, 3) == 'NA'
 
     def test_zero(self):
-        nt.assert_equal(self.fmt._sig_figs(0, 3), '0')
+        assert self.fmt._sig_figs(0, 3) == '0'
 
     def test_trailing_zeros(self):
-        nt.assert_equal(self.fmt._sig_figs(self.x, 8), self.known_8)
+        assert self.fmt._sig_figs(self.x, 8) == self.known_8
 
-    @nptest.raises(ValueError)
     def test_sigFigs_zero_n(self):
-        self.fmt._sig_figs(self.x, 0)
+        with pytest.raises(ValueError):
+            self.fmt._sig_figs(self.x, 0)
 
-    @nptest.raises(ValueError)
     def test_sigFigs_negative_n(self):
-        self.fmt._sig_figs(self.x, -1)
+        with pytest.raises(ValueError):
+            self.fmt._sig_figs(self.x, -1)
 
     def test_forceint(self):
-        nt.assert_equal(
-            self.fmt._sig_figs(self.x, 3, forceint=True),
-            self.known_int
-        )
+        assert self.fmt._sig_figs(self.x, 3, forceint=True) == self.known_int
 
 
 class Mixin_Check_PctFormatter_sig_figs(Mixin_Check_Formatter_sig_figs):
     fmt = formatters.PctFormatter()
     def test__call__(self):
-        nt.assert_equal(self.fmt(0.0301), '0.03')
-        nt.assert_equal(self.fmt(0.2), '0.2')
-        nt.assert_equal(self.fmt(0.1), '0.1')
-        nt.assert_equal(self.fmt(10), '10')
-        nt.assert_equal(self.fmt(5), '5')
-        nt.assert_equal(self.fmt(50), '50')
-        nt.assert_equal(self.fmt(99), '99')
-        nt.assert_equal(self.fmt(99.1), '99.1')
-        nt.assert_equal(self.fmt(99.99), '99.99')
+        assert self.fmt(0.0301) == '0.03'
+        assert self.fmt(0.2) == '0.2'
+        assert self.fmt(0.1) == '0.1'
+        assert self.fmt(10) == '10'
+        assert self.fmt(5) == '5'
+        assert self.fmt(50) == '50'
+        assert self.fmt(99) == '99'
+        assert self.fmt(99.1) == '99.1'
+        assert self.fmt(99.99) == '99.99'
 
 
 class Mixin_Check_ProbFormatter_sig_figs(Mixin_Check_Formatter_sig_figs):
     fmt = formatters.ProbFormatter()
     def test__call__(self):
-        nt.assert_equal(self.fmt(0.000301), '0.0003')
-        nt.assert_equal(self.fmt(0.001), '0.001')
-        nt.assert_equal(self.fmt(0.10), '0.10')
-        nt.assert_equal(self.fmt(0.05), '0.05')
-        nt.assert_equal(self.fmt(0.50), '0.50')
-        nt.assert_equal(self.fmt(0.99), '0.99')
-        nt.assert_equal(self.fmt(0.991), '0.991')
-        nt.assert_equal(self.fmt(0.9999), '0.9999')
+        assert self.fmt(0.000301) == '0.0003'
+        assert self.fmt(0.001) == '0.001'
+        assert self.fmt(0.10) == '0.10'
+        assert self.fmt(0.05) == '0.05'
+        assert self.fmt(0.50) == '0.50'
+        assert self.fmt(0.99) == '0.99'
+        assert self.fmt(0.991) == '0.991'
+        assert self.fmt(0.9999) == '0.9999'
 
 
 class Test_PctFormatter_sig_figs_gt1(Mixin_Check_PctFormatter_sig_figs):

probscale/tests/test_probscale.py

@@ -1,103 +1,98 @@
 import sys
 PYTHON27 = sys.version_info.major == 2
 
-import numpy as np
+import numpy
 import matplotlib.pyplot as plt
 
 try:
     from scipy import stats
 except:
     stats = None
 
-from matplotlib.testing.decorators import image_comparison, cleanup
-import nose.tools as nt
-import numpy.testing as nptest
+import pytest
 
 import probscale
 from probscale.probscale import _minimal_norm
 
 
-class Test__minimal_norm(object):
-    def setup(self):
-        self.mn = _minimal_norm()
-        self.known__A = 0.1400122886866665
-
-        self.input = np.array([
-            0.331, 0.742, 0.067, 0.826, 0.357, 0.089,
-            0.754, 0.342, 0.762, 0.658, 0.239, 0.910,
-        ])
-
-        self.known_erf = np.array([
-            0.36029027,  0.70598131,  0.07548843,  0.75724986,
-            0.38635283,  0.10016122,  0.71371964,  0.37137355,
-            0.71880142,  0.64791492,  0.26463458,  0.80188283,
-        ])
-
-        self.known_ppf = np.array([
-            -0.43715354,  0.6495236 , -1.49851307,  0.93847570,
-            -0.36648929, -1.34693863,  0.68713129, -0.40701088,
-             0.71275076,  0.40701088, -0.70952297,  1.34075503,
-        ])
-
-        self.known_cdf = np.array([
-            0.62967776, 0.77095633, 0.52670915,  0.79559795,
-            0.63945410, 0.53545904, 0.77457539,  0.63382455,
-            0.77697000, 0.74473093, 0.59444721,  0.81858875
-        ])
-
-    def test__A(self):
-        nt.assert_true(hasattr(self.mn, '_A'))
-        nt.assert_almost_equal(self.mn._A, self.known__A)
-
-    def test__approx_erf(self):
-        nptest.assert_array_almost_equal(
-            self.mn._approx_erf(self.input),
-            self.known_erf,
-            decimal=3
-        )
-
-    def test__approx_inv_erf(self):
-        nptest.assert_array_almost_equal(
-            self.input,
-            self.mn._approx_inv_erf(self.mn._approx_erf(self.input)),
-            decimal=3
-        )
-
-    def test_ppf(self):
-        nptest.assert_array_almost_equal(
-            self.mn.ppf(self.input),
-            self.known_ppf,
-            decimal=3
-        )
-
-    def test_cdf(self):
-        nptest.assert_array_almost_equal(
-            self.mn.cdf(self.input),
-            self.known_cdf,
-            decimal=3
-        )
-
-
-@image_comparison(baseline_images=['test_the_scale_default'], extensions=['png'])
-@nptest.dec.skipif(PYTHON27)
+@pytest.fixture
+def mn():
+    return _minimal_norm()
+
+
+@pytest.fixture
+def mn_input():
+    x = numpy.array([
+        0.331, 0.742, 0.067, 0.826, 0.357, 0.089,
+        0.754, 0.342, 0.762, 0.658, 0.239, 0.910,
+    ])
+    return x
+
+
+def test_minimal_norm_A(mn):
+    known__A = 0.1400122886866665
+    assert abs(mn._A - known__A) < 0.0000001
+
+
+def test_minimal_norm__approx_erf(mn, mn_input):
+    known_erf = numpy.array([
+        0.36029027,  0.70598131,  0.07548843,  0.75724986,
+        0.38635283,  0.10016122,  0.71371964,  0.37137355,
+        0.71880142,  0.64791492,  0.26463458,  0.80188283,
+    ])
+
+    diff = mn._approx_erf(mn_input) - known_erf
+    assert numpy.all(numpy.abs(diff) < 0.001)
+
+
+def test_minimal_norm__approx_inv_erf(mn, mn_input):
+    diff = mn._approx_inv_erf(mn._approx_erf(mn_input)) - mn_input
+    assert numpy.all(numpy.abs(diff) < 0.00001)
+
+
+def test_minimal_norm_ppf(mn, mn_input):
+    known_ppf = numpy.array([
+        -0.43715354,  0.6495236 , -1.49851307,  0.93847570,
+        -0.36648929, -1.34693863,  0.68713129, -0.40701088,
+         0.71275076,  0.40701088, -0.70952297,  1.34075503,
+    ])
+    diff = mn.ppf(mn_input) - known_ppf
+    assert numpy.all(numpy.abs(diff) < 0.001)
+
+
+def test_minimal_norm_cdf(mn, mn_input):
+    known_cdf = numpy.array([
+        0.62967776, 0.77095633, 0.52670915,  0.79559795,
+        0.63945410, 0.53545904, 0.77457539,  0.63382455,
+        0.77697000, 0.74473093, 0.59444721,  0.81858875
+    ])
+    diff = mn.cdf(mn_input) - known_cdf
+    assert numpy.all(numpy.abs(diff) < 0.001)
+
+
+@pytest.mark.mpl_image_compare(baseline_dir='baseline_images/test_probscale')
+@pytest.mark.skipif(PYTHON27, reason="legacy python")
 def test_the_scale_default():
     fig, ax = plt.subplots(figsize=(4, 8))
     ax.set_yscale('prob')
     ax.set_ylim(0.01, 99.99)
     fig.tight_layout()
+    return fig
 
 
-@image_comparison(baseline_images=['test_the_scale_not_as_pct'], extensions=['png'])
+@pytest.mark.mpl_image_compare(baseline_dir='baseline_images/test_probscale')
 def test_the_scale_not_as_pct():
     fig, ax = plt.subplots(figsize=(4, 8))
     ax.set_yscale('prob', as_pct=False)
     ax.set_ylim(0.02, 0.98)
+    return fig
 
 
-@image_comparison(baseline_images=['test_the_scale_beta'], extensions=['png'])
-@nptest.dec.skipif(stats is None)
+@pytest.mark.mpl_image_compare(baseline_dir='baseline_images/test_probscale')
+@pytest.mark.skipif(stats is None, reason="scipy not installed")
 def test_the_scale_beta():
     fig, ax = plt.subplots(figsize=(4, 8))
     ax.set_yscale('prob', as_pct=True, dist=stats.beta(3, 2))
     ax.set_ylim(1, 99)
     fig.tight_layout()
+    return fig

probscale/tests/test_transforms.py

@@ -1,26 +1,25 @@
 import numpy
-import matplotlib
-matplotlib.use('agg')
 
-import nose.tools as nt
+import pytest
 import numpy.testing as nptest
 
 from probscale.probscale import _minimal_norm
 from probscale import transforms
 
 
 def test__mask_out_of_bounds():
-    x = [-0.1, 0, 0.1, 0.5, 0.9, 1.0, 1.1]
     known = numpy.array([numpy.nan, numpy.nan, 0.1, 0.5, 0.9, numpy.nan, numpy.nan])
+    x = [-0.1, 0, 0.1, 0.5, 0.9, 1.0, 1.1]
     result = transforms._mask_out_of_bounds(x)
-    nptest.assert_array_almost_equal(result, known)
+    nptest.assert_array_equal(known, result)
 
 
 def test__clip_out_of_bounds():
-    x = [-0.1, 0, 0.1, 0.5, 0.9, 1.0, 1.1]
     known = numpy.array([0.0, 0.0, 0.1, 0.5, 0.9, 1.0, 1.0])
+    x = [-0.1, 0, 0.1, 0.5, 0.9, 1.0, 1.1]
     result = transforms._clip_out_of_bounds(x)
-    nptest.assert_array_almost_equal(result, known)
+    diff = numpy.abs(result - known)
+    assert numpy.all(diff < 0.0001)
 
 
 class Mixin_Transform(object):
@@ -30,38 +29,36 @@ class Mixin_Transform(object):
     known_has_inverse = True
 
     def test_input_dims(self):
-        nt.assert_true(hasattr(self.trans, 'input_dims'))
-        nt.assert_equal(self.trans.input_dims, self.known_input_dims)
+        assert hasattr(self.trans, 'input_dims')
+        assert self.trans.input_dims == self.known_input_dims
 
     def test_output_dims(self):
-        nt.assert_true(hasattr(self.trans, 'output_dims'))
-        nt.assert_equal(self.trans.output_dims, self.known_output_dims)
+        assert hasattr(self.trans, 'output_dims')
+        assert self.trans.output_dims == self.known_output_dims
 
     def test_is_separable(self):
-        nt.assert_true(hasattr(self.trans, 'is_separable'))
-        nt.assert_equal(self.trans.is_separable, self.known_is_separable)
+        assert hasattr(self.trans, 'is_separable')
+        assert self.trans.is_separable == self.known_is_separable
 
     def test_has_inverse(self):
-        nt.assert_true(hasattr(self.trans, 'has_inverse'))
-        nt.assert_equal(self.trans.has_inverse, self.known_has_inverse)
+        assert hasattr(self.trans, 'has_inverse')
+        assert self.trans.has_inverse == self.known_has_inverse
 
     def test_dist(self):
-        nt.assert_true(hasattr(self.trans, 'dist'))
-        nt.assert_equal(self.trans.dist, _minimal_norm)
+        assert hasattr(self.trans, 'dist')
+        assert self.trans.dist == _minimal_norm
 
     def test_transform_non_affine(self):
-        nt.assert_true(hasattr(self.trans, 'transform_non_affine'))
-        nptest.assert_almost_equal(self.trans.transform_non_affine([0.5]), self.known_tras_na)
+        assert hasattr(self.trans, 'transform_non_affine')
+        diff = numpy.abs(self.trans.transform_non_affine([0.5]) - self.known_tras_na)
+        assert numpy.all(diff < 0.0001)
 
     def test_inverted(self):
-        nt.assert_true(hasattr(self.trans, 'inverted'))
+        assert hasattr(self.trans, 'inverted')
 
-    @nt.raises(ValueError)
     def test_bad_non_pos(self):
-        self._trans(_minimal_norm, nonpos='junk')
-
-    # def test_non_pos_default(self):
-    #     x = [-0.1, 0, 0.1, 0.5, 0.99, 1, 1.1]
+        with pytest.raises(ValueError):
+            self._trans(_minimal_norm, nonpos='junk')
 
     def test_non_pos_clip(self):
         self._trans(_minimal_norm, nonpos='clip')
@@ -75,9 +72,9 @@ def setup(self):
 
     def test_inverted(self):
         inv_trans = self.trans.inverted()
-        nt.assert_equal(self.trans.dist, inv_trans.dist)
-        nt.assert_equal(self.trans.factor, inv_trans.factor)
-        nt.assert_equal(self.trans.nonpos, inv_trans.nonpos)
+        assert self.trans.dist == inv_trans.dist
+        assert self.trans.factor == inv_trans.factor
+        assert self.trans.nonpos == inv_trans.nonpos
 
 
 class Test_QuantileTransform(Mixin_Transform):
@@ -88,6 +85,6 @@ def setup(self):
 
     def test_inverted(self):
         inv_trans = self.trans.inverted()
-        nt.assert_equal(self.trans.dist, inv_trans.dist)
-        nt.assert_equal(self.trans.factor, inv_trans.factor)
-        nt.assert_equal(self.trans.nonpos, inv_trans.nonpos)
+        assert self.trans.dist == inv_trans.dist
+        assert self.trans.factor == inv_trans.factor
+        assert self.trans.nonpos == inv_trans.nonpos