"""Test Collection features on a client that does not connect.

@classmethod

def setUpClass(cls):

cls.db = MongoClient(connect=False).pymongo_test

def test_collection(self):

self.assertRaises(TypeError, Collection, self.db, 5)

def make_col(base, name):

return base[name]

self.assertRaises(InvalidName, make_col, self.db, "")

self.assertRaises(InvalidName, make_col, self.db, "te$t")

self.assertRaises(InvalidName, make_col, self.db, ".test")

self.assertRaises(InvalidName, make_col, self.db, "test.")

self.assertRaises(InvalidName, make_col, self.db, "tes..t")

self.assertRaises(InvalidName, make_col, self.db.test, "")

self.assertRaises(InvalidName, make_col, self.db.test, "te$t")

self.assertRaises(InvalidName, make_col, self.db.test, ".test")

self.assertRaises(InvalidName, make_col, self.db.test, "test.")

self.assertRaises(InvalidName, make_col, self.db.test, "tes..t")

self.assertRaises(InvalidName, make_col, self.db.test, "tes\x00t")

def test_getattr(self):

coll = self.db.test

self.assertTrue(isinstance(coll['_does_not_exist'], Collection))

with self.assertRaises(AttributeError) as context:

coll._does_not_exist

# Message should be:

# "AttributeError: Collection has no attribute '_does_not_exist'. To

# access the test._does_not_exist collection, use

# database['test._does_not_exist']."

self.assertIn("has no attribute '_does_not_exist'",

str(context.exception))

coll2 = coll.with_options(write_concern=WriteConcern(w=0))

self.assertEqual(coll2.write_concern, WriteConcern(w=0))

self.assertNotEqual(coll.write_concern, coll2.write_concern)

coll3 = coll2.subcoll

self.assertEqual(coll2.write_concern, coll3.write_concern)

coll4 = coll2["subcoll"]

self.assertEqual(coll2.write_concern, coll4.write_concern)

def test_iteration(self):

@classmethod

def setUpClass(cls):

super(TestCollection, cls).setUpClass()

cls.w = client_context.w

@classmethod

def tearDownClass(cls):

cls.db.drop_collection("test_large_limit")

@contextlib.contextmanager

def write_concern_collection(self):

if client_context.version.at_least(3, 3, 9) and client_context.is_rs:

with self.assertRaises(WriteConcernError):

# Unsatisfiable write concern.

yield Collection(

self.db, 'test',

write_concern=WriteConcern(w=len(client_context.nodes) + 1))

else:

yield self.db.test

def test_equality(self):

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"])

self.assertEqual(self.db.test["mike"], self.db["test.mike"])

@client_context.require_version_min(3, 3, 9)

def test_create(self):

# No Exception.

db = client_context.client.pymongo_test

db.create_test_no_wc.drop()

wait_until(

lambda: 'create_test_no_wc' not in db.list_collection_names(),

'drop create_test_no_wc collection')

Collection(db, name='create_test_no_wc', create=True)

wait_until(

lambda: 'create_test_no_wc' in db.list_collection_names(),

'create create_test_no_wc collection')

# SERVER-33317

if (not client_context.is_mongos or not

client_context.version.at_least(3, 7, 0)):

with self.assertRaises(OperationFailure):

Collection(

db, name='create-test-wc',

write_concern=IMPOSSIBLE_WRITE_CONCERN,

create=True)

def test_drop_nonexistent_collection(self):

self.db.drop_collection('test')

self.assertFalse('test' in self.db.list_collection_names())

# No exception

self.db.drop_collection('test')

def test_create_indexes(self):

db = self.db

self.assertRaises(TypeError, db.test.create_indexes, 'foo')

self.assertRaises(TypeError, db.test.create_indexes, ['foo'])

self.assertRaises(TypeError, IndexModel, 5)

self.assertRaises(ValueError, IndexModel, [])

db.test.drop_indexes()

db.test.insert_one({})

self.assertEqual(len(db.test.index_information()), 1)

db.test.create_indexes([IndexModel("hello")])

db.test.create_indexes([IndexModel([("hello", DESCENDING),

("world", ASCENDING)])])

# Tuple instead of list.

db.test.create_indexes([IndexModel((("world", ASCENDING),))])

self.assertEqual(len(db.test.index_information()), 4)

db.test.drop_indexes()

names = db.test.create_indexes([IndexModel([("hello", DESCENDING),

("world", ASCENDING)],

name="hello_world")])

self.assertEqual(names, ["hello_world"])

db.test.drop_indexes()

self.assertEqual(len(db.test.index_information()), 1)

db.test.create_indexes([IndexModel("hello")])

self.assertTrue("hello_1" in db.test.index_information())

db.test.drop_indexes()

self.assertEqual(len(db.test.index_information()), 1)

names = db.test.create_indexes([IndexModel([("hello", DESCENDING),

("world", ASCENDING)]),

IndexModel("hello")])

info = db.test.index_information()

for name in names:

self.assertTrue(name in info)

db.test.drop()

db.test.insert_one({'a': 1})

db.test.insert_one({'a': 1})

self.assertRaises(

DuplicateKeyError,

db.test.create_indexes,

[IndexModel('a', unique=True)])

with self.write_concern_collection() as coll:

coll.create_indexes([IndexModel('hello')])

def test_create_index(self):

db = self.db

self.assertRaises(TypeError, db.test.create_index, 5)

self.assertRaises(TypeError, db.test.create_index, {"hello": 1})

self.assertRaises(ValueError, db.test.create_index, [])

db.test.drop_indexes()

db.test.insert_one({})

self.assertEqual(len(db.test.index_information()), 1)

db.test.create_index("hello")

db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)])

# Tuple instead of list.

db.test.create_index((("world", ASCENDING),))

self.assertEqual(len(db.test.index_information()), 4)

db.test.drop_indexes()

ix = db.test.create_index([("hello", DESCENDING),

("world", ASCENDING)], name="hello_world")

self.assertEqual(ix, "hello_world")

db.test.drop_indexes()

self.assertEqual(len(db.test.index_information()), 1)

db.test.create_index("hello")

self.assertTrue("hello_1" in db.test.index_information())

db.test.drop_indexes()

self.assertEqual(len(db.test.index_information()), 1)

db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)])

self.assertTrue("hello_-1_world_1" in db.test.index_information())

db.test.drop()

db.test.insert_one({'a': 1})

db.test.insert_one({'a': 1})

self.assertRaises(

DuplicateKeyError, db.test.create_index, 'a', unique=True)

with self.write_concern_collection() as coll:

coll.create_index([('hello', DESCENDING)])

def test_drop_index(self):

db = self.db

db.test.drop_indexes()

db.test.create_index("hello")

name = db.test.create_index("goodbye")

self.assertEqual(len(db.test.index_information()), 3)

self.assertEqual(name, "goodbye_1")

db.test.drop_index(name)

# Drop it again.

with self.assertRaises(OperationFailure):

db.test.drop_index(name)

self.assertEqual(len(db.test.index_information()), 2)

self.assertTrue("hello_1" in db.test.index_information())

db.test.drop_indexes()

db.test.create_index("hello")

name = db.test.create_index("goodbye")

self.assertEqual(len(db.test.index_information()), 3)

self.assertEqual(name, "goodbye_1")

db.test.drop_index([("goodbye", ASCENDING)])

self.assertEqual(len(db.test.index_information()), 2)

self.assertTrue("hello_1" in db.test.index_information())

with self.write_concern_collection() as coll:

coll.drop_index('hello_1')

@client_context.require_no_mongos

@client_context.require_test_commands

def test_index_management_max_time_ms(self):

if (client_context.version[:2] == (3, 4) and

client_context.version[2] < 4):

raise unittest.SkipTest("SERVER-27711")

coll = self.db.test

self.client.admin.command("configureFailPoint",

"maxTimeAlwaysTimeOut",

mode="alwaysOn")

try:

self.assertRaises(

ExecutionTimeout, coll.create_index, "foo", maxTimeMS=1)

self.assertRaises(

ExecutionTimeout,

coll.create_indexes,

[IndexModel("foo")],

maxTimeMS=1)

self.assertRaises(

ExecutionTimeout, coll.drop_index, "foo", maxTimeMS=1)

self.assertRaises(

ExecutionTimeout, coll.drop_indexes, maxTimeMS=1)

self.assertRaises(

ExecutionTimeout, coll.reindex, maxTimeMS=1)

finally:

self.client.admin.command("configureFailPoint",

"maxTimeAlwaysTimeOut",

mode="off")

def test_reindex(self):

if not client_context.supports_reindex:

raise unittest.SkipTest(

"reindex is no longer supported by mongos 4.1+")

db = self.db

db.drop_collection("test")

db.test.insert_one({"foo": "bar", "who": "what", "when": "how"})

db.test.create_index("foo")

db.test.create_index("who")

db.test.create_index("when")

info = db.test.index_information()

def check_result(result):

self.assertEqual(4, result['nIndexes'])

indexes = result['indexes']

names = [idx['name'] for idx in indexes]

for name in names:

self.assertTrue(name in info)

for key in info:

self.assertTrue(key in names)

reindexed = db.test.reindex()

if 'raw' in reindexed:

# mongos

for result in itervalues(reindexed['raw']):

check_result(result)

else:

check_result(reindexed)

coll = Collection(

self.db,

'test',

write_concern=WriteConcern(w=100))

# No error since writeConcern is not sent.

coll.reindex()

def test_list_indexes(self):

db = self.db

db.test.drop()

db.test.insert_one({}) # create collection

def map_indexes(indexes):

return dict([(index["name"], index) for index in indexes])

indexes = list(db.test.list_indexes())

self.assertEqual(len(indexes), 1)

self.assertTrue("_id_" in map_indexes(indexes))

db.test.create_index("hello")

indexes = list(db.test.list_indexes())

self.assertEqual(len(indexes), 2)

self.assertEqual(map_indexes(indexes)["hello_1"]["key"],

SON([("hello", ASCENDING)]))

db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)],

unique=True)

indexes = list(db.test.list_indexes())

self.assertEqual(len(indexes), 3)

index_map = map_indexes(indexes)

self.assertEqual(index_map["hello_-1_world_1"]["key"],

SON([("hello", DESCENDING), ("world", ASCENDING)]))

self.assertEqual(True, index_map["hello_-1_world_1"]["unique"])

# List indexes on a collection that does not exist.

indexes = list(db.does_not_exist.list_indexes())

self.assertEqual(len(indexes), 0)

# List indexes on a database that does not exist.

indexes = list(self.client.db_does_not_exist.coll.list_indexes())

self.assertEqual(len(indexes), 0)

def test_index_info(self):

db = self.db

db.test.drop()

db.test.insert_one({}) # create collection

self.assertEqual(len(db.test.index_information()), 1)

self.assertTrue("_id_" in db.test.index_information())

db.test.create_index("hello")

self.assertEqual(len(db.test.index_information()), 2)

self.assertEqual(db.test.index_information()["hello_1"]["key"],

[("hello", ASCENDING)])

db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)],

unique=True)

self.assertEqual(db.test.index_information()["hello_1"]["key"],

[("hello", ASCENDING)])

self.assertEqual(len(db.test.index_information()), 3)

self.assertEqual([("hello", DESCENDING), ("world", ASCENDING)],

db.test.index_information()["hello_-1_world_1"]["key"]

)

self.assertEqual(

True, db.test.index_information()["hello_-1_world_1"]["unique"])

def test_index_geo2d(self):

db = self.db

db.test.drop_indexes()

self.assertEqual('loc_2d', db.test.create_index([("loc", GEO2D)]))

index_info = db.test.index_information()['loc_2d']

self.assertEqual([('loc', '2d')], index_info['key'])

@client_context.require_no_mongos

def test_index_haystack(self):

db = self.db

db.test.drop()

_id = db.test.insert_one({

"pos": {"long": 34.2, "lat": 33.3},

"type": "restaurant"

}).inserted_id

db.test.insert_one({

"pos": {"long": 34.2, "lat": 37.3}, "type": "restaurant"

})

db.test.insert_one({

"pos": {"long": 59.1, "lat": 87.2}, "type": "office"

})

db.test.create_index(

[("pos", GEOHAYSTACK), ("type", ASCENDING)],

bucketSize=1

)

results = db.command(SON([

("geoSearch", "test"),

("near", [33, 33]),

("maxDistance", 6),

("search", {"type": "restaurant"}),

("limit", 30),

]))['results']

self.assertEqual(2, len(results))

self.assertEqual({

"_id": _id,

"pos": {"long": 34.2, "lat": 33.3},

"type": "restaurant"

}, results[0])

@client_context.require_no_mongos

def test_index_text(self):

db = self.db

db.test.drop_indexes()

self.assertEqual("t_text", db.test.create_index([("t", TEXT)]))

index_info = db.test.index_information()["t_text"]

self.assertTrue("weights" in index_info)

db.test.insert_many([

{'t': 'spam eggs and spam'},

{'t': 'spam'},

{'t': 'egg sausage and bacon'}])

# MongoDB 2.6 text search. Create 'score' field in projection.

cursor = db.test.find(

{'$text': {'$search': 'spam'}},

{'score': {'$meta': 'textScore'}})

# Sort by 'score' field.

cursor.sort([('score', {'$meta': 'textScore'})])

results = list(cursor)

self.assertTrue(results[0]['score'] >= results[1]['score'])

db.test.drop_indexes()

def test_index_2dsphere(self):

db = self.db

db.test.drop_indexes()

self.assertEqual("geo_2dsphere",

db.test.create_index([("geo", GEOSPHERE)]))

for dummy, info in db.test.index_information().items():

field, idx_type = info['key'][0]

if field == 'geo' and idx_type == '2dsphere':

break

else:

self.fail("2dsphere index not found.")

poly = {"type": "Polygon",

"coordinates": [[[40, 5], [40, 6], [41, 6], [41, 5], [40, 5]]]}

query = {"geo": {"$within": {"$geometry": poly}}}

# This query will error without a 2dsphere index.

db.test.find(query)

db.test.drop_indexes()

def test_index_hashed(self):

db = self.db

db.test.drop_indexes()

self.assertEqual("a_hashed",

db.test.create_index([("a", HASHED)]))

for dummy, info in db.test.index_information().items():

field, idx_type = info['key'][0]

if field == 'a' and idx_type == 'hashed':

break

else:

self.fail("hashed index not found.")

db.test.drop_indexes()

def test_index_sparse(self):

db = self.db

db.test.drop_indexes()

db.test.create_index([('key', ASCENDING)], sparse=True)

self.assertTrue(db.test.index_information()['key_1']['sparse'])

def test_index_background(self):

db = self.db

db.test.drop_indexes()

db.test.create_index([('keya', ASCENDING)])

db.test.create_index([('keyb', ASCENDING)], background=False)

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.assertTrue(db.test.index_information()['keyc_1']['background'])

def _drop_dups_setup(self, db):

db.drop_collection('test')

db.test.insert_one({'i': 1})

db.test.insert_one({'i': 2})

db.test.insert_one({'i': 2}) # duplicate

db.test.insert_one({'i': 3})

@client_context.require_version_max(2, 6)

def test_index_drop_dups(self):

# Try dropping duplicates

db = self.db

self._drop_dups_setup(db)

# No error, just drop the duplicate

db.test.create_index([('i', ASCENDING)], unique=True, dropDups=True)

# Duplicate was dropped

self.assertEqual(3, db.test.count_documents({}))

# Index was created, plus the index on _id

self.assertEqual(2, len(db.test.index_information()))

def test_index_dont_drop_dups(self):

# Try *not* dropping duplicates

db = self.db

self._drop_dups_setup(db)

# There's a duplicate

def test_create():

db.test.create_index(

[('i', ASCENDING)],

unique=True,

dropDups=False

)

self.assertRaises(DuplicateKeyError, test_create)

# Duplicate wasn't dropped

self.assertEqual(4, db.test.count_documents({}))

# Index wasn't created, only the default index on _id

self.assertEqual(1, len(db.test.index_information()))

# Get the plan dynamically because the explain format will change.

def get_plan_stage(self, root, stage):

if root.get('stage') == stage:

return root

elif "inputStage" in root:

return self.get_plan_stage(root['inputStage'], stage)

elif "inputStages" in root:

for i in root['inputStages']:

stage = self.get_plan_stage(i, stage)

if stage:

return stage

elif "shards" in root:

for i in root['shards']:

stage = self.get_plan_stage(i['winningPlan'], stage)

if stage:

return stage

return {}

@client_context.require_version_min(3, 1, 9, -1)

def test_index_filter(self):

db = self.db

db.drop_collection("test")

# Test bad filter spec on create.

self.assertRaises(OperationFailure, db.test.create_index, "x",

partialFilterExpression=5)

self.assertRaises(OperationFailure, db.test.create_index, "x",

partialFilterExpression={"x": {"$asdasd": 3}})

self.assertRaises(OperationFailure, db.test.create_index, "x",

partialFilterExpression={"$and": 5})

self.assertRaises(OperationFailure, db.test.create_index, "x",

partialFilterExpression={

"$and": [{"$and": [{"x": {"$lt": 2}},

{"x": {"$gt": 0}}]},

{"x": {"$exists": True}}]})

self.assertEqual("x_1", db.test.create_index(

[('x', ASCENDING)], partialFilterExpression={"a": {"$lte": 1.5}}))

db.test.insert_one({"x": 5, "a": 2})

db.test.insert_one({"x": 6, "a": 1})

# Operations that use the partial index.

explain = db.test.find({"x": 6, "a": 1}).explain()

stage = self.get_plan_stage(explain['queryPlanner']['winningPlan'],

'IXSCAN')

self.assertEqual("x_1", stage.get('indexName'))

self.assertTrue(stage.get('isPartial'))

explain = db.test.find({"x": {"$gt": 1}, "a": 1}).explain()

stage = self.get_plan_stage(explain['queryPlanner']['winningPlan'],

'IXSCAN')

self.assertEqual("x_1", stage.get('indexName'))

self.assertTrue(stage.get('isPartial'))

explain = db.test.find({"x": 6, "a": {"$lte": 1}}).explain()

stage = self.get_plan_stage(explain['queryPlanner']['winningPlan'],

'IXSCAN')

self.assertEqual("x_1", stage.get('indexName'))

self.assertTrue(stage.get('isPartial'))

# Operations that do not use the partial index.

explain = db.test.find({"x": 6, "a": {"$lte": 1.6}}).explain()

stage = self.get_plan_stage(explain['queryPlanner']['winningPlan'],

'COLLSCAN')

self.assertNotEqual({}, stage)

explain = db.test.find({"x": 6}).explain()

stage = self.get_plan_stage(explain['queryPlanner']['winningPlan'],

'COLLSCAN')

self.assertNotEqual({}, stage)

# Test drop_indexes.

db.test.drop_index("x_1")

explain = db.test.find({"x": 6, "a": 1}).explain()

stage = self.get_plan_stage(explain['queryPlanner']['winningPlan'],

'COLLSCAN')

self.assertNotEqual({}, stage)

def test_field_selection(self):

db = self.db

db.drop_collection("test")

doc = {"a": 1, "b": 5, "c": {"d": 5, "e": 10}}

db.test.insert_one(doc)

# Test field inclusion

doc = next(db.test.find({}, ["_id"]))

self.assertEqual(list(doc), ["_id"])

doc = next(db.test.find({}, ["a"]))

l = list(doc)

l.sort()

self.assertEqual(l, ["_id", "a"])

doc = next(db.test.find({}, ["b"]))

l = list(doc)

l.sort()

self.assertEqual(l, ["_id", "b"])

doc = next(db.test.find({}, ["c"]))

l = list(doc)

l.sort()

self.assertEqual(l, ["_id", "c"])

doc = next(db.test.find({}, ["a"]))

self.assertEqual(doc["a"], 1)

doc = next(db.test.find({}, ["b"]))

self.assertEqual(doc["b"], 5)

doc = next(db.test.find({}, ["c"]))

self.assertEqual(doc["c"], {"d": 5, "e": 10})

# Test inclusion of fields with dots

doc = next(db.test.find({}, ["c.d"]))

self.assertEqual(doc["c"], {"d": 5})

doc = next(db.test.find({}, ["c.e"]))

self.assertEqual(doc["c"], {"e": 10})

doc = next(db.test.find({}, ["b", "c.e"]))

self.assertEqual(doc["c"], {"e": 10})

doc = next(db.test.find({}, ["b", "c.e"]))

l = list(doc)

l.sort()

self.assertEqual(l, ["_id", "b", "c"])

doc = next(db.test.find({}, ["b", "c.e"]))

self.assertEqual(doc["b"], 5)

# Test field exclusion

doc = next(db.test.find({}, {"a": False, "b": 0}))

l = list(doc)

l.sort()

self.assertEqual(l, ["_id", "c"])

doc = next(db.test.find({}, {"_id": False}))

l = list(doc)

self.assertFalse("_id" in l)

def test_options(self):

db = self.db

db.drop_collection("test")

db.create_collection("test", capped=True, size=4096)

result = db.test.options()

# mongos 2.2.x adds an $auth field when auth is enabled.

result.pop('$auth', None)

self.assertEqual(result, {"capped": True, 'size': 4096})

db.drop_collection("test")

def test_insert_one(self):

db = self.db

db.test.drop()

document = {"_id": 1000}

result = db.test.insert_one(document)

self.assertTrue(isinstance(result, InsertOneResult))

self.assertTrue(isinstance(result.inserted_id, int))

self.assertEqual(document["_id"], result.inserted_id)

self.assertTrue(result.acknowledged)

self.assertIsNotNone(db.test.find_one({"_id": document["_id"]}))

self.assertEqual(1, db.test.count_documents({}))

document = {"foo": "bar"}

result = db.test.insert_one(document)

self.assertTrue(isinstance(result, InsertOneResult))

self.assertTrue(isinstance(result.inserted_id, ObjectId))

self.assertEqual(document["_id"], result.inserted_id)

self.assertTrue(result.acknowledged)

self.assertIsNotNone(db.test.find_one({"_id": document["_id"]}))

self.assertEqual(2, db.test.count_documents({}))

db = db.client.get_database(db.name,

write_concern=WriteConcern(w=0))

result = db.test.insert_one(document)

self.assertTrue(isinstance(result, InsertOneResult))

self.assertTrue(isinstance(result.inserted_id, ObjectId))

self.assertEqual(document["_id"], result.inserted_id)

self.assertFalse(result.acknowledged)

# The insert failed duplicate key...

wait_until(lambda: 2 == db.test.count_documents({}),

'forcing duplicate key error')

document = RawBSONDocument(

bson.BSON.encode({'_id': ObjectId(), 'foo': 'bar'}))

result = db.test.insert_one(document)

self.assertTrue(isinstance(result, InsertOneResult))

self.assertEqual(result.inserted_id, None)

def test_insert_many(self):

db = self.db

db.test.drop()

docs = [{} for _ in range(5)]

result = db.test.insert_many(docs)

self.assertTrue(isinstance(result, InsertManyResult))

self.assertTrue(isinstance(result.inserted_ids, list))

self.assertEqual(5, len(result.inserted_ids))

for doc in docs:

_id = doc["_id"]

self.assertTrue(isinstance(_id, ObjectId))

self.assertTrue(_id in result.inserted_ids)

self.assertEqual(1, db.test.count_documents({'_id': _id}))

self.assertTrue(result.acknowledged)

docs = [{"_id": i} for i in range(5)]

result = db.test.insert_many(docs)

self.assertTrue(isinstance(result, InsertManyResult))

self.assertTrue(isinstance(result.inserted_ids, list))

self.assertEqual(5, len(result.inserted_ids))

for doc in docs:

_id = doc["_id"]

self.assertTrue(isinstance(_id, int))

self.assertTrue(_id in result.inserted_ids)

self.assertEqual(1, db.test.count_documents({"_id": _id}))

self.assertTrue(result.acknowledged)

docs = [RawBSONDocument(bson.BSON.encode({"_id": i + 5}))

for i in range(5)]

result = db.test.insert_many(docs)

self.assertTrue(isinstance(result, InsertManyResult))

self.assertTrue(isinstance(result.inserted_ids, list))

self.assertEqual([], result.inserted_ids)

db = db.client.get_database(db.name,

write_concern=WriteConcern(w=0))

docs = [{} for _ in range(5)]

result = db.test.insert_many(docs)

self.assertTrue(isinstance(result, InsertManyResult))

self.assertFalse(result.acknowledged)

self.assertEqual(20, db.test.count_documents({}))

def test_delete_one(self):

self.db.test.drop()

self.db.test.insert_one({"x": 1})

self.db.test.insert_one({"y": 1})

self.db.test.insert_one({"z": 1})

result = self.db.test.delete_one({"x": 1})

self.assertTrue(isinstance(result, DeleteResult))

self.assertEqual(1, result.deleted_count)

self.assertTrue(result.acknowledged)

self.assertEqual(2, self.db.test.count_documents({}))

result = self.db.test.delete_one({"y": 1})

self.assertTrue(isinstance(result, DeleteResult))

self.assertEqual(1, result.deleted_count)

self.assertTrue(result.acknowledged)

self.assertEqual(1, self.db.test.count_documents({}))

db = self.db.client.get_database(self.db.name,

write_concern=WriteConcern(w=0))

result = db.test.delete_one({"z": 1})

self.assertTrue(isinstance(result, DeleteResult))

self.assertRaises(InvalidOperation, lambda: result.deleted_count)

self.assertFalse(result.acknowledged)

wait_until(lambda: 0 == db.test.count_documents({}), 'delete 1 documents')

def test_delete_many(self):

self.db.test.drop()

self.db.test.insert_one({"x": 1})

self.db.test.insert_one({"x": 1})

self.db.test.insert_one({"y": 1})

self.db.test.insert_one({"y": 1})

result = self.db.test.delete_many({"x": 1})

self.assertTrue(isinstance(result, DeleteResult))

self.assertEqual(2, result.deleted_count)

self.assertTrue(result.acknowledged)

self.assertEqual(0, self.db.test.count_documents({"x": 1}))

db = self.db.client.get_database(self.db.name,

write_concern=WriteConcern(w=0))

result = db.test.delete_many({"y": 1})

self.assertTrue(isinstance(result, DeleteResult))

self.assertRaises(InvalidOperation, lambda: result.deleted_count)

self.assertFalse(result.acknowledged)

wait_until(

lambda: 0 == db.test.count_documents({}), 'delete 2 documents')

def test_command_document_too_large(self):

large = '*' * (self.client.max_bson_size + _COMMAND_OVERHEAD)

coll = self.db.test

self.assertRaises(

DocumentTooLarge, coll.insert_one, {'data': large})

# update_one and update_many are the same

self.assertRaises(

DocumentTooLarge, coll.replace_one, {}, {'data': large})

self.assertRaises(

DocumentTooLarge, coll.delete_one, {'data': large})

@client_context.require_version_min(3, 1, 9, -1)

def test_insert_bypass_document_validation(self):

db = self.db

db.test.drop()

db.create_collection("test", validator={"a": {"$exists": True}})

db_w0 = self.db.client.get_database(

self.db.name, write_concern=WriteConcern(w=0))

# Test insert_one

self.assertRaises(OperationFailure, db.test.insert_one,

{"_id": 1, "x": 100})

result = db.test.insert_one({"_id": 1, "x": 100},

bypass_document_validation=True)

self.assertTrue(isinstance(result, InsertOneResult))

self.assertEqual(1, result.inserted_id)

result = db.test.insert_one({"_id":2, "a":0})

self.assertTrue(isinstance(result, InsertOneResult))

self.assertEqual(2, result.inserted_id)

if client_context.version < (3, 6):

# Uses OP_INSERT which does not support bypass_document_validation.

self.assertRaises(OperationFailure, db_w0.test.insert_one,

{"y": 1}, bypass_document_validation=True)

else:

db_w0.test.insert_one({"y": 1}, bypass_document_validation=True)

wait_until(lambda: db_w0.test.find_one({"y": 1}),

"find w:0 inserted document")

# Test insert_many

docs = [{"_id": i, "x": 100 - i} for i in range(3, 100)]

self.assertRaises(OperationFailure, db.test.insert_many, docs)

result = db.test.insert_many(docs, bypass_document_validation=True)

self.assertTrue(isinstance(result, InsertManyResult))

self.assertTrue(97, len(result.inserted_ids))

for doc in docs:

_id = doc["_id"]

self.assertTrue(isinstance(_id, int))

self.assertTrue(_id in result.inserted_ids)

self.assertEqual(1, db.test.count_documents({"x": doc["x"]}))

self.assertTrue(result.acknowledged)

docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)]

result = db.test.insert_many(docs)

self.assertTrue(isinstance(result, InsertManyResult))

self.assertTrue(97, len(result.inserted_ids))

for doc in docs:

_id = doc["_id"]

self.assertTrue(isinstance(_id, int))

self.assertTrue(_id in result.inserted_ids)

self.assertEqual(1, db.test.count_documents({"a": doc["a"]}))

self.assertTrue(result.acknowledged)

self.assertRaises(OperationFailure, db_w0.test.insert_many,

[{"x": 1}, {"x": 2}],

bypass_document_validation=True)

@client_context.require_version_min(3, 1, 9, -1)

def test_replace_bypass_document_validation(self):

db = self.db

db.test.drop()

db.create_collection("test", validator={"a": {"$exists": True}})

db_w0 = self.db.client.get_database(

self.db.name, write_concern=WriteConcern(w=0))

# Test replace_one

db.test.insert_one({"a": 101})

self.assertRaises(OperationFailure, db.test.replace_one,

{"a": 101}, {"y": 1})

self.assertEqual(0, db.test.count_documents({"y": 1}))

self.assertEqual(1, db.test.count_documents({"a": 101}))

db.test.replace_one({"a": 101}, {"y": 1},

bypass_document_validation=True)

self.assertEqual(0, db.test.count_documents({"a": 101}))

self.assertEqual(1, db.test.count_documents({"y": 1}))

db.test.replace_one({"y": 1}, {"a": 102})

self.assertEqual(0, db.test.count_documents({"y": 1}))

self.assertEqual(0, db.test.count_documents({"a": 101}))

self.assertEqual(1, db.test.count_documents({"a": 102}))

db.test.insert_one({"y": 1}, bypass_document_validation=True)

self.assertRaises(OperationFailure, db.test.replace_one,

{"y": 1}, {"x": 101})

self.assertEqual(0, db.test.count_documents({"x": 101}))

self.assertEqual(1, db.test.count_documents({"y": 1}))

db.test.replace_one({"y": 1}, {"x": 101},

bypass_document_validation=True)

self.assertEqual(0, db.test.count_documents({"y": 1}))