Python mongo.Mongo类代码示例

 def test_combine_queries(self):
     mongo = Mongo(None)
     query_a = {"username": {"$exists": True}}
     query_b = {"username": "mike"}
     combined = mongo.combine_queries(query_a, query_b)
     self.assertEqual(
         combined, {"$and": [{"username": {"$exists": True}}, {"username": "mike"}]}
     )

 def test_combine_queries(self):
     mongo = Mongo(None)
     query_a = {'username': {'$exists': True}}
     query_b = {'username': 'mike'}
     combined = mongo.combine_queries(query_a, query_b)
     self.assertEqual(
         combined,
         {'$and': [{'username': {'$exists': True}}, {'username': 'mike'}]}
     )

 def test_get_value_from_query(self):
     mongo = Mongo(None)
     simple_query = {'_id': 'abcdef012345678901234567'}
     compound_query = {'$and': [
         {'username': {'$exists': False}},
         {'_id': 'abcdef012345678901234567'}
     ]}
     self.assertEqual(mongo.get_value_from_query(simple_query, '_id'),
                      'abcdef012345678901234567')
     self.assertEqual(mongo.get_value_from_query(compound_query, '_id'),
                      'abcdef012345678901234567')

 def test_query_contains_field(self):
     mongo = Mongo(None)
     simple_query = {"_id": "abcdef012345678901234567"}
     compound_query = {
         "$and": [
             {"username": {"$exists": False}},
             {"_id": "abcdef012345678901234567"},
         ]
     }
     self.assertTrue(mongo.query_contains_field(simple_query, "_id"))
     self.assertFalse(mongo.query_contains_field(simple_query, "fake-field"))
     self.assertTrue(mongo.query_contains_field(compound_query, "_id"))
     self.assertFalse(mongo.query_contains_field(compound_query, "fake-field"))

 def test_query_contains_field(self):
     mongo = Mongo(None)
     simple_query = {'_id': 'abcdef012345678901234567'}
     compound_query = {'$and': [
         {'username': {'$exists': False}},
         {'_id': 'abcdef012345678901234567'}
     ]}
     self.assertTrue(mongo.query_contains_field(simple_query, '_id'))
     self.assertFalse(mongo.query_contains_field(simple_query,
                                                 'fake-field'))
     self.assertTrue(mongo.query_contains_field(compound_query, '_id'))
     self.assertFalse(mongo.query_contains_field(compound_query,
                                                 'fake-field'))

 def test_get_value_from_query(self):
     mongo = Mongo(None)
     simple_query = {"_id": "abcdef012345678901234567"}
     compound_query = {
         "$and": [
             {"username": {"$exists": False}},
             {"_id": "abcdef012345678901234567"},
         ]
     }
     self.assertEqual(
         mongo.get_value_from_query(simple_query, "_id"), "abcdef012345678901234567"
     )
     self.assertEqual(
         mongo.get_value_from_query(compound_query, "_id"),
         "abcdef012345678901234567",
     )

 def init_app(self, app):
     app.data = self  # app.data must be set for locks to work
     self.mongo = Mongo(app)
     self.driver = self.mongo.driver
     self.storage = self.driver
     self.elastic = Elastic(app, serializer=SuperdeskJSONEncoder(), skip_index_init=True)
     self.init_elastic(app)

 def test_json_encoder_class(self):
     mongo = Mongo(None)
     self.assertTrue((mongo.json_encoder_class(), MongoJSONEncoder))
     self.assertTrue((mongo.json_encoder_class(), json.JSONEncoder))

class SuperdeskDataLayer(DataLayer):
    """Superdesk Data Layer.

    Implements eve data layer interface, is used to make eve work with superdesk service layer.
    It handles app initialization and later it forwards eve calls to respective service.
    """

    serializers = {}
    serializers.update(Mongo.serializers)
    serializers.update(Elastic.serializers)

    def init_app(self, app):
        app.data = self  # app.data must be set for locks to work
        self.mongo = Mongo(app)
        self.driver = self.mongo.driver
        self.storage = self.driver
        self.elastic = Elastic(app, serializer=SuperdeskJSONEncoder(), skip_index_init=True, retry_on_timeout=True)

    def init_elastic(self, app):
        """Init elastic index.

        It will create index and put mapping. It should run only once so locks are in place.
        Thus mongo must be already setup before running this.
        """
        with app.app_context():
            if lock('elastic', expire=10):
                try:
                    self.elastic.init_index(app)
                finally:
                    unlock('elastic')

    def find(self, resource, req, lookup):
        return superdesk.get_resource_service(resource).get(req=req, lookup=lookup)

    def find_all(self, resource, max_results=1000):
        req = ParsedRequest()
        req.max_results = max_results
        return self._backend(resource).find(resource, req, None)

    def find_one(self, resource, req, **lookup):
        return superdesk.get_resource_service(resource).find_one(req=req, **lookup)

    def find_one_raw(self, resource, _id):
        return self._backend(resource).find_one_raw(resource, _id)

    def find_list_of_ids(self, resource, ids, client_projection=None):
        return self._backend(resource).find_list_of_ids(resource, ids, client_projection)

    def insert(self, resource, docs, **kwargs):
        return superdesk.get_resource_service(resource).create(docs, **kwargs)

    def update(self, resource, id_, updates, original):
        return superdesk.get_resource_service(resource).update(id=id_, updates=updates, original=original)

    def update_all(self, resource, query, updates):
        datasource = self.datasource(resource)
        driver = self._backend(resource).driver
        collection = driver.db[datasource[0]]
        return collection.update(query, {'$set': updates}, multi=True)

    def replace(self, resource, id_, document, original):
        return superdesk.get_resource_service(resource).replace(id=id_, document=document, original=original)

    def remove(self, resource, lookup=None):
        if lookup is None:
            lookup = {}
        return superdesk.get_resource_service(resource).delete(lookup=lookup)

    def is_empty(self, resource):
        return self._backend(resource).is_empty(resource)

    def _search_backend(self, resource):
        if resource.endswith(current_app.config['VERSIONS']):
            return
        datasource = self.datasource(resource)
        backend = config.SOURCES.get(datasource[0], {}).get('search_backend', None)
        return getattr(self, backend) if backend is not None else None

    def _backend(self, resource):
        datasource = self.datasource(resource)
        backend = config.SOURCES.get(datasource[0], {'backend': 'mongo'}).get('backend', 'mongo')
        return getattr(self, backend)

    def get_mongo_collection(self, resource):
        return self.mongo.pymongo('users').db[resource]