converted collection, objectid and cursor

qcheck fixed (maybe, i'm understand it not very clearly)

Author: sovnarkom

pymongo/collection.py

@@ -107,12 +107,14 @@ def __getitem__(self, name):
     def __repr__(self):
         return "Collection(%r, %r)" % (self.__database, self.__name)
 
-    def __cmp__(self, other):
+    def __ne__(self, other):
         if isinstance(other, Collection):
-            return cmp((self.__database, self.__name),
-                       (other.__database, other.__name))
+            return (self.__database, self.__name) != (other.__database, other.__name)
         return NotImplemented
 
+    def __eq__(self, other):
+        return not self.__ne__(other)
+
     def full_name(self):
         """The full name of this :class:`Collection`.
 

pymongo/objectid.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 """Tools for working with MongoDB `ObjectIds
 <http://www.mongodb.org/display/DOCS/Object+IDs>`_.
 """
@@ -26,6 +27,8 @@
 import hashlib
 _md5func = hashlib.md5
 
+from binascii import hexlify
+
 from .errors import InvalidId
 
 
@@ -153,16 +156,21 @@ def generation_time(self):
     generation_time = property(generation_time)
 
     def __str__(self):
-        return self.__id.encode("hex")
+        return hexlify(self.__id).decode()
+
 
     def __repr__(self):
-        return "ObjectId('%s')" % self.__id.encode("hex")
+        return "ObjectId(%s)" % (hexlify(self.__id).decode())
 
-    def __cmp__(self, other):
+    def __ne__(self, other):
         if isinstance(other, ObjectId):
-            return cmp(self.__id, other.__id)
+            return self.__id != other.__id
         return NotImplemented
 
+    def __eq__(self, other):
+        return not self.__ne__(other)
+    
+
     def __hash__(self):
         """Get a hash value for this :class:`ObjectId`.
 

test/qcheck.py

@@ -16,7 +16,6 @@
 import traceback
 import datetime
 import re
-import types
 import sys
 from functools import reduce
 sys.path[0:0] = [""]
@@ -107,10 +106,8 @@ def gen_datetime():
 def gen_dict(gen_key, gen_value, gen_length):
 
     def a_dict(gen_key, gen_value, length):
-        result = {}
         for _ in range(length):
-            result[gen_key()] = gen_value()
-        return result
+            yield (gen_key(), gen_value())
     return lambda: a_dict(gen_key, gen_value, gen_length())
 
 
@@ -145,7 +142,7 @@ def gen_dbref():
 def gen_mongo_value(depth, ref):
     choices = [gen_unicode(gen_range(0, 50)),
                gen_printable_string(gen_range(0, 50)),
-               list(map(gen_string(gen_range(0, 1000)), Binary)),
+               map(gen_string(gen_range(0, 1000)), Binary),
                gen_int(),
                gen_float(),
                gen_boolean(),
@@ -165,9 +162,9 @@ def gen_mongo_list(depth, ref):
 
 
 def gen_mongo_dict(depth, ref=True):
-    return list(map(gen_dict(gen_unicode(gen_range(0, 20)),
+    return map(gen_dict(gen_unicode(gen_range(0, 20)),
                         gen_mongo_value(depth - 1, ref),
-                        gen_range(0, 10)), SON))
+                        gen_range(0, 10)), SON)
 
 
 def simplify(case): # TODO this is a hack

test/test_collection.py

@@ -21,11 +21,11 @@
 import sys
 sys.path[0:0] = [""]
 
-from nose.plugins.skip import SkipTest
+#from nose.plugins.skip import SkipTest
 
-from . import qcheck
-from .test_connection import get_connection
-from . import version
+import qcheck
+from test_connection import get_connection
+import version
 from pymongo.objectid import ObjectId
 from pymongo.code import Code
 from pymongo.binary import Binary
@@ -243,31 +243,31 @@ def test_field_selection(self):
 
         doc = {"a": 1, "b": 5, "c": {"d": 5, "e": 10}}
         db.test.insert(doc)
-
-        self.assertEqual(list(db.test.find({}, ["_id"]).next().keys()), ["_id"])
-        l = list(db.test.find({}, ["a"]).next().keys())
+        
+        self.assertEqual(list(next(db.test.find({}, ["_id"])).keys()), ["_id"])
+        l = list(next(db.test.find({}, ["a"])))
         l.sort()
         self.assertEqual(l, ["_id", "a"])
-        l = list(db.test.find({}, ["b"]).next().keys())
+        l = list(next(db.test.find({}, ["b"])))
         l.sort()
         self.assertEqual(l, ["_id", "b"])
-        l = list(db.test.find({}, ["c"]).next().keys())
+        l = list(next(db.test.find({}, ["c"])))
         l.sort()
         self.assertEqual(l, ["_id", "c"])
-        self.assertEqual(db.test.find({}, ["a"]).next()["a"], 1)
-        self.assertEqual(db.test.find({}, ["b"]).next()["b"], 5)
-        self.assertEqual(db.test.find({}, ["c"]).next()["c"],
+        self.assertEqual(next(db.test.find({}, ["a"]))["a"], 1)
+        self.assertEqual(next(db.test.find({}, ["b"]))["b"], 5)
+        self.assertEqual(next(db.test.find({}, ["c"]))["c"],
                          {"d": 5, "e": 10})
 
-        self.assertEqual(db.test.find({}, ["c.d"]).next()["c"], {"d": 5})
-        self.assertEqual(db.test.find({}, ["c.e"]).next()["c"], {"e": 10})
-        self.assertEqual(db.test.find({}, ["b", "c.e"]).next()["c"],
+        self.assertEqual(next(db.test.find({}, ["c.d"]))["c"], {"d": 5})
+        self.assertEqual(next(db.test.find({}, ["c.e"]))["c"], {"e": 10})
+        self.assertEqual(next(db.test.find({}, ["b", "c.e"]))["c"],
                          {"e": 10})
 
-        l = list(db.test.find({}, ["b", "c.e"]).next().keys())
+        l = list(next(db.test.find({}, ["b", "c.e"])))
         l.sort()
         self.assertEqual(l, ["_id", "b", "c"])
-        self.assertEqual(db.test.find({}, ["b", "c.e"]).next()["b"], 5)
+        self.assertEqual(next(db.test.find({}, ["b", "c.e"]))["b"], 5)
 
     def test_options(self):
         db = self.db
@@ -297,6 +297,8 @@ def remove_insert_find_one(dict):
             db.test.remove({})
             db.test.insert(dict)
             return db.test.find_one() == dict
+        
+        a = qcheck.gen_mongo_dict(3)
 
         qcheck.check_unittest(self, remove_insert_find_one,
                               qcheck.gen_mongo_dict(3))
@@ -452,7 +454,7 @@ def test_unique_index(self):
         db.test.save({"hello": "world"})
         db.test.save({"hello": "mike"})
         db.test.save({"hello": "world"})
-        self.failIf(db.error())
+        self.assertFalse(db.error())
 
         db.drop_collection("test")
         db.test.create_index("hello", unique=True)
@@ -469,7 +471,7 @@ def test_index_on_subfield(self):
         db.test.insert({"hello": {"a": 4, "b": 5}})
         db.test.insert({"hello": {"a": 7, "b": 2}})
         db.test.insert({"hello": {"a": 4, "b": 10}})
-        self.failIf(db.error())
+        self.assertFalse(db.error())
 
         db.drop_collection("test")
         db.test.create_index("hello.a", unique=True)

test/test_cursor.py

@@ -21,15 +21,15 @@
 import itertools
 sys.path[0:0] = [""]
 
-from nose.plugins.skip import SkipTest
+#from nose.plugins.skip import SkipTest
 
 from pymongo.errors import InvalidOperation, OperationFailure
 from pymongo.cursor import Cursor
 from pymongo.database import Database
 from pymongo.code import Code
 from pymongo import ASCENDING, DESCENDING
-from .test_connection import get_connection
-from . import version
+from test_connection import get_connection
+import version
 
 
 class TestCursor(unittest.TestCase):
@@ -96,7 +96,7 @@ def test_slave_okay(self):
 
         warnings.simplefilter("error")
 
-        self.assertEqual(1, db.test.find().next()["x"])
+        self.assertEqual(1, next(db.test.find())["x"])
         self.assertRaises(DeprecationWarning, db.test.find, slave_okay=True)
         self.assertRaises(DeprecationWarning, db.test.find, slave_okay=False)
 
@@ -467,7 +467,6 @@ def test_getitem_slice_index(self):
         for i in range(100):
             self.db.test.save({"i": i})
 
-        izip = itertools.izip
         count = itertools.count
 
         self.assertRaises(IndexError, lambda: self.db.test.find()[-1:])