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

* MAINT, TST: Remove nose imports and use pytest for testing

* CI: Use pytest

* MAINT: Remove unused imports

* MAINT: Import error

* ENH: Apply suggestions

* STY: Fix pep8

Author: Smit-create

.github/workflows/test.yml

@@ -46,6 +46,7 @@ jobs:
     - name: Run Tests (pytest)
       run: |
         pytest quantecon/game_theory
+        pytest quantecon/markov
     - name: Coveralls Parallel
       uses: AndreMiras/coveralls-python-action@develop
       if: runner.os == 'Linux'

quantecon/markov/tests/test_approximation.py

@@ -2,16 +2,16 @@
 Tests for approximation.py file (i.e. tauchen)
 
 """
-import sys
-import unittest
 import numpy as np
 from quantecon.markov import tauchen, rouwenhorst
+from numpy.testing import assert_, assert_allclose
+
 #from quantecon.markov.approximation import rouwenhorst
 
 
-class TestTauchen(unittest.TestCase):
+class TestTauchen:
 
-    def setUp(self):
+    def setup(self):
         self.rho, self.sigma_u = np.random.rand(2)
         self.n = np.random.random_integers(3, 25)
         self.m = np.random.random_integers(4)
@@ -29,33 +29,32 @@ def testStateCenter(self):
         for b in [0., 1., -1.]:
             mu = b / (1 - self.rho)
             mc = tauchen(self.rho, self.sigma_u, b, self.m, self.n)
-            self.assertTrue(np.allclose(mu, np.mean(mc.state_values),
-                                        atol=self.tol))
+            assert_allclose(mu, np.mean(mc.state_values), atol=self.tol)
 
     def testShape(self):
         i, j = self.P.shape
 
-        self.assertTrue(i == j)
+        assert_(i == j)
 
     def testDim(self):
         dim_x = self.x.ndim
         dim_P = self.P.ndim
 
-        self.assertTrue(dim_x == 1 and dim_P == 2)
+        assert_(dim_x == 1 and dim_P == 2)
 
     def test_transition_mat_row_sum_1(self):
-        self.assertTrue(np.allclose(np.sum(self.P, axis=1), 1, atol=self.tol))
+        assert_allclose(np.sum(self.P, axis=1), 1, atol=self.tol)
 
     def test_positive_probs(self):
-        self.assertTrue(np.all(self.P) > -self.tol)
+        assert_(np.all(self.P > -self.tol))
 
     def test_states_sum_0(self):
-        self.assertTrue(abs(np.sum(self.x)) < self.tol)
+        assert_(abs(np.sum(self.x)) < self.tol)
 
 
-class TestRouwenhorst(unittest.TestCase):
+class TestRouwenhorst:
 
-    def setUp(self):
+    def setup(self):
         self.rho, self.sigma = np.random.uniform(0, 1, size=2)
         self.n = np.random.random_integers(3, 25)
         self.ybar = np.random.random_integers(0, 10)
@@ -71,22 +70,22 @@ def tearDown(self):
     def testShape(self):
         i, j = self.P.shape
 
-        self.assertTrue(i == j)
+        assert_(i == j)
 
     def testDim(self):
         dim_x = self.x.ndim
         dim_P = self.P.ndim
-        self.assertTrue(dim_x == 1 and dim_P == 2)
+        assert_(dim_x == 1 and dim_P == 2)
 
     def test_transition_mat_row_sum_1(self):
-        self.assertTrue(np.allclose(np.sum(self.P, axis=1), 1, atol=self.tol))
+        assert_allclose(np.sum(self.P, axis=1), 1, atol=self.tol)
 
     def test_positive_probs(self):
-        self.assertTrue(np.all(self.P) > -self.tol)
+        assert_(np.all(self.P > -self.tol))
 
     def test_states_sum_0(self):
         tol = self.tol + self.n*(self.ybar/(1 - self.rho))
-        self.assertTrue(abs(np.sum(self.x)) < tol)
+        assert_(abs(np.sum(self.x)) < tol)
 
     def test_control_case(self):
         n = 3; ybar = 1; sigma = 0.5; rho = 0.8;
@@ -97,11 +96,5 @@ def test_control_case(self):
         known_x = np.array([-psi+5.0, 5., psi+5.0])
         known_P = np.array(
             [[0.81, 0.18, 0.01], [0.09, 0.82, 0.09], [0.01, 0.18, 0.81]])
-        self.assertTrue(sum(mc_rouwenhorst.x - known_x) <
-                        self.tol and sum(sum(mc_rouwenhorst.P - known_P)) < self.tol)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(
-        [TestTauchen, TestRouwenhorst])
-    unittest.TextTestRunner(verbosity=2, stream=sys.stderr).run(suite)
+        assert_(np.sum(mc_rouwenhorst.x - known_x) < self.tol and
+                np.sum(mc_rouwenhorst.P - known_P) < self.tol)

quantecon/markov/tests/test_core.py

@@ -11,9 +11,9 @@
 from scipy import sparse
 import itertools
 from numpy.testing import (
-    assert_allclose, assert_array_equal, assert_array_less, assert_raises
+    assert_allclose, assert_array_equal, assert_array_less, assert_raises,
+    assert_
 )
-from nose.tools import eq_, ok_, raises
 
 from quantecon.markov import (
     MarkovChain, mc_compute_stationary, mc_sample_path
@@ -27,7 +27,7 @@ def list_of_array_equal(s, t):
     s, t: lists of numpy.ndarrays
 
     """
