Make an independent test case for 18434

Author: Xbar

pandas/core/indexes/multi.py

@@ -1212,7 +1212,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
                                   of iterables
         """
         if not is_list_like(tuples):
-            raise TypeError('Input must be a list /sequence of tuple-likes.')
+            raise TypeError('Input must be a list / sequence of tuple-likes.')
         elif is_iterator(tuples):
             tuples = list(tuples)
 

pandas/tests/indexes/test_multi.py

@@ -676,21 +676,27 @@ def test_from_arrays(self):
         result = MultiIndex.from_arrays(arrays)
         assert list(result) == list(self.index)
 
-        # iterator as input
-        result2 = MultiIndex.from_arrays(iter(arrays))
-        assert list(result2) == list(self.index)
-
-        # invlide iterator input
-        with tm.assert_raises_regex(
-                TypeError, "Input must be a list / sequence of array-likes."):
-            MultiIndex.from_arrays(0)
-
         # infer correctly
         result = MultiIndex.from_arrays([[pd.NaT, Timestamp('20130101')],
                                          ['a', 'b']])
         assert result.levels[0].equals(Index([Timestamp('20130101')]))
         assert result.levels[1].equals(Index(['a', 'b']))
 
+    def test_from_arrays_iterator(self):
+        # GH 18434
+        arrays = []
+        for lev, lab in zip(self.index.levels, self.index.labels):
+            arrays.append(np.asarray(lev).take(lab))
+
+        # iterator as input
+        result = MultiIndex.from_arrays(iter(arrays))
+        assert list(result) == list(self.index)
+
+        # invalid iterator input
+        with tm.assert_raises_regex(
+                TypeError, "Input must be a list / sequence of array-likes."):
+            MultiIndex.from_arrays(0)
+
     def test_from_arrays_index_series_datetimetz(self):
         idx1 = pd.date_range('2015-01-01 10:00', freq='D', periods=3,
                              tz='US/Eastern')
@@ -837,10 +843,20 @@ def test_from_product(self):
         tm.assert_index_equal(result, expected)
         assert result.names == names
 
+    def test_from_product_iterator(self):
+        # GH 18434
+        first = ['foo', 'bar', 'buz']
+        second = ['a', 'b', 'c']
+        names = ['first', 'second']
+        tuples = [('foo', 'a'), ('foo', 'b'), ('foo', 'c'), ('bar', 'a'),
+                  ('bar', 'b'), ('bar', 'c'), ('buz', 'a'), ('buz', 'b'),
+                  ('buz', 'c')]
+        expected = MultiIndex.from_tuples(tuples, names=names)
+
         # iterator as input
-        result2 = MultiIndex.from_product(iter([first, second]), names=names)
-        assert result2.equals(expected)
-        assert result2.names == names
+        result = MultiIndex.from_product(iter([first, second]), names=names)
+        assert result.equals(expected)
+        assert result.names == names
 
         # Invalid non-iterable input
         with tm.assert_raises_regex(
@@ -1750,18 +1766,24 @@ def test_from_tuples(self):
                               names=['a', 'b'])
 
         # input tuples
-        res1 = MultiIndex.from_tuples(((1, 2), (3, 4)), names=['a', 'b'])
-        assert expected.names == res1.names
-        assert res1.equals(expected)
+        result = MultiIndex.from_tuples(((1, 2), (3, 4)), names=['a', 'b'])
+        assert expected.names == result.names
+        assert result.equals(expected)
 
+    def test_from_tuples_iterator(self):
+        # GH 18434
         # input iterator for tuples
-        res2 = MultiIndex.from_tuples(zip([1, 3], [2, 4]), names=['a', 'b'])
-        assert expected.names == res2.names
-        assert res2.equals(expected)
+        expected = MultiIndex(levels=[[1, 3], [2, 4]],
+                              labels=[[0, 1], [0, 1]],
+                              names=['a', 'b'])
+
+        result = MultiIndex.from_tuples(zip([1, 3], [2, 4]), names=['a', 'b'])
+        assert expected.names == result.names
+        assert result.equals(expected)
 
         # input non-iterables
         with tm.assert_raises_regex(
-                TypeError, 'Input must be a list /sequence of tuple-likes.'):
+                TypeError, 'Input must be a list / sequence of tuple-likes.'):
             MultiIndex.from_tuples(0)
 
     def test_from_tuples_empty(self):