diff --git a/test/test_binary.py b/test/test_binary.py index 92ff34ee2..653850f23 100644 --- a/test/test_binary.py +++ b/test/test_binary.py @@ -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") diff --git a/test/test_bson.py b/test/test_bson.py index 8b67b8412..060b4864c 100644 --- a/test/test_bson.py +++ b/test/test_bson.py @@ -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. diff --git a/test/test_code.py b/test/test_code.py index 84fa199fa..13678ca6d 100644 --- a/test/test_code.py +++ b/test/test_code.py @@ -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 diff --git a/test/test_collection.py b/test/test_collection.py index 446fdda84..ecee4ae63 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -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"]) diff --git a/test/test_common.py b/test/test_common.py index 68abffc0b..db5eeb123 100644 --- a/test/test_common.py +++ b/test/test_common.py @@ -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() diff --git a/test/test_connection.py b/test/test_connection.py index bf16fdfc5..a5d87cb42 100644 --- a/test/test_connection.py +++ b/test/test_connection.py @@ -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 diff --git a/test/test_cursor.py b/test/test_cursor.py index 5853f45d1..0b01ca396 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -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()) diff --git a/test/test_database.py b/test/test_database.py index aacb84846..d6f87ad47 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -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__": diff --git a/test/test_dbref.py b/test/test_dbref.py index 203c059d2..c1aa9da92 100644 --- a/test/test_dbref.py +++ b/test/test_dbref.py @@ -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)) diff --git a/test/test_grid_file.py b/test/test_grid_file.py index a6797d4b9..00e829abf 100644 --- a/test/test_grid_file.py +++ b/test/test_grid_file.py @@ -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" diff --git a/test/test_gridfs.py b/test/test_gridfs.py index d12e3747e..80fe7b10e 100644 --- a/test/test_gridfs.py +++ b/test/test_gridfs.py @@ -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})) diff --git a/test/test_master_slave_connection.py b/test/test_master_slave_connection.py index 3340b9355..1af78b31d 100644 --- a/test/test_master_slave_connection.py +++ b/test/test_master_slave_connection.py @@ -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) diff --git a/test/test_objectid.py b/test/test_objectid.py index dea6b6336..900368d09 100644 --- a/test/test_objectid.py +++ b/test/test_objectid.py @@ -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: diff --git a/test/test_paired.py b/test/test_paired.py index 4a3ef1a8c..d5a1fa6b1 100644 --- a/test/test_paired.py +++ b/test/test_paired.py @@ -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() diff --git a/test/test_pooling.py b/test/test_pooling.py index c7f0815bc..857f5e5be 100644 --- a/test/test_pooling.py +++ b/test/test_pooling.py @@ -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 ) diff --git a/test/test_pymongo.py b/test/test_pymongo.py index 143127950..964ed07c6 100644 --- a/test/test_pymongo.py +++ b/test/test_pymongo.py @@ -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) diff --git a/test/test_replica_set_connection.py b/test/test_replica_set_connection.py index fae1c4198..4116c30e7 100644 --- a/test/test_replica_set_connection.py +++ b/test/test_replica_set_connection.py @@ -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 diff --git a/test/test_son.py b/test/test_son.py index 4d3ffaa5e..aec305538 100644 --- a/test/test_son.py +++ b/test/test_son.py @@ -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): diff --git a/test/test_son_manipulator.py b/test/test_son_manipulator.py index 889e2515b..8fa14c189 100644 --- a/test/test_son_manipulator.py +++ b/test/test_son_manipulator.py @@ -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): diff --git a/test/test_ssl.py b/test/test_ssl.py index 4053bf0cd..ebee3d7f1 100644 --- a/test/test_ssl.py +++ b/test/test_ssl.py @@ -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) diff --git a/test/test_timestamp.py b/test/test_timestamp.py index 81e8a7140..18482b60d 100644 --- a/test/test_timestamp.py +++ b/test/test_timestamp.py @@ -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) diff --git a/test/test_uri_parser.py b/test/test_uri_parser.py index 16f36a87e..4ff207fea 100644 --- a/test/test_uri_parser.py +++ b/test/test_uri_parser.py @@ -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'))