TST: adding join_types fixture

Author: almaleksia

pandas/conftest.py

@@ -99,3 +99,17 @@ def compression_no_zip(request):
 def datetime_tz_utc():
     from datetime import timezone
     return timezone.utc
+
+
+JOIN_TYPES = ['inner', 'outer', 'left', 'right']
+
+
+# workaround for parametrized tests
+@pytest.fixture(params=JOIN_TYPES)
+def join_type(request):
+    return request.param
+
+
+@pytest.fixture(scope='module')
+def join_types():
+    return JOIN_TYPES

pandas/tests/indexes/common.py

@@ -978,11 +978,10 @@ def test_empty(self):
         assert not index.empty
         assert index[:0].empty
 
-    @pytest.mark.parametrize('how', ['outer', 'inner', 'left', 'right'])
-    def test_join_self_unique(self, how):
+    def test_join_self_unique(self, join_type):
         index = self.create_index()
         if index.is_unique:
-            joined = index.join(index, how=how)
+            joined = index.join(index, how=join_type)
             assert (index == joined).all()
 
     def test_searchsorted_monotonic(self, indices):

pandas/tests/indexes/datetimes/test_datetime.py

@@ -250,10 +250,9 @@ def test_does_not_convert_mixed_integer(self):
         assert cols.dtype == joined.dtype
         tm.assert_numpy_array_equal(cols.values, joined.values)
 
-    @pytest.mark.parametrize('how', ['outer', 'inner', 'left', 'right'])
-    def test_join_self(self, how):
+    def test_join_self(self, join_type):
         index = date_range('1/1/2000', periods=10)
-        joined = index.join(index, how=how)
+        joined = index.join(index, how=join_type)
         assert index is joined
 
     def assert_index_parameters(self, index):
@@ -274,8 +273,7 @@ def test_ns_index(self):
                                      freq=index.freq)
         self.assert_index_parameters(new_index)
 
-    @pytest.mark.parametrize('how', ['left', 'right', 'inner', 'outer'])
-    def test_join_with_period_index(self, how):
+    def test_join_with_period_index(self, join_type):
         df = tm.makeCustomDataframe(
             10, 10, data_gen_f=lambda *args: np.random.randint(2),
             c_idx_type='p', r_idx_type='dt')
@@ -284,7 +282,7 @@ def test_join_with_period_index(self, how):
         with tm.assert_raises_regex(ValueError,
                                     'can only call with other '
                                     'PeriodIndex-ed objects'):
