robustify tests and add additional comments

Author: ChrisRobo

pandas/tests/frame/indexing/test_indexing.py

@@ -1403,22 +1403,59 @@ def test_set_value_resize(self, float_frame):
     def test_reindex_with_multi_index(self):
         # https://github.com/pandas-dev/pandas/issues/29896
         # tests for reindexing a multi-indexed DataFrame with a new MultiIndex
-        df = pd.DataFrame(
-            {"a": [0] * 7, "b": list(range(7)), "c": list(range(7))}
-        ).set_index(["a", "b"])
+        #
+        # confirms that we can reindex a multi-indexed DataFrame with a new
+        # MultiIndex object correctly when using no filling, backfilling, and
+        # padding
+        #
+        # The DataFrame, `df`, used in this test is:
+        #       c
+        #  a b
+        # -1 0  A
+        #    1  B
+        #    2  C
+        #    3  D
+        #    4  E
+        #    5  F
+        #    6  G
+        #  0 0  A
+        #    1  B
+        #    2  C
+        #    3  D
+        #    4  E
+        #    5  F
+        #    6  G
+        #  1 0  A
+        #    1  B
+        #    2  C
+        #    3  D
+        #    4  E
+        #    5  F
+        #    6  G
+        #
+        # and the other MultiIndex, `new_multi_index`, is:
+        # 0: 0 0.5
+        # 1:   2.0
+        # 2:   5.0
+        # 3:   5.8
+        df = pd.DataFrame({
+            "a": [-1] * 7 + [0] * 7 + [1] * 7 ,
+            "b": list(range(7)) * 3,
+            "c": ["A", "B", "C", "D", "E", "F", "G"] * 3,
+        }).set_index(["a", "b"])
         new_index = [0.5, 2.0, 5.0, 5.8]
         new_multi_index = MultiIndex.from_product([[0], new_index], names=["a", "b"])
 
         # reindexing w/o a `method` value
         reindexed = df.reindex(new_multi_index)
         expected = pd.DataFrame(
-            {"a": [0] * 4, "b": new_index, "c": [np.nan, 2.0, 5.0, np.nan]}
+            {"a": [0] * 4, "b": new_index, "c": [np.nan, "C", "F", np.nan]}
         ).set_index(["a", "b"])
         tm.assert_frame_equal(expected, reindexed)
 
         # reindexing with backfilling
         expected = pd.DataFrame(
-            {"a": [0] * 4, "b": new_index, "c": [1, 2, 5, 6]}
+            {"a": [0] * 4, "b": new_index, "c": ["B", "C", "F", "G"]}
         ).set_index(["a", "b"])
         reindexed_with_backfilling = df.reindex(new_multi_index, method="bfill")
         tm.assert_frame_equal(expected, reindexed_with_backfilling)
@@ -1428,7 +1465,7 @@ def test_reindex_with_multi_index(self):
 
         # reindexing with padding
         expected = pd.DataFrame(
-            {"a": [0] * 4, "b": new_index, "c": [0, 2, 5, 5]}
+            {"a": [0] * 4, "b": new_index, "c": ["A", "C", "F", "F"]}
         ).set_index(["a", "b"])
         reindexed_with_padding = df.reindex(new_multi_index, method="pad")
         tm.assert_frame_equal(expected, reindexed_with_padding)

pandas/tests/indexes/multi/test_indexing.py

@@ -186,27 +186,53 @@ def test_get_indexer():
 def test_get_indexer_methods():
     # https://github.com/pandas-dev/pandas/issues/29896
     # test getting an indexer for another index with different methods
-    mult_idx_1 = MultiIndex.from_product([[0], [0, 2, 3, 4]])
+    # confirms that getting an indexer without a filling method, getting an
+    # indexer and backfilling, and getting an indexer and padding all behave
+    # correctly in the case where all of the target values fall in between
+    # several levels in the MultiIndex into which they are getting an indexer
+    #
+    # visually, the MultiIndexes used in this test are:
+    # mult_idx_1:
+    #  0: -1 0
+    #  1:    2
+    #  2:    3
+    #  3:    4
+    #  4:  0 0
+    #  5:    2
+    #  6:    3
+    #  7:    4
+    #  8:  1 0
+    #  9:    2
+    # 10:    3
+    # 11:    4
+    #
+    # mult_idx_2:
+    #  0: 0 1
+    #  1:   3
+    #  2:   4
+    mult_idx_1 = MultiIndex.from_product([[-1, 0, 1], [0, 2, 3, 4]])
     mult_idx_2 = MultiIndex.from_product([[0], [1, 3, 4]])
 
     indexer = mult_idx_1.get_indexer(mult_idx_2)
-    expected = np.array([-1, 2, 3], dtype=indexer.dtype)
+    expected = np.array([-1, 6, 7], dtype=indexer.dtype)
     tm.assert_almost_equal(expected, indexer)
 
     backfill_indexer = mult_idx_1.get_indexer(mult_idx_2, method="backfill")
-    expected = np.array([1, 2, 3], dtype=backfill_indexer.dtype)
+    expected = np.array([5, 6, 7], dtype=backfill_indexer.dtype)
     tm.assert_almost_equal(expected, backfill_indexer)
 
+    # ensure the legacy "bfill" option functions identically to "backfill"
     backfill_indexer = mult_idx_1.get_indexer(mult_idx_2, method="bfill")
-    expected = np.array([1, 2, 3], dtype=backfill_indexer.dtype)
+    expected = np.array([5, 6, 7], dtype=backfill_indexer.dtype)
     tm.assert_almost_equal(expected, backfill_indexer)
 
     pad_indexer = mult_idx_1.get_indexer(mult_idx_2, method="pad")
-    expected = np.array([0, 2, 3], dtype=pad_indexer.dtype)
+    expected = np.array([4, 6, 7], dtype=pad_indexer.dtype)
     tm.assert_almost_equal(expected, pad_indexer)
 
+    # ensure the legacy "ffill" option functions identically to "pad"
     pad_indexer = mult_idx_1.get_indexer(mult_idx_2, method="ffill")
-    expected = np.array([0, 2, 3], dtype=pad_indexer.dtype)
+    expected = np.array([4, 6, 7], dtype=pad_indexer.dtype)
     tm.assert_almost_equal(expected, pad_indexer)
 
 def test_get_indexer_three_or_more_levels():