MAINT, TST: Remove nose imports and use pytest (#611)

* MAINT, TST: Remove nose imports and use pytest

* CI: Use pytest

Author: Smit-create

.github/workflows/test.yml

@@ -47,6 +47,8 @@ jobs:
       run: |
         pytest quantecon/game_theory
         pytest quantecon/markov
+        pytest quantecon/optimize
+        pytest quantecon/random
     - name: Coveralls Parallel
       uses: AndreMiras/coveralls-python-action@develop
       if: runner.os == 'Linux'

quantecon/optimize/tests/test_linprog_simplex.py

@@ -239,13 +239,3 @@ def test_bug_8662(self):
         desired_fun = -36.0000000000
         res = linprog_simplex(c, A_ub=A_ub, b_ub=b_ub)
         _assert_success(res, c, b_ub=b_ub, desired_fun=desired_fun)
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)

quantecon/optimize/tests/test_nelder_mead.py

@@ -5,8 +5,7 @@
 
 import numpy as np
 from numba import njit
-from numpy.testing import assert_allclose
-from nose.tools import raises
+from numpy.testing import assert_allclose, assert_raises
 
 from quantecon.optimize import nelder_mead
 from ..nelder_mead import _nelder_mead_algorithm
@@ -330,71 +329,59 @@ def test_discontinuous(self):
         assert_allclose(results.fun, fun)
 
 
-@raises(ValueError)
 def test_invalid_bounds_1():
     x0 = np.array([-2., 1.])
     bounds = np.array([[10., -10.], [10., -10.]])
-    nelder_mead(rosenbrock, x0, bounds=bounds)
+    assert_raises(ValueError, nelder_mead, rosenbrock, x0, bounds=bounds)
 
 
-@raises(ValueError)
 def test_invalid_bounds_2():
     x0 = np.array([-2., 1.])
     bounds = np.array([[10., -10., 10., -10.]])
-    nelder_mead(rosenbrock, x0, bounds=bounds)
+    assert_raises(ValueError, nelder_mead, rosenbrock, x0, bounds=bounds)
 
 
-@raises(ValueError)
 def test_invalid_ρ():
     vertices = np.array([[-2., 1.],
                          [1.05 * -2., 1.],
                          [-2., 1.05 * 1.]])
     invalid_ρ = -1.
-    _nelder_mead_algorithm(rosenbrock, vertices, ρ=invalid_ρ)
+    assert_raises(ValueError, _nelder_mead_algorithm, rosenbrock,
+                  vertices, ρ=invalid_ρ)
 
 
-@raises(ValueError)
 def test_invalid_χ():
     vertices = np.array([[-2., 1.],
                          [1.05 * -2., 1.],
                          [-2., 1.05 * 1.]])
     invalid_χ = 0.5
-    _nelder_mead_algorithm(rosenbrock, vertices, χ=invalid_χ)
+    assert_raises(ValueError, _nelder_mead_algorithm, rosenbrock,
+                  vertices, χ=invalid_χ)
 
 
-@raises(ValueError)
 def test_invalid_ρχ():
     vertices = np.array([[-2., 1.],
                          [1.05 * -2., 1.],
                          [-2., 1.05 * 1.]])
     ρ = 2
     χ = 1.5
-    _nelder_mead_algorithm(rosenbrock, vertices, ρ=ρ, χ=χ)
+    assert_raises(ValueError, _nelder_mead_algorithm, rosenbrock,
+                  vertices, ρ=ρ, χ=χ)
 
 
-@raises(ValueError)
 def test_invalid_γ():
     vertices = np.array([[-2., 1.],
                          [1.05 * -2., 1.],
                          [-2., 1.05 * 1.]])
     invalid_γ = -1e-7
-    _nelder_mead_algorithm(rosenbrock, vertices, γ=invalid_γ)
+    assert_raises(ValueError, _nelder_mead_algorithm, rosenbrock,
+                  vertices, γ=invalid_γ)
 
 
-@raises(ValueError)
 def test_invalid_σ():
     vertices = np.array([[-2., 1.],
                          [1.05 * -2., 1.],
                          [-2., 1.05 * 1.]])
     invalid_σ = 1. + 1e-7
-    _nelder_mead_algorithm(rosenbrock, vertices, σ=invalid_σ)
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)
+    assert_raises(ValueError, _nelder_mead_algorithm, rosenbrock,
+                  vertices, σ=invalid_σ)

quantecon/optimize/tests/test_root_finding.py

