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

* TST: remove nose imports

* TST: remove nose imports

* TST: remove nose imports

* TST: remove nose imports

* CI: Add pytest testing for game_theory

* STY: pep8 fixes

* CI: Add docs

* Trigger CI

Author: Smit-create

.github/workflows/test.yml

@@ -37,12 +37,15 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -U nose coverage numpy scipy pandas numba sympy ipython statsmodels flake8
+        pip install -U nose coverage numpy scipy pandas numba sympy ipython statsmodels flake8 pytest
         python setup.py install
-    - name: Run Tests
+    - name: Run Tests (nose)
       run: |
         flake8 --select F401, F405,E231 quantecon
         nosetests --with-coverage -a "!slow" --cover-package=quantecon
+    - name: Run Tests (pytest)
+      run: |
+        pytest quantecon/game_theory
     - name: Coveralls Parallel
       uses: AndreMiras/coveralls-python-action@develop
       if: runner.os == 'Linux'

quantecon/game_theory/tests/test_lemke_howson.py

@@ -1,15 +1,13 @@
 """
 Tests for lemke_howson.py
-
 """
 import numpy as np
-from numpy.testing import assert_allclose
-from nose.tools import eq_, raises
+from numpy.testing import assert_allclose, assert_, assert_raises
 from quantecon.game_theory import Player, NormalFormGame, lemke_howson
 
 
 class TestLemkeHowson():
-    def setUp(self):
+    def setup(self):
         self.game_dicts = []
 
         # From von Stengel 2007 in Algorithmic Game Theory
@@ -32,7 +30,7 @@ def test_lemke_howson(self):
 
 
 class TestLemkeHowsonDegenerate():
-    def setUp(self):
+    def setup(self):
         self.game_dicts = []
 
         # From von Stengel 2007 in Algorithmic Game Theory
@@ -80,7 +78,7 @@ def test_lemke_howson_degenerate(self):
                 for action_computed, action in zip(NE_computed,
                                                    d['NEs_dict'][k]):
                     assert_allclose(action_computed, action)
-                eq_(res.converged, d['converged'])
+                assert_(res.converged == d['converged'])
 
 
 def test_lemke_howson_capping():
@@ -98,47 +96,34 @@ def test_lemke_howson_capping():
                                  capping=max_iter, full_output=True)
         for action0, action1 in zip(NE0, NE1):
             assert_allclose(action0, action1)
-        eq_(res0.init, res1.init)
+        assert_(res0.init == res1.init)
 
     init_pivot = 1
     max_iter = m+n
     NE, res = lemke_howson(g, init_pivot=init_pivot, max_iter=max_iter,
                            capping=1, full_output=True)
-    eq_(res.num_iter, max_iter)
-    eq_(res.init, init_pivot-1)
+    assert_(res.num_iter == max_iter)
+    assert_(res.init == init_pivot-1)
 
 
-@raises(TypeError)
 def test_lemke_howson_invalid_g():
     bimatrix = [[(3, 3), (3, 2)],
                 [(2, 2), (5, 6)],
                 [(0, 3), (6, 1)]]
-    lemke_howson(bimatrix)
+    assert_raises(TypeError, lemke_howson, bimatrix)
 
 
-@raises(ValueError)
 def test_lemke_howson_invalid_init_pivot_integer():
     bimatrix = [[(3, 3), (3, 2)],
                 [(2, 2), (5, 6)],
                 [(0, 3), (6, 1)]]
     g = NormalFormGame(bimatrix)
-    lemke_howson(g, -1)
+    assert_raises(ValueError, lemke_howson, g, -1)
 
 
-@raises(TypeError)
 def test_lemke_howson_invalid_init_pivot_float():
     bimatrix = [[(3, 3), (3, 2)],
                 [(2, 2), (5, 6)],
                 [(0, 3), (6, 1)]]
     g = NormalFormGame(bimatrix)
