Replace deprecated unittest assert method aliases.
assert_ -> assertTrue assertEquals -> assertEqual This is needed to clean up deprecation warnings in python >= 3.2
This commit is contained in:
behackett
parent
11abdfe08d
commit
2d21ba9376
@ -36,9 +36,9 @@ class TestBinary(unittest.TestCase):
|
||||
def test_binary(self):
|
||||
a_string = "hello world"
|
||||
a_binary = Binary("hello world")
|
||||
self.assert_(a_binary.startswith("hello"))
|
||||
self.assert_(a_binary.endswith("world"))
|
||||
self.assert_(isinstance(a_binary, Binary))
|
||||
self.assertTrue(a_binary.startswith("hello"))
|
||||
self.assertTrue(a_binary.endswith("world"))
|
||||
self.assertTrue(isinstance(a_binary, Binary))
|
||||
self.assertFalse(isinstance(a_string, Binary))
|
||||
|
||||
def test_exceptions(self):
|
||||
@ -50,8 +50,8 @@ class TestBinary(unittest.TestCase):
|
||||
self.assertRaises(TypeError, Binary, "hello", "100")
|
||||
self.assertRaises(ValueError, Binary, "hello", -1)
|
||||
self.assertRaises(ValueError, Binary, "hello", 256)
|
||||
self.assert_(Binary("hello", 0))
|
||||
self.assert_(Binary("hello", 255))
|
||||
self.assertTrue(Binary("hello", 0))
|
||||
self.assertTrue(Binary("hello", 255))
|
||||
|
||||
def test_subtype(self):
|
||||
a = Binary("hello")
|
||||
|
||||
@ -62,8 +62,8 @@ class TestBSON(unittest.TestCase):
|
||||
self.assertFalse(is_valid("test"))
|
||||
|
||||
# the simplest valid BSON document
|
||||
self.assert_(is_valid("\x05\x00\x00\x00\x00"))
|
||||
self.assert_(is_valid(BSON("\x05\x00\x00\x00\x00")))
|
||||
self.assertTrue(is_valid("\x05\x00\x00\x00\x00"))
|
||||
self.assertTrue(is_valid(BSON("\x05\x00\x00\x00\x00")))
|
||||
self.assertFalse(is_valid("\x04\x00\x00\x00\x00"))
|
||||
self.assertFalse(is_valid("\x05\x00\x00\x00\x01"))
|
||||
self.assertFalse(is_valid("\x05\x00\x00\x00"))
|
||||
@ -166,7 +166,7 @@ class TestBSON(unittest.TestCase):
|
||||
self.assertEqual(dict, (BSON.encode(dict)).decode())
|
||||
helper({})
|
||||
helper({"test": u"hello"})
|
||||
self.assert_(isinstance(BSON.encode({"hello": "world"})
|
||||
self.assertTrue(isinstance(BSON.encode({"hello": "world"})
|
||||
.decode()["hello"],
|
||||
unicode))
|
||||
helper({"mike": -10120})
|
||||
@ -253,11 +253,11 @@ class TestBSON(unittest.TestCase):
|
||||
self.assertRaises(RuntimeError, BSON.encode, evil_data)
|
||||
|
||||
def test_overflow(self):
|
||||
self.assert_(BSON.encode({"x": 9223372036854775807L}))
|
||||
self.assertTrue(BSON.encode({"x": 9223372036854775807L}))
|
||||
self.assertRaises(OverflowError, BSON.encode,
|
||||
{"x": 9223372036854775808L})
|
||||
|
||||
self.assert_(BSON.encode({"x": -9223372036854775808L}))
|
||||
self.assertTrue(BSON.encode({"x": -9223372036854775808L}))
|
||||
self.assertRaises(OverflowError, BSON.encode,
|
||||
{"x": -9223372036854775809L})
|
||||
|
||||
@ -285,7 +285,7 @@ class TestBSON(unittest.TestCase):
|
||||
id = uuid.uuid4()
|
||||
transformed_id = (BSON.encode({"id": id})).decode()["id"]
|
||||
|
||||
self.assert_(isinstance(transformed_id, uuid.UUID))
|
||||
self.assertTrue(isinstance(transformed_id, uuid.UUID))
|
||||
self.assertEqual(id, transformed_id)
|
||||
self.assertNotEqual(uuid.uuid4(), transformed_id)
|
||||
|
||||
@ -295,9 +295,9 @@ class TestBSON(unittest.TestCase):
|
||||
|
||||
id = uuid.uuid4()
|
||||
legacy = UUIDLegacy(id)
|
||||
self.assertEquals(3, legacy.subtype)
|
||||
self.assertEqual(3, legacy.subtype)
|
||||
transformed = (BSON.encode({"uuid": legacy})).decode()["uuid"]
|
||||
self.assert_(isinstance(transformed, uuid.UUID))
|
||||
self.assertTrue(isinstance(transformed, uuid.UUID))
|
||||
self.assertEqual(id, transformed)
|
||||
self.assertNotEqual(UUIDLegacy(uuid.uuid4()), UUIDLegacy(transformed))
|
||||
|
||||
@ -365,14 +365,14 @@ class TestBSON(unittest.TestCase):
|
||||
raise
|
||||
|
||||
def test_custom_class(self):
|
||||
self.assert_(isinstance(BSON.encode({}).decode(), dict))
|
||||
self.assertTrue(isinstance(BSON.encode({}).decode(), dict))
|
||||
self.assertFalse(isinstance(BSON.encode({}).decode(), SON))
|
||||
self.assert_(isinstance(BSON.encode({}).decode(SON), SON))
|
||||
self.assertTrue(isinstance(BSON.encode({}).decode(SON), SON))
|
||||
|
||||
self.assertEqual(1, BSON.encode({"x": 1}).decode(SON)["x"])
|
||||
|
||||
x = BSON.encode({"x": [{"y": 1}]})
|
||||
self.assert_(isinstance(x.decode(SON)["x"][0], SON))
|
||||
self.assertTrue(isinstance(x.decode(SON)["x"][0], SON))
|
||||
|
||||
def test_subclasses(self):
|
||||
# make sure we can serialize subclasses of native Python types.
|
||||
|
||||
@ -31,10 +31,10 @@ class TestCode(unittest.TestCase):
|
||||
self.assertRaises(TypeError, Code, None)
|
||||
self.assertRaises(TypeError, Code, "aoeu", 5)
|
||||
self.assertRaises(TypeError, Code, u"aoeu", 5)
|
||||
self.assert_(Code("aoeu"))
|
||||
self.assert_(Code(u"aoeu"))
|
||||
self.assert_(Code("aoeu", {}))
|
||||
self.assert_(Code(u"aoeu", {}))
|
||||
self.assertTrue(Code("aoeu"))
|
||||
self.assertTrue(Code(u"aoeu"))
|
||||
self.assertTrue(Code("aoeu", {}))
|
||||
self.assertTrue(Code(u"aoeu", {}))
|
||||
|
||||
def test_read_only(self):
|
||||
c = Code("blah")
|
||||
@ -46,9 +46,9 @@ class TestCode(unittest.TestCase):
|
||||
def test_code(self):
|
||||
a_string = "hello world"
|
||||
a_code = Code("hello world")
|
||||
self.assert_(a_code.startswith("hello"))
|
||||
self.assert_(a_code.endswith("world"))
|
||||
self.assert_(isinstance(a_code, Code))
|
||||
self.assertTrue(a_code.startswith("hello"))
|
||||
self.assertTrue(a_code.endswith("world"))
|
||||
self.assertTrue(isinstance(a_code, Code))
|
||||
self.assertFalse(isinstance(a_string, Code))
|
||||
self.assertEqual(a_code.scope, {})
|
||||
a_code.scope["my_var"] = 5
|
||||
|
||||
@ -81,7 +81,7 @@ class TestCollection(unittest.TestCase):
|
||||
self.assertRaises(InvalidName, make_col, self.db.test, "tes..t")
|
||||
self.assertRaises(InvalidName, make_col, self.db.test, "tes\x00t")
|
||||
|
||||
self.assert_(isinstance(self.db.test, Collection))
|
||||
self.assertTrue(isinstance(self.db.test, Collection))
|
||||
self.assertEqual(self.db.test, self.db["test"])
|
||||
self.assertEqual(self.db.test, Collection(self.db, "test"))
|
||||
self.assertEqual(self.db.test.mike, self.db["test.mike"])
|
||||
@ -115,23 +115,23 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.drop_indexes()
|
||||
ix = db.test.create_index([("hello", DESCENDING),
|
||||
("world", ASCENDING)], name="hello_world")
|
||||
self.assertEquals(ix, "hello_world")
|
||||
self.assertEqual(ix, "hello_world")
|
||||
|
||||
db.test.drop_indexes()
|
||||
self.assertEqual(db.system.indexes.find({"ns": u"pymongo_test.test"})
|
||||
.count(), 1)
|
||||
db.test.create_index("hello")
|
||||
self.assert_(u"hello_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
self.assertTrue(u"hello_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
|
||||
db.test.drop_indexes()
|
||||
self.assertEqual(db.system.indexes.find({"ns": u"pymongo_test.test"})
|
||||
.count(), 1)
|
||||
db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)])
|
||||
self.assert_(u"hello_-1_world_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
self.assertTrue(u"hello_-1_world_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
|
||||
db.test.drop()
|
||||
db.test.insert({'a': 1})
|
||||
@ -250,9 +250,9 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.drop_index(name)
|
||||
self.assertEqual(db.system.indexes.find({"ns": u"pymongo_test.test"})
|
||||
.count(), 2)
|
||||
self.assert_(u"hello_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
self.assertTrue(u"hello_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
|
||||
db.test.drop_indexes()
|
||||
db.test.create_index("hello")
|
||||
@ -264,9 +264,9 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.drop_index([("goodbye", ASCENDING)])
|
||||
self.assertEqual(db.system.indexes.find({"ns": u"pymongo_test.test"})
|
||||
.count(), 2)
|
||||
self.assert_(u"hello_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
self.assertTrue(u"hello_1" in
|
||||
[a["name"] for a in db.system.indexes
|
||||
.find({"ns": u"pymongo_test.test"})])
|
||||
|
||||
def test_reindex(self):
|
||||
db = self.db
|
||||
@ -292,7 +292,7 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.remove({})
|
||||
db.test.save({}) # create collection
|
||||
self.assertEqual(len(db.test.index_information()), 1)
|
||||
self.assert_("_id_" in db.test.index_information())
|
||||
self.assertTrue("_id_" in db.test.index_information())
|
||||
|
||||
db.test.create_index("hello")
|
||||
self.assertEqual(len(db.test.index_information()), 2)
|
||||
@ -355,7 +355,7 @@ class TestCollection(unittest.TestCase):
|
||||
db = self.db
|
||||
db.test.drop_indexes()
|
||||
db.test.create_index([('key', ASCENDING)], sparse=True)
|
||||
self.assert_(db.test.index_information()['key_1']['sparse'])
|
||||
self.assertTrue(db.test.index_information()['key_1']['sparse'])
|
||||
|
||||
def test_index_background(self):
|
||||
db = self.db
|
||||
@ -365,7 +365,7 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.create_index([('keyc', ASCENDING)], background=True)
|
||||
self.assertFalse('background' in db.test.index_information()['keya_1'])
|
||||
self.assertFalse(db.test.index_information()['keyb_1']['background'])
|
||||
self.assert_(db.test.index_information()['keyc_1']['background'])
|
||||
self.assertTrue(db.test.index_information()['keyc_1']['background'])
|
||||
|
||||
def _drop_dups_setup(self, db):
|
||||
db.drop_collection('test')
|
||||
@ -491,7 +491,7 @@ class TestCollection(unittest.TestCase):
|
||||
self.assertEqual(db.test.find().count(), 1)
|
||||
self.assertEqual(doc, db.test.find_one())
|
||||
self.assertEqual(doc["_id"], id)
|
||||
self.assert_(isinstance(id, ObjectId))
|
||||
self.assertTrue(isinstance(id, ObjectId))
|
||||
|
||||
def remove_insert_find_one(dict):
|
||||
db.test.remove({}, safe=True)
|
||||
@ -527,15 +527,15 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.insert({"x": 1, "mike": "awesome",
|
||||
"extra thing": "abcdefghijklmnopqrstuvwxyz"})
|
||||
self.assertEqual(1, db.test.count())
|
||||
self.assert_("x" in db.test.find({}).next())
|
||||
self.assert_("mike" in db.test.find({}).next())
|
||||
self.assert_("extra thing" in db.test.find({}).next())
|
||||
self.assert_("x" in db.test.find({}, ["x", "mike"]).next())
|
||||
self.assert_("mike" in db.test.find({}, ["x", "mike"]).next())
|
||||
self.assertTrue("x" in db.test.find({}).next())
|
||||
self.assertTrue("mike" in db.test.find({}).next())
|
||||
self.assertTrue("extra thing" in db.test.find({}).next())
|
||||
self.assertTrue("x" in db.test.find({}, ["x", "mike"]).next())
|
||||
self.assertTrue("mike" in db.test.find({}, ["x", "mike"]).next())
|
||||
self.assertFalse("extra thing" in db.test.find({},
|
||||
["x", "mike"]).next())
|
||||
self.assertFalse("x" in db.test.find({}, ["mike"]).next())
|
||||
self.assert_("mike" in db.test.find({}, ["mike"]).next())
|
||||
self.assertTrue("mike" in db.test.find({}, ["mike"]).next())
|
||||
self.assertFalse("extra thing" in db.test.find({}, ["mike"]).next())
|
||||
|
||||
def test_fields_specifier_as_dict(self):
|
||||
@ -549,8 +549,8 @@ class TestCollection(unittest.TestCase):
|
||||
self.assertEqual([2, 3],
|
||||
db.test.find_one(fields={"x": {"$slice":
|
||||
-2}})["x"])
|
||||
self.assert_("x" not in db.test.find_one(fields={"x": 0}))
|
||||
self.assert_("mike" in db.test.find_one(fields={"x": 0}))
|
||||
self.assertTrue("x" not in db.test.find_one(fields={"x": 0}))
|
||||
self.assertTrue("mike" in db.test.find_one(fields={"x": 0}))
|
||||
|
||||
def test_find_w_regex(self):
|
||||
db = self.db
|
||||
@ -577,7 +577,7 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.remove({})
|
||||
auto_id = {"hello": "world"}
|
||||
db.test.insert(auto_id)
|
||||
self.assert_(isinstance(auto_id["_id"], ObjectId))
|
||||
self.assertTrue(isinstance(auto_id["_id"], ObjectId))
|
||||
|
||||
numeric = {"_id": 240, "hello": "world"}
|
||||
db.test.insert(numeric)
|
||||
@ -589,7 +589,7 @@ class TestCollection(unittest.TestCase):
|
||||
|
||||
for x in db.test.find():
|
||||
self.assertEqual(x["hello"], u"world")
|
||||
self.assert_("_id" in x)
|
||||
self.assertTrue("_id" in x)
|
||||
|
||||
def test_iteration(self):
|
||||
db = self.db
|
||||
@ -644,7 +644,7 @@ class TestCollection(unittest.TestCase):
|
||||
self.assertEqual(doc2["_id"], ids[1])
|
||||
|
||||
id = db.test.insert([{"hello": 1}])
|
||||
self.assert_(isinstance(id, list))
|
||||
self.assertTrue(isinstance(id, list))
|
||||
self.assertEqual(1, len(id))
|
||||
|
||||
self.assertRaises(InvalidOperation, db.test.insert, [])
|
||||
@ -691,7 +691,7 @@ class TestCollection(unittest.TestCase):
|
||||
# Save a doc with autogenerated id
|
||||
id = self.db.test.save({"hello": "world"})
|
||||
self.assertEqual(self.db.test.find_one()["_id"], id)
|
||||
self.assert_(isinstance(id, ObjectId))
|
||||
self.assertTrue(isinstance(id, ObjectId))
|
||||
|
||||
# Save a doc with explicit id
|
||||
self.db.test.save({"_id": "explicit_id", "hello": "bar"})
|
||||
@ -727,7 +727,7 @@ class TestCollection(unittest.TestCase):
|
||||
|
||||
def test_save_with_invalid_key(self):
|
||||
self.db.drop_collection("test")
|
||||
self.assert_(self.db.test.insert({"hello": "world"}))
|
||||
self.assertTrue(self.db.test.insert({"hello": "world"}))
|
||||
doc = self.db.test.find_one()
|
||||
doc['a.b'] = 'c'
|
||||
self.assertRaises(InvalidDocument, self.db.test.save, doc)
|
||||
@ -749,7 +749,7 @@ class TestCollection(unittest.TestCase):
|
||||
db.test.save({"hello": "world"})
|
||||
db.test.save({"hello": "mike"})
|
||||
db.test.save({"hello": "world"})
|
||||
self.assert_(db.error())
|
||||
self.assertTrue(db.error())
|
||||
|
||||
def test_duplicate_key_error(self):
|
||||
db = self.db
|
||||
@ -848,7 +848,7 @@ class TestCollection(unittest.TestCase):
|
||||
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.assert_(db.error())
|
||||
self.assertTrue(db.error())
|
||||
|
||||
def test_safe_insert(self):
|
||||
db = self.db
|
||||
@ -857,7 +857,7 @@ class TestCollection(unittest.TestCase):
|
||||
a = {"hello": "world"}
|
||||
db.test.insert(a)
|
||||
db.test.insert(a)
|
||||
self.assert_("E11000" in db.error()["err"])
|
||||
self.assertTrue("E11000" in db.error()["err"])
|
||||
|
||||
self.assertRaises(OperationFailure, db.test.insert, a, safe=True)
|
||||
|
||||
@ -917,11 +917,11 @@ class TestCollection(unittest.TestCase):
|
||||
|
||||
self.assertEqual(None, db.test.update({"_id": id}, {"$inc": {"x": 1}}))
|
||||
if v19:
|
||||
self.assert_(db.error()["err"].startswith("E11000"))
|
||||
self.assertTrue(db.error()["err"].startswith("E11000"))
|
||||
elif v113minus:
|
||||
self.assert_(db.error()["err"].startswith("E11001"))
|
||||
self.assertTrue(db.error()["err"].startswith("E11001"))
|
||||
else:
|
||||
self.assert_(db.error()["err"].startswith("E12011"))
|
||||
self.assertTrue(db.error()["err"].startswith("E12011"))
|
||||
|
||||
self.assertRaises(OperationFailure, db.test.update,
|
||||
{"_id": id}, {"$inc": {"x": 1}}, safe=True)
|
||||
@ -941,7 +941,7 @@ class TestCollection(unittest.TestCase):
|
||||
|
||||
db.test.save({"hello": "world"})
|
||||
db.test.save({"hello": "world"})
|
||||
self.assert_("E11000" in db.error()["err"])
|
||||
self.assertTrue("E11000" in db.error()["err"])
|
||||
|
||||
self.assertRaises(OperationFailure, db.test.save,
|
||||
{"hello": "world"}, safe=True)
|
||||
@ -1210,8 +1210,8 @@ class TestCollection(unittest.TestCase):
|
||||
self.assertEqual(db.test.find_one({"hello": "world"}),
|
||||
db.test.find_one())
|
||||
|
||||
self.assert_("hello" in db.test.find_one(fields=["hello"]))
|
||||
self.assert_("hello" not in db.test.find_one(fields=["foo"]))
|
||||
self.assertTrue("hello" in db.test.find_one(fields=["hello"]))
|
||||
self.assertTrue("hello" not in db.test.find_one(fields=["foo"]))
|
||||
self.assertEqual(["_id"], db.test.find_one(fields=[]).keys())
|
||||
|
||||
self.assertEqual(None, db.test.find_one({"hello": "foo"}))
|
||||
@ -1223,7 +1223,7 @@ class TestCollection(unittest.TestCase):
|
||||
|
||||
db.test.save({"_id": 5})
|
||||
|
||||
self.assert_(db.test.find_one(5))
|
||||
self.assertTrue(db.test.find_one(5))
|
||||
self.assertFalse(db.test.find_one(6))
|
||||
|
||||
def test_remove_non_objectid(self):
|
||||
@ -1273,17 +1273,17 @@ class TestCollection(unittest.TestCase):
|
||||
def test_insert_adds_id(self):
|
||||
doc = {"hello": "world"}
|
||||
self.db.test.insert(doc)
|
||||
self.assert_("_id" in doc)
|
||||
self.assertTrue("_id" in doc)
|
||||
|
||||
docs = [{"hello": "world"}, {"hello": "world"}]
|
||||
self.db.test.insert(docs)
|
||||
for doc in docs:
|
||||
self.assert_("_id" in doc)
|
||||
self.assertTrue("_id" in doc)
|
||||
|
||||
def test_save_adds_id(self):
|
||||
doc = {"hello": "world"}
|
||||
self.db.test.save(doc)
|
||||
self.assert_("_id" in doc)
|
||||
self.assertTrue("_id" in doc)
|
||||
|
||||
# TODO doesn't actually test functionality, just that it doesn't blow up
|
||||
def test_cursor_timeout(self):
|
||||
@ -1485,13 +1485,13 @@ class TestCollection(unittest.TestCase):
|
||||
c.drop()
|
||||
c.insert({"x": 1})
|
||||
|
||||
self.assert_(isinstance(c.find().next(), dict))
|
||||
self.assertTrue(isinstance(c.find().next(), dict))
|
||||
self.assertFalse(isinstance(c.find().next(), SON))
|
||||
self.assert_(isinstance(c.find(as_class=SON).next(), SON))
|
||||
self.assertTrue(isinstance(c.find(as_class=SON).next(), SON))
|
||||
|
||||
self.assert_(isinstance(c.find_one(), dict))
|
||||
self.assertTrue(isinstance(c.find_one(), dict))
|
||||
self.assertFalse(isinstance(c.find_one(), SON))
|
||||
self.assert_(isinstance(c.find_one(as_class=SON), SON))
|
||||
self.assertTrue(isinstance(c.find_one(as_class=SON), SON))
|
||||
|
||||
self.assertEqual(1, c.find_one(as_class=SON)["x"])
|
||||
self.assertEqual(1, c.find(as_class=SON).next()["x"])
|
||||
|
||||
@ -145,13 +145,13 @@ class TestCommon(unittest.TestCase):
|
||||
self.assertRaises(TypeError, coll._BaseObject__set_safe, 20)
|
||||
|
||||
coll.remove()
|
||||
self.assertEquals(None, coll.find_one(slave_okay=True))
|
||||
self.assertEqual(None, coll.find_one(slave_okay=True))
|
||||
coll.unset_lasterror_options()
|
||||
coll.set_lasterror_options(w=4, wtimeout=10)
|
||||
# Fails if we don't have 4 active nodes or we don't have replication...
|
||||
self.assertRaises(OperationFailure, coll.insert, {'foo': 'bar'})
|
||||
# Succeeds since we override the lasterror settings per query.
|
||||
self.assert_(coll.insert({'foo': 'bar'}, fsync=True))
|
||||
self.assertTrue(coll.insert({'foo': 'bar'}, fsync=True))
|
||||
c.drop_database(db)
|
||||
warnings.resetwarnings()
|
||||
|
||||
|
||||
@ -63,26 +63,26 @@ class TestConnection(unittest.TestCase):
|
||||
def test_constants(self):
|
||||
Connection.HOST = self.host
|
||||
Connection.PORT = self.port
|
||||
self.assert_(Connection())
|
||||
self.assertTrue(Connection())
|
||||
|
||||
Connection.HOST = "somedomainthatdoesntexist.org"
|
||||
Connection.PORT = 123456789
|
||||
self.assertRaises(ConnectionFailure, Connection, connectTimeoutMS=600)
|
||||
self.assert_(Connection(self.host, self.port))
|
||||
self.assertTrue(Connection(self.host, self.port))
|
||||
|
||||
Connection.HOST = self.host
|
||||
Connection.PORT = self.port
|
||||
self.assert_(Connection())
|
||||
self.assertTrue(Connection())
|
||||
|
||||
def test_connect(self):
|
||||
self.assertRaises(ConnectionFailure, Connection,
|
||||
"somedomainthatdoesntexist.org", connectTimeoutMS=600)
|
||||
self.assertRaises(ConnectionFailure, Connection, self.host, 123456789)
|
||||
|
||||
self.assert_(Connection(self.host, self.port))
|
||||
self.assertTrue(Connection(self.host, self.port))
|
||||
|
||||
def test_host_w_port(self):
|
||||
self.assert_(Connection("%s:%d" % (self.host, self.port)))
|
||||
self.assertTrue(Connection("%s:%d" % (self.host, self.port)))
|
||||
self.assertRaises(ConnectionFailure, Connection,
|
||||
"%s:1234567" % (self.host,), self.port)
|
||||
|
||||
@ -109,7 +109,7 @@ class TestConnection(unittest.TestCase):
|
||||
self.assertRaises(InvalidName, make_db, connection, "te/t")
|
||||
self.assertRaises(InvalidName, make_db, connection, "te st")
|
||||
|
||||
self.assert_(isinstance(connection.test, Database))
|
||||
self.assertTrue(isinstance(connection.test, Database))
|
||||
self.assertEqual(connection.test, connection["test"])
|
||||
self.assertEqual(connection.test, Database(connection, "test"))
|
||||
|
||||
@ -120,8 +120,8 @@ class TestConnection(unittest.TestCase):
|
||||
connection.pymongo_test_mike.test.save({"dummy": u"object"})
|
||||
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assert_("pymongo_test_mike" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test_mike" in dbs)
|
||||
|
||||
def test_drop_database(self):
|
||||
connection = Connection(self.host, self.port)
|
||||
@ -131,21 +131,21 @@ class TestConnection(unittest.TestCase):
|
||||
|
||||
connection.pymongo_test.test.save({"dummy": u"object"})
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
connection.drop_database("pymongo_test")
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" not in dbs)
|
||||
self.assertTrue("pymongo_test" not in dbs)
|
||||
|
||||
connection.pymongo_test.test.save({"dummy": u"object"})
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
connection.drop_database(connection.pymongo_test)
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" not in dbs)
|
||||
self.assertTrue("pymongo_test" not in dbs)
|
||||
|
||||
def test_copy_db(self):
|
||||
c = Connection(self.host, self.port)
|
||||
self.assert_(c.in_request())
|
||||
self.assertTrue(c.in_request())
|
||||
|
||||
self.assertRaises(TypeError, c.copy_database, 4, "foo")
|
||||
self.assertRaises(TypeError, c.copy_database, "foo", 4)
|
||||
@ -166,9 +166,9 @@ class TestConnection(unittest.TestCase):
|
||||
|
||||
c.copy_database("pymongo_test", "pymongo_test1")
|
||||
# copy_database() didn't accidentally end the request
|
||||
self.assert_(c.in_request())
|
||||
self.assertTrue(c.in_request())
|
||||
|
||||
self.assert_("pymongo_test1" in c.database_names())
|
||||
self.assertTrue("pymongo_test1" in c.database_names())
|
||||
self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
|
||||
|
||||
c.end_request()
|
||||
@ -177,7 +177,7 @@ class TestConnection(unittest.TestCase):
|
||||
# copy_database() didn't accidentally restart the request
|
||||
self.assertFalse(c.in_request())
|
||||
|
||||
self.assert_("pymongo_test2" in c.database_names())
|
||||
self.assertTrue("pymongo_test2" in c.database_names())
|
||||
self.assertEqual("bar", c.pymongo_test2.test.find_one()["foo"])
|
||||
|
||||
if version.at_least(c, (1, 3, 3, 1)):
|
||||
@ -200,7 +200,7 @@ class TestConnection(unittest.TestCase):
|
||||
|
||||
c.copy_database("pymongo_test", "pymongo_test1",
|
||||
username="mike", password="password")
|
||||
self.assert_("pymongo_test1" in c.database_names())
|
||||
self.assertTrue("pymongo_test1" in c.database_names())
|
||||
self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
|
||||
|
||||
def test_iteration(self):
|
||||
@ -279,10 +279,10 @@ class TestConnection(unittest.TestCase):
|
||||
Connection("mongodb://user:pass@%s:%d/pymongo_test" %
|
||||
(self.host, self.port))
|
||||
|
||||
self.assert_(Connection("mongodb://%s:%d" %
|
||||
self.assertTrue(Connection("mongodb://%s:%d" %
|
||||
(self.host, self.port),
|
||||
slave_okay=True).slave_okay)
|
||||
self.assert_(Connection("mongodb://%s:%d/?slaveok=true;w=2" %
|
||||
self.assertTrue(Connection("mongodb://%s:%d/?slaveok=true;w=2" %
|
||||
(self.host, self.port)).slave_okay)
|
||||
c.admin.system.users.remove({})
|
||||
c.pymongo_test.system.users.remove({})
|
||||
@ -352,33 +352,33 @@ class TestConnection(unittest.TestCase):
|
||||
db.test.insert({"x": 1})
|
||||
|
||||
self.assertEqual(dict, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), dict))
|
||||
self.assertTrue(isinstance(db.test.find_one(), dict))
|
||||
self.assertFalse(isinstance(db.test.find_one(), SON))
|
||||
|
||||
c.document_class = SON
|
||||
|
||||
self.assertEqual(SON, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), SON))
|
||||
self.assertTrue(isinstance(db.test.find_one(), SON))
|
||||
self.assertFalse(isinstance(db.test.find_one(as_class=dict), SON))
|
||||
|
||||
c = Connection(self.host, self.port, document_class=SON)
|
||||
db = c.pymongo_test
|
||||
|
||||
self.assertEqual(SON, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), SON))
|
||||
self.assertTrue(isinstance(db.test.find_one(), SON))
|
||||
self.assertFalse(isinstance(db.test.find_one(as_class=dict), SON))
|
||||
|
||||
c.document_class = dict
|
||||
|
||||
self.assertEqual(dict, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), dict))
|
||||
self.assertTrue(isinstance(db.test.find_one(), dict))
|
||||
self.assertFalse(isinstance(db.test.find_one(), SON))
|
||||
|
||||
def test_timeouts(self):
|
||||
conn = Connection(self.host, self.port, connectTimeoutMS=300)
|
||||
self.assertEquals(0.3, conn._Connection__pool.conn_timeout)
|
||||
self.assertEqual(0.3, conn._Connection__pool.conn_timeout)
|
||||
conn = Connection(self.host, self.port, socketTimeoutMS=300)
|
||||
self.assertEquals(0.3, conn._Connection__pool.net_timeout)
|
||||
self.assertEqual(0.3, conn._Connection__pool.net_timeout)
|
||||
|
||||
def test_network_timeout(self):
|
||||
no_timeout = Connection(self.host, self.port)
|
||||
@ -439,8 +439,8 @@ class TestConnection(unittest.TestCase):
|
||||
connection.pymongo_test_bernie.test.save({"dummy": u"object"})
|
||||
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assert_("pymongo_test_bernie" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test_bernie" in dbs)
|
||||
|
||||
def test_fsync_lock_unlock(self):
|
||||
c = get_connection()
|
||||
@ -478,7 +478,7 @@ class TestConnection(unittest.TestCase):
|
||||
# these with-statements won't even compile.
|
||||
exec """
|
||||
with contextlib.closing(conn):
|
||||
self.assertEquals("bar", conn.pymongo_test.test.find_one()["foo"])
|
||||
self.assertEqual("bar", conn.pymongo_test.test.find_one()["foo"])
|
||||
"""
|
||||
|
||||
# Calling conn.close() has reset the pool
|
||||
@ -486,7 +486,7 @@ with contextlib.closing(conn):
|
||||
|
||||
exec """
|
||||
with get_connection() as connection:
|
||||
self.assertEquals("bar", connection.pymongo_test.test.find_one()["foo"])
|
||||
self.assertEqual("bar", connection.pymongo_test.test.find_one()["foo"])
|
||||
# Calling conn.close() has reset the pool
|
||||
self.assertEqual(0, len(connection._Connection__pool.sockets))
|
||||
"""
|
||||
@ -516,7 +516,7 @@ with get_connection() as connection:
|
||||
self.assertEqual(NO_SOCKET_YET, pool._get_request_state())
|
||||
|
||||
def assertRequestSocket(self, pool):
|
||||
self.assert_(isinstance(pool._get_request_state(), SocketInfo))
|
||||
self.assertTrue(isinstance(pool._get_request_state(), SocketInfo))
|
||||
|
||||
def test_with_start_request(self):
|
||||
conn = get_connection(auto_start_request=False)
|
||||
@ -528,7 +528,7 @@ with get_connection() as connection:
|
||||
|
||||
# Start a request
|
||||
request_context_mgr = conn.start_request()
|
||||
self.assert_(
|
||||
self.assertTrue(
|
||||
isinstance(request_context_mgr, object)
|
||||
)
|
||||
|
||||
@ -621,7 +621,7 @@ with conn.start_request() as request:
|
||||
|
||||
# Can't use self.assertRaises() because it doesn't catch system
|
||||
# exceptions
|
||||
self.assert_(raised, "Didn't raise expected KeyboardInterrupt")
|
||||
self.assertTrue(raised, "Didn't raise expected KeyboardInterrupt")
|
||||
|
||||
# Raises AssertionError due to PYTHON-294 -- Mongo's response to the
|
||||
# previous find() is still waiting to be read on the socket, so the
|
||||
|
||||
@ -49,7 +49,7 @@ class TestCursor(unittest.TestCase):
|
||||
del c["millis"]
|
||||
c.pop("oldPlan", None)
|
||||
self.assertEqual(b, c)
|
||||
self.assert_("cursor" in b)
|
||||
self.assertTrue("cursor" in b)
|
||||
|
||||
def test_hint(self):
|
||||
db = self.db
|
||||
@ -184,27 +184,27 @@ class TestCursor(unittest.TestCase):
|
||||
|
||||
curs = db.test.find().limit(0).batch_size(10)
|
||||
curs.next()
|
||||
self.assertEquals(10, curs._Cursor__retrieved)
|
||||
self.assertEqual(10, curs._Cursor__retrieved)
|
||||
|
||||
curs = db.test.find().limit(-2).batch_size(0)
|
||||
curs.next()
|
||||
self.assertEquals(2, curs._Cursor__retrieved)
|
||||
self.assertEqual(2, curs._Cursor__retrieved)
|
||||
|
||||
curs = db.test.find().limit(-4).batch_size(5)
|
||||
curs.next()
|
||||
self.assertEquals(4, curs._Cursor__retrieved)
|
||||
self.assertEqual(4, curs._Cursor__retrieved)
|
||||
|
||||
curs = db.test.find().limit(50).batch_size(500)
|
||||
curs.next()
|
||||
self.assertEquals(50, curs._Cursor__retrieved)
|
||||
self.assertEqual(50, curs._Cursor__retrieved)
|
||||
|
||||
curs = db.test.find().batch_size(500)
|
||||
curs.next()
|
||||
self.assertEquals(500, curs._Cursor__retrieved)
|
||||
self.assertEqual(500, curs._Cursor__retrieved)
|
||||
|
||||
curs = db.test.find().limit(50)
|
||||
curs.next()
|
||||
self.assertEquals(50, curs._Cursor__retrieved)
|
||||
self.assertEqual(50, curs._Cursor__retrieved)
|
||||
|
||||
# these two might be shaky, as the default
|
||||
# is set by the server. as of 2.0.0-rc0, 101
|
||||
@ -212,11 +212,11 @@ class TestCursor(unittest.TestCase):
|
||||
# for queries without ntoreturn
|
||||
curs = db.test.find()
|
||||
curs.next()
|
||||
self.assertEquals(101, curs._Cursor__retrieved)
|
||||
self.assertEqual(101, curs._Cursor__retrieved)
|
||||
|
||||
curs = db.test.find().limit(0).batch_size(0)
|
||||
curs.next()
|
||||
self.assertEquals(101, curs._Cursor__retrieved)
|
||||
self.assertEqual(101, curs._Cursor__retrieved)
|
||||
|
||||
def test_skip(self):
|
||||
db = self.db
|
||||
@ -327,7 +327,7 @@ class TestCursor(unittest.TestCase):
|
||||
db.test.save({"x": i})
|
||||
|
||||
self.assertEqual(10, db.test.find().count())
|
||||
self.assert_(isinstance(db.test.find().count(), int))
|
||||
self.assertTrue(isinstance(db.test.find().count(), int))
|
||||
self.assertEqual(10, db.test.find().limit(5).count())
|
||||
self.assertEqual(10, db.test.find().skip(5).count())
|
||||
|
||||
|
||||
@ -85,11 +85,11 @@ class TestDatabase(unittest.TestCase):
|
||||
test = db.create_collection("test")
|
||||
test.save({"hello": u"world"})
|
||||
self.assertEqual(db.test.find_one()["hello"], "world")
|
||||
self.assert_(u"test" in db.collection_names())
|
||||
self.assertTrue(u"test" in db.collection_names())
|
||||
|
||||
db.drop_collection("test.foo")
|
||||
db.create_collection("test.foo")
|
||||
self.assert_(u"test.foo" in db.collection_names())
|
||||
self.assertTrue(u"test.foo" in db.collection_names())
|
||||
self.assertEqual(db.test.foo.options(), {})
|
||||
self.assertRaises(CollectionInvalid, db.create_collection, "test.foo")
|
||||
|
||||
@ -99,10 +99,10 @@ class TestDatabase(unittest.TestCase):
|
||||
db.test.mike.save({"dummy": u"object"})
|
||||
|
||||
colls = db.collection_names()
|
||||
self.assert_("test" in colls)
|
||||
self.assert_("test.mike" in colls)
|
||||
self.assertTrue("test" in colls)
|
||||
self.assertTrue("test.mike" in colls)
|
||||
for coll in colls:
|
||||
self.assert_("$" not in coll)
|
||||
self.assertTrue("$" not in coll)
|
||||
|
||||
def test_drop_collection(self):
|
||||
db = Database(self.connection, "pymongo_test")
|
||||
@ -111,22 +111,22 @@ class TestDatabase(unittest.TestCase):
|
||||
self.assertRaises(TypeError, db.drop_collection, None)
|
||||
|
||||
db.test.save({"dummy": u"object"})
|
||||
self.assert_("test" in db.collection_names())
|
||||
self.assertTrue("test" in db.collection_names())
|
||||
db.drop_collection("test")
|
||||
self.assertFalse("test" in db.collection_names())
|
||||
|
||||
db.test.save({"dummy": u"object"})
|
||||
self.assert_("test" in db.collection_names())
|
||||
self.assertTrue("test" in db.collection_names())
|
||||
db.drop_collection(u"test")
|
||||
self.assertFalse("test" in db.collection_names())
|
||||
|
||||
db.test.save({"dummy": u"object"})
|
||||
self.assert_("test" in db.collection_names())
|
||||
self.assertTrue("test" in db.collection_names())
|
||||
db.drop_collection(db.test)
|
||||
self.assertFalse("test" in db.collection_names())
|
||||
|
||||
db.test.save({"dummy": u"object"})
|
||||
self.assert_("test" in db.collection_names())
|
||||
self.assertTrue("test" in db.collection_names())
|
||||
db.test.drop()
|
||||
self.assertFalse("test" in db.collection_names())
|
||||
db.test.drop()
|
||||
@ -146,12 +146,12 @@ class TestDatabase(unittest.TestCase):
|
||||
self.assertRaises(OperationFailure, db.validate_collection,
|
||||
db.test.doesnotexist)
|
||||
|
||||
self.assert_(db.validate_collection("test"))
|
||||
self.assert_(db.validate_collection(db.test))
|
||||
self.assert_(db.validate_collection(db.test, full=True))
|
||||
self.assert_(db.validate_collection(db.test, scandata=True))
|
||||
self.assert_(db.validate_collection(db.test, scandata=True, full=True))
|
||||
self.assert_(db.validate_collection(db.test, True, True))
|
||||
self.assertTrue(db.validate_collection("test"))
|
||||
self.assertTrue(db.validate_collection(db.test))
|
||||
self.assertTrue(db.validate_collection(db.test, full=True))
|
||||
self.assertTrue(db.validate_collection(db.test, scandata=True))
|
||||
self.assertTrue(db.validate_collection(db.test, scandata=True, full=True))
|
||||
self.assertTrue(db.validate_collection(db.test, True, True))
|
||||
|
||||
def test_profiling_levels(self):
|
||||
db = self.connection.pymongo_test
|
||||
@ -178,7 +178,7 @@ class TestDatabase(unittest.TestCase):
|
||||
db.set_profiling_level(OFF)
|
||||
|
||||
info = db.profiling_info()
|
||||
self.assert_(isinstance(info, list))
|
||||
self.assertTrue(isinstance(info, list))
|
||||
|
||||
# Check if we're going to fail because of SERVER-4754, in which
|
||||
# profiling info isn't collected if mongod was started with --auth
|
||||
@ -187,20 +187,20 @@ class TestDatabase(unittest.TestCase):
|
||||
"We need SERVER-4754 fixed for the rest of this test to pass"
|
||||
)
|
||||
|
||||
self.assert_(len(info) >= 1)
|
||||
self.assertTrue(len(info) >= 1)
|
||||
# These basically clue us in to server changes.
|
||||
if version.at_least(db.connection, (1, 9, 1, -1)):
|
||||
self.assert_(isinstance(info[0]['responseLength'], int))
|
||||
self.assert_(isinstance(info[0]['millis'], int))
|
||||
self.assert_(isinstance(info[0]['client'], basestring))
|
||||
self.assert_(isinstance(info[0]['user'], basestring))
|
||||
self.assert_(isinstance(info[0]['ntoreturn'], int))
|
||||
self.assert_(isinstance(info[0]['ns'], basestring))
|
||||
self.assert_(isinstance(info[0]['op'], basestring))
|
||||
self.assertTrue(isinstance(info[0]['responseLength'], int))
|
||||
self.assertTrue(isinstance(info[0]['millis'], int))
|
||||
self.assertTrue(isinstance(info[0]['client'], basestring))
|
||||
self.assertTrue(isinstance(info[0]['user'], basestring))
|
||||
self.assertTrue(isinstance(info[0]['ntoreturn'], int))
|
||||
self.assertTrue(isinstance(info[0]['ns'], basestring))
|
||||
self.assertTrue(isinstance(info[0]['op'], basestring))
|
||||
else:
|
||||
self.assert_(isinstance(info[0]["info"], basestring))
|
||||
self.assert_(isinstance(info[0]["millis"], float))
|
||||
self.assert_(isinstance(info[0]["ts"], datetime.datetime))
|
||||
self.assertTrue(isinstance(info[0]["info"], basestring))
|
||||
self.assertTrue(isinstance(info[0]["millis"], float))
|
||||
self.assertTrue(isinstance(info[0]["ts"], datetime.datetime))
|
||||
|
||||
def test_iteration(self):
|
||||
db = self.connection.pymongo_test
|
||||
@ -218,11 +218,11 @@ class TestDatabase(unittest.TestCase):
|
||||
self.assertEqual(None, db.previous_error())
|
||||
|
||||
db.command("forceerror", check=False)
|
||||
self.assert_(db.error())
|
||||
self.assert_(db.previous_error())
|
||||
self.assertTrue(db.error())
|
||||
self.assertTrue(db.previous_error())
|
||||
|
||||
db.command("forceerror", check=False)
|
||||
self.assert_(db.error())
|
||||
self.assertTrue(db.error())
|
||||
prev_error = db.previous_error()
|
||||
self.assertEqual(prev_error["nPrev"], 1)
|
||||
del prev_error["nPrev"]
|
||||
@ -236,7 +236,7 @@ class TestDatabase(unittest.TestCase):
|
||||
|
||||
db.test.find_one()
|
||||
self.assertEqual(None, db.error())
|
||||
self.assert_(db.previous_error())
|
||||
self.assertTrue(db.previous_error())
|
||||
self.assertEqual(db.previous_error()["nPrev"], 2)
|
||||
|
||||
db.reset_error_history()
|
||||
@ -255,7 +255,7 @@ class TestDatabase(unittest.TestCase):
|
||||
db.test.save({"i": 1})
|
||||
|
||||
db.test.update({"i": 1}, {"$set": {"i": 2}})
|
||||
self.assert_(db.last_status()["updatedExisting"])
|
||||
self.assertTrue(db.last_status()["updatedExisting"])
|
||||
|
||||
db.test.update({"i": 1}, {"$set": {"i": 500}})
|
||||
self.assertFalse(db.last_status()["updatedExisting"])
|
||||
@ -265,7 +265,7 @@ class TestDatabase(unittest.TestCase):
|
||||
self.assertRaises(TypeError, helpers._password_digest, True)
|
||||
self.assertRaises(TypeError, helpers._password_digest, None)
|
||||
|
||||
self.assert_(isinstance(helpers._password_digest("mike", "password"),
|
||||
self.assertTrue(isinstance(helpers._password_digest("mike", "password"),
|
||||
unicode))
|
||||
self.assertEqual(helpers._password_digest("mike", "password"),
|
||||
u"cd7e45b3b2767dc2fa9b6b548457ed00")
|
||||
@ -285,23 +285,23 @@ class TestDatabase(unittest.TestCase):
|
||||
|
||||
self.assertFalse(db.authenticate("mike", "not a real password"))
|
||||
self.assertFalse(db.authenticate("faker", "password"))
|
||||
self.assert_(db.authenticate("mike", "password"))
|
||||
self.assert_(db.authenticate(u"mike", u"password"))
|
||||
self.assertTrue(db.authenticate("mike", "password"))
|
||||
self.assertTrue(db.authenticate(u"mike", u"password"))
|
||||
|
||||
db.remove_user("mike")
|
||||
self.assertFalse(db.authenticate("mike", "password"))
|
||||
|
||||
self.assertFalse(db.authenticate("Gustave", u"Dor\xe9"))
|
||||
db.add_user("Gustave", u"Dor\xe9")
|
||||
self.assert_(db.authenticate("Gustave", u"Dor\xe9"))
|
||||
self.assertTrue(db.authenticate("Gustave", u"Dor\xe9"))
|
||||
|
||||
db.add_user("Gustave", "password")
|
||||
self.assertFalse(db.authenticate("Gustave", u"Dor\xe9"))
|
||||
self.assert_(db.authenticate("Gustave", u"password"))
|
||||
self.assertTrue(db.authenticate("Gustave", u"password"))
|
||||
|
||||
db.add_user("Ross", "password", read_only=True)
|
||||
self.assert_(db.authenticate("Ross", u"password"))
|
||||
self.assert_(db.system.users.find({"readOnly": True}).count())
|
||||
self.assertTrue(db.authenticate("Ross", u"password"))
|
||||
self.assertTrue(db.system.users.find({"readOnly": True}).count())
|
||||
|
||||
# just make sure there are no exceptions here
|
||||
db.logout()
|
||||
@ -399,7 +399,7 @@ class TestDatabase(unittest.TestCase):
|
||||
|
||||
a_doc = SON({"hello": u"world"})
|
||||
a_key = db.test.save(a_doc)
|
||||
self.assert_(isinstance(a_doc["_id"], ObjectId))
|
||||
self.assertTrue(isinstance(a_doc["_id"], ObjectId))
|
||||
self.assertEqual(a_doc["_id"], a_key)
|
||||
self.assertEqual(a_doc, db.test.find_one({"_id": a_doc["_id"]}))
|
||||
self.assertEqual(a_doc, db.test.find_one(a_key))
|
||||
@ -452,11 +452,11 @@ class TestDatabase(unittest.TestCase):
|
||||
db.test.save({"x": 2})
|
||||
db.test.save({"x": 3})
|
||||
|
||||
self.assert_(db.test.find_one({"x": 2}))
|
||||
self.assertTrue(db.test.find_one({"x": 2}))
|
||||
db.test.remove({"x": 2})
|
||||
self.assertFalse(db.test.find_one({"x": 2}))
|
||||
|
||||
self.assert_(db.test.find_one())
|
||||
self.assertTrue(db.test.find_one())
|
||||
db.test.remove({})
|
||||
self.assertFalse(db.test.find_one())
|
||||
|
||||
@ -577,10 +577,10 @@ class TestDatabase(unittest.TestCase):
|
||||
|
||||
def test_manipulator_properties(self):
|
||||
db = self.connection.foo
|
||||
self.assertEquals(['ObjectIdInjector'], db.incoming_manipulators)
|
||||
self.assertEquals([], db.incoming_copying_manipulators)
|
||||
self.assertEquals([], db.outgoing_manipulators)
|
||||
self.assertEquals([], db.outgoing_copying_manipulators)
|
||||
self.assertEqual(['ObjectIdInjector'], db.incoming_manipulators)
|
||||
self.assertEqual([], db.incoming_copying_manipulators)
|
||||
self.assertEqual([], db.outgoing_manipulators)
|
||||
self.assertEqual([], db.outgoing_copying_manipulators)
|
||||
db.add_son_manipulator(AutoReference(db))
|
||||
db.add_son_manipulator(NamespaceInjector())
|
||||
db.add_son_manipulator(ObjectIdShuffler())
|
||||
@ -590,8 +590,8 @@ class TestDatabase(unittest.TestCase):
|
||||
self.assertEqual(2, len(db.incoming_copying_manipulators))
|
||||
for name in db.incoming_copying_manipulators:
|
||||
self.assertTrue(name in ('ObjectIdShuffler', 'AutoReference'))
|
||||
self.assertEquals([], db.outgoing_manipulators)
|
||||
self.assertEquals(['AutoReference'], db.outgoing_copying_manipulators)
|
||||
self.assertEqual([], db.outgoing_manipulators)
|
||||
self.assertEqual(['AutoReference'], db.outgoing_copying_manipulators)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@ -39,10 +39,10 @@ class TestDBRef(unittest.TestCase):
|
||||
self.assertRaises(TypeError, DBRef, a, a)
|
||||
self.assertRaises(TypeError, DBRef, None, a)
|
||||
self.assertRaises(TypeError, DBRef, "coll", a, 5)
|
||||
self.assert_(DBRef("coll", a))
|
||||
self.assert_(DBRef(u"coll", a))
|
||||
self.assert_(DBRef(u"coll", 5))
|
||||
self.assert_(DBRef(u"coll", 5, "database"))
|
||||
self.assertTrue(DBRef("coll", a))
|
||||
self.assertTrue(DBRef(u"coll", a))
|
||||
self.assertTrue(DBRef(u"coll", 5))
|
||||
self.assertTrue(DBRef(u"coll", 5, "database"))
|
||||
|
||||
def test_read_only(self):
|
||||
a = DBRef("coll", ObjectId())
|
||||
@ -133,11 +133,11 @@ class TestDBRef(unittest.TestCase):
|
||||
def test_dbref_hash(self):
|
||||
dbref_1a = DBRef('collection', 'id', 'database')
|
||||
dbref_1b = DBRef('collection', 'id', 'database')
|
||||
self.assertEquals(hash(dbref_1a), hash(dbref_1b))
|
||||
self.assertEqual(hash(dbref_1a), hash(dbref_1b))
|
||||
|
||||
dbref_2a = DBRef('collection', 'id', 'database', custom='custom')
|
||||
dbref_2b = DBRef('collection', 'id', 'database', custom='custom')
|
||||
self.assertEquals(hash(dbref_2a), hash(dbref_2b))
|
||||
self.assertEqual(hash(dbref_2a), hash(dbref_2b))
|
||||
|
||||
self.assertNotEqual(hash(dbref_1a), hash(dbref_2a))
|
||||
|
||||
|
||||
@ -102,7 +102,7 @@ class TestGridFile(unittest.TestCase):
|
||||
|
||||
a = GridIn(self.db.fs)
|
||||
|
||||
self.assert_(isinstance(a._id, ObjectId))
|
||||
self.assertTrue(isinstance(a._id, ObjectId))
|
||||
self.assertRaises(AttributeError, setattr, a, "_id", 5)
|
||||
|
||||
self.assertEqual(None, a.filename)
|
||||
@ -135,7 +135,7 @@ class TestGridFile(unittest.TestCase):
|
||||
|
||||
a.close()
|
||||
|
||||
self.assert_(isinstance(a._id, ObjectId))
|
||||
self.assertTrue(isinstance(a._id, ObjectId))
|
||||
self.assertRaises(AttributeError, setattr, a, "_id", 5)
|
||||
|
||||
self.assertEqual("my_file", a.filename)
|
||||
@ -148,7 +148,7 @@ class TestGridFile(unittest.TestCase):
|
||||
self.assertEqual(256 * 1024, a.chunk_size)
|
||||
self.assertRaises(AttributeError, setattr, a, "chunk_size", 5)
|
||||
|
||||
self.assert_(isinstance(a.upload_date, datetime.datetime))
|
||||
self.assertTrue(isinstance(a.upload_date, datetime.datetime))
|
||||
self.assertRaises(AttributeError, setattr, a, "upload_date", 5)
|
||||
|
||||
self.assertEqual(["foo"], a.aliases)
|
||||
@ -195,7 +195,7 @@ class TestGridFile(unittest.TestCase):
|
||||
self.assertEqual(0, b.length)
|
||||
self.assertEqual(None, b.content_type)
|
||||
self.assertEqual(256 * 1024, b.chunk_size)
|
||||
self.assert_(isinstance(b.upload_date, datetime.datetime))
|
||||
self.assertTrue(isinstance(b.upload_date, datetime.datetime))
|
||||
self.assertEqual(None, b.aliases)
|
||||
self.assertEqual(None, b.metadata)
|
||||
self.assertEqual("d41d8cd98f00b204e9800998ecf8427e", b.md5)
|
||||
@ -217,7 +217,7 @@ class TestGridFile(unittest.TestCase):
|
||||
self.assertEqual(11, b.length)
|
||||
self.assertEqual("text/html", b.content_type)
|
||||
self.assertEqual(1000, b.chunk_size)
|
||||
self.assert_(isinstance(b.upload_date, datetime.datetime))
|
||||
self.assertTrue(isinstance(b.upload_date, datetime.datetime))
|
||||
self.assertEqual(["foo"], b.aliases)
|
||||
self.assertEqual({"foo": 1, "bar": 2}, b.metadata)
|
||||
self.assertEqual(3, b.bar)
|
||||
@ -464,7 +464,7 @@ Bye""")
|
||||
self.assertEqual("foo", f._id)
|
||||
self.assertEqual("foo", f.bar)
|
||||
self.assertEqual(5, f.baz)
|
||||
self.assert_(f.uploadDate)
|
||||
self.assertTrue(f.uploadDate)
|
||||
|
||||
self.assertRaises(AttributeError, setattr, f, "_id", 5)
|
||||
f.bar = "a"
|
||||
|
||||
@ -116,9 +116,9 @@ class TestGridfs(unittest.TestCase):
|
||||
raw = self.db.fs.files.find_one()
|
||||
self.assertEqual(0, raw["length"])
|
||||
self.assertEqual(oid, raw["_id"])
|
||||
self.assert_(isinstance(raw["uploadDate"], datetime.datetime))
|
||||
self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime))
|
||||
self.assertEqual(256 * 1024, raw["chunkSize"])
|
||||
self.assert_(isinstance(raw["md5"], basestring))
|
||||
self.assertTrue(isinstance(raw["md5"], basestring))
|
||||
|
||||
def test_alt_collection(self):
|
||||
oid = self.alt.put("hello world")
|
||||
@ -272,23 +272,23 @@ class TestGridfs(unittest.TestCase):
|
||||
|
||||
def test_exists(self):
|
||||
oid = self.fs.put("hello")
|
||||
self.assert_(self.fs.exists(oid))
|
||||
self.assert_(self.fs.exists({"_id": oid}))
|
||||
self.assert_(self.fs.exists(_id=oid))
|
||||
self.assertTrue(self.fs.exists(oid))
|
||||
self.assertTrue(self.fs.exists({"_id": oid}))
|
||||
self.assertTrue(self.fs.exists(_id=oid))
|
||||
|
||||
self.assertFalse(self.fs.exists(filename="mike"))
|
||||
self.assertFalse(self.fs.exists("mike"))
|
||||
|
||||
oid = self.fs.put("hello", filename="mike", foo=12)
|
||||
self.assert_(self.fs.exists(oid))
|
||||
self.assert_(self.fs.exists({"_id": oid}))
|
||||
self.assert_(self.fs.exists(_id=oid))
|
||||
self.assert_(self.fs.exists(filename="mike"))
|
||||
self.assert_(self.fs.exists({"filename": "mike"}))
|
||||
self.assert_(self.fs.exists(foo=12))
|
||||
self.assert_(self.fs.exists({"foo": 12}))
|
||||
self.assert_(self.fs.exists(foo={"$gt": 11}))
|
||||
self.assert_(self.fs.exists({"foo": {"$gt": 11}}))
|
||||
self.assertTrue(self.fs.exists(oid))
|
||||
self.assertTrue(self.fs.exists({"_id": oid}))
|
||||
self.assertTrue(self.fs.exists(_id=oid))
|
||||
self.assertTrue(self.fs.exists(filename="mike"))
|
||||
self.assertTrue(self.fs.exists({"filename": "mike"}))
|
||||
self.assertTrue(self.fs.exists(foo=12))
|
||||
self.assertTrue(self.fs.exists({"foo": 12}))
|
||||
self.assertTrue(self.fs.exists(foo={"$gt": 11}))
|
||||
self.assertTrue(self.fs.exists({"foo": {"$gt": 11}}))
|
||||
|
||||
self.assertFalse(self.fs.exists(foo=13))
|
||||
self.assertFalse(self.fs.exists({"foo": 13}))
|
||||
|
||||
@ -85,11 +85,11 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
Connection()]
|
||||
|
||||
self.connection.disconnect()
|
||||
self.assertEquals(1,
|
||||
self.assertEqual(1,
|
||||
self.connection._MasterSlaveConnection__master._disconnects)
|
||||
self.assertEquals(1,
|
||||
self.assertEqual(1,
|
||||
self.connection._MasterSlaveConnection__slaves[0]._disconnects)
|
||||
self.assertEquals(1,
|
||||
self.assertEqual(1,
|
||||
self.connection._MasterSlaveConnection__slaves[1]._disconnects)
|
||||
|
||||
def test_continue_until_slave_works(self):
|
||||
@ -122,9 +122,9 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
self.connection._MasterSlaveConnection__slaves = NotRandomList()
|
||||
|
||||
response = self.connection._send_message_with_response('message')
|
||||
self.assertEquals((NotRandomList.last_idx, 'sent'), response)
|
||||
self.assertEqual((NotRandomList.last_idx, 'sent'), response)
|
||||
self.assertNotEquals(-1, NotRandomList.last_idx)
|
||||
self.assertEquals(3, Slave.calls)
|
||||
self.assertEqual(3, Slave.calls)
|
||||
|
||||
def test_raise_autoreconnect_if_all_slaves_fail(self):
|
||||
class Slave(object):
|
||||
@ -154,7 +154,7 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
|
||||
self.assertRaises(AutoReconnect,
|
||||
self.connection._send_message_with_response, 'message')
|
||||
self.assertEquals(4, Slave.calls)
|
||||
self.assertEqual(4, Slave.calls)
|
||||
|
||||
def test_get_db(self):
|
||||
|
||||
@ -168,7 +168,7 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
self.assertRaises(InvalidName, make_db, self.connection, "te/t")
|
||||
self.assertRaises(InvalidName, make_db, self.connection, "te st")
|
||||
|
||||
self.assert_(isinstance(self.connection.test, Database))
|
||||
self.assertTrue(isinstance(self.connection.test, Database))
|
||||
self.assertEqual(self.connection.test, self.connection["test"])
|
||||
self.assertEqual(self.connection.test, Database(self.connection,
|
||||
"test"))
|
||||
@ -178,8 +178,8 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
self.connection.pymongo_test_mike.test.save({"dummy": u"object"})
|
||||
|
||||
dbs = self.connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assert_("pymongo_test_mike" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test_mike" in dbs)
|
||||
|
||||
def test_drop_database(self):
|
||||
self.assertRaises(TypeError, self.connection.drop_database, 5)
|
||||
@ -189,17 +189,17 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
|
||||
self.connection.pymongo_test.test.save({"dummy": u"object"}, safe=True)
|
||||
dbs = self.connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.connection.drop_database("pymongo_test")
|
||||
dbs = self.connection.database_names()
|
||||
self.assert_("pymongo_test" not in dbs)
|
||||
self.assertTrue("pymongo_test" not in dbs)
|
||||
|
||||
self.connection.pymongo_test.test.save({"dummy": u"object"})
|
||||
dbs = self.connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.connection.drop_database(self.connection.pymongo_test)
|
||||
dbs = self.connection.database_names()
|
||||
self.assert_("pymongo_test" not in dbs)
|
||||
self.assertTrue("pymongo_test" not in dbs)
|
||||
|
||||
def test_iteration(self):
|
||||
|
||||
@ -227,7 +227,7 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
self.connection.drop_database('pymongo_test')
|
||||
|
||||
collection = self.db.create_collection('test')
|
||||
self.assert_(isinstance(collection, Collection))
|
||||
self.assertTrue(isinstance(collection, Collection))
|
||||
|
||||
self.assertRaises(CollectionInvalid, self.db.create_collection, 'test')
|
||||
|
||||
@ -252,7 +252,7 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
count += 1
|
||||
except:
|
||||
count += 1
|
||||
self.assert_(count)
|
||||
self.assertTrue(count)
|
||||
|
||||
# NOTE this test is non-deterministic, but hopefully we pause long enough
|
||||
# for the slaves to pull...
|
||||
@ -376,10 +376,10 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
self.assertTrue(bool(cursor._Cursor__read_preference))
|
||||
|
||||
coll.insert({'foo': 'bar'})
|
||||
self.assertEquals(1, coll.find({'foo': 'bar'}).count())
|
||||
self.assert_(coll.find({'foo': 'bar'}))
|
||||
self.assertEqual(1, coll.find({'foo': 'bar'}).count())
|
||||
self.assertTrue(coll.find({'foo': 'bar'}))
|
||||
coll.remove({'foo': 'bar'})
|
||||
self.assertEquals(0, coll.find({'foo': 'bar'}).count())
|
||||
self.assertEqual(0, coll.find({'foo': 'bar'}).count())
|
||||
|
||||
# Set self.connection back to defaults
|
||||
c.safe = False
|
||||
@ -396,46 +396,46 @@ class TestMasterSlaveConnection(unittest.TestCase):
|
||||
time.sleep(1)
|
||||
|
||||
self.assertEqual(dict, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), dict))
|
||||
self.assertTrue(isinstance(db.test.find_one(), dict))
|
||||
self.assertFalse(isinstance(db.test.find_one(), SON))
|
||||
|
||||
c.document_class = SON
|
||||
|
||||
self.assertEqual(SON, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), SON))
|
||||
self.assertTrue(isinstance(db.test.find_one(), SON))
|
||||
self.assertFalse(isinstance(db.test.find_one(as_class=dict), SON))
|
||||
|
||||
c = MasterSlaveConnection(self.master, self.slaves, document_class=SON)
|
||||
db = c.pymongo_test
|
||||
|
||||
self.assertEqual(SON, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), SON))
|
||||
self.assertTrue(isinstance(db.test.find_one(), SON))
|
||||
self.assertFalse(isinstance(db.test.find_one(as_class=dict), SON))
|
||||
|
||||
c.document_class = dict
|
||||
|
||||
self.assertEqual(dict, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), dict))
|
||||
self.assertTrue(isinstance(db.test.find_one(), dict))
|
||||
self.assertFalse(isinstance(db.test.find_one(), SON))
|
||||
|
||||
def test_tz_aware(self):
|
||||
dt = datetime.datetime.utcnow()
|
||||
conn = MasterSlaveConnection(self.master, self.slaves)
|
||||
self.assertEquals(False, conn.tz_aware)
|
||||
self.assertEqual(False, conn.tz_aware)
|
||||
db = conn.pymongo_test
|
||||
db.tztest.insert({'dt': dt}, safe=True)
|
||||
time.sleep(0.5)
|
||||
self.assertEqual(None, db.tztest.find_one()['dt'].tzinfo)
|
||||
|
||||
conn = MasterSlaveConnection(self.master, self.slaves, tz_aware=True)
|
||||
self.assertEquals(True, conn.tz_aware)
|
||||
self.assertEqual(True, conn.tz_aware)
|
||||
db = conn.pymongo_test
|
||||
db.tztest.insert({'dt': dt}, safe=True)
|
||||
time.sleep(0.5)
|
||||
self.assertEqual(utc, db.tztest.find_one()['dt'].tzinfo)
|
||||
|
||||
conn = MasterSlaveConnection(self.master, self.slaves, tz_aware=False)
|
||||
self.assertEquals(False, conn.tz_aware)
|
||||
self.assertEqual(False, conn.tz_aware)
|
||||
db = conn.pymongo_test
|
||||
db.tztest.insert({'dt': dt})
|
||||
time.sleep(0.5)
|
||||
|
||||
@ -47,10 +47,10 @@ class TestObjectId(unittest.TestCase):
|
||||
self.assertRaises(InvalidId, ObjectId, "")
|
||||
self.assertRaises(InvalidId, ObjectId, "12345678901")
|
||||
self.assertRaises(InvalidId, ObjectId, "1234567890123")
|
||||
self.assert_(ObjectId())
|
||||
self.assert_(ObjectId("123456789012"))
|
||||
self.assertTrue(ObjectId())
|
||||
self.assertTrue(ObjectId("123456789012"))
|
||||
a = ObjectId()
|
||||
self.assert_(ObjectId(a))
|
||||
self.assertTrue(ObjectId(a))
|
||||
|
||||
def test_unicode(self):
|
||||
a = ObjectId()
|
||||
@ -107,7 +107,7 @@ class TestObjectId(unittest.TestCase):
|
||||
map = {}
|
||||
|
||||
for id in ids:
|
||||
self.assert_(id not in map)
|
||||
self.assertTrue(id not in map)
|
||||
map[id] = True
|
||||
|
||||
def test_generation_time(self):
|
||||
@ -116,7 +116,7 @@ class TestObjectId(unittest.TestCase):
|
||||
|
||||
self.assertEqual(utc, d2.tzinfo)
|
||||
d2 = d2.replace(tzinfo=None)
|
||||
self.assert_(d2 - d1 < datetime.timedelta(seconds=2))
|
||||
self.assertTrue(d2 - d1 < datetime.timedelta(seconds=2))
|
||||
|
||||
def test_from_datetime(self):
|
||||
if 'PyPy 1.8.0' in sys.version:
|
||||
|
||||
@ -60,13 +60,13 @@ class TestPaired(unittest.TestCase):
|
||||
[self.bad, self.bad])
|
||||
|
||||
connection = Connection([self.left, self.right])
|
||||
self.assert_(connection)
|
||||
self.assertTrue(connection)
|
||||
|
||||
host = connection.host
|
||||
port = connection.port
|
||||
|
||||
connection = Connection([self.right, self.left])
|
||||
self.assert_(connection)
|
||||
self.assertTrue(connection)
|
||||
self.assertEqual(host, connection.host)
|
||||
self.assertEqual(port, connection.port)
|
||||
|
||||
@ -103,7 +103,7 @@ class TestPaired(unittest.TestCase):
|
||||
for _ in range(100):
|
||||
db.test.remove({})
|
||||
db.test.insert({})
|
||||
self.assert_(db.test.find_one())
|
||||
self.assertTrue(db.test.find_one())
|
||||
connection.end_request()
|
||||
|
||||
|
||||
|
||||
@ -215,7 +215,7 @@ class TestPooling(unittest.TestCase):
|
||||
)
|
||||
|
||||
def assert_request_with_socket(self):
|
||||
self.assert_(isinstance(
|
||||
self.assertTrue(isinstance(
|
||||
self.c._Connection__pool._get_request_state(), SocketInfo
|
||||
))
|
||||
|
||||
@ -321,7 +321,7 @@ class TestPooling(unittest.TestCase):
|
||||
t = OneOp(self.c)
|
||||
t.start()
|
||||
t.join()
|
||||
self.assert_(t.passed, "OneOp.run() threw exception")
|
||||
self.assertTrue(t.passed, "OneOp.run() threw exception")
|
||||
|
||||
self.assert_pool_size(1)
|
||||
self.c.test.test.find_one()
|
||||
@ -408,9 +408,9 @@ class TestPooling(unittest.TestCase):
|
||||
|
||||
b_sock = cp1.recv()
|
||||
c_sock = cp2.recv()
|
||||
self.assert_(a_sock.sock.getsockname() != b_sock)
|
||||
self.assert_(a_sock.sock.getsockname() != c_sock)
|
||||
self.assert_(b_sock != c_sock)
|
||||
self.assertTrue(a_sock.sock.getsockname() != b_sock)
|
||||
self.assertTrue(a_sock.sock.getsockname() != c_sock)
|
||||
self.assertTrue(b_sock != c_sock)
|
||||
self.assertEqual(a_sock,
|
||||
a._Connection__pool.get_socket((a.host, a.port)))
|
||||
|
||||
@ -580,7 +580,7 @@ class TestPooling(unittest.TestCase):
|
||||
t.join()
|
||||
|
||||
for t in threads:
|
||||
self.assert_(t.passed)
|
||||
self.assertTrue(t.passed)
|
||||
|
||||
# Critical: release refs to threads, so SocketInfo.__del__() executes
|
||||
del threads
|
||||
@ -591,7 +591,7 @@ class TestPooling(unittest.TestCase):
|
||||
|
||||
# There's a race condition, so be lenient
|
||||
nsock = len(cx_pool.sockets)
|
||||
self.assert_(
|
||||
self.assertTrue(
|
||||
abs(4 - nsock) < 4,
|
||||
"Expected about 4 sockets in the pool, got %d" % nsock
|
||||
)
|
||||
|
||||
@ -30,7 +30,7 @@ class TestPyMongo(unittest.TestCase):
|
||||
|
||||
def test_connection_alias(self):
|
||||
c = pymongo.Connection(self.host, self.port)
|
||||
self.assert_(c)
|
||||
self.assertTrue(c)
|
||||
self.assertEqual(c.host, self.host)
|
||||
self.assertEqual(c.port, self.port)
|
||||
|
||||
|
||||
@ -98,7 +98,7 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
connectTimeoutMS=600)
|
||||
self.assertRaises(ConfigurationError, ReplicaSetConnection,
|
||||
pair, replicaSet='fdlksjfdslkjfd')
|
||||
self.assert_(ReplicaSetConnection(pair, replicaSet=self.name))
|
||||
self.assertTrue(ReplicaSetConnection(pair, replicaSet=self.name))
|
||||
|
||||
def test_repr(self):
|
||||
connection = self._get_connection()
|
||||
@ -155,7 +155,7 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
self.assertRaises(InvalidName, make_db, connection, "te/t")
|
||||
self.assertRaises(InvalidName, make_db, connection, "te st")
|
||||
|
||||
self.assert_(isinstance(connection.test, Database))
|
||||
self.assertTrue(isinstance(connection.test, Database))
|
||||
self.assertEqual(connection.test, connection["test"])
|
||||
self.assertEqual(connection.test, Database(connection, "test"))
|
||||
connection.close()
|
||||
@ -220,8 +220,8 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
connection.pymongo_test_mike.test.save({"dummy": u"object"})
|
||||
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assert_("pymongo_test_mike" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test_mike" in dbs)
|
||||
connection.close()
|
||||
|
||||
def test_drop_database(self):
|
||||
@ -232,22 +232,22 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
|
||||
connection.pymongo_test.test.save({"dummy": u"object"})
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
connection.drop_database("pymongo_test")
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" not in dbs)
|
||||
self.assertTrue("pymongo_test" not in dbs)
|
||||
|
||||
connection.pymongo_test.test.save({"dummy": u"object"})
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
connection.drop_database(connection.pymongo_test)
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" not in dbs)
|
||||
self.assertTrue("pymongo_test" not in dbs)
|
||||
connection.close()
|
||||
|
||||
def test_copy_db(self):
|
||||
c = self._get_connection()
|
||||
self.assert_(c.in_request())
|
||||
self.assertTrue(c.in_request())
|
||||
|
||||
self.assertRaises(TypeError, c.copy_database, 4, "foo")
|
||||
self.assertRaises(TypeError, c.copy_database, "foo", 4)
|
||||
@ -265,9 +265,9 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
|
||||
c.copy_database("pymongo_test", "pymongo_test1")
|
||||
# copy_database() didn't accidentally end the request
|
||||
self.assert_(c.in_request())
|
||||
self.assertTrue(c.in_request())
|
||||
|
||||
self.assert_("pymongo_test1" in c.database_names())
|
||||
self.assertTrue("pymongo_test1" in c.database_names())
|
||||
self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
|
||||
|
||||
c.end_request()
|
||||
@ -279,7 +279,7 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
|
||||
time.sleep(1)
|
||||
|
||||
self.assert_("pymongo_test2" in c.database_names())
|
||||
self.assertTrue("pymongo_test2" in c.database_names())
|
||||
self.assertEqual("bar", c.pymongo_test2.test.find_one()["foo"])
|
||||
|
||||
if version.at_least(c, (1, 3, 3, 1)):
|
||||
@ -299,7 +299,7 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
|
||||
c.copy_database("pymongo_test", "pymongo_test1",
|
||||
username="mike", password="password")
|
||||
self.assert_("pymongo_test1" in c.database_names())
|
||||
self.assertTrue("pymongo_test1" in c.database_names())
|
||||
time.sleep(2)
|
||||
self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
|
||||
c.close()
|
||||
@ -421,13 +421,13 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
db.test.insert({"x": 1})
|
||||
|
||||
self.assertEqual(dict, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), dict))
|
||||
self.assertTrue(isinstance(db.test.find_one(), dict))
|
||||
self.assertFalse(isinstance(db.test.find_one(), SON))
|
||||
|
||||
c.document_class = SON
|
||||
|
||||
self.assertEqual(SON, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), SON))
|
||||
self.assertTrue(isinstance(db.test.find_one(), SON))
|
||||
self.assertFalse(isinstance(db.test.find_one(as_class=dict), SON))
|
||||
c.close()
|
||||
|
||||
@ -435,13 +435,13 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
db = c.pymongo_test
|
||||
|
||||
self.assertEqual(SON, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), SON))
|
||||
self.assertTrue(isinstance(db.test.find_one(), SON))
|
||||
self.assertFalse(isinstance(db.test.find_one(as_class=dict), SON))
|
||||
|
||||
c.document_class = dict
|
||||
|
||||
self.assertEqual(dict, c.document_class)
|
||||
self.assert_(isinstance(db.test.find_one(), dict))
|
||||
self.assertTrue(isinstance(db.test.find_one(), dict))
|
||||
self.assertFalse(isinstance(db.test.find_one(), SON))
|
||||
c.close()
|
||||
|
||||
@ -512,8 +512,8 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
connection.pymongo_test_bernie.test.save({"dummy": u"object"})
|
||||
|
||||
dbs = connection.database_names()
|
||||
self.assert_("pymongo_test" in dbs)
|
||||
self.assert_("pymongo_test_bernie" in dbs)
|
||||
self.assertTrue("pymongo_test" in dbs)
|
||||
self.assertTrue("pymongo_test_bernie" in dbs)
|
||||
connection.close()
|
||||
|
||||
def test_kill_cursors_explicit(self):
|
||||
@ -611,7 +611,7 @@ class TestConnection(TestConnectionReplicaSetBase):
|
||||
|
||||
# Can't use self.assertRaises() because it doesn't catch system
|
||||
# exceptions
|
||||
self.assert_(raised, "Didn't raise expected ConnectionFailure")
|
||||
self.assertTrue(raised, "Didn't raise expected ConnectionFailure")
|
||||
|
||||
# Raises AssertionError due to PYTHON-294 -- Mongo's response to the
|
||||
# previous find() is still waiting to be read on the socket, so the
|
||||
|
||||
@ -61,8 +61,8 @@ class TestSON(unittest.TestCase):
|
||||
|
||||
for protocol in [0, 1, 2, -1]:
|
||||
pickled = pickle.loads(pickle.dumps(complex_son, protocol=protocol))
|
||||
self.assertEquals(pickled['son'], pickled['list'][0])
|
||||
self.assertEquals(pickled['son'], pickled['list'][1])
|
||||
self.assertEqual(pickled['son'], pickled['list'][0])
|
||||
self.assertEqual(pickled['son'], pickled['list'][1])
|
||||
|
||||
def test_pickle_backwards_compatability(self):
|
||||
|
||||
|
||||
@ -78,10 +78,10 @@ class TestSONManipulator(unittest.TestCase):
|
||||
break
|
||||
return son_in == son
|
||||
|
||||
self.assert_(incoming_moves_id({}))
|
||||
self.assert_(incoming_moves_id({"_id": 12}))
|
||||
self.assert_(incoming_moves_id({"hello": "world", "_id": 12}))
|
||||
self.assert_(incoming_moves_id(SON([("hello", "world"),
|
||||
self.assertTrue(incoming_moves_id({}))
|
||||
self.assertTrue(incoming_moves_id({"_id": 12}))
|
||||
self.assertTrue(incoming_moves_id({"hello": "world", "_id": 12}))
|
||||
self.assertTrue(incoming_moves_id(SON([("hello", "world"),
|
||||
("_id", 12)])))
|
||||
|
||||
def outgoing_is_identity(son):
|
||||
|
||||
@ -71,7 +71,7 @@ class TestSSL(unittest.TestCase):
|
||||
ssl=True)
|
||||
|
||||
db = conn.pymongo_ssl_test
|
||||
self.assert_(db.test.insert({'ssl': True}, safe=True))
|
||||
self.assertTrue(db.test.insert({'ssl': True}, safe=True))
|
||||
self.assertTrue(db.test.find_one()['ssl'])
|
||||
conn.drop_database(db)
|
||||
|
||||
|
||||
@ -34,7 +34,7 @@ class TestTimestamp(unittest.TestCase):
|
||||
t = Timestamp(123, 456)
|
||||
self.assertEqual(t.time, 123)
|
||||
self.assertEqual(t.inc, 456)
|
||||
self.assert_(isinstance(t, Timestamp))
|
||||
self.assertTrue(isinstance(t, Timestamp))
|
||||
|
||||
def test_datetime(self):
|
||||
d = datetime.datetime(2010, 5, 5, tzinfo=utc)
|
||||
@ -62,7 +62,7 @@ class TestTimestamp(unittest.TestCase):
|
||||
self.assertRaises(TypeError, Timestamp, 123, 1.2)
|
||||
self.assertRaises(ValueError, Timestamp, 0, -1)
|
||||
self.assertRaises(ValueError, Timestamp, -1, 0)
|
||||
self.assert_(Timestamp(0, 0))
|
||||
self.assertTrue(Timestamp(0, 0))
|
||||
|
||||
def test_equality(self):
|
||||
t = Timestamp(1, 1)
|
||||
|
||||
@ -48,7 +48,7 @@ class TestURI(unittest.TestCase):
|
||||
self.assertRaises(InvalidURI, parse_userinfo,
|
||||
'fo::o:p@ssword')
|
||||
self.assertRaises(InvalidURI, parse_userinfo, ':')
|
||||
self.assert_(parse_userinfo('user:password'))
|
||||
self.assertTrue(parse_userinfo('user:password'))
|
||||
self.assertEqual(('us:r', 'p@ssword'),
|
||||
parse_userinfo('us%3Ar:p%40ssword'))
|
||||
self.assertEqual(('us er', 'p ssword'),
|
||||
@ -84,20 +84,20 @@ class TestURI(unittest.TestCase):
|
||||
self.assertRaises(ConfigurationError, split_options, 'socketTimeoutMS=0.0')
|
||||
self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=foo')
|
||||
self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=0.0')
|
||||
self.assert_(split_options('socketTimeoutMS=300'))
|
||||
self.assert_(split_options('connectTimeoutMS=300'))
|
||||
self.assertEquals({'sockettimeoutms': 0.3}, split_options('socketTimeoutMS=300'))
|
||||
self.assertEquals({'sockettimeoutms': 0.0001}, split_options('socketTimeoutMS=0.1'))
|
||||
self.assertEquals({'connecttimeoutms': 0.3}, split_options('connectTimeoutMS=300'))
|
||||
self.assertEquals({'connecttimeoutms': 0.0001}, split_options('connectTimeoutMS=0.1'))
|
||||
self.assert_(split_options('connectTimeoutMS=300'))
|
||||
self.assertTrue(split_options('socketTimeoutMS=300'))
|
||||
self.assertTrue(split_options('connectTimeoutMS=300'))
|
||||
self.assertEqual({'sockettimeoutms': 0.3}, split_options('socketTimeoutMS=300'))
|
||||
self.assertEqual({'sockettimeoutms': 0.0001}, split_options('socketTimeoutMS=0.1'))
|
||||
self.assertEqual({'connecttimeoutms': 0.3}, split_options('connectTimeoutMS=300'))
|
||||
self.assertEqual({'connecttimeoutms': 0.0001}, split_options('connectTimeoutMS=0.1'))
|
||||
self.assertTrue(split_options('connectTimeoutMS=300'))
|
||||
self.assertTrue(isinstance(split_options('w=5')['w'], int))
|
||||
self.assertTrue(isinstance(split_options('w=5.5')['w'], basestring))
|
||||
self.assert_(split_options('w=foo'))
|
||||
self.assert_(split_options('w=majority'))
|
||||
self.assertTrue(split_options('w=foo'))
|
||||
self.assertTrue(split_options('w=majority'))
|
||||
self.assertRaises(ConfigurationError, split_options, 'wtimeoutms=foo')
|
||||
self.assertRaises(ConfigurationError, split_options, 'wtimeoutms=5.5')
|
||||
self.assert_(split_options('wtimeoutms=500'))
|
||||
self.assertTrue(split_options('wtimeoutms=500'))
|
||||
self.assertRaises(ConfigurationError, split_options, 'fsync=foo')
|
||||
self.assertRaises(ConfigurationError, split_options, 'fsync=5.5')
|
||||
self.assertEqual({'fsync': True}, split_options('fsync=true'))
|
||||
|
||||
Loading…
Reference in New Issue
Block a user