Address @seancribbs's initial comments:

Brett Hazen · Brett Hazen · commit 5b006f73c7f5 · 2014-11-13T16:20:19.000-07:00
- actually return from __next()__
- use isinstance instead == to determine object type
- import print_function from __future__ for Python 2
- port assertItemsEqual() from Python2 to Python3
- actually run the YZ tests 😲
diff --git a/riak/benchmark.py b/riak/benchmark.py
@@ -16,6 +16,7 @@
 under the License.
 """
 
+from __future__ import print_function
 import os
 import gc
 
@@ -113,7 +114,7 @@ def next(self):
 
     def __next__(self):
         # Python 3.x Version
-        self.next()
+        return self.next()
 
     def report(self, name):
         """
diff --git a/riak/client/__init__.py b/riak/client/__init__.py
@@ -43,7 +43,7 @@ def default_encoder(obj):
     Default encoder for JSON datatypes, which returns UTF-8 encoded
     json instead of the default bloated backslash u XXXX escaped ASCII strings.
     """
-    if type(obj) == bytes:
+    if isinstance(obj, bytes):
         return json.dumps(bytes_to_str(obj),
                           ensure_ascii=False).encode("utf-8")
     else:
@@ -55,7 +55,7 @@ def binary_json_encoder(obj):
     Default encoder for JSON datatypes, which returns UTF-8 encoded
     json instead of the default bloated backslash u XXXX escaped ASCII strings.
     """
-    if type(obj) == bytes:
+    if isinstance(obj, bytes):
         return json.dumps(bytes_to_str(obj),
                           ensure_ascii=False).encode("utf-8")
     else:
diff --git a/riak/client/multiget.py b/riak/client/multiget.py
@@ -16,6 +16,7 @@
 under the License.
 """
 
+from __future__ import print_function
 from collections import namedtuple
 from threading import Thread, Lock, Event
 from multiprocessing import cpu_count
diff --git a/riak/mapreduce.py b/riak/mapreduce.py
@@ -18,6 +18,7 @@
 under the License.
 """
 
+from __future__ import print_function
 from collections import Iterable, namedtuple
 from riak import RiakError
 from six import string_types, PY2
diff --git a/riak/test_server.py b/riak/test_server.py
@@ -1,3 +1,4 @@
+from __future__ import print_function
 import os.path
 import threading
 import string
diff --git a/riak/tests/pool-grinder.py b/riak/tests/pool-grinder.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 
+from __future__ import print_function
 from six import PY2
 if PY2:
     from Queue import Queue
diff --git a/riak/tests/test_btypes.py b/riak/tests/test_btypes.py
@@ -123,7 +123,7 @@ def test_default_btype_list_buckets(self):
 
         self.assertIn(bucket, buckets)
 
-        self.assert_items_equal(buckets, self.client.get_buckets())
+        self.assertItemsEqual(buckets, self.client.get_buckets())
 
     @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_default_btype_list_keys(self):
@@ -142,7 +142,7 @@ def test_default_btype_list_keys(self):
         self.assertIn(self.key_name, keys)
 
         oldapikeys = self.client.get_keys(self.client.bucket(self.bucket_name))
-        self.assert_items_equal(keys, oldapikeys)
+        self.assertItemsEqual(keys, oldapikeys)
 
     @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_multiget_bucket_types(self):
diff --git a/riak/tests/test_datatypes.py b/riak/tests/test_datatypes.py
@@ -104,7 +104,7 @@ def op(self, dtype):
 
     def check_op_output(self, op):
         self.assertIn('adds', op)
-        self.assert_items_equal(op['adds'], ['bar', 'foo'])
+        self.assertItemsEqual(op['adds'], ['bar', 'foo'])
         self.assertIn('removes', op)
         self.assertIn('foo', op['removes'])
 
@@ -227,7 +227,7 @@ def test_dt_map(self):
         mymap.reload()
         self.assertNotIn('a', mymap.counters)
         self.assertIn('f', mymap.sets)
