Python Stub.set_response_body方法代码示例

# 需要导入模块: from stubo.model.stub import Stub [as 别名]
# 或者: from stubo.model.stub.Stub import set_response_body [as 别名]
 def insert_stub(self, doc, stateful):
     from stubo.model.stub import Stub
     matchers = doc['stub'].contains_matchers()
     scenario = doc['scenario']
     stubs_cursor = self.get_stubs(scenario)
     if stubs_cursor.count():
         for stub in stubs_cursor:
             the_stub = Stub(stub['stub'], scenario)
             if matchers and matchers == the_stub.contains_matchers():
                 if not stateful and \
                     doc['stub'].response_body() == the_stub.response_body():
                     msg = 'duplicate stub found, not inserting.'
                     log.warn(msg)
                     return msg
                 log.debug('In scenario: {0} found exact match for matchers:'
                   ' {1}. Perform stateful update of stub.'.format(scenario,
                                                                   matchers))
                 response = the_stub.response_body()
                 response.extend(doc['stub'].response_body())
                 the_stub.set_response_body(response)   
                 self.db.scenario_stub.update(
                     {'_id': ObjectId(stub['_id'])},
                     {'$set' : {'stub' : the_stub.payload}})
                 return 'updated with stateful response'
     doc['stub'] = doc['stub'].payload       
     status = self.db.scenario_stub.insert(doc)
     return 'inserted scenario_stub: {0}'.format(status)

# 需要导入模块: from stubo.model.stub import Stub [as 别名]
# 或者: from stubo.model.stub.Stub import set_response_body [as 别名]
    def insert_stub(self, doc, stateful):
        """
        Insert stub into DB. Performs a check whether this stub already exists in database or not.  If it exists
        and stateful is True - new response is appended to the response list, else - reports that duplicate stub
        found and it will not be inserted.

        :param doc: Stub class with Stub that will be inserted
        :param stateful: <boolean> specify whether stub insertion should be stateful or not
        :return: <string> message with insertion status:
           ignored - if not stateful and stub was already present
           updated - if stateful and stub was already present
           created - if stub was not present in database
        """
        # getting initial values - stub matchers, scenario name
        matchers = doc["stub"].contains_matchers()
        scenario = doc["scenario"]

        matchers_hash = self._create_hash(matchers)
        # check if we have matchers - should be None for REST calls
        if matchers is not None:
            # additional helper value for indexing
            doc["matchers_hash"] = matchers_hash
            matched_stub = self.get_matched_stub(name=scenario, matchers_hash=matchers_hash)
            # checking if stub already exists
            if matched_stub:
                # creating stub object from found document
                the_stub = Stub(matched_stub["stub"], scenario)
                if not stateful and doc["stub"].response_body() == the_stub.response_body():
                    msg = "duplicate stub found, not inserting."
                    log.warn(msg)
                    result = {"status": "ignored", "msg": msg, "key": str(matched_stub["_id"])}
                    return result
                # since stateful is true - updating stub body by extending the list
                log.debug(
                    "In scenario: {0} found exact match for matchers:"
                    " {1}. Perform stateful update of stub.".format(scenario, matchers)
                )
                response = the_stub.response_body()
                response.extend(doc["stub"].response_body())
                the_stub.set_response_body(response)
                # updating Stub body and size, writing to database
                self.db.scenario_stub.update(
                    {"_id": matched_stub["_id"]},
                    {"$set": {"stub": the_stub.payload, "space_used": len(unicode(the_stub.payload))}},
                )
                result = {"status": "updated", "msg": "Updated with stateful response", "key": str(matched_stub["_id"])}
                return result

        # inserting stub into DB
        status = self.db.scenario_stub.insert(self.get_stub_document(doc))

        result = {"status": "created", "msg": "Inserted scenario_stub", "key": str(status)}
        return result

# 需要导入模块: from stubo.model.stub import Stub [as 别名]
# 或者: from stubo.model.stub.Stub import set_response_body [as 别名]
    def insert_stub(self, doc, stateful):
        """
        Insert stub into DB. Performs a check whether this stub already exists in database or not.  If it exists
        and stateful is True - new response is appended to the response list, else - reports that duplicate stub
        found and it will not be inserted.

        :param doc: Stub class with Stub that will be inserted
        :param stateful: <boolean> specify whether stub insertion should be stateful or not
        :return: <string> message with insertion status
        """
        matchers = doc['stub'].contains_matchers()
        scenario = doc['scenario']
        stubs_cursor = self.get_stubs(scenario)
        if stubs_cursor.count():
            for stub in stubs_cursor:
                the_stub = Stub(stub['stub'], scenario)
                if matchers and matchers == the_stub.contains_matchers():
                    if not stateful and \
                        doc['stub'].response_body() == the_stub.response_body():
                        msg = 'duplicate stub found, not inserting.'
                        log.warn(msg)
                        return msg
                    log.debug('In scenario: {0} found exact match for matchers:'
                      ' {1}. Perform stateful update of stub.'.format(scenario,
                                                                      matchers))
                    response = the_stub.response_body()
                    response.extend(doc['stub'].response_body())
                    the_stub.set_response_body(response)   
                    self.db.scenario_stub.update(
                        {'_id': ObjectId(stub['_id'])},
                        {'$set' : {'stub' : the_stub.payload}})
                    return 'updated with stateful response'
        doc['stub'] = doc['stub'].payload       
        status = self.db.scenario_stub.insert(doc)
        self.db.scenario_stub.create_index([("stub.priority", ASCENDING), ("scenario", ASCENDING)])
        return 'inserted scenario_stub: {0}'.format(status)