-    eq_(len(s), len(t))
+    assert_(len(s) == len(t))
     all(assert_array_equal(x, y) for x, y in zip(s, t))
 
 
@@ -191,7 +191,7 @@ class Test_markovchain_stationary_distributions_KMRMarkovMatrix2():
     p = 1/3
     TOL = 1e-2
 
-    def setUp(self):
+    def setup(self):
         """ Setup a KMRMarkovMatrix and Compute Stationary Values """
         self.P = KMR_Markov_matrix_sequential(self.N, self.p, self.epsilon)
         self.mc = MarkovChain(self.P)
@@ -315,7 +315,7 @@ def test_simulate_ergodicity():
 
     x = mc.simulate(ts_length, init=init, num_reps=num_reps, random_state=seed)
     frequency_1 = x[:, -1].mean()
-    ok_(np.abs(frequency_1 - stationary_dist[1]) < tol)
+    assert_(np.abs(frequency_1 - stationary_dist[1]) < tol)
 
 
 def test_simulate_for_matrices_with_C_F_orders():
@@ -405,11 +405,11 @@ def test_mc_sample_path_lln():
 
     frequency_1 = mc_sample_path(P, init=init, sample_size=sample_size,
                                  random_state=seed).mean()
-    ok_(np.abs(frequency_1 - stationary_dist[1]) < tol)
+    assert_(np.abs(frequency_1 - stationary_dist[1]) < tol)
 
 
 class TestMCStateValues:
-    def setUp(self):
+    def setup(self):
         state_values = [[0, 1], [2, 3], [4, 5]]  # Pass python list
         self.state_values = np.array(state_values)
 
@@ -519,29 +519,28 @@ def test_get_index():
     P = [[0.4, 0.6], [0.2, 0.8]]
     mc = MarkovChain(P)
 
-    eq_(mc.get_index(0), 0)
-    eq_(mc.get_index(1), 1)
+    assert_(mc.get_index(0) == 0)
+    assert_(mc.get_index(1) == 1)
     assert_raises(ValueError, mc.get_index, 2)
     assert_array_equal(mc.get_index([1, 0]), [1, 0])
     assert_raises(ValueError, mc.get_index, [[1]])
 
     mc.state_values = [1, 2]
-    eq_(mc.get_index(1), 0)
-    eq_(mc.get_index(2), 1)
+    assert_(mc.get_index(1) == 0)
+    assert_(mc.get_index(2) == 1)
     assert_raises(ValueError, mc.get_index, 0)
     assert_array_equal(mc.get_index([2, 1]), [1, 0])
     assert_raises(ValueError, mc.get_index, [[1]])
 
     mc.state_values = [[1, 2], [3, 4]]
-    eq_(mc.get_index([1, 2]), 0)
+    assert_(mc.get_index([1, 2]) == 0)
     assert_raises(ValueError, mc.get_index, 1)
     assert_array_equal(mc.get_index([[3, 4], [1, 2]]), [1, 0])
 
 
-@raises(ValueError)
 def test_raises_value_error_non_2dim():
     """Test with non 2dim input"""
-    MarkovChain(np.array([0.4, 0.6]))
+    assert_raises(ValueError, MarkovChain, np.array([0.4, 0.6]))
 
 
 def test_raises_value_error_non_sym():
@@ -581,13 +580,3 @@ def test_raises_non_homogeneous_state_values():
     P = [[0.4, 0.6], [0.2, 0.8]]
     state_values = [(0, 1), 2]
     assert_raises(ValueError, MarkovChain, P, state_values=state_values)
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)

quantecon/markov/tests/test_ddp.py

