Refactor tests for pytest

Author: mckelvin

tests/test_abstract.py

@@ -1,10 +1,5 @@
 import numpy as np
-from nose.tools import (
-    assert_equals,
-    assert_true,
-    assert_false,
-    assert_raises,
-    )
+import pytest
 
 try:
     from collections import OrderedDict
@@ -14,7 +9,7 @@
 import talib
 from talib import func
 from talib import abstract
-from talib.test_data import ford_2012, assert_np_arrays_equal, assert_np_arrays_not_equal
+from test_data import ford_2012, assert_np_arrays_equal, assert_np_arrays_not_equal
 
 
 def test_pandas():
@@ -24,20 +19,20 @@ def test_pandas():
 
     expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) # 5, 3, 0, 3, 0
     output = abstract.Function('stoch', input_df).outputs
-    assert_true(isinstance(output, pandas.DataFrame))
+    assert isinstance(output, pandas.DataFrame)
     assert_np_arrays_equal(expected_k, output['slowk'])
     assert_np_arrays_equal(expected_d, output['slowd'])
     output = abstract.Function('stoch', input_dict).outputs
-    assert_true(isinstance(output, list))
+    assert isinstance(output, list)
     assert_np_arrays_equal(expected_k, output[0])
     assert_np_arrays_equal(expected_d, output[1])
 
     expected = func.SMA(ford_2012['close'], 10)
     output = abstract.Function('sma', input_df, 10).outputs
-    assert_true(isinstance(output, pandas.Series))
+    assert isinstance(output, pandas.Series)
     assert_np_arrays_equal(expected, output)
     output = abstract.Function('sma', input_dict, 10).outputs
-    assert_true(isinstance(output, np.ndarray))
+    assert isinstance(output, np.ndarray)
     assert_np_arrays_equal(expected, output)
 
 
@@ -86,12 +81,13 @@ def test_doji_candle():
 
 def test_MAVP():
     mavp = abstract.MAVP
-    assert_raises(Exception, mavp.set_input_arrays, ford_2012)
+    with pytest.raises(Exception):
+        mavp.set_input_arrays(ford_2012)
     input_d = {}
     input_d['close'] = ford_2012['close']
     input_d['periods'] = np.arange(30)
-    assert_true(mavp.set_input_arrays(input_d))
-    assert_equals(mavp.input_arrays, input_d)
+    assert mavp.set_input_arrays(input_d)
+    assert mavp.input_arrays == input_d
 
 def test_info():
     stochrsi = abstract.Function('STOCHRSI')
@@ -115,7 +111,7 @@ def test_info():
             ('fastd_matype', 1),
             ]),
         }
-    assert_equals(expected, stochrsi.info)
+    assert expected == stochrsi.info
 
     expected = {
         'display_name': 'Bollinger Bands',
@@ -136,11 +132,11 @@ def test_info():
             ('matype', 0),
             ]),
         }
-    assert_equals(expected, abstract.Function('BBANDS').info)
+    assert expected == abstract.Function('BBANDS').info
 
 def test_input_names():
     expected = OrderedDict([('price', 'close')])
-    assert_equals(expected, abstract.Function('MAMA').input_names)
+    assert expected == abstract.Function('MAMA').input_names
 
     # test setting input_names
     obv = abstract.Function('OBV')
@@ -149,13 +145,13 @@ def test_input_names():
         ('prices', ['volume']),
         ])
     obv.input_names = expected
-    assert_equals(obv.input_names, expected)
+    assert obv.input_names == expected
 
     obv.input_names = {
         'price': 'open',
         'prices': ['volume'],
         }
-    assert_equals(obv.input_names, expected)
+    assert obv.input_names == expected
 
 def test_input_arrays():
     mama = abstract.Function('MAMA')
@@ -167,33 +163,34 @@ def test_input_arrays():
         'close': None,
         'volume': None,
         }
-    assert_equals(expected, mama.get_input_arrays())
+    assert expected == mama.get_input_arrays()
     # test setting/getting input_arrays
-    assert_true(mama.set_input_arrays(ford_2012))
-    assert_equals(mama.get_input_arrays(), ford_2012)
-    assert_raises(Exception,
-                  mama.set_input_arrays, {'hello': 'fail', 'world': 'bye'})
+    assert mama.set_input_arrays(ford_2012)
+    assert mama.get_input_arrays() == ford_2012
+    with pytest.raises(Exception):
+        mama.set_input_arrays({'hello': 'fail', 'world': 'bye'})
 
     # test only required keys are needed
     willr = abstract.Function('WILLR')
     reqd = willr.input_names['prices']
     input_d = dict([(key, ford_2012[key]) for key in reqd])
