fix tests

Author: natmokval

pandas/core/groupby/grouper.py

@@ -679,7 +679,7 @@ def groups(self) -> dict[Hashable, Index]:
                 FutureWarning,
                 stacklevel=find_stack_level(),
             )
-            cats = [(key,) for key in cats]
+            cats = [(key,) for key in cats]  # type: ignore[assignment]
         return self._index.groupby(cats)
 
     @property

pandas/tests/groupby/test_grouping.py

@@ -548,45 +548,13 @@ def test_multiindex_columns_empty_level(self):
         grouped = df.groupby("to filter").groups
         assert grouped["A"] == [0]
 
-        grouped = df.groupby([("to filter", "")]).groups
-        assert grouped["A"] == [0]
-
-        df = DataFrame([[1, "A"], [2, "B"]], columns=midx)
-
-        expected = df.groupby("to filter").groups
-        result = df.groupby([("to filter", "")]).groups
-        assert result == expected
-
-        df = DataFrame([[1, "A"], [2, "A"]], columns=midx)
+        msg = "`groups` by one element list returns scalar is deprecated"
 
-        expected = df.groupby("to filter").groups
-        result = df.groupby([("to filter", "")]).groups
-        tm.assert_dict_equal(result, expected)
-
-    def test_groupby_multiindex_tuple(self):
-        # GH 17979
-        df = DataFrame(
-            [[1, 2, 3, 4], [3, 4, 5, 6], [1, 4, 2, 3]],
-            columns=MultiIndex.from_arrays([["a", "b", "b", "c"], [1, 1, 2, 2]]),
-        )
-        expected = df.groupby([("b", 1)]).groups
-        result = df.groupby(("b", 1)).groups
-        tm.assert_dict_equal(expected, result)
-
-        df2 = DataFrame(
-            df.values,
-            columns=MultiIndex.from_arrays(
-                [["a", "b", "b", "c"], ["d", "d", "e", "e"]]
-            ),
-        )
-        expected = df2.groupby([("b", "d")]).groups
-        result = df.groupby(("b", 1)).groups
-        tm.assert_dict_equal(expected, result)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            grouped = df.groupby([("to filter", "")]).groups
+        assert grouped[("A",)] == [0]
 
-        df3 = DataFrame(df.values, columns=[("a", "d"), ("b", "d"), ("b", "e"), "c"])
-        expected = df3.groupby([("b", "d")]).groups
-        result = df.groupby(("b", 1)).groups
-        tm.assert_dict_equal(expected, result)
+        df = DataFrame([[1, "A"], [2, "B"]], columns=midx)
 
     def test_groupby_multiindex_partial_indexing_equivalence(self):
         # GH 17977
@@ -615,8 +583,11 @@ def test_groupby_multiindex_partial_indexing_equivalence(self):
         result_max = df.groupby([("a", 1)])["b"].max()
         tm.assert_frame_equal(expected_max, result_max)
 
-        expected_groups = df.groupby([("a", 1)])[[("b", 1), ("b", 2)]].groups
-        result_groups = df.groupby([("a", 1)])["b"].groups
+        msg = "`groups` by one element list returns scalar is deprecated"
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            expected_groups = df.groupby([("a", 1)])[[("b", 1), ("b", 2)]].groups
+            result_groups = df.groupby([("a", 1)])["b"].groups
         tm.assert_dict_equal(expected_groups, result_groups)
 
     def test_groupby_level(self, sort, multiindex_dataframe_random_data, df):
@@ -723,11 +694,15 @@ def test_list_grouper_with_nat(self):
         df = DataFrame({"date": date_range("1/1/2011", periods=365, freq="D")})
         df.iloc[-1] = pd.NaT
         grouper = Grouper(key="date", freq="YS")
+        msg = "`groups` by one element list returns scalar is deprecated"
 
         # Grouper in a list grouping
         result = df.groupby([grouper])
-        expected = {Timestamp("2011-01-01"): Index(list(range(364)))}
-        tm.assert_dict_equal(result.groups, expected)
+        expected = {(Timestamp("2011-01-01"),): list(range(364)), (pd.NaT,): [364]}
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            result = result.groups
+        tm.assert_dict_equal(result, expected)
 
         # Test case without a list
         result = df.groupby(grouper)
@@ -994,11 +969,14 @@ def test_gb_key_len_equal_axis_len(self):
 class TestIteration:
     def test_groups(self, df):
         grouped = df.groupby(["A"])
-        groups = grouped.groups
+        msg = "`groups` by one element list returns scalar is deprecated"
+
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            groups = grouped.groups
         assert groups is grouped.groups  # caching works
 
         for k, v in grouped.groups.items():
-            assert (df.loc[v]["A"] == k).all()
+            assert (df.loc[v]["A"] == k[0]).all()
 
         grouped = df.groupby(["A", "B"])
         groups = grouped.groups

pandas/tests/groupby/test_raises.py

@@ -534,6 +534,9 @@ def test_groupby_raises_category_np(
     _call_and_check(klass, msg, how, gb, groupby_func_np, ())
 
 
+@pytest.mark.filterwarnings(
+    "ignore:`groups` by one element list returns scalar is deprecated"
+)
 @pytest.mark.parametrize("how", ["method", "agg", "transform"])
 def test_groupby_raises_category_on_category(
     how,