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 == 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 'put {0} stub'.format(status)
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)
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
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)
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)
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)
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
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(
412,
title="Precondition failed: no stubs were"
" found in database for scenario: {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
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
