TST: Parametrize remaining simple yield tests.

Simple meaning those that loop through a constant and are not in a
unittest class.

Author: QuLogic

pandas/tests/computation/test_eval.py

@@ -1737,17 +1737,17 @@ def setUpClass(cls):
 
 class TestScope(object):
 
-    def check_global_scope(self, e, engine, parser):
+    @pytest.mark.parametrize('engine', _engines)
+    @pytest.mark.parametrize('parser', expr._parsers)
+    def test_global_scope(self, engine, parser):
         tm.skip_if_no_ne(engine)
+        e = '_var_s * 2'
         tm.assert_numpy_array_equal(_var_s * 2, pd.eval(e, engine=engine,
                                                         parser=parser))
 
-    def test_global_scope(self):
-        e = '_var_s * 2'
-        for engine, parser in product(_engines, expr._parsers):
-            yield self.check_global_scope, e, engine, parser
-
-    def check_no_new_locals(self, engine, parser):
+    @pytest.mark.parametrize('engine', _engines)
+    @pytest.mark.parametrize('parser', expr._parsers)
+    def test_no_new_locals(self, engine, parser):
         tm.skip_if_no_ne(engine)
         x = 1
         lcls = locals().copy()
@@ -1756,22 +1756,16 @@ def check_no_new_locals(self, engine, parser):
         lcls2.pop('lcls')
         tm.assert_equal(lcls, lcls2)
 
-    def test_no_new_locals(self):
-        for engine, parser in product(_engines, expr._parsers):
-            yield self.check_no_new_locals, engine, parser
-
-    def check_no_new_globals(self, engine, parser):
+    @pytest.mark.parametrize('engine', _engines)
+    @pytest.mark.parametrize('parser', expr._parsers)
+    def test_no_new_globals(self, engine, parser):
         tm.skip_if_no_ne(engine)
         x = 1
         gbls = globals().copy()
         pd.eval('x + 1', engine=engine, parser=parser)
         gbls2 = globals().copy()
         tm.assert_equal(gbls, gbls2)
 
-    def test_no_new_globals(self):
-        for engine, parser in product(_engines, expr._parsers):
-            yield self.check_no_new_globals, engine, parser
-
 
 def test_invalid_engine():
     tm.skip_if_no_ne()
@@ -1791,7 +1785,9 @@ def test_invalid_parser():
             'pandas': PandasExprVisitor}
 
 
-def check_disallowed_nodes(engine, parser):
+@pytest.mark.parametrize('engine', _parsers)
+@pytest.mark.parametrize('parser', _parsers)
+def test_disallowed_nodes(engine, parser):
     tm.skip_if_no_ne(engine)
     VisitorClass = _parsers[parser]
     uns_ops = VisitorClass.unsupported_nodes
@@ -1802,11 +1798,6 @@ def check_disallowed_nodes(engine, parser):
             getattr(inst, ops)()
 
 
-def test_disallowed_nodes():
-    for engine, visitor in product(_parsers, repeat=2):
-        yield check_disallowed_nodes, engine, visitor
-
-
 @pytest.mark.parametrize('engine', _engines)
 @pytest.mark.parametrize('parser', expr._parsers)
 def test_syntax_error_exprs(engine, parser):
@@ -1883,9 +1874,19 @@ def test_more_than_one_expression_raises(engine, parser):
         pd.eval('1 + 1; 2 + 2', engine=engine, parser=parser)
 
 
-def check_bool_ops_fails_on_scalars(gen, lhs, cmp, rhs, engine, parser):
+@pytest.mark.parametrize('engine', _engines)
+@pytest.mark.parametrize('parser', expr._parsers)
+@pytest.mark.parametrize('cmp', ('and', 'or'))
+@pytest.mark.parametrize('lhs', (int, float))
+@pytest.mark.parametrize('rhs', (int, float))
+def test_bool_ops_fails_on_scalars(lhs, cmp, rhs, engine, parser):
     tm.skip_if_no_ne(engine)
-    mid = gen[type(lhs)]()
+    gen = {int: lambda: np.random.randint(10), float: np.random.randn}
+
+    mid = gen[lhs]()
+    lhs = gen[lhs]()
+    rhs = gen[rhs]()
+
     ex1 = 'lhs {0} mid {1} rhs'.format(cmp, cmp)
     ex2 = 'lhs {0} mid and mid {1} rhs'.format(cmp, cmp)
     ex3 = '(lhs {0} mid) & (mid {1} rhs)'.format(cmp, cmp)
