def test_index_info(self): db = self.db yield db.test.drop_indexes() yield db.test.remove({}) db.test.save({}) # create collection ix_info = yield db.test.index_information() self.assertEqual(len(ix_info), 1) self.assertEqual(ix_info["_id_"]["name"], "_id_") yield db.test.create_index(qf.sort(qf.ASCENDING("hello"))) ix_info = yield db.test.index_information() self.assertEqual(len(ix_info), 2) self.assertEqual(ix_info["hello_1"]["name"], "hello_1") yield db.test.create_index( qf.sort(qf.DESCENDING("hello") + qf.ASCENDING("world")), unique=True, sparse=True) ix_info = yield db.test.index_information() self.assertEqual(ix_info["hello_1"]["name"], "hello_1") self.assertEqual(len(ix_info), 3) self.assertEqual({ "hello": -1, "world": 1 }, ix_info["hello_-1_world_1"]["key"]) self.assertEqual(True, ix_info["hello_-1_world_1"]["unique"]) self.assertEqual(True, ix_info["hello_-1_world_1"]["sparse"]) yield db.test.drop_indexes() yield db.test.remove({})
def example(): mongo = yield txmongo.MongoConnection() foo = mongo.foo # `foo` database test = foo.test # `test` collection idx = filter.sort(filter.ASCENDING("something") + filter.DESCENDING("else")) print "IDX:", idx result = yield test.create_index(idx) print "create_index:", result result = yield test.index_information() print "index_information:", result result = yield test.drop_index(idx) print "drop_index:", result # Geohaystack example geoh_idx = filter.sort(filter.GEOHAYSTACK("loc") + filter.ASCENDING("type")) print "IDX:", geoh_idx result = yield test.create_index(geoh_idx, **{'bucketSize':1}) print "index_information:", result result = yield test.drop_index(geoh_idx) print "drop_index:", result # 2D geospatial index geo_idx = filter.sort(filter.GEO2D("pos")) print "IDX:", geo_idx result = yield test.create_index(geo_idx, **{ 'min':-100, 'max':100 }) print "index_information:", result result = yield test.drop_index(geo_idx) print "drop_index:", result
def test_index_info(self): db = self.db yield db.test.drop_indexes() yield db.test.remove({}) db.test.save({}) # create collection ix_info = yield db.test.index_information() self.assertEqual(len(ix_info), 1) self.assert_("_id_" in ix_info) yield db.test.create_index(filter.sort(filter.ASCENDING("hello"))) ix_info = yield db.test.index_information() self.assertEqual(len(ix_info), 2) self.assertEqual(ix_info["hello_1"], [("hello", 1)]) yield db.test.create_index(filter.sort( filter.DESCENDING("hello") + filter.ASCENDING("world")), unique=True) ix_info = yield db.test.index_information() self.assertEqual(ix_info["hello_1"], [("hello", 1)]) self.assertEqual(len(ix_info), 3) self.assertEqual([("world", 1), ("hello", -1)], ix_info["hello_-1_world_1"]) # Unique key will not show until index_information is updated with changes introduced in version 1.7 #self.assertEqual(True, ix_info["hello_-1_world_1"]["unique"]) yield db.test.drop_indexes() yield db.test.remove({})
def test_hint(self): yield self.coll.create_index(qf.sort(qf.ASCENDING('x'))) yield self.db.command("profile", 2) cnt = yield self.coll.count(hint=qf.hint(qf.ASCENDING('x'))) self.assertEqual(cnt, 3) yield self.db.command("profile", 0) cmds = yield self.db.system.profile.count({"command.hint": {"x": 1}}) self.assertEqual(cmds, 1) self.assertRaises(TypeError, self.coll.count, hint={'x': 1}) self.assertRaises(TypeError, self.coll.count, hint=[('x', 1)])
def process_message(self, msg): headers = 'headers' in msg.content.properties and \ msg.content.properties['headers'] or None data = msg.content.body log.msg('RECEIVED MSG: {}'.format(str(headers))) log.msg(data) part = {} for key, value in self.run(data, headers): ap = part.get(key, None) if ap is None: ap = [] part[key] = ap ap.append((key, value)) data = dict(**headers) data['result'] = json.dumps(part) yield self.results.insert(SON(data)) # TODO: I think this is not right place for this code. @german idx = filter.sort(filter.ASCENDING("task")) self.results.ensure_index(idx) headers['worker'] = 'map' self.publisher.sendMessage('OK', routing_key=ns.MASTER_QUEUE, headers=headers) returnValue(msg)
def test_create_index_nodup(self): coll = self.coll yield coll.insert({'b': 1}) yield coll.insert({'b': 1}) ix = coll.create_index(qf.sort(qf.ASCENDING("b")), unique=True) yield self.assertFailure(ix, errors.DuplicateKeyError)
def test_Failures(self): # can't alter _id yield self.assertFailure(self.coll.update_many({}, {"$set": {"_id": 1}}), WriteError) # invalid field name yield self.assertFailure(self.coll.update_many({}, {"$set": {'$': 1}}), WriteError) yield self.coll.create_index(qf.sort(qf.ASCENDING('x')), unique=True) yield self.assertFailure(self.coll.update_many({'x': 2}, {"$set": {'x': 1}}), DuplicateKeyError)
def test_ensure_index(self): db = self.db coll = self.coll yield coll.ensure_index(qf.sort(qf.ASCENDING("hello"))) indices = yield db.system.indexes.find({"ns": u"mydb.mycol"}) self.assert_(u"hello_1" in [a["name"] for a in indices]) yield coll.drop_indexes()
def test_Failures(self): yield self.assertFailure( self.coll.replace_one({'x': 1}, {'x': { '$': 5 }}), WriteError) yield self.coll.create_index(qf.sort(qf.ASCENDING('x')), unique=True) yield self.assertFailure(self.coll.replace_one({'x': 1}, {'x': 2}), DuplicateKeyError)
def test_ensure_index(self): db = self.db coll = self.coll yield coll.ensure_index(qf.sort(qf.ASCENDING("hello"))) indices = yield coll.index_information() self.assert_(u"hello_1" in indices) yield coll.drop_indexes()
def test_FilterMerge(self): self.assertEqual( qf.sort(qf.ASCENDING('x') + qf.DESCENDING('y')), qf.sort(qf.ASCENDING('x')) + qf.sort(qf.DESCENDING('y'))) comment = "hello world" yield self.db.command("profile", 2) yield self.coll.find({}, filter=qf.sort(qf.ASCENDING('x')) + qf.comment(comment)) yield self.db.command("profile", 0) cnt = yield self.db.system.profile.count({ "query.$orderby.x": 1, "query.$comment": comment }) self.assertEqual(cnt, 1)
def test_create_index_nodup(self): coll = self.coll coll.drop() coll.insert({'b': 1}) coll.insert({'b': 1}) ix = coll.create_index(filter.sort(filter.ASCENDING("b")), unique=True) return self.assertFailure(ix, errors.DuplicateKeyError)
def test_FilterMerge(self): self.assertEqual( qf.sort(qf.ASCENDING('x') + qf.DESCENDING('y')), qf.sort(qf.ASCENDING('x')) + qf.sort(qf.DESCENDING('y'))) comment = "hello world" yield self.db.command("profile", 2) yield self.coll.find({}, filter=qf.sort(qf.ASCENDING('x')) + qf.comment(comment)) yield self.db.command("profile", 0) if (yield self.__3_2_or_higher()): profile_filter = {"query.sort.x": 1, "query.comment": comment} else: profile_filter = {"query.$orderby.x": 1, "query.$comment": comment} cnt = yield self.db.system.profile.count(profile_filter) self.assertEqual(cnt, 1)
def test_create_index(self): db = self.db coll = self.coll self.assertRaises(TypeError, coll.create_index, 5) self.assertRaises(TypeError, coll.create_index, {"hello": 1}) yield coll.insert({'c': 1}) # make sure collection exists. yield coll.drop_indexes() count = len((yield coll.index_information())) self.assertEqual(count, 1) self.assertIsInstance(count, int) yield coll.create_index(qf.sort(qf.ASCENDING("hello"))) yield coll.create_index( qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world"))) count = len((yield coll.index_information())) self.assertEqual(count, 3) yield coll.drop_indexes() ix = yield coll.create_index( qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world")), name="hello_world") self.assertEquals(ix, "hello_world") yield coll.drop_indexes() count = len((yield coll.index_information())) self.assertEqual(count, 1) yield coll.create_index(qf.sort(qf.ASCENDING("hello"))) indices = yield coll.index_information() self.assert_(u"hello_1" in indices) yield coll.drop_indexes() count = len((yield coll.index_information())) self.assertEqual(count, 1) ix = yield coll.create_index( qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world"))) self.assertEquals(ix, "hello_1_world_-1")
def test_create_index(self): db = self.db coll = self.coll self.assertFailure(coll.create_index(5), TypeError) self.assertFailure(coll.create_index({"hello": 1}), TypeError) yield coll.insert({'c': 1}) # make sure collection exists. yield coll.drop_indexes() count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 1) self.assertIsInstance(count, int) yield coll.create_index(qf.sort(qf.ASCENDING("hello"))) yield coll.create_index( qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world"))) count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 3) yield coll.drop_indexes() ix = yield coll.create_index( qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world")), name="hello_world") self.assertEquals(ix, "hello_world") yield coll.drop_indexes() count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 1) yield coll.create_index(qf.sort(qf.ASCENDING("hello"))) indices = yield db.system.indexes.find({"ns": u"mydb.mycol"}) self.assert_(u"hello_1" in [a["name"] for a in indices]) yield coll.drop_indexes() count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 1) ix = yield coll.create_index( qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world"))) self.assertEquals(ix, "hello_1_world_-1")
def test_Sort(self): doc = yield self.coll.find_one_and_delete({'x': {"$exists": True}}, sort=qf.sort(qf.ASCENDING('y'))) self.assertEqual(doc['x'], 1) doc = yield self.coll.find_one_and_delete({'x': {"$exists": True}}, sort=qf.sort(qf.DESCENDING('y'))) self.assertEqual(doc['x'], 3) cnt = yield self.coll.count() self.assertEqual(cnt, 1)
def test_index_haystack(self): db = self.db coll = self.coll yield coll.drop_indexes() _id = yield coll.insert({ "pos": { "long": 34.2, "lat": 33.3 }, "type": "restaurant" }) yield coll.insert({ "pos": { "long": 34.2, "lat": 37.3 }, "type": "restaurant" }) yield coll.insert({ "pos": { "long": 59.1, "lat": 87.2 }, "type": "office" }) yield coll.create_index( filter.sort(filter.GEOHAYSTACK("pos") + filter.ASCENDING("type")), **{'bucket_size': 1}) # TODO: A db.command method has not been implemented yet. # Sending command directly command = SON([ ("geoSearch", "mycol"), ("near", [33, 33]), ("maxDistance", 6), ("search", { "type": "restaurant" }), ("limit", 30), ]) results = yield db["$cmd"].find_one(command) self.assertEqual(2, len(results['results'])) self.assertEqual( { "_id": _id, "pos": { "long": 34.2, "lat": 33.3 }, "type": "restaurant" }, results["results"][0])
def test_Hint(self): # find() should fail with 'bad hint' if hint specifier works correctly self.assertFailure(self.coll.find({}, filter=qf.hint([('x', 1)])), OperationFailure) # create index and test it is honoured yield self.coll.create_index(qf.sort(qf.ASCENDING("x")), name="test_index") found_1 = yield self.coll.find({}, filter=qf.hint([('x', 1)])) found_2 = yield self.coll.find({}, filter=qf.hint(qf.ASCENDING("x"))) found_3 = yield self.coll.find({}, filter=qf.hint("test_index")) self.assertTrue(found_1 == found_2 == found_3) # find() should fail with 'bad hint' if hint specifier works correctly self.assertFailure( self.coll.find({}, filter=qf.hint(["test_index", 1])), OperationFailure) self.assertFailure( self.coll.find({}, filter=qf.hint(qf.ASCENDING("test_index"))), OperationFailure)
def test_create_index(self): db = self.db coll = self.coll self.assertRaises(TypeError, coll.create_index, 5) self.assertRaises(TypeError, coll.create_index, {"hello": 1}) yield coll.insert({'c': 1}) # make sure collection exists. yield coll.drop_indexes() count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 1) result1 = yield coll.create_index( filter.sort(filter.ASCENDING("hello"))) result2 = yield coll.create_index(filter.sort(filter.ASCENDING("hello") + \ filter.DESCENDING("world"))) count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 3) yield coll.drop_indexes() ix = yield coll.create_index(filter.sort(filter.ASCENDING("hello") + \ filter.DESCENDING("world")), name="hello_world") self.assertEquals(ix, "hello_world") yield coll.drop_indexes() count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 1) yield coll.create_index(filter.sort(filter.ASCENDING("hello"))) indices = yield db.system.indexes.find({"ns": u"mydb.mycol"}) self.assert_(u"hello_1" in [a["name"] for a in indices]) yield coll.drop_indexes() count = yield db.system.indexes.count({"ns": u"mydb.mycol"}) self.assertEqual(count, 1) ix = yield coll.create_index(filter.sort(filter.ASCENDING("hello") + \ filter.DESCENDING("world"))) self.assertEquals(ix, "hello_1_world_-1")
def test_drop_index(self): index = qf.sort(qf.ASCENDING("hello") + qf.DESCENDING("world")) yield self.coll.create_index(index, name="myindex") res = yield self.coll.drop_index("myindex") self.assertEqual(res["ok"], 1) yield self.coll.create_index(index) res = yield self.coll.drop_index(index) self.assertEqual(res["ok"], 1) self.assertRaises(TypeError, self.coll.drop_index, 123)
def test_Sort(self): doc = yield self.coll.find_one_and_update({}, {"$set": {'y': 5}}, projection={"_id": 0}, sort=qf.sort(qf.ASCENDING('y'))) self.assertEqual(doc, {'x': 10, 'y': 10}) doc = yield self.coll.find_one_and_update({}, {"$set": {'y': 35}}, projection={"_id": 0}, sort=qf.sort(qf.DESCENDING('y'))) self.assertEqual(doc, {'x': 30, 'y': 30}) ys = yield self.coll.distinct('y') self.assertEqual(set(ys), {5, 20, 35})
def test_create_index_dropdups(self): # dropDups was removed from MongoDB v3.0 ismaster = yield self.db.command("ismaster") if ismaster["maxWireVersion"] >= 3: raise unittest.SkipTest("dropDups was removed from MongoDB 3") yield self.coll.insert([{'b': 1}, {'b': 1}]) yield self.coll.create_index(qf.sort(qf.ASCENDING('b')), unique=True, drop_dups=True) docs = yield self.coll.find(fields={"_id": 0}) self.assertEqual(docs, [{'b': 1}])
def test_index_haystack(self): db = self.db coll = self.coll yield coll.drop_indexes() _id = yield coll.insert({ "pos": { "long": 34.2, "lat": 33.3 }, "type": "restaurant" }) yield coll.insert({ "pos": { "long": 34.2, "lat": 37.3 }, "type": "restaurant" }) yield coll.insert({ "pos": { "long": 59.1, "lat": 87.2 }, "type": "office" }) yield coll.create_index( qf.sort(qf.GEOHAYSTACK("pos") + qf.ASCENDING("type")), **{"bucket_size": 1}) results = yield db.command("geoSearch", "mycol", near=[33, 33], maxDistance=6, search={"type": "restaurant"}, limit=30) self.assertEqual(2, len(results["results"])) self.assertEqual( { "_id": _id, "pos": { "long": 34.2, "lat": 33.3 }, "type": "restaurant" }, results["results"][0])
def test_Timestamps(self): """Tests mongo operations with Timestamps""" conn = yield txmongo.MongoConnection(mongo_host, mongo_port) test = conn.foo.test_ts test.drop() # insert with specific timestamp doc1 = {'_id':objectid.ObjectId(), 'ts':timestamp.Timestamp(1, 2)} yield test.insert(doc1, safe=True) result = yield test.find_one(doc1) self.assertEqual(result.get('ts').time, 1) self.assertEqual(result.get('ts').inc, 2) # insert with specific timestamp doc2 = {'_id':objectid.ObjectId(), 'ts':timestamp.Timestamp(2, 1)} yield test.insert(doc2, safe=True) # the objects come back sorted by ts correctly. # (test that we stored inc/time in the right fields) result = yield test.find(filter=qf.sort(qf.ASCENDING('ts'))) self.assertEqual(len(result), 2) self.assertEqual(result[0]['_id'], doc1['_id']) self.assertEqual(result[1]['_id'], doc2['_id']) # insert with null timestamp doc3 = {'_id':objectid.ObjectId(), 'ts':timestamp.Timestamp(0, 0)} yield test.insert(doc3, safe=True) # time field loaded correctly result = yield test.find_one(doc3['_id']) now = time.time() self.assertTrue(now - 2 <= result['ts'].time <= now) # delete yield test.remove(doc1["_id"], safe=True) yield test.remove(doc2["_id"], safe=True) yield test.remove(doc3["_id"], safe=True) # disconnect yield conn.disconnect()
def example(): mongo = yield txmongo.MongoConnection() foo = mongo.foo # `foo` database test = foo.test # `test` collection idx = filter.sort( filter.ASCENDING("something") + filter.DESCENDING("else")) print "IDX:", idx result = yield test.create_index(idx) print "create_index:", result result = yield test.index_information() print "index_information:", result result = yield test.drop_index(idx) print "drop_index:", result
def test_SortAscendingMultipleFields(self): self.assertEqual(qf.sort(qf.ASCENDING(['x', 'y'])), qf.sort(qf.ASCENDING('x') + qf.ASCENDING('y')))
def test_convert(self): self.assertEqual( Collection._find_args_compat(spec={'x': 42}), { "filter": { 'x': 42 }, "projection": None, "skip": 0, "limit": 0, "sort": None, "cursor": False }) self.assertEqual( Collection._find_args_compat(filter={'x': 42}), { "filter": { 'x': 42 }, "projection": None, "skip": 0, "limit": 0, "sort": None }) self.assertEqual( Collection._find_args_compat(filter=qf.sort(qf.ASCENDING('x'))), { "filter": None, "projection": None, "skip": 0, "limit": 0, "sort": qf.sort(qf.ASCENDING('x')), "cursor": False }) self.assertEqual( Collection._find_args_compat(sort=qf.sort(qf.ASCENDING('x'))), { "filter": None, "projection": None, "skip": 0, "limit": 0, "sort": qf.sort(qf.ASCENDING('x')) }) self.assertEqual( Collection._find_args_compat({'x': 42}), { "filter": { 'x': 42 }, "projection": None, "skip": 0, "limit": 0, "sort": None }) self.assertEqual( Collection._find_args_compat({'x': 42}, unknown_arg=123), { "filter": { 'x': 42 }, "projection": None, "skip": 0, "limit": 0, "sort": None, "unknown_arg": 123 }) self.assertEqual( Collection._find_args_compat({'x': 42}, {'a': 1}), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 0, "limit": 0, "sort": None }) self.assertEqual( Collection._find_args_compat({'x': 42}, projection={'a': 1}), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 0, "limit": 0, "sort": None }) self.assertEqual( Collection._find_args_compat({'x': 42}, fields={'a': 1}), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 0, "limit": 0, "sort": None, "cursor": False }) self.assertEqual( Collection._find_args_compat({'x': 42}, 5), { "filter": { 'x': 42 }, "projection": None, "skip": 5, "limit": 0, "sort": None, "cursor": False }) self.assertEqual( Collection._find_args_compat({'x': 42}, {'a': 1}, 5), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 0, "sort": None }) self.assertEqual( Collection._find_args_compat({'x': 42}, {'a': 1}, 5, 6), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": None }) self.assertEqual( Collection._find_args_compat({'x': 42}, 5, 6, {'a': 1}), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": None, "cursor": False }) self.assertEqual( Collection._find_args_compat({'x': 42}, {'a': 1}, 5, 6, qf.sort([('s', 1)])), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": qf.sort([('s', 1)]) }) self.assertEqual( Collection._find_args_compat({'x': 42}, 5, 6, {'a': 1}, qf.sort([('s', 1)])), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": qf.sort([('s', 1)]), "cursor": False }) self.assertEqual( Collection._find_args_compat({'x': 42}, 5, 6, {'a': 1}, qf.sort([('s', 1)]), True), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": qf.sort([('s', 1)]), "cursor": True }) self.assertEqual( Collection._find_args_compat(spec={'x': 42}, filter=qf.sort([('s', 1)]), limit=6, fields={'a': 1}, skip=5), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": qf.sort([('s', 1)]), "cursor": False }) self.assertEqual( Collection._find_args_compat(filter={'x': 42}, sort=qf.sort([('s', 1)]), limit=6, projection={'a': 1}, skip=5), { "filter": { 'x': 42 }, "projection": { 'a': 1 }, "skip": 5, "limit": 6, "sort": qf.sort([('s', 1)]) })
def configure_db(): """ Initialize the database, configure indexes. Add a dummy campaigns for events without campaigns. :return: """ logger = logging.getLogger(__name__) yield get_mongo_db() campaign_idx = filter.sort(filter.ASCENDING("campaign_id")) banner_idx = filter.sort(filter.ASCENDING("banner_id")) timestamp_idx = filter.sort(filter.ASCENDING("timestamp")) event_idx = filter.sort(filter.ASCENDING("event_id")) user_idx = filter.sort(filter.ASCENDING("user_id")) keyword_idx = filter.sort(filter.ASCENDING("keyword")) updated_idx = filter.sort(filter.ASCENDING("updated")) campaign_event_idx = filter.sort( filter.ASCENDING("campaign_id") + filter.ASCENDING("event_id")) campaign_collection = yield get_campaign_collection() yield campaign_collection.create_index(campaign_idx, unique=True) banner_collection = yield get_banner_collection() yield banner_collection.create_index(banner_idx, unique=True) yield banner_collection.create_index(campaign_idx) event_collection = yield get_event_collection() yield event_collection.create_index(event_idx, unique=True) yield event_collection.create_index(timestamp_idx) yield event_collection.create_index(banner_idx) yield event_collection.create_index(user_idx) payment_collection = yield get_payment_collection() yield payment_collection.create_index(timestamp_idx) yield payment_collection.create_index(campaign_event_idx) payment_round_collection = yield get_payment_rounds_collection() yield payment_round_collection.create_index(timestamp_idx, unique=True) user_value_collection = yield get_user_value_collection() yield user_value_collection.create_index(user_idx) yield user_value_collection.create_index(campaign_idx) user_score_collection = yield get_user_score_collection() yield user_score_collection.create_index(timestamp_idx) yield user_value_collection.create_index(campaign_idx) yield user_value_collection.create_index(user_idx) user_keyword_frequency_collection = yield get_user_keyword_frequency_collection( ) yield user_keyword_frequency_collection.create_index(user_idx) yield user_keyword_frequency_collection.create_index(keyword_idx) user_profile_collection = yield get_user_profile_collection() yield user_profile_collection.create_index(user_idx) keyword_frequency_collection = yield get_keyword_frequency_collection() yield keyword_frequency_collection.create_index(updated_idx) yield keyword_frequency_collection.create_index(keyword_idx) yield logger.debug('Database configured successfully.') # Add default campaign yield campaign_collection.replace_one({'campaign_id': 'not_found'}, { 'campaign_id': 'not_found', 'time_start': 0, 'time_end': 2147483646, 'filters': { 'require': {}, 'exclude': {} }, 'keywords': {}, 'banners': [], 'max_cpc': 0, 'max_cpm': 0, 'budget': 0 }, upsert=True)
def test_Repr(self): self.assertEqual(repr(qf.sort(qf.ASCENDING('x'))), "<mongodb QueryFilter: {'orderby': (('x', 1),)}>")