-        self.assert_items_equal(['thing1', 'thing2'], mymap.sets['f'].value)
+        self.assertItemsEqual(['thing1', 'thing2'], mymap.sets['f'].value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_remove_without_context(self):
@@ -256,7 +256,7 @@ def test_dt_set_remove_fetching_context(self):
         set.store()
 
         set2 = bucket.get(self.key_name)
-        self.assert_items_equal(['X', 'Y'], set2.value)
+        self.assertItemsEqual(['X', 'Y'], set2.value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_add_twice(self):
@@ -273,7 +273,7 @@ def test_dt_set_add_twice(self):
         set.store()
 
         set2 = bucket.get(self.key_name)
-        self.assert_items_equal(['X', 'Y'], set2.value)
+        self.assertItemsEqual(['X', 'Y'], set2.value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_add_wins_in_same_op(self):
@@ -291,7 +291,7 @@ def test_dt_set_add_wins_in_same_op(self):
         set.store()
 
         set2 = bucket.get(self.key_name)
-        self.assert_items_equal(['X', 'Y'], set2.value)
+        self.assertItemsEqual(['X', 'Y'], set2.value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_add_wins_in_same_op_reversed(self):
@@ -309,7 +309,7 @@ def test_dt_set_add_wins_in_same_op_reversed(self):
         set.store()
 
         set2 = bucket.get(self.key_name)
-        self.assert_items_equal(['X', 'Y'], set2.value)
+        self.assertItemsEqual(['X', 'Y'], set2.value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_remove_old_context(self):
@@ -331,7 +331,7 @@ def test_dt_set_remove_old_context(self):
         set.store()
 
         set2 = bucket.get(self.key_name)
-        self.assert_items_equal(['X', 'Y', 'Z'], set2.value)
+        self.assertItemsEqual(['X', 'Y', 'Z'], set2.value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_remove_updated_context(self):
@@ -352,7 +352,7 @@ def test_dt_set_remove_updated_context(self):
         set.store()
 
         set2 = bucket.get(self.key_name)
-        self.assert_items_equal(['X', 'Y'], set2.value)
+        self.assertItemsEqual(['X', 'Y'], set2.value)
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_map_remove_set_update_same_op(self):
@@ -370,7 +370,7 @@ def test_dt_map_remove_set_update_same_op(self):
         map.store()
 
         map2 = bucket.get(self.key_name)
-        self.assert_items_equal(["Z"], map2.sets['set'])
+        self.assertItemsEqual(["Z"], map2.sets['set'])
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_map_remove_counter_increment_same_op(self):
@@ -406,7 +406,7 @@ def test_dt_map_remove_map_update_same_op(self):
         map.store()
 
         map2 = bucket.get(self.key_name)
-        self.assert_items_equal(["Z"], map2.maps['map'].sets['set'])
+        self.assertItemsEqual(["Z"], map2.maps['map'].sets['set'])
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_return_body_true_default(self):
@@ -420,11 +420,11 @@ def test_dt_set_return_body_true_default(self):
 
         myset.add('Y')
         myset.store()
-        self.assert_items_equal(myset.value, ['X', 'Y'])
+        self.assertItemsEqual(myset.value, ['X', 'Y'])
 
         myset.discard('X')
         myset.store()
-        self.assert_items_equal(myset.value, ['Y'])
+        self.assertItemsEqual(myset.value, ['Y'])
 
     @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_map_return_body_true_default(self):
@@ -440,11 +440,11 @@ def test_dt_map_return_body_true_default(self):
 
         mymap.sets['a'].add('Y')
         mymap.store()
-        self.assert_items_equal(mymap.sets['a'].value, ['X', 'Y'])
+        self.assertItemsEqual(mymap.sets['a'].value, ['X', 'Y'])
 
         mymap.sets['a'].discard('X')
         mymap.store()
-        self.assert_items_equal(mymap.sets['a'].value, ['Y'])
+        self.assertItemsEqual(mymap.sets['a'].value, ['Y'])
 
         del mymap.sets['a']
         mymap.store()
diff --git a/riak/tests/test_mapreduce.py b/riak/tests/test_mapreduce.py
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+from __future__ import print_function
 from six import PY2
 from riak.mapreduce import RiakMapReduce
 from riak import key_filter, RiakError
diff --git a/riak/tests/test_pool.py b/riak/tests/test_pool.py
@@ -263,7 +263,7 @@ def _run():
             for thr in threads:
                 thr.join()
 
-            self.assert_items_equal(pool.resources, touched)
+            self.assertItemsEqual(pool.resources, touched)
 
     def test_clear(self):
         """
diff --git a/riak/tests/test_search.py b/riak/tests/test_search.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from __future__ import print_function
 import platform
 if platform.python_version() < '2.7':
     unittest = __import__('unittest2')
diff --git a/riak/tests/test_six.py b/riak/tests/test_six.py
@@ -15,7 +15,9 @@
 specific language governing permissions and limitations
 under the License.
 """
-from six import PY2
+from six import PY2, PY3
+import collections
+import warnings
 
 
 class Comparison(object):
@@ -24,11 +26,108 @@ class Comparison(object):
     since its name changed between Python 2.x and Python 3.x
     '''
 
-    def assert_items_equal(self, first, second, msg=None):
-        if PY2:
-            self.assertItemsEqual(first, second, msg)
-        else:
-            self.assertCountEqual(first, second, msg)
+    if PY3:
+        # Stolen from Python 2.7.8's unittest
+        _Mismatch = collections.namedtuple('Mismatch', 'actual expected value')
+
+        def _count_diff_all_purpose(self, actual, expected):
+            '''
+            Returns list of (cnt_act, cnt_exp, elem)
+            triples where the counts differ
+            '''
+            # elements need not be hashable
+            s, t = list(actual), list(expected)
+            m, n = len(s), len(t)
+            NULL = object()
+            result = []
+            for i, elem in enumerate(s):
+                if elem is NULL:
+                    continue
+                cnt_s = cnt_t = 0
+                for j in range(i, m):
+                    if s[j] == elem:
+                        cnt_s += 1
+                        s[j] = NULL
+                for j, other_elem in enumerate(t):
+                    if other_elem == elem:
+                        cnt_t += 1
+                        t[j] = NULL
+                if cnt_s != cnt_t:
+                    diff = self._Mismatch(cnt_s, cnt_t, elem)
+                    result.append(diff)
+
+            for i, elem in enumerate(t):
+                if elem is NULL:
+                    continue
+                cnt_t = 0
+                for j in range(i, n):
+                    if t[j] == elem:
+                        cnt_t += 1
+                        t[j] = NULL
+                diff = self._Mismatch(0, cnt_t, elem)
+                result.append(diff)
+            return result
+
+        def _count_diff_hashable(self, actual, expected):
+            '''
+            Returns list of (cnt_act, cnt_exp, elem) triples
+            where the counts differ
+            '''
+            # elements must be hashable
+            s, t = self._ordered_count(actual), self._ordered_count(expected)
+            result = []
+            for elem, cnt_s in s.items():
+                cnt_t = t.get(elem, 0)
+                if cnt_s != cnt_t:
+                    diff = self._Mismatch(cnt_s, cnt_t, elem)
+                    result.append(diff)
+            for elem, cnt_t in t.items():
+                if elem not in s:
+                    diff = self._Mismatch(0, cnt_t, elem)
+                    result.append(diff)
+            return result
+
+        def _ordered_count(self, iterable):
+            'Return dict of element counts, in the order they were first seen'
+            c = collections.OrderedDict()
+            for elem in iterable:
+                c[elem] = c.get(elem, 0) + 1
+            return c
+
+        def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
+            """An unordered sequence specific comparison. It asserts that
+            actual_seq and expected_seq have the same element counts.
+            Equivalent to::
+
+                self.assertEqual(Counter(iter(actual_seq)),
+                                 Counter(iter(expected_seq)))
+
+            Asserts that each element has the same count in both sequences.
+            Example:
+                - [0, 1, 1] and [1, 0, 1] compare equal.
+                - [0, 0, 1] and [0, 1] compare unequal.
+            """
+            first_seq, second_seq = list(expected_seq), list(actual_seq)
+            with warnings.catch_warnings():
+                try:
+                    first = collections.Counter(first_seq)
+                    second = collections.Counter(second_seq)
+                except TypeError:
+                    # Handle case with unhashable elements
+                    differences = self._count_diff_all_purpose(first_seq,
+                                                               second_seq)
+                else:
+                    if first == second:
+                        return
+                    differences = self._count_diff_hashable(first_seq,
+                                                            second_seq)
+
+            if differences:
+                standardMsg = 'Element counts were not equal:\n'
+                lines = ['First has %d, Second has %d:  %r' %
+                         diff for diff in differences]
+                diffMsg = '\n'.join(lines)
+                standardMsg = self._truncateMessage(standardMsg, diffMsg)
 
     def assert_raises_regex(self, exception, regexp, msg=None):
         if PY2:
diff --git a/riak/tests/test_yokozuna.py b/riak/tests/test_yokozuna.py
@@ -24,7 +24,6 @@ def wait_for_yz_index(bucket, key, index=None):
 class YZSearchTests(object):
     @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_from_bucket(self):
-        return
         bucket = self.client.bucket(self.yz['bucket'])
         bucket.new("user", {"user_s": "Z"}).store()
         wait_for_yz_index(bucket, "user")
@@ -137,7 +136,6 @@ def test_yz_create_bad_schema(self):
 
     @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_queries(self):
-        return
         bucket = self.client.bucket(self.yz['bucket'])
         bucket.new("Z", {"username_s": "Z", "name_s": "ryan",
                          "age_i": 30}).store()
@@ -176,7 +174,6 @@ def test_yz_search_queries(self):
 
     @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_utf8(self):
-        return
         bucket = self.client.bucket(self.yz['bucket'])
         body = {"text_ja": u"私はハイビスカスを食べるのが 大好き"}
         bucket.new(self.key_name, body).store()
@@ -198,4 +195,4 @@ def test_yz_multivalued_fields(self):
         self.assertIn('groups_ss', doc)
         field = doc['groups_ss']
         self.assertIsInstance(field, list)
-        self.assert_items_equal(['a', 'b', 'c'], field)
+        self.assertItemsEqual(['a', 'b', 'c'], field)
diff --git a/riak/transports/pool.py b/riak/transports/pool.py
@@ -16,6 +16,7 @@
 under the License.
 """
 
+from __future__ import print_function
 from contextlib import contextmanager
 import threading
 
diff --git a/riak/util.py b/riak/util.py
@@ -16,6 +16,7 @@
 under the License.
 """
 
+from __future__ import print_function
 import warnings
 from collections import Mapping
 from six import string_types, PY2
diff --git a/version.py b/version.py

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+from __future__ import print_function`
`1`	`2`	`import os.path`
`2`	`3`	`import threading`
`3`	`4`	`import string`