-    assert_true(willr.set_input_arrays(input_d))
-    assert_equals(willr.input_arrays, input_d)
+    assert willr.set_input_arrays(input_d)
+    assert willr.input_arrays == input_d
 
     # test extraneous keys are ignored
     input_d['extra_stuffs'] = 'you should never see me'
     input_d['date'] = np.random.rand(100)
-    assert_true(willr.set_input_arrays(input_d))
+    assert willr.set_input_arrays(input_d)
 
     # test missing keys get detected
     input_d['open'] = ford_2012['open']
     input_d.pop('close')
-    assert_raises(Exception, willr.set_input_arrays, input_d)
+    with pytest.raises(Exception):
+        willr.set_input_arrays(input_d)
 
     # test changing input_names on the Function
     willr.input_names = {'prices': ['high', 'low', 'open']}
-    assert_true(willr.set_input_arrays(input_d))
+    assert willr.set_input_arrays(input_d)
 
 def test_parameters():
     stoch = abstract.Function('STOCH')
@@ -204,31 +201,31 @@ def test_parameters():
         ('slowd_period', 3),
         ('slowd_matype', 0),
         ])
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {'fastk_period': 10}
     expected['fastk_period'] = 10
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {'slowk_period': 8, 'slowd_period': 5}
     expected['slowk_period'] = 8
     expected['slowd_period'] = 5
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {'slowd_matype': talib.MA_Type.T3}
     expected['slowd_matype'] = 8
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {
         'slowk_matype': talib.MA_Type.WMA,
         'slowd_matype': talib.MA_Type.EMA,
         }
     expected['slowk_matype'] = 2
     expected['slowd_matype'] = 1
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
 def test_lookback():
-    assert_equals(abstract.Function('SMA', 10).lookback, 9)
+    assert abstract.Function('SMA', 10).lookback == 9
 
     stochrsi = abstract.Function('stochrsi', 20, 5, 3)
-    assert_equals(stochrsi.lookback, 26)
+    assert stochrsi.lookback == 26

tests/test_data.py

@@ -3,7 +3,6 @@
 
 import numpy as np
 