@@ -1894,17 +1895,6 @@ def check_bool_ops_fails_on_scalars(gen, lhs, cmp, rhs, engine, parser):
             pd.eval(ex, engine=engine, parser=parser)
 
 
-def test_bool_ops_fails_on_scalars():
-    _bool_ops_syms = 'and', 'or'
-    dtypes = int, float
-    gen = {int: lambda: np.random.randint(10), float: np.random.randn}
-    for engine, parser, dtype1, cmp, dtype2 in product(_engines, expr._parsers,
-                                                       dtypes, _bool_ops_syms,
-                                                       dtypes):
-        yield (check_bool_ops_fails_on_scalars, gen, gen[dtype1](), cmp,
-               gen[dtype2](), engine, parser)
-
-
 @pytest.mark.parametrize('engine', _engines)
 @pytest.mark.parametrize('parser', expr._parsers)
 def test_inf(engine, parser):
@@ -1915,7 +1905,9 @@ def test_inf(engine, parser):
     tm.assert_equal(result, expected)
 
 
-def check_negate_lt_eq_le(engine, parser):
+@pytest.mark.parametrize('engine', _engines)
+@pytest.mark.parametrize('parser', expr._parsers)
+def test_negate_lt_eq_le(engine, parser):
     tm.skip_if_no_ne(engine)
     df = pd.DataFrame([[0, 10], [1, 20]], columns=['cat', 'count'])
     expected = df[~(df.cat > 0)]
@@ -1931,11 +1923,6 @@ def check_negate_lt_eq_le(engine, parser):
         tm.assert_frame_equal(result, expected)
 
 
-def test_negate_lt_eq_le():
-    for engine, parser in product(_engines, expr._parsers):
-        yield check_negate_lt_eq_le, engine, parser
-
-
 class TestValidate(tm.TestCase):
 
     def test_validate_bool_args(self):

pandas/tests/io/parser/test_network.py

@@ -7,7 +7,6 @@
 
 import os
 import pytest
-from itertools import product
 
 import pandas.util.testing as tm
 from pandas import DataFrame
@@ -21,29 +20,30 @@ def salaries_table():
 
 
 @pytest.mark.parametrize(
-    "compression,extension", [('gzip', '.gz'), ('bz2', '.bz2'),
-                              ('zip', '.zip'), ('xz', '.xz')])
-def test_compressed_urls(salaries_table, compression, extension):
-    check_compressed_urls(salaries_table, compression, extension)
+    "compression,extension",
+    [('gzip', '.gz'), ('bz2', '.bz2'), ('zip', '.zip'),
+     tm._mark_skipif_no_lzma(('xz', '.xz'))])
+@pytest.mark.parametrize('mode', ['explicit', 'infer'])
+@pytest.mark.parametrize('engine', ['python', 'c'])
+def test_compressed_urls(salaries_table, compression, extension, mode, engine):
+    check_compressed_urls(salaries_table, compression, extension, mode, engine)
 
 
 @tm.network
-def check_compressed_urls(salaries_table, compression, extension):
+def check_compressed_urls(salaries_table, compression, extension, mode,
+                          engine):
     # test reading compressed urls with various engines and
     # extension inference
     base_url = ('https://github.com/pandas-dev/pandas/raw/master/'
                 'pandas/tests/io/parser/data/salaries.csv')
 
     url = base_url + extension
 
-    # args is a (compression, engine) tuple
-    for (c, engine) in product([compression, 'infer'], ['python', 'c']):
+    if mode != 'explicit':
+        compression = mode
 
-        if url.endswith('.xz'):
-            tm._skip_if_no_lzma()
-
-        url_table = read_table(url, compression=c, engine=engine)
-        tm.assert_frame_equal(url_table, salaries_table)
+    url_table = read_table(url, compression=compression, engine=engine)
+    tm.assert_frame_equal(url_table, salaries_table)
 
 
 class TestS3(tm.TestCase):

pandas/util/testing.py

@@ -307,12 +307,21 @@ def _skip_if_scipy_0_17():
         pytest.skip("scipy 0.17")
 
 
-def _skip_if_no_lzma():
+def _check_if_lzma():
     try:
         return compat.import_lzma()
     except ImportError:
-        import pytest
-        pytest.skip('need backports.lzma to run')
+        return False
+
+
+def _skip_if_no_lzma():
+    return _check_if_lzma() or pytest.skip('need backports.lzma to run')
+
+
+_mark_skipif_no_lzma = pytest.mark.skipif(
+    not _check_if_lzma(),
+    reason='need backports.lzma to run'
+)
 
 
 def _skip_if_no_xarray():