TST: fixtures for timezones

Author: almaleksia

pandas/conftest.py

@@ -97,3 +97,24 @@ def join_type(request):
     Fixture for trying all types of join operations
     """
     return request.param
+
+
+TIMEZONES = [None, 'UTC', 'US/Eastern', 'Asia/Tokyo', 'dateutil/US/Pacific']
+
+
+@td.parametrize_fixture_doc(str(TIMEZONES))
+@pytest.fixture(params=TIMEZONES)
+def tz_naive_fixture(request):
+    """
+    Fixture for trying timezones including default (None): {0}
+    """
+    return request.param
+
+
+@td.parametrize_fixture_doc(str(TIMEZONES[1:]))
+@pytest.fixture(params=TIMEZONES[1:])
+def tz_aware_fixture(request):
+    """
+    Fixture for trying explicit timezones: {0}
+    """
+    return request.param

pandas/tests/dtypes/test_cast.py

@@ -144,16 +144,6 @@ def testinfer_dtype_from_scalar(self):
             dtype, val = infer_dtype_from_scalar(data)
             assert dtype == 'm8[ns]'
 
-        for tz in ['UTC', 'US/Eastern', 'Asia/Tokyo']:
-            dt = Timestamp(1, tz=tz)
-            dtype, val = infer_dtype_from_scalar(dt, pandas_dtype=True)
-            assert dtype == 'datetime64[ns, {0}]'.format(tz)
-            assert val == dt.value
-
-            dtype, val = infer_dtype_from_scalar(dt)
-            assert dtype == np.object_
-            assert val == dt
-
         for freq in ['M', 'D']:
             p = Period('2011-01-01', freq=freq)
             dtype, val = infer_dtype_from_scalar(p, pandas_dtype=True)
@@ -171,6 +161,17 @@ def testinfer_dtype_from_scalar(self):
             dtype, val = infer_dtype_from_scalar(data)
             assert dtype == np.object_
 
+    @pytest.mark.parametrize('tz', ['UTC', 'US/Eastern', 'Asia/Tokyo'])
+    def testinfer_from_scalar_tz(self, tz):
+        dt = Timestamp(1, tz=tz)
+        dtype, val = infer_dtype_from_scalar(dt, pandas_dtype=True)
+        assert dtype == 'datetime64[ns, {0}]'.format(tz)
+        assert val == dt.value
+
+        dtype, val = infer_dtype_from_scalar(dt)
+        assert dtype == np.object_
+        assert val == dt
+
     def testinfer_dtype_from_scalar_errors(self):
         with pytest.raises(ValueError):
             infer_dtype_from_scalar(np.array([1]))

pandas/tests/frame/test_alter_axes.py

@@ -269,25 +269,26 @@ def test_set_index_cast_datetimeindex(self):
         df.pop('ts')
         assert_frame_equal(df, expected)
 
+    def test_reset_index_tz(self, tz_aware_fixture):
         # GH 3950
         # reset_index with single level
-        for tz in ['UTC', 'Asia/Tokyo', 'US/Eastern']:
-            idx = pd.date_range('1/1/2011', periods=5,
-                                freq='D', tz=tz, name='idx')
-            df = pd.DataFrame(
-                {'a': range(5), 'b': ['A', 'B', 'C', 'D', 'E']}, index=idx)
-
-            expected = pd.DataFrame({'idx': [datetime(2011, 1, 1),
-                                             datetime(2011, 1, 2),
-                                             datetime(2011, 1, 3),
-                                             datetime(2011, 1, 4),
-                                             datetime(2011, 1, 5)],
-                                     'a': range(5),
-                                     'b': ['A', 'B', 'C', 'D', 'E']},
-                                    columns=['idx', 'a', 'b'])
-            expected['idx'] = expected['idx'].apply(
-                lambda d: pd.Timestamp(d, tz=tz))
-            assert_frame_equal(df.reset_index(), expected)
+        tz = tz_aware_fixture
+        idx = pd.date_range('1/1/2011', periods=5,
+                            freq='D', tz=tz, name='idx')
+        df = pd.DataFrame(
+            {'a': range(5), 'b': ['A', 'B', 'C', 'D', 'E']}, index=idx)
+
+        expected = pd.DataFrame({'idx': [datetime(2011, 1, 1),
+                                         datetime(2011, 1, 2),
+                                         datetime(2011, 1, 3),
+                                         datetime(2011, 1, 4),
+                                         datetime(2011, 1, 5)],
+                                 'a': range(5),
+                                 'b': ['A', 'B', 'C', 'D', 'E']},
+                                columns=['idx', 'a', 'b'])
+        expected['idx'] = expected['idx'].apply(
+            lambda d: pd.Timestamp(d, tz=tz))
+        assert_frame_equal(df.reset_index(), expected)
 
     def test_set_index_timezone(self):
         # GH 12358

pandas/tests/indexes/datetimes/test_arithmetic.py

@@ -876,23 +876,24 @@ def test_dti_with_offset_series(self, tz, names):
             res3 = dti - other
         tm.assert_series_equal(res3, expected_sub)
 
-    def test_dti_add_offset_tzaware(self):
-        dates = date_range('2012-11-01', periods=3, tz='US/Pacific')
-        offset = dates + pd.offsets.Hour(5)
-        assert dates[0] + pd.offsets.Hour(5) == offset[0]
+    def test_dti_add_offset_tzaware(self, tz_aware_fixture):
+        timezone = tz_aware_fixture
+        if timezone == 'US/Pacific':
+            dates = date_range('2012-11-01', periods=3, tz=timezone)
+            offset = dates + pd.offsets.Hour(5)
+            assert dates[0] + pd.offsets.Hour(5) == offset[0]
 
-        # GH#6818
-        for tz in ['UTC', 'US/Pacific', 'Asia/Tokyo']:
-            dates = date_range('2010-11-01 00:00', periods=3, tz=tz, freq='H')
-            expected = DatetimeIndex(['2010-11-01 05:00', '2010-11-01 06:00',
-                                      '2010-11-01 07:00'], freq='H', tz=tz)
+        dates = date_range('2010-11-01 00:00',
+                           periods=3, tz=timezone, freq='H')
+        expected = DatetimeIndex(['2010-11-01 05:00', '2010-11-01 06:00',
+                                  '2010-11-01 07:00'], freq='H', tz=timezone)
 
-            offset = dates + pd.offsets.Hour(5)
-            tm.assert_index_equal(offset, expected)
-            offset = dates + np.timedelta64(5, 'h')
-            tm.assert_index_equal(offset, expected)
-            offset = dates + timedelta(hours=5)
-            tm.assert_index_equal(offset, expected)
+        offset = dates + pd.offsets.Hour(5)
+        tm.assert_index_equal(offset, expected)
+        offset = dates + np.timedelta64(5, 'h')
+        tm.assert_index_equal(offset, expected)
+        offset = dates + timedelta(hours=5)
+        tm.assert_index_equal(offset, expected)
 
 
 @pytest.mark.parametrize('klass,assert_func', [

pandas/tests/indexes/datetimes/test_construction.py

@@ -450,9 +450,8 @@ def test_dti_constructor_preserve_dti_freq(self):
         rng2 = DatetimeIndex(rng)
         assert rng.freq == rng2.freq
 
-    @pytest.mark.parametrize('tz', [None, 'UTC', 'Asia/Tokyo',
-                                    'dateutil/US/Pacific'])
-    def test_dti_constructor_years_only(self, tz):
+    def test_dti_constructor_years_only(self, tz_naive_fixture):
+        tz = tz_naive_fixture
         # GH 6961
         rng1 = date_range('2014', '2015', freq='M', tz=tz)
         expected1 = date_range('2014-01-31', '2014-12-31', freq='M', tz=tz)

pandas/tests/indexes/datetimes/test_datetime.py

@@ -329,8 +329,8 @@ def test_factorize(self):
         tm.assert_numpy_array_equal(arr, exp_arr)
         tm.assert_index_equal(idx, idx3)
 
-    @pytest.mark.parametrize('tz', [None, 'UTC', 'US/Eastern', 'Asia/Tokyo'])
-    def test_factorize_tz(self, tz):
+    def test_factorize_tz(self, tz_naive_fixture):
+        tz = tz_naive_fixture
         # GH#13750
         base = pd.date_range('2016-11-05', freq='H', periods=100, tz=tz)
         idx = base.repeat(5)