-    lemke_howson(g, 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(TypeError, lemke_howson, g, 1.0)

quantecon/game_theory/tests/test_mclennan_tourky.py

@@ -1,18 +1,16 @@
 """
 Tests for mclennan_tourky.py
-
 """
 import numpy as np
-from numpy.testing import assert_array_equal
-from nose.tools import ok_, raises
+from numpy.testing import assert_array_equal, assert_raises, assert_
 from quantecon.game_theory import Player, NormalFormGame, mclennan_tourky
 from quantecon.game_theory.mclennan_tourky import (
-     _best_response_selection, _flatten_action_profile, _is_epsilon_nash
+    _best_response_selection, _flatten_action_profile, _is_epsilon_nash
 )
 
 
 class TestMclennanTourky():
-    def setUp(self):
+    def setup(self):
         def anti_coordination(N, v):
             payoff_array = np.empty((2,)*N)
             payoff_array[0, :] = 1
@@ -48,37 +46,34 @@ def epsilon_nash_interval(N, v, epsilon):
     def test_convergence_default(self):
         for d in self.game_dicts:
             NE, res = mclennan_tourky(d['g'], full_output=True)
-            ok_(res.converged)
+            assert_(res.converged)
 
     def test_pure_nash(self):
         for d in self.game_dicts:
             init = (1,) + (0,)*(d['g'].N-1)
             NE, res = mclennan_tourky(d['g'], init=init, full_output=True)
-            ok_(res.num_iter==1)
+            assert_(res.num_iter == 1)
 
 
 class TestMclennanTourkyInvalidInputs():
-    def setUp(self):
+    def setup(self):
             self.bimatrix = [[(3, 3), (3, 2)],
                              [(2, 2), (5, 6)],
                              [(0, 3), (6, 1)]]
             self.g = NormalFormGame(self.bimatrix)
 
-    @raises(TypeError)
     def test_mclennan_tourky_invalid_g(self):
-        mclennan_tourky(self.bimatrix)
+        assert_raises(TypeError, mclennan_tourky, self.bimatrix)
 
-    @raises(TypeError)
     def test_mclennan_tourky_invalid_init_type(self):
-        mclennan_tourky(self.g, 1)
+        assert_raises(TypeError, mclennan_tourky, self.g, 1)
 
-    @raises(ValueError)
     def test_mclennan_tourky_invalid_init_length(self):
-        mclennan_tourky(self.g, [1])
+        assert_raises(ValueError, mclennan_tourky, self.g, [1])
 
 
 class TestEpsilonNash():
-    def setUp(self):
+    def setup(self):
         def anti_coordination(N, v):
             payoff_array = np.empty((2,)*N)
             payoff_array[0, :] = 1
@@ -121,17 +116,17 @@ def test_epsilon_nash_with_full_output(self):
             NE, res = \
                 mclennan_tourky(d['g'], epsilon=d['epsilon'], full_output=True)
             for i in range(d['g'].N):
-                ok_(d['lb'] < NE[i][0] < d['ub'])
+                assert_(d['lb'] < NE[i][0] < d['ub'])
 
     def test_epsilon_nash_without_full_output(self):
         for d in self.game_dicts:
             NE = mclennan_tourky(d['g'], epsilon=d['epsilon'],
                                  full_output=False)
             for i in range(d['g'].N):
-                ok_(d['lb'] < NE[i][0] < d['ub'])
+                assert_(d['lb'] < NE[i][0] < d['ub'])
 
     def test_is_epsilon_nash_no_indptr(self):
-        ok_(_is_epsilon_nash([1., 0., 0., 1., 0.], self.g, 1e-5))
+        assert_(_is_epsilon_nash([1., 0., 0., 1., 0.], self.g, 1e-5))
 
 
 def test_flatten_action_profile():
@@ -151,13 +146,3 @@ def test_best_response_selection_no_indptr():
     expected_output = np.array([0., 1., 0., 0., 1.])
 
     assert_array_equal(test_obj, expected_output)
-
-
-if __name__ == '__main__':
-    import sys
-    import nose
-
-    argv = sys.argv[:]
-    argv.append('--verbose')
-    argv.append('--nocapture')
-    nose.main(argv=argv, defaultTest=__file__)