# 需要导入模块: from stubo.model.stub import Stub [as 别名]
# 或者: from stubo.model.stub.Stub import set_response_body [as 别名]
    def insert_stub(self, doc, stateful):
        """
        Insert stub into DB. Performs a check whether this stub already exists in database or not.  If it exists
        and stateful is True - new response is appended to the response list, else - reports that duplicate stub
        found and it will not be inserted.

        :param doc: Stub class with Stub that will be inserted
        :param stateful: <boolean> specify whether stub insertion should be stateful or not
        :return: <string> message with insertion status
        """
        # getting initial values - stub matchers, scenario name
        matchers = doc['stub'].contains_matchers()
        scenario = doc['scenario']

        matchers_hash = self._create_hash(matchers)
        # check if we have matchers - should be None for REST calls
        if matchers is not None:
            # additional helper value for indexing
            doc['matchers_hash'] = matchers_hash
            matched_stub = self.get_matched_stub(name=scenario, matchers_hash=matchers_hash)

            # checking if stub already exists
            if matched_stub:
                # creating stub object from found document
                the_stub = Stub(matched_stub['stub'], scenario)
                if not stateful and doc['stub'].response_body() == the_stub.response_body():
                    msg = 'duplicate stub found, not inserting.'
                    log.warn(msg)
                    return msg
                # since stateful is true - updating stub body by extending the list
                log.debug('In scenario: {0} found exact match for matchers:'
                          ' {1}. Perform stateful update of stub.'.format(scenario, matchers))
                response = the_stub.response_body()
                response.extend(doc['stub'].response_body())
                the_stub.set_response_body(response)
                # updating Stub body and size, writing to database
                self.db.scenario_stub.update(
                    {'_id': matched_stub['_id']},
                    {'$set': {'stub': the_stub.payload,
                              'space_used': len(unicode(the_stub.payload))}})
                return 'updated with stateful response'

        # Stub doesn't exist in DB - preparing new object
        doc['stub'] = doc['stub'].payload

        # additional helper for aggregation framework
        try:
            doc['recorded'] = doc['stub']['recorded']
        except KeyError:
            # during tests "recorded" value is not supplied
            pass
        # calculating stub size
        doc['space_used'] = len(unicode(doc['stub']))

        # inserting stub into DB
        status = self.db.scenario_stub.insert(doc)

        # create indexes
        if matchers_hash:
            self._create_index(key="matchers_hash")
        # creating index for scenario and priority
        self._create_index(key="scenario")
        if 'priority' in doc['stub']:
            # creating index for priority
            self._create_index("stub.priority")

        return 'inserted scenario_stub: {0}'.format(status)

# 需要导入模块: from stubo.model.stub import Stub [as 别名]
# 或者: from stubo.model.stub.Stub import set_response_body [as 别名]
 def create_session_cache(self, scenario_name, session_name, 
                          system_date=None):
     scenario_key = self.scenario_key_name(scenario_name)
     log.debug("create_session_cache: scenario_key={0}, session_name={1}".format(
               scenario_key, session_name))
     session = self.get(scenario_key, session_name)
     if not session:
         # must be using a different session name for playback than record
         session = {
             'session' : session_name,
             'scenario' : scenario_key 
         }
         # add to sessions map
         self.set_raw('{0}:sessions'.format(self.host), session_name, scenario_name) 
                
     session['status'] = 'playback'
     session['system_date'] = system_date or datetime.date.today().strftime(
         '%Y-%m-%d')
     session['last_used'] = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
     cache_info = []
     
     # copy mongo scenario stubs to redis cache
     scenario_col = Scenario()   
     stubs_cursor = scenario_col.get_stubs(scenario_key)
     stubs = list(stubs_cursor)
     if not stubs:
         raise exception_response(500,
             title="found no stubs in mongo for {0}".format(scenario_key))
     from stubo.ext.module import Module
     for scenario_stub in stubs:
         stub = Stub(scenario_stub['stub'], scenario_stub['scenario'])
         if stub.module():
             module_name = stub.module()['name']
             # tag this stub with the latest version of the module
             module = Module(self.host)
             version = module.latest_version(module_name)
             if not version:
                 raise exception_response(500,
                     title="module '{0}' not found in cache".format(
                     module.key(module_name)))
             stub.module()['version'] = version
         
         response_ids = []
         response_bodys = stub.response_body()
         # cache each response id -> response (text, status) etc
         for response_text in response_bodys:
             stub.set_response_body(response_text)
             response_id = response_hash(response_text, stub)
             self.set_response(scenario_name, session_name, response_id,
                               stub.response())
             response_ids.append(response_id) 
         
         # replace response text with response hash ids for session cache 
         stub.response().pop('body', None)
         stub.response()['ids'] = response_ids
         delay_policy_name = stub.delay_policy()
         if delay_policy_name:
             # Note: the delay policy is not really cached with the session.
             # The get/response call will just use the name to get the latest
             # delay value from the 'delay_policy' key in redis.
             delay_policy_key = '{0}:delay_policy'.format(self.host)
             delay_policy = self.get(delay_policy_key, delay_policy_name)
             if not delay_policy:
                 log.warn('unable to find delay_policy: {0}'.format(
                          delay_policy_name))
             stub.set_delay_policy(delay_policy)
         #_id = ObjectId(scenario_stub['_id'])
         #stub['recorded'] = str(_id.generation_time.date())
         cache_info.append(stub.payload)
     session['stubs'] = cache_info 
     #log.debug('stubs: {0}'.format(session['stubs']))
     self.set(scenario_key, session_name, session)
     log.debug('created session cache: {0}:{1}'.format(session['scenario'],
                                                       session['session']))
     return session