MAINT: Remove nose imports and use pytest (#613)

* MAINT: Remove nose imports and use pytest

* STY: pep8 fixes

* MAINT: Remove nose imports and use pytest

* MAINT: Remove nose imports and use pytest

* CI: Add pytest in environment.yml

* MAINT: Remove nose imports and use pytest

* MAINT: Add missing __init__ files

* CI: Move to pytest

* FIX: Specify dtype=np.int64 to avoid overflow on Windows

Co-Authored-By: Daisuke Oyama <[email protected]>

* STY: Fix pep8 issues

Co-authored-by: Daisuke Oyama <[email protected]>

Author: Smit-create

.github/workflows/test.yml

@@ -34,27 +34,28 @@ jobs:
       uses: actions/setup-python@v1
       with:
         python-version: ${{ matrix.python-version }}
+
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -U nose coverage numpy scipy pandas numba sympy ipython statsmodels flake8 pytest
+        pip install -U coverage numpy scipy pandas numba sympy ipython statsmodels flake8 pytest
         python setup.py install
-    - name: Run Tests (nose)
+
+    - name: flake8 Tests
       run: |
         flake8 --select F401, F405,E231 quantecon
-        nosetests --with-coverage -a "!slow" --cover-package=quantecon
+
     - name: Run Tests (pytest)
       run: |
-        pytest quantecon/game_theory
-        pytest quantecon/markov
-        pytest quantecon/optimize
-        pytest quantecon/random
+        pytest quantecon
+
     - name: Coveralls Parallel
       uses: AndreMiras/coveralls-python-action@develop
       if: runner.os == 'Linux'
       with:
         flag-name: run-${{ matrix.test_number }}
         parallel: true
+
   coveralls_finish:
     needs: tests
     runs-on: ubuntu-latest

environment.yml

@@ -14,3 +14,4 @@ dependencies:
   - statsmodels
   - flake8
   - requests
+  - pytest

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')

quantecon/game_theory/game_generators/tests/__init__.py

@@ -155,7 +155,8 @@ def qnwequi(n, a, b, kind="N", equidist_pp=None, random_state=None):
     if b.size == 1:
         b = np.repeat(b, d)
 
-    i = np.arange(1, n + 1)
+    # Specify `dtype=np.int64` to avoid overflow on Windows
+    i = np.arange(1, n + 1, dtype=np.int64)
 
     if kind.upper() == "N":  # Neiderreiter
         j = 2.0 ** (np.arange(1, d+1) / (d+1))

quantecon/game_theory/tests/__init__.py

@@ -3,15 +3,13 @@
 covered by the numpy tests since we rely on much of their code.
 
 """
-import sys
-import unittest
 import numpy as np
-from numpy.testing import assert_array_equal
+from numpy.testing import assert_array_equal, assert_
 from quantecon.arma import ARMA
 
 
-class TestARMA(unittest.TestCase):
-    def setUp(self):
+class TestARMA():
+    def setup(self):
         # Initial Values
         phi = np.array([.95, -.4, -.4])
         theta = np.zeros(3)
@@ -28,7 +26,7 @@ def test_simulate(self):
 
         sim = lp.simulation(ts_length=250)
 
-        self.assertTrue(sim.size==250)
+        assert_(sim.size == 250)
 
     def test_simulate_with_seed(self):
         lp = self.lp
@@ -43,10 +41,4 @@ def test_impulse_response(self):
 
         imp_resp = lp.impulse_response(impulse_length=75)
 
-        self.assertTrue(imp_resp.size==75)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TestARMA)
-    unittest.TextTestRunner(verbosity=2, stream=sys.stderr).run(suite)
-
+        assert_(imp_resp.size == 75)

quantecon/markov/tests/__init__.py

@@ -9,16 +9,15 @@
 TODO: add multivariate case
 
 """
-import unittest
 import numpy as np
-from nose.tools import ok_, raises
+from numpy.testing import assert_, assert_raises
 from quantecon import compute_fixed_point
 
 
-class TestFPLogisticEquation(unittest.TestCase):
+class TestFPLogisticEquation():
 
     @classmethod
-    def setUpClass(cls):
+    def setup(cls):
         cls.mu_1 = 0.2  # 0 is unique fixed point forall x_0 \in [0, 1]
 
         # (4mu - 1)/(4mu) is a fixed point forall x_0 \in [0, 1]
@@ -38,34 +37,31 @@ def test_contraction_1(self):
         f = lambda x: self.T(x, self.mu_1)
         for i in self.unit_inverval:
             # should have fixed point of 0.0
-            self.assertTrue(abs(compute_fixed_point(f, i, **self.kwargs))
-                            < 1e-4)
+            assert_(abs(compute_fixed_point(f, i, **self.kwargs)) < 1e-4)
 
     def test_not_contraction_2(self):
         "compute_fp: no convergence outside interval of convergence"
         f = lambda x: self.T(x, self.mu_2)
         for i in self.unit_inverval:
             # This shouldn't converge to 0.0
-            self.assertFalse(abs(compute_fixed_point(f, i, **self.kwargs))
-                             < 1e-4)
+            assert_(not (abs(compute_fixed_point(f, i, **self.kwargs)) < 1e-4))
 
     def test_contraction_2(self):
         "compute_fp: convergence inside interval of convergence"
         f = lambda x: self.T(x, self.mu_2)
         fp = (4 * self.mu_2 - 1) / (4 * self.mu_2)
         for i in self.unit_inverval:
             # This should converge to fp
-            self.assertTrue(abs(compute_fixed_point(f, i, **self.kwargs)-fp)
-                            < 1e-4)
+            assert_(abs(compute_fixed_point(f, i, **self.kwargs)-fp) < 1e-4)
 
     def test_not_contraction_1(self):
         "compute_fp: no convergence outside interval of convergence"
         f = lambda x: self.T(x, self.mu_1)
         fp = (4 * self.mu_1 - 1) / (4 * self.mu_1)
         for i in self.unit_inverval:
             # This should not converge  (b/c unique fp is 0.0)
-            self.assertFalse(abs(compute_fixed_point(f, i, **self.kwargs)-fp)
-                             < 1e-4)
+            assert_(not (abs(compute_fixed_point(f, i, **self.kwargs)-fp)
+                    < 1e-4))
 
     def test_imitation_game_method(self):
         "compute_fp: Test imitation game method"
@@ -76,22 +72,22 @@ def test_imitation_game_method(self):
             for i in self.unit_inverval:
                 fp_computed = compute_fixed_point(self.T, i, method=method,
                                                   mu=mu, **self.kwargs)
-                self.assertTrue(
+                assert_(
                     abs(self.T(fp_computed, mu=mu) - fp_computed) <= error_tol
                 )
 
             # numpy array input
             i = np.asarray(self.unit_inverval)
             fp_computed = compute_fixed_point(self.T, i, method=method, mu=mu,
                                               **self.kwargs)
-            self.assertTrue(
+            assert_(
                 abs(self.T(fp_computed, mu=mu) - fp_computed).max() <=
                 error_tol
             )
 
 
 class TestComputeFPContraction():
-    def setUp(self):
+    def setup(self):
         self.coeff = 0.5
         self.methods = ['iteration', 'imitation_game']
 
@@ -106,7 +102,7 @@ def test_num_iter_one(self):
             fp_computed = compute_fixed_point(self.f, init,
                                               error_tol=error_tol,
                                               method=method)
-            ok_(fp_computed <= error_tol * 2)
+            assert_(fp_computed <= error_tol * 2)
 
     def test_num_iter_large(self):
         init = 1.
@@ -119,7 +115,7 @@ def test_num_iter_large(self):
                                               error_tol=error_tol,
                                               max_iter=max_iter, method=method,
                                               print_skip=max_iter)
-            ok_(fp_computed <= error_tol * 2)
+            assert_(fp_computed <= error_tol * 2)
 
     def test_2d_input(self):
         error_tol = self.coeff**4
@@ -129,12 +125,11 @@ def test_2d_input(self):
             fp_computed = compute_fixed_point(self.f, init,
                                               error_tol=error_tol,
                                               method=method)
-            ok_((fp_computed <= error_tol * 2).all())
+            assert_((fp_computed <= error_tol * 2).all())
 
 
-@raises(ValueError)
 def test_raises_value_error_nonpositive_max_iter():
     f = lambda x: 0.5*x
     init = 1.
     max_iter = 0
-    compute_fixed_point(f, init, max_iter=max_iter)
+    assert_raises(ValueError, compute_fixed_point, f, init, max_iter=max_iter)