@@ -4,14 +4,14 @@
 """
 import numpy as np
 import scipy.sparse as sparse
-from numpy.testing import assert_array_equal, assert_allclose, assert_raises
-from nose.tools import ok_
+from numpy.testing import (assert_array_equal, assert_allclose, assert_raises,
+                           assert_)
 
 from quantecon.markov import DiscreteDP, backward_induction
 
 
 class TestDiscreteDP:
-    def setUp(self):
+    def setup(self):
         # From Puterman 2005, Section 3.1
         beta = 0.95
 
@@ -57,8 +57,8 @@ def test_value_iteration(self):
                                  epsilon=self.epsilon)
 
             # Check v is an epsilon/2-approximation of v_star
-            ok_(np.abs(res.v - self.v_star).max() < self.epsilon/2)
-            ok_(np.abs(res_init.v - self.v_star).max() < self.epsilon/2)
+            assert_(np.abs(res.v - self.v_star).max() < self.epsilon/2)
+            assert_(np.abs(res_init.v - self.v_star).max() < self.epsilon/2)
 
             # Check sigma == sigma_star
             assert_array_equal(res.sigma, self.sigma_star)
@@ -90,8 +90,8 @@ def test_modified_policy_iteration(self):
                                  epsilon=self.epsilon)
 
             # Check v is an epsilon/2-approximation of v_star
-            ok_(np.abs(res.v - self.v_star).max() < self.epsilon/2)
-            ok_(np.abs(res_init.v - self.v_star).max() < self.epsilon/2)
+            assert_(np.abs(res.v - self.v_star).max() < self.epsilon/2)
+            assert_(np.abs(res_init.v - self.v_star).max() < self.epsilon/2)
 
             # Check sigma == sigma_star
             assert_array_equal(res.sigma, self.sigma_star)
@@ -104,7 +104,7 @@ def test_modified_policy_iteration_k0(self):
                             epsilon=self.epsilon, k=k)
 
             # Check v is an epsilon/2-approximation of v_star
-            ok_(np.abs(res.v - self.v_star).max() < self.epsilon/2)
+            assert_(np.abs(res.v - self.v_star).max() < self.epsilon/2)
 
             # Check sigma == sigma_star
             assert_array_equal(res.sigma, self.sigma_star)
@@ -194,7 +194,7 @@ def test_ddp_sorting():
 
 
 class TestFiniteHorizon:
-    def setUp(self):
+    def setup(self):
         # From Puterman 2005, Section 3.2, Section 4.6.1
         # "single-product stochastic inventory control"
         s_indices = [0, 0, 0, 0, 1, 1, 1, 2, 2, 3]
@@ -338,13 +338,3 @@ def test_ddp_to_sa_and_to_product():
 
             for k in ["v", "sigma", "num_iter"]:
                 assert_allclose(sol1[k], sol2[k])
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)

quantecon/markov/tests/test_gth_solve.py

@@ -3,8 +3,8 @@
 
 """
 import numpy as np
-from numpy.testing import assert_array_equal
-from nose.tools import eq_, ok_, raises
+from numpy.testing import (assert_array_equal, assert_raises, assert_,
+                           assert_allclose)
 
 from quantecon.markov import gth_solve
 
@@ -130,22 +130,22 @@ def __init__(self):
 
 class StationaryDistSumOne(AddDescription):
     def __call__(self, x):
-        ok_(np.allclose(sum(x), 1, atol=TOL))
+        assert_allclose(np.sum(x), 1, atol=TOL)
 
 
 class StationaryDistNonnegative(AddDescription):
     def __call__(self, x):
-        eq_(np.prod(x >= 0-TOL), 1)
+        assert_(np.prod(x >= 0-TOL) == 1)
 
 
 class StationaryDistLeftEigenVec(AddDescription):
     def __call__(self, A, x):
-        ok_(np.allclose(np.dot(x, A), x, atol=TOL))
+        assert_allclose(np.dot(x, A), x, atol=TOL)
 
 
 class StationaryDistEqualToKnown(AddDescription):
     def __call__(self, y, x):
-        ok_(np.allclose(y, x, atol=TOL))
+        assert_allclose(y, x, atol=TOL)
 
 
 def test_matrices_with_C_F_orders():
@@ -171,23 +171,11 @@ def test_matrices_with_C_F_orders():
     assert_array_equal(computed_F, stationary_dist)
 
 
-@raises(ValueError)
 def test_raises_value_error_non_2dim():
     """Test with non 2dim input"""
-    gth_solve(np.array([0.4, 0.6]))
+    assert_raises(ValueError, gth_solve, np.array([0.4, 0.6]))
 
 
-@raises(ValueError)
 def test_raises_value_error_non_square():
     """Test with non square input"""
-    gth_solve(np.array([[0.4, 0.6]]))
-
-
-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, gth_solve, np.array([[0.4, 0.6]]))