@@ -57,17 +57,17 @@ def func_two_prime2(x):
 
 def test_newton_basic():
     """
-    Uses the function f defined above to test the scalar maximization 
+    Uses the function f defined above to test the scalar maximization
     routine.
     """
     true_fval = 1.0
     fval = newton(func, 5, func_prime)
     assert_almost_equal(true_fval, fval.root, decimal=4)
-    
+
 
 def test_newton_basic_two():
     """
-    Uses the function f defined above to test the scalar maximization 
+    Uses the function f defined above to test the scalar maximization
     routine.
     """
     true_fval = 1.0
@@ -83,7 +83,7 @@ def test_newton_hard():
     fval = newton(func_two, 0.4, func_two_prime)
     assert_allclose(true_fval, fval.root, rtol=1e-5, atol=0.01)
 
-    
+
 def test_halley_basic():
     """
     Basic test for halley method
@@ -135,15 +135,3 @@ def test_bisect_basic():
 
 def test_brentq_basic():
     run_check(brentq, 'brentq')
-
-# executing testcases.
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)

quantecon/optimize/tests/test_scalar_max.py

@@ -3,8 +3,7 @@
 
 """
 import numpy as np
-from numpy.testing import assert_almost_equal
-from nose.tools import raises
+from numpy.testing import assert_almost_equal, assert_raises
 from numba import njit
 
 from quantecon.optimize import brent_max
@@ -51,26 +50,13 @@ def test_g():
     assert_almost_equal(true_xf, xf, decimal=4)
 
 
-@raises(ValueError)
 def test_invalid_a_brent_max():
-    brent_max(f, -np.inf, 2)
+    assert_raises(ValueError, brent_max, f, -np.inf, 2)
 
 
-@raises(ValueError)
 def test_invalid_b_brent_max():
-    brent_max(f, -2, np.inf)
+    assert_raises(ValueError, brent_max, f, -2, -np.inf)
 
 
-@raises(ValueError)
 def test_invalid_a_b_brent_max():
-    brent_max(f, 1, 0)
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)
+    assert_raises(ValueError, brent_max, f, 1, 0)

quantecon/random/tests/test_utilities.py

@@ -9,15 +9,15 @@
 """
 import numbers
 import numpy as np
-from numpy.testing import assert_array_equal, assert_allclose, assert_raises
-from nose.tools import eq_, ok_
+from numpy.testing import (assert_array_equal, assert_allclose, assert_raises,
+                           assert_)
 from quantecon.random import probvec, sample_without_replacement, draw
 
 
 # probvec #
 
 class TestProbvec:
-    def setUp(self):
+    def setup(self):
         self.m, self.k = 2, 3  # m vectors of dimension k
         seed = 1234
 
@@ -27,7 +27,7 @@ def setUp(self):
 
     def test_shape(self):
         for out in [self.out_parallel, self.out_cpu]:
-            eq_(out.shape, (self.m, self.k))
+            assert_(out.shape == (self.m, self.k))
 
     def test_parallel_cpu(self):
         assert_array_equal(self.out_parallel, self.out_cpu)
@@ -53,7 +53,7 @@ def test_sample_without_replacement_uniqueness():
     n = 10
     a = sample_without_replacement(n, n)
     b = np.unique(a)
-    eq_(len(b), n)
+    assert_(len(b) == n)
 
 
 def test_sample_without_replacement_value_error():
@@ -68,26 +68,26 @@ def test_sample_without_replacement_value_error():
 # draw #
 
 class TestDraw:
-    def setUp(self):
+    def setup(self):
         self.pmf = np.array([0.4, 0.1, 0.5])
         self.cdf = np.cumsum(self.pmf)
         self.n = len(self.pmf)
 
     def test_return_types(self):
         out = draw(self.cdf)
-        ok_(isinstance(out, numbers.Integral))
+        assert_(isinstance(out, numbers.Integral))
 
         size = 10
         out = draw(self.cdf, size)
-        eq_(out.shape, (size,))
+        assert_(out.shape == (size,))
 
     def test_return_values(self):
         out = draw(self.cdf)
-        ok_(out in range(self.n))
+        assert_(out in range(self.n))
 
         size = 10
         out = draw(self.cdf, size)
-        ok_(np.isin(out, range(self.n)).all())
+        assert_(np.isin(out, range(self.n)).all())
 
     def test_lln(self):
         size = 1000000
@@ -96,13 +96,3 @@ def test_lln(self):
         pmf_computed = hist * np.diff(bin_edges)
         atol = 1e-2
         assert_allclose(pmf_computed, self.pmf, atol=atol)
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)