-from nose.tools import assert_equal, assert_not_equal, assert_true
 
 ford_2012_dates = np.asarray([ 20120103, 20120104, 20120105, 20120106, 20120109,
     20120110, 20120111, 20120112, 20120113, 20120117, 20120118, 20120119,
@@ -217,9 +216,9 @@
 def assert_np_arrays_equal(expected, got):
     for i, value in enumerate(expected):
         if np.isnan(value):
-            assert_true(np.isnan(got[i]))
+            assert np.isnan(got[i])
         else:
-            assert_equal(value, got[i])
+            assert value == got[i]
 
 def assert_np_arrays_not_equal(expected, got):
     ''' Verifies expected and got have the same number of leading nan fields,
@@ -229,11 +228,11 @@ def assert_np_arrays_not_equal(expected, got):
     equals = []
     for i, value in enumerate(expected):
         if np.isnan(value):
-            assert_true(np.isnan(got[i]))
+            assert np.isnan(got[i])
             nans.append(value)
         else:
             try:
-                assert_not_equal(value, got[i])
+                assert value != got[i]
             except AssertionError:
                 equals.append(got[i])
     if len(equals) == len(expected[len(nans):]):

tests/test_func.py

@@ -1,20 +1,20 @@
 import numpy as np
-from nose.tools import assert_equals, assert_true, assert_raises
+import pytest
 
 import talib
 from talib import func
-from talib.test_data import series, assert_np_arrays_equal, assert_np_arrays_not_equal
+from test_data import series, assert_np_arrays_equal, assert_np_arrays_not_equal
 
 def test_input_lengths():
     a1 = np.arange(10, dtype=float)
     a2 = np.arange(11, dtype=float)
-    with assert_raises(Exception):
+    with pytest.raises(Exception):
         func.BOP(a2, a1, a1, a1)
-    with assert_raises(Exception):
+    with pytest.raises(Exception):
         func.BOP(a1, a2, a1, a1)
-    with assert_raises(Exception):
+    with pytest.raises(Exception):
         func.BOP(a1, a1, a2, a1)
-    with assert_raises(Exception):
+    with pytest.raises(Exception):
         func.BOP(a1, a1, a1, a2)
 
 def test_input_nans():
@@ -41,23 +41,23 @@ def test_unstable_period():
 def test_MIN():
     result = func.MIN(series, timeperiod=4)
     i = np.where(~np.isnan(result))[0][0]
-    assert_equals(len(series), len(result))
-    assert_equals(result[i + 1], 93.780)
-    assert_equals(result[i + 2], 93.780)
-    assert_equals(result[i + 3], 92.530)
-    assert_equals(result[i + 4], 92.530)
+    assert len(series) == len(result)
+    assert result[i + 1] == 93.780
+    assert result[i + 2] == 93.780
+    assert result[i + 3] == 92.530
+    assert result[i + 4] == 92.530
     values = np.array([np.nan, 5., 4., 3., 5., 7.])
     result = func.MIN(values, timeperiod=2)
     assert_np_arrays_equal(result, [np.nan, np.nan, 4, 3, 3, 5])
 
 def test_MAX():
     result = func.MAX(series, timeperiod=4)
     i = np.where(~np.isnan(result))[0][0]
-    assert_equals(len(series), len(result))
-    assert_equals(result[i + 2], 95.090)
-    assert_equals(result[i + 3], 95.090)
-    assert_equals(result[i + 4], 94.620)
-    assert_equals(result[i + 5], 94.620)
+    assert len(series) == len(result)
+    assert result[i + 2] == 95.090
+    assert result[i + 3] == 95.090
+    assert result[i + 4] == 94.620
+    assert result[i + 5] == 94.620
 
 def test_MOM():
     values = np.array([90.0,88.0,89.0])
@@ -75,29 +75,29 @@ def test_BBANDS():
                                         nbdevup=2.0, nbdevdn=2.0,
                                         matype=talib.MA_Type.EMA)
     i = np.where(~np.isnan(upper))[0][0]
-    assert_true(len(upper) == len(middle) == len(lower) == len(series))
-    #assert_true(abs(upper[i + 0] - 98.0734) < 1e-3)
-    assert_true(abs(middle[i + 0] - 92.8910) < 1e-3)
-    assert_true(abs(lower[i + 0] - 87.7086) < 1e-3)
-    #assert_true(abs(upper[i + 13] - 93.674) < 1e-3)
-    assert_true(abs(middle[i + 13] - 87.679) < 1e-3)
-    assert_true(abs(lower[i + 13] - 81.685) < 1e-3)
+    assert len(upper) == len(middle) == len(lower) == len(series)
+    # assert abs(upper[i + 0] - 98.0734) < 1e-3
+    assert abs(middle[i + 0] - 92.8910) < 1e-3
+    assert abs(lower[i + 0] - 87.7086) < 1e-3
+    # assert abs(upper[i + 13] - 93.674) < 1e-3
+    assert abs(middle[i + 13] - 87.679) < 1e-3
+    assert abs(lower[i + 13] - 81.685) < 1e-3
 
 def test_DEMA():
     result = func.DEMA(series)
     i = np.where(~np.isnan(result))[0][0]
-    assert_true(len(series) == len(result))
-    assert_true(abs(result[i + 1] - 86.765) < 1e-3)
-    assert_true(abs(result[i + 2] - 86.942) < 1e-3)
-    assert_true(abs(result[i + 3] - 87.089) < 1e-3)
-    assert_true(abs(result[i + 4] - 87.656) < 1e-3)
+    assert len(series) == len(result)
+    assert abs(result[i + 1] - 86.765) < 1e-3
+    assert abs(result[i + 2] - 86.942) < 1e-3
+    assert abs(result[i + 3] - 87.089) < 1e-3
+    assert abs(result[i + 4] - 87.656) < 1e-3
 
 def test_EMAEMA():
     result = func.EMA(series, timeperiod=2)
     result = func.EMA(result, timeperiod=2)
     i = np.where(~np.isnan(result))[0][0]
-    assert_true(len(series) == len(result))
-    assert_equals(i, 2)
+    assert len(series) == len(result)
+    assert i == 2
 
 def test_CDL3BLACKCROWS():
     o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00, 27.66, 30.80])

tests/test_stream.py

@@ -1,25 +1,24 @@
 import numpy as np
-from nose.tools import assert_equals, assert_true, assert_raises
 
 import talib
 from talib import stream
 
 def test_streaming():
     a = np.array([1,1,2,3,5,8,13], dtype=float)
     r = stream.MOM(a, timeperiod=1)
-    assert_equals(r, 5)
+    assert r == 5
     r = stream.MOM(a, timeperiod=2)
-    assert_equals(r, 8)
+    assert r == 8
     r = stream.MOM(a, timeperiod=3)
-    assert_equals(r, 10)
+    assert r == 10
     r = stream.MOM(a, timeperiod=4)
-    assert_equals(r, 11)
+    assert r == 11
     r = stream.MOM(a, timeperiod=5)
-    assert_equals(r, 12)
+    assert r == 12
     r = stream.MOM(a, timeperiod=6)
-    assert_equals(r, 12)
+    assert r == 12
     r = stream.MOM(a, timeperiod=7)
-    assert_true(np.isnan(r))
+    assert np.isnan(r)
 
 def test_CDL3BLACKCROWS():
     o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00])
@@ -28,4 +27,4 @@ def test_CDL3BLACKCROWS():
     c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03])
 
     r = stream.CDL3BLACKCROWS(o, h, l, c)
-    assert_equals(r, -100)
+    assert r == -100