MAINT: Fix pytest warnings and use pytest in Conda CI (#615)

* MAINT: Fix pytest warnings

* CI: Use pytest on conda build

* CI: Fix coverage

Author: Smit-create

.github/workflows/conda_ci.yml

@@ -43,11 +43,15 @@ jobs:
         conda activate test
         python setup.py build
 
-    - name: Run Tests
+    - name: flake8 Tests
       shell: bash -l {0}
       run: |
         flake8 --select F401, F405, E231 quantecon
-        coverage run -m nose -a "!slow"
+
+    - name: Run Tests (pytest)
+      shell: bash -l {0}
+      run: |
+        coverage run -m pytest quantecon
         coverage lcov
 
     - name: Coveralls

.github/workflows/test.yml

@@ -47,7 +47,7 @@ jobs:
 
     - name: Run Tests (pytest)
       run: |
-        coverage run -m pytest
+        coverage run -m pytest quantecon
         coverage lcov
 
     - name: Coveralls

.gitignore

@@ -14,3 +14,7 @@ quantecon.egg-info/
 # Numba cache files
 *.nbc
 *.nbi
+
+# Coverage
+
+coverage.xml

environment.yml

@@ -3,7 +3,6 @@ channels:
   - conda-forge
   - defaults
 dependencies:
-  - nose
   - coverage
   - numpy
   - scipy

quantecon/dle.py

@@ -22,38 +22,38 @@ class DLE(object):
         h_t = \Delta_h h_{t-1} + \Theta_h c_t
         s_t = \Lambda h_{t-1} + \Pi c_t
 
-    and 
+    and
 
         z_{t+1} = A_{22} z_t + C_2 w_{t+1}
         b_t = U_b z_t
-        d_t = U_d z_t 
+        d_t = U_d z_t
 
     where h_{-1}, k_{-1}, and z_0 are given as initial conditions.
 
-    Section 5.5 of HS2013 describes how to map these matrices into those of 
-    a LQ problem. 
+    Section 5.5 of HS2013 describes how to map these matrices into those of
+    a LQ problem.
 
     HS2013 sort the matrices defining the problem into three groups:
 
-    Information: A_{22}, C_2, U_b , and U_d characterize the motion of information 
+    Information: A_{22}, C_2, U_b , and U_d characterize the motion of information
     sets and of taste and technology shocks
 
-    Technology: \Phi_c, \Phi_g, \Phi_i, \Gamma, \Delta_k, and \Theta_k determine the 
+    Technology: \Phi_c, \Phi_g, \Phi_i, \Gamma, \Delta_k, and \Theta_k determine the
     technology for producing consumption goods
 
-    Preferences: \Delta_h, \Theta_h, \Lambda, and \Pi determine the technology for 
-    producing consumption services from consumer goods. A scalar discount factor \beta 
+    Preferences: \Delta_h, \Theta_h, \Lambda, and \Pi determine the technology for
+    producing consumption services from consumer goods. A scalar discount factor \beta
     determines the preference ordering over consumption services.
 
     Parameters
     ----------
     Information : tuple
         Information is a tuple containing the matrices A_{22}, C_2, U_b, and U_d
     Technology : tuple
-        Technology is a tuple containing the matrices \Phi_c, \Phi_g, \Phi_i, \Gamma, 
+        Technology is a tuple containing the matrices \Phi_c, \Phi_g, \Phi_i, \Gamma,
         \Delta_k, and \Theta_k
     Preferences : tuple
-        Preferences is a tuple containing the matrices \Delta_h, \Theta_h, \Lambda, 
+        Preferences is a tuple containing the matrices \Delta_h, \Theta_h, \Lambda,
         \Pi, and the scalar \beta
 
     """
@@ -145,9 +145,9 @@ def __init__(self, information, technology, preferences):
 
         # === Construct matrices for Lagrange Multipliers === #
 
-        self.Mk = -2 * np.asscalar(self.beta) * (np.hstack((np.zeros((self.nk, self.nh)), np.eye(
+        self.Mk = -2 * self.beta.item() * (np.hstack((np.zeros((self.nk, self.nh)), np.eye(
             self.nk), np.zeros((self.nk, self.nz))))).dot(self.P).dot(self.A0)
-        self.Mh = -2 * np.asscalar(self.beta) * (np.hstack((np.eye(self.nh), np.zeros(
+        self.Mh = -2 * self.beta.item() * (np.hstack((np.eye(self.nh), np.zeros(
             (self.nh, self.nk)), np.zeros((self.nh, self.nz))))).dot(self.P).dot(self.A0)
         self.Ms = -(self.Sb - self.Ss)
         self.Md = -(np.linalg.inv(np.vstack((self.phic.T, self.phig.T))).dot(
@@ -296,7 +296,7 @@ def irf(self, ts_length=100, shock=None):
         return
 
     def canonical(self):
-        """ 
+        """
         Compute canonical preference representation
         Uses auxiliary problem of 9.4.2, with the preference shock process reintroduced
         Calculates pihat, llambdahat and ubhat for the equivalent canonical household technology

quantecon/markov/tests/test_approximation.py

@@ -13,8 +13,8 @@ class TestTauchen:
 
     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)
+        self.n = np.random.randint(3, 25)
+        self.m = np.random.randint(5)
         self.tol = 1e-12
         self.b = 0.
 
@@ -56,8 +56,8 @@ class TestRouwenhorst:
 
     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)
+        self.n = np.random.randint(3, 26)
+        self.ybar = np.random.randint(0, 11)
         self.tol = 1e-10
 
         mc = rouwenhorst(self.n, self.ybar, self.sigma, self.rho)

quantecon/markov/tests/test_gth_solve.py

@@ -7,6 +7,7 @@
                            assert_allclose)
 
 from quantecon.markov import gth_solve
+import pytest
 
 
 TOL = 1e-15
@@ -90,39 +91,6 @@ def __init__(self):
         self.gen_matrix_dicts.append(matrix_dict)
 
 
-def test_stoch_matrix():
-    """Test with stochastic matrices"""
-    print(__name__ + '.' + test_stoch_matrix.__name__)
-    matrices = Matrices()
-    for matrix_dict in matrices.stoch_matrix_dicts:
-        x = gth_solve(matrix_dict['A'])
-        yield StationaryDistSumOne(), x
-        yield StationaryDistNonnegative(), x
-        yield StationaryDistEqualToKnown(), matrix_dict['stationary_dist'], x
-
-
-def test_kmr_matrix():
-    """Test with KMR matrices"""
-    print(__name__ + '.' + test_kmr_matrix.__name__)
-    matrices = Matrices()
-    for matrix_dict in matrices.kmr_matrix_dicts:
-        x = gth_solve(matrix_dict['A'])
-        yield StationaryDistSumOne(), x
-        yield StationaryDistNonnegative(), x
-        yield StationaryDistLeftEigenVec(), matrix_dict['A'], x
-
-
-def test_gen_matrix():
-    """Test with generator matrices"""
-    print(__name__ + '.' + test_gen_matrix.__name__)
-    matrices = Matrices()
-    for matrix_dict in matrices.gen_matrix_dicts:
-        x = gth_solve(matrix_dict['A'])
-        yield StationaryDistSumOne(), x
-        yield StationaryDistNonnegative(), x
-        yield StationaryDistEqualToKnown(), matrix_dict['stationary_dist'], x
-
-
 class AddDescription:
     def __init__(self):
         self.description = self.__class__.__name__
@@ -148,6 +116,63 @@ def __call__(self, y, x):
         assert_allclose(y, x, atol=TOL)
 
 
+test_classes = [
+    StationaryDistSumOne,
+    StationaryDistNonnegative,
+]
+
+
+@pytest.mark.parametrize("test_class", test_classes)
+def test_stoch_matrix(test_class):
+    """Test with stochastic matrices"""
+    matrices = Matrices()
+    for matrix_dict in matrices.stoch_matrix_dicts:
+        x = gth_solve(matrix_dict['A'])
+        test_class()(x)
+
+
+def test_stoch_matrix_1():
+    """Test with stochastic matrices"""
+    matrices = Matrices()
+    for matrix_dict in matrices.stoch_matrix_dicts:
+        x = gth_solve(matrix_dict['A'])
+        StationaryDistEqualToKnown()(matrix_dict['stationary_dist'], x)
+
+
+@pytest.mark.parametrize("test_class", test_classes)
+def test_kmr_matrix(test_class):
+    """Test with KMR matrices"""
+    matrices = Matrices()
+    for matrix_dict in matrices.kmr_matrix_dicts:
+        x = gth_solve(matrix_dict['A'])
+        test_class()(x)
+
+
+def test_kmr_matrix_1():
+    """Test with KMR matrices"""
+    matrices = Matrices()
+    for matrix_dict in matrices.kmr_matrix_dicts:
+        x = gth_solve(matrix_dict['A'])
+        StationaryDistLeftEigenVec()(matrix_dict['A'], x)
+
+
+@pytest.mark.parametrize("test_class", test_classes)
+def test_gen_matrix(test_class):
+    """Test with generator matrices"""
+    matrices = Matrices()
+    for matrix_dict in matrices.gen_matrix_dicts:
+        x = gth_solve(matrix_dict['A'])
+        test_class()(x)
+
+
+def test_gen_matrix_1():
+    """Test with generator matrices"""
+    matrices = Matrices()
+    for matrix_dict in matrices.gen_matrix_dicts:
+        x = gth_solve(matrix_dict['A'])
+        StationaryDistEqualToKnown()(matrix_dict['stationary_dist'], x)
+
+
 def test_matrices_with_C_F_orders():
     """
     Test matrices with C- and F-contiguous orders

quantecon/tests/test_ivp.py

@@ -9,7 +9,7 @@
 
 # use the Solow Model with Cobb-Douglas production as test case
 def solow_model(t, k, g, n, s, alpha, delta):
-    """
+    r"""
     Equation of motion for capital stock (per unit effective labor).
 
     Parameters
@@ -41,7 +41,7 @@ def solow_model(t, k, g, n, s, alpha, delta):
 
 
 def solow_jacobian(t, k, g, n, s, alpha, delta):
-    """
+    r"""
     Jacobian matrix for the Solow model.
 
     Parameters
@@ -73,7 +73,7 @@ def solow_jacobian(t, k, g, n, s, alpha, delta):
 
 
 def solow_steady_state(g, n, s, alpha, delta):
-    """
+    r"""
     Steady-state level of capital stock (per unit effective labor).
 
     Parameters
@@ -101,7 +101,7 @@ def solow_steady_state(g, n, s, alpha, delta):
 
 
 def solow_analytic_solution(t, k0, g, n, s, alpha, delta):
-    """
+    r"""
     Analytic solution for the path of capital stock (per unit effective labor).
 
     Parameters

quantecon/tests/test_ricatti.py

@@ -5,6 +5,7 @@
 import numpy as np
 from numpy.testing import assert_allclose, assert_raises
 from quantecon.matrix_eqn import solve_discrete_riccati
+import pytest
 
 
 def dare_golden_num_float(method):
@@ -73,13 +74,15 @@ def dare_tjm_3(method):
 ]
 
 
-def test_solve_discrete_riccati():
-    def _test_factory(func, method):
-        func(method)
+_test_methods = [
+    'doubling', 'qz'
+]
+
 
-    for method in ['doubling', 'qz']:
-        for func in _test_funcs:
-            yield _test_factory, func, method
+@pytest.mark.parametrize("test_func", _test_funcs)
+@pytest.mark.parametrize("test_method", _test_methods)
+def test_solve_discrete_riccati(test_func, test_method):
+    test_func(test_method)
 
 
 def test_solve_discrete_riccati_invalid_method():