TST: Add test for issue pandas-dev#28518

* test_lexsort_depth verify that lexsort_depth return the correct depth
when sortorder is passed to the MultiIndex constructor
* test_raise_invalid_sortorder test that the MultiIndex constructor
raise when passing an incorrect sortorder
* test_merge_multiindex_columns test the original issue

Author: nrebena

pandas/tests/indexes/multi/test_indexing.py

@@ -96,7 +96,6 @@ def test_slice_locs_not_contained():
     index = MultiIndex(
         levels=[[0, 2, 4, 6], [0, 2, 4]],
         codes=[[0, 0, 0, 1, 1, 2, 3, 3, 3], [0, 1, 2, 1, 2, 2, 0, 1, 2]],
-        sortorder=0,
     )
 
     result = index.slice_locs((1, 0), (5, 2))

pandas/tests/reshape/merge/test_merge.py

@@ -2094,3 +2094,32 @@ def test_merge_equal_cat_dtypes2():
 
     # Categorical is unordered, so don't check ordering.
     tm.assert_frame_equal(result, expected, check_categorical=False)
+
+def test_merge_multiindex_columns():
+    # Issue #28518
+    # Verify that merging two dataframes give the expected labels
+    # The original cause of this issue come from a bug lexsort_depth and is tested in
+    # test_lexsort_depth
+    
+    index_tuples=[]
+    letters = ["a", "b", "c", "d"]
+    numbers = ["1", "2", "3"]
+
+    for l in letters:
+        for n in numbers:
+            index_tuples.append([l, n])
+
+    index = pd.MultiIndex.from_tuples(index_tuples, names=["outer", "inner"])
+
+    frame_x = pd.DataFrame(columns = index)
+    frame_x["id"]=""
+
+    frame_y = pd.DataFrame(columns = index)
+    frame_y["id"]=""
+
+    l_suf = '_x'
+    r_suf = '_y'
+    expected_labels = sum(([l + l_suf, l + r_suf] for l in letters), [])
+    merged_frame = frame_x.merge(frame_y, on="id", suffixes=((l_suf, r_suf))).columns
+    for label in expected_labels:
+        assert label in merged_frame

pandas/tests/test_multilevel.py

@@ -2056,6 +2056,54 @@ def test_is_lexsorted(self):
         assert not index.is_lexsorted()
         assert index.lexsort_depth == 0
 
+    def test_raise_invalid_sortorder(self):
+        # Test that the MultiIndex constructor raise when a incorrect sortorder is given
+        # Issue #28518
+
+        levels = [[0, 1], [0, 1, 2]]
+
+        # Correct sortorder
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]],
+            sortorder=2,
+        )
+
+        with pytest.raises(ValueError, match=r".* sortorder 2 with lexsort_depth 1.*"):
+            index = MultiIndex(
+                levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]],
+                sortorder=2,
+            )
+
+        with pytest.raises(ValueError, match=r".* sortorder 1 with lexsort_depth 0.*"):
+            index = MultiIndex(
+                levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]],
+                sortorder=1,
+            ) 
+
+    def test_lexsort_depth(self):
+        # Test that lexsort_depth return the  correct sortorder when it was given to the MultiIndex const.
+        # Issue #28518
+
+        levels = [[0, 1], [0, 1, 2]]
+
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]],
+            sortorder=2,
+        )
+        assert index.lexsort_depth == 2
+
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 2, 1]],
+            sortorder=1,
+        )
+        assert index.lexsort_depth == 1
+
+        index = MultiIndex(
+            levels=levels, codes=[[0, 0, 1, 0, 1, 1], [0, 1, 0, 2, 2, 1]],
+            sortorder=0,
+        )
+        assert index.lexsort_depth == 0
+
     def test_sort_index_and_reconstruction(self):
 
         # 15622