-            df.columns.join(s.index, how=how)
+            df.columns.join(s.index, how=join_type)
 
     def test_factorize(self):
         idx1 = DatetimeIndex(['2014-01', '2014-01', '2014-02', '2014-02',

pandas/tests/indexes/datetimes/test_timezones.py

@@ -700,18 +700,17 @@ def test_dti_tz_constructors(self, tzstr):
     # -------------------------------------------------------------
     # Unsorted
 
-    @pytest.mark.parametrize('how', ['inner', 'outer', 'left', 'right'])
-    def test_join_utc_convert(self, how):
+    def test_join_utc_convert(self, join_type):
         rng = date_range('1/1/2011', periods=100, freq='H', tz='utc')
 
         left = rng.tz_convert('US/Eastern')
         right = rng.tz_convert('Europe/Berlin')
 
-        result = left.join(left[:-5], how=how)
+        result = left.join(left[:-5], how=join_type)
         assert isinstance(result, DatetimeIndex)
         assert result.tz == left.tz
 
-        result = left.join(right[:-5], how=how)
+        result = left.join(right[:-5], how=join_type)
         assert isinstance(result, DatetimeIndex)
         assert result.tz.zone == 'UTC'
 

pandas/tests/indexes/period/test_period.py

@@ -532,10 +532,9 @@ def test_map(self):
         exp = Index([x.ordinal for x in index])
         tm.assert_index_equal(result, exp)
 
-    @pytest.mark.parametrize('how', ['outer', 'inner', 'left', 'right'])
-    def test_join_self(self, how):
+    def test_join_self(self, join_type):
         index = period_range('1/1/2000', periods=10)
-        joined = index.join(index, how=how)
+        joined = index.join(index, how=join_type)
         assert index is joined
 
     def test_insert(self):

pandas/tests/indexes/period/test_setops.py

@@ -14,20 +14,18 @@ def _permute(obj):
 
 class TestPeriodIndex(object):
 
-    @pytest.mark.parametrize('kind', ['inner', 'outer', 'left', 'right'])
-    def test_joins(self, kind):
+    def test_joins(self, join_type):
         index = period_range('1/1/2000', '1/20/2000', freq='D')
 
-        joined = index.join(index[:-5], how=kind)
+        joined = index.join(index[:-5], how=join_type)
 
         assert isinstance(joined, PeriodIndex)
         assert joined.freq == index.freq
 
-    @pytest.mark.parametrize('kind', ['inner', 'outer', 'left', 'right'])
-    def test_join_self(self, kind):
+    def test_join_self(self, join_type):
         index = period_range('1/1/2000', '1/20/2000', freq='D')
 
-        res = index.join(index, how=kind)
+        res = index.join(index, how=join_type)
         assert index is res
 
     def test_join_does_not_recur(self):

pandas/tests/indexes/test_base.py

@@ -1599,16 +1599,14 @@ def test_slice_keep_name(self):
         idx = Index(['a', 'b'], name='asdf')
         assert idx.name == idx[1:].name
 
-    def test_join_self(self):
-        # instance attributes of the form self.<name>Index
-        indices = 'unicode', 'str', 'date', 'int', 'float'
-        kinds = 'outer', 'inner', 'left', 'right'
-        for index_kind in indices:
-            res = getattr(self, '{0}Index'.format(index_kind))
-
-            for kind in kinds:
-                joined = res.join(res, how=kind)
-                assert res is joined
+    # instance attributes of the form self.<name>Index
+    @pytest.mark.parametrize('index_kind', ['unicode', 'str', 'date', 'int', 'float'])
+    def test_join_self(self, join_type, index_kind):
+
+        res = getattr(self, '{0}Index'.format(index_kind))
+
+        joined = res.join(res, how=join_type)
+        assert res is joined
 
     def test_str_attribute(self):
         # GH9068

pandas/tests/indexes/test_multi.py

@@ -2210,42 +2210,36 @@ def take_invalid_kwargs(self):
         tm.assert_raises_regex(ValueError, msg, idx.take,
                                indices, mode='clip')
 
-    def test_join_level(self):
-        def _check_how(other, how):
-            join_index, lidx, ridx = other.join(self.index, how=how,
-                                                level='second',
-                                                return_indexers=True)
-
-            exp_level = other.join(self.index.levels[1], how=how)
-            assert join_index.levels[0].equals(self.index.levels[0])
-            assert join_index.levels[1].equals(exp_level)
-
-            # pare down levels
-            mask = np.array(
-                [x[1] in exp_level for x in self.index], dtype=bool)
-            exp_values = self.index.values[mask]
-            tm.assert_numpy_array_equal(join_index.values, exp_values)
-
-            if how in ('outer', 'inner'):
-                join_index2, ridx2, lidx2 = \
-                    self.index.join(other, how=how, level='second',
-                                    return_indexers=True)
-
-                assert join_index.equals(join_index2)
-                tm.assert_numpy_array_equal(lidx, lidx2)
-                tm.assert_numpy_array_equal(ridx, ridx2)
-                tm.assert_numpy_array_equal(join_index2.values, exp_values)
-
-        def _check_all(other):
-            _check_how(other, 'outer')
-            _check_how(other, 'inner')
-            _check_how(other, 'left')
-            _check_how(other, 'right')
-
-        _check_all(Index(['three', 'one', 'two']))
-        _check_all(Index(['one']))
-        _check_all(Index(['one', 'three']))
-
+    @pytest.mark.parametrize('other',
+                            [Index(['three', 'one', 'two']),
+                             Index(['one']),
+                             Index(['one', 'three'])])
+    def test_join_level(self, other, join_type):
+        join_index, lidx, ridx = other.join(self.index, how=join_type,
+                                            level='second',
+                                            return_indexers=True)
+
+        exp_level = other.join(self.index.levels[1], how=join_type)
+        assert join_index.levels[0].equals(self.index.levels[0])
+        assert join_index.levels[1].equals(exp_level)
+
+        # pare down levels
+        mask = np.array(
+            [x[1] in exp_level for x in self.index], dtype=bool)
+        exp_values = self.index.values[mask]
+        tm.assert_numpy_array_equal(join_index.values, exp_values)
+
+        if join_type in ('outer', 'inner'):
+            join_index2, ridx2, lidx2 = \
+                self.index.join(other, how=join_type, level='second',
+                                return_indexers=True)
+
+            assert join_index.equals(join_index2)
+            tm.assert_numpy_array_equal(lidx, lidx2)
+            tm.assert_numpy_array_equal(ridx, ridx2)
+            tm.assert_numpy_array_equal(join_index2.values, exp_values)
+
+    def test_join_level_corner_case(self):
         # some corner cases
         idx = Index(['three', 'one', 'two'])
         result = idx.join(self.index, level='second')
@@ -2254,12 +2248,10 @@ def _check_all(other):
         tm.assert_raises_regex(TypeError, "Join.*MultiIndex.*ambiguous",
                                self.index.join, self.index, level=1)
 
-    def test_join_self(self):
-        kinds = 'outer', 'inner', 'left', 'right'
-        for kind in kinds:
-            res = self.index
-            joined = res.join(res, how=kind)
-            assert res is joined
+    def test_join_self(self, join_type):
+        res = self.index
+        joined = res.join(res, how=join_type)
+        assert res is joined
 
     def test_join_multi(self):
         # GH 10665

pandas/tests/indexes/timedeltas/test_timedelta.py

@@ -102,10 +102,9 @@ def test_factorize(self):
         tm.assert_numpy_array_equal(arr, exp_arr)
         tm.assert_index_equal(idx, idx3)
 
-    @pytest.mark.parametrize('kind', ['outer', 'inner', 'left', 'right'])
-    def test_join_self(self, kind):
+    def test_join_self(self, join_type):
         index = timedelta_range('1 day', periods=10)
-        joined = index.join(index, how=kind)
+        joined = index.join(index, how=join_type)
         tm.assert_index_equal(index, joined)
 
     def test_does_not_convert_mixed_integer(self):

pandas/tests/reshape/merge/test_join.py

@@ -297,7 +297,7 @@ def test_join_on_series_buglet(self):
                               'b': [2, 2]}, index=df.index)
         tm.assert_frame_equal(result, expected)
 
-    def test_join_index_mixed(self):
+    def test_join_index_mixed(self, join_types):
         df1 = DataFrame({'A': 1., 'B': 2, 'C': 'foo', 'D': True},
                         index=np.arange(10),
                         columns=['A', 'B', 'C', 'D'])
@@ -326,7 +326,7 @@ def test_join_index_mixed(self):
         df2['int'] = 1
         df2['float'] = 1.
 
-        for kind in ['inner', 'outer', 'left', 'right']:
+        for kind in join_types:
 
             joined = df1.join(df2, how=kind)
             expected = _join_by_hand(df1, df2, how=kind)