def _func(self, session, stub, request_id='1', response_id='1'):
from stubo.model.stub import StubCache
from stubo.cache import add_request
stub_cache = StubCache(stub.payload, session.get('scenario'),
session.get('session'))
stub_cache.payload['response']['ids'] = [response_id]
return add_request(session, request_id, stub_cache, '2013-09-05', 0)
def _func(self, session, stub, request_id='1', response_id='1'):
from stubo.model.stub import StubCache
from stubo.cache import add_request
stub_cache = StubCache(stub.payload, session.get('scenario'), session.get('session'))
stub_cache.payload['response']['ids'] = [response_id]
return add_request(session, request_id, stub_cache, '2013-09-05', 0)
def get_request_index_hash_key(session, stub_number):
"""
Return the self.hash_cls() of the scenario_name+matchers
"""
scenario_key = session['scenario']
session_name = session['session']
matching_stub = StubCache(session['stubs'][stub_number], scenario_key,
session_name)
return matching_stub.request_index_id()
def get_request_index_hash_key(session, stub_number):
"""
Return the self.hash_cls() of the scenario_name+matchers
"""
scenario_key = session['scenario']
session_name = session['session']
matching_stub = StubCache(session['stubs'][stub_number], scenario_key,
session_name)
return matching_stub.request_index_id()
def get_request_index_hash_key(session, stub_number):
'''
Return the self.hash_cls() of the scenario_name+matchers
'''
scenario_key = session['scenario']
session_name = session['session']
scenario_name = scenario_key.partition(':')[-1]
matching_stub = StubCache(session['stubs'][stub_number], scenario_key,
session_name)
matchers = u"".join([u''.join(
x.split()).strip() for x in matching_stub.contains_matchers()])
return compute_hash(u"".join([scenario_name, matchers]))
def test_update_dormant_session_with_stubs(self):
self.hash.set('somehost:foo', 'bar', {
'status': 'dormant',
'session': 'bar',
'scenario': 'localhost:foo'
})
scenario_name = 'foo'
self._make_scenario('localhost:foo')
from stubo.model.stub import create, Stub, response_hash
stub = Stub(create('<test>match this</test>', '<test>OK</test>'),
'localhost:foo')
doc = dict(scenario='localhost:foo', stub=stub)
self.scenario.insert_stub(doc, stateful=True)
cache = self._get_cache()
cache.create_session_cache('foo', 'bar')
session = self.hash.get('localhost:foo', 'bar')
self.assertEqual(session["status"], "playback")
self.assertEqual(session['session'], 'bar')
self.assertEqual(session["scenario"], "localhost:foo")
self.assertTrue('stubs' in session)
stubs = session['stubs']
self.assertEqual(len(stubs), 1)
from stubo.model.stub import StubCache
stub = StubCache(stubs[0], session["scenario"], session['session'])
self.assertEqual(stub.contains_matchers(), ["<test>match this</test>"])
self.assertEqual(stub.response_ids(),
[response_hash('<test>OK</test>', stub)])
def test_new_session_with_state(self):
scenario_name = 'foo'
self._make_scenario('localhost:foo')
from stubo.model.stub import create, Stub, response_hash
stub = Stub(create('<test>match this</test>', '<test>OK</test>'),
'localhost:foo')
doc = dict(scenario='localhost:foo', stub=stub)
self.scenario.insert_stub(doc, stateful=True)
stub2 = Stub(create('<test>match this</test>', '<test>BAD</test>'),
'localhost:foo')
doc2 = dict(scenario='localhost:foo', stub=stub2)
self.scenario.insert_stub(doc2, stateful=True)
cache = self._get_cache()
cache.create_session_cache('foo', 'bar')
session = self.hash.get('localhost:foo', 'bar')
self.assertEqual(session["status"], "playback")
self.assertEqual(session['session'], 'bar')
self.assertEqual(session["scenario"], "localhost:foo")
self.assertTrue('stubs' in session)
stubs = session['stubs']
self.assertEqual(len(stubs), 1)
from stubo.model.stub import StubCache
stub = StubCache(stubs[0], session["scenario"], session['session'])
responses = stub.response_ids()
self.assertEqual(len(responses), 2)
self.assertEqual(stub.contains_matchers(), ["<test>match this</test>"])
self.assertEqual(responses, [
response_hash('<test>OK</test>', stub),
response_hash('<test>BAD</test>', stub2)
])
self.assertEqual(self.hash.get_raw('localhost:sessions', 'bar'), 'foo')
def test_update_dormat_session_with_stubs_and_delay(self):
self.hash.set('localhost:foo', 'bar', {
'status': 'dormant',
'session': 'bar',
'scenario': 'localhost:foo'
})
delay_policy = {
"delay_type": "fixed",
"name": "slow",
"milliseconds": "500"
}
self.hash.set('localhost:delay_policy', 'slow', delay_policy)
self._make_scenario('localhost:foo')
from stubo.model.stub import create, Stub
stub = Stub(create('<test>match this</test>', '<test>OK</test>'),
'localhost:foo')
stub.set_delay_policy('slow')
doc = dict(scenario='localhost:foo', stub=stub)
self.scenario.insert_stub(doc, stateful=True)
self._get_cache().create_session_cache('foo', 'bar')
session = self.hash.get('localhost:foo', 'bar')
self.assertTrue('stubs' in session)
stubs = session['stubs']
self.assertEqual(len(stubs), 1)
from stubo.model.stub import StubCache
stub = StubCache(stubs[0], session["scenario"], session['session'])
self.assertEqual(stub.delay_policy(), delay_policy)
def test_update_dormat_session_with_stubs_and_module(self):
self.hash.set('localhost:foo', 'bar', {
'status': 'dormant',
'session': 'bar',
'scenario': 'localhost:foo'
})
module = {"system_date": "2013-09-24", "version": 1, "name": "funcky"}
self._make_scenario('localhost:foo')
from stubo.model.stub import create, Stub
stub = Stub(create('<test>match this</test>', '<test>OK</test>'),
'localhost:foo')
stub.set_module(module)
doc = dict(scenario='localhost:foo', stub=stub)
self.scenario.insert_stub(doc, stateful=True)
self._get_cache().create_session_cache('foo', 'bar')
session = self.hash.get('localhost:foo', 'bar')
self.assertTrue('stubs' in session)
stubs = session['stubs']
self.assertEqual(len(stubs), 1)
from stubo.model.stub import StubCache
stub = StubCache(stubs[0], session["scenario"], session['session'])
self.assertEqual(stub.module(), module)
def match(request, session, trace, system_date, url_args, hooks,
module_system_date=None):
"""Returns the stats of a request match process
:param request: source stubo request
:param session: cached session payload associated with this request
:param module_system_date: optional system date of an external module
"""
request_text = request.request_body()
scenario_key = session['scenario']
session_name = session['session']
log.debug(u'match: request_text={0}'.format(request_text))
trace.info('system_date={0}, module_system_date={1}'.format(
system_date, module_system_date))
stats = []
if 'stubs' not in session or not len(session['stubs']):
if session.get('status') != 'playback':
raise exception_response(400,
title="session {0} not in playback mode for scenario "
"{1}".format(session_name, scenario_key))
raise exception_response(500,
title="no stubs found in session {0} for {1}, status={2}".format(
session_name, scenario_key, session.get('status')))
stub_count = len(session['stubs'])
trace.info(u'matching against {0} stubs'.format(stub_count))
for stub_number in range(stub_count):
trace.info('stub ({0})'.format(stub_number))
stub = StubCache(session['stubs'][stub_number], scenario_key,
session_name)
source_stub = copy.deepcopy(stub)
request_copy = copy.deepcopy(request)
stub, request_copy = transform(stub,
request_copy,
module_system_date=module_system_date,
system_date=system_date,
function='get/response',
cache=session.get('ext_cache'),
hooks=hooks,
stage='matcher',
trace=trace,
url_args=url_args)
trace.info('finished transformation')
if source_stub != stub:
trace.diff('stub ({0}) was transformed'.format(stub_number),
source_stub.payload, stub.payload)
trace.info('stub ({0}) was transformed into'.format(stub_number),
stub.payload)
if request_copy != request:
trace.diff('request was transformed', request_copy.request_body(),
request.request_body())
trace.info('request was transformed into', request_copy.request_body())
matcher = StubMatcher(trace)
if matcher.match(request_copy, stub):
return (True, stub_number, stub)
return (False,)
def _func(self,
session,
request_id,
response_ids,
delay_policy_name,
recorded='2013-09-05',
system_date='2013-09-05',
module=None,
stub_number=0):
from stubo.model.stub import StubCache
from stubo.cache import add_request
stub = StubCache({}, session.get('scenario'), session.get('session'))
stub.load_from_cache(response_ids, delay_policy_name, recorded,
system_date, module, request_id)
stub.set_delay_policy(dict(name=delay_policy_name))
module = module or {}
return add_request(session, request_id, stub, system_date, stub_number)
def get_response(handler, session_name):
request = handler.request
stubo_request = StuboRequest(request)
request_body = stubo_request.request_body()
if not request_body:
# TODO: not an error if they match on other attrs
raise exception_response(400, title='No text in body')
cache = Cache(get_hostname(request))
if cache.blacklisted():
raise exception_response(
400,
title="Sorry the host URL '{0}' has been "
"blacklisted. Please contact Stub-O-Matic support.".format(
cache.host))
scenario_key = cache.find_scenario_key(session_name)
scenario_name = scenario_key.partition(':')[-1]
handler.track.scenario = scenario_name
request_id = compute_hash(request_body)
module_system_date = handler.get_argument('system_date', None)
url_args = handler.track.request_params
if not module_system_date:
# BA LEGACY
module_system_date = handler.get_argument('stubbedSystemDate', None)
trace_matcher = TrackTrace(handler.track, 'matcher')
user_cache = handler.settings['ext_cache']
# check cached requests
cached_request = cache.get_request(scenario_name, session_name, request_id)
if cached_request:
response_ids, delay_policy_name, recorded, system_date, module_info, request_index_key = cached_request
else:
retry_count = 5 if handler.settings.get('is_cluster', False) else 1
session, retries = cache.get_session_with_delay(
scenario_name,
session_name,
retry_count=retry_count,
retry_interval=1)
if retries > 0:
log.warn("replication was slow for session: {0} {1}, it took {2} "\
"secs!".format(scenario_key, session_name, retries+1))
if session['status'] != 'playback':
raise exception_response(
500,
title='cache status != playback. session={0}'.format(session))
system_date = session['system_date']
if not system_date:
raise exception_response(
500,
title="slave session {0} not available for scenario {1}".
format(session_name, scenario_key))
session['ext_cache'] = user_cache
results = match(stubo_request,
session,
trace_matcher,
as_date(system_date),
url_args=url_args,
hooks=handler.settings['hooks'],
module_system_date=module_system_date)
# 0 is best match
hits_info, stub = results[0]
log.debug(u'match result: (hits_info={0}, stub={1})'.format(
hits_info, stub.payload))
hits, stub_number = hits_info
if not hits:
raise exception_response(400,
title='E017:No matching response found')
response_ids = stub.response_ids()
delay_policy_name = stub.delay_policy_name()
recorded = stub.recorded()
module_info = stub.module()
request_index_key = add_request(
session, request_id, stub, system_date, stub_number,
handler.settings['request_cache_limit'])
if not stub.response_body():
stub.set_response_body(
stub.get_response_body_from_cache(request_index_key))
if delay_policy_name:
stub.load_delay_from_cache(delay_policy_name)
if cached_request:
stub = StubCache({}, scenario_key, session_name)
stub.load_from_cache(response_ids, delay_policy_name, recorded,
system_date, module_info, request_index_key)
trace_response = TrackTrace(handler.track, 'response')
if module_info:
trace_response.info('module used', str(module_info))
response_text = stub.response_body()
if not response_text:
raise exception_response(
500,
title='Unable to find response in '
'cache using session: {0}:{1}, response_ids: {2}'.format(
scenario_key, session_name, response_ids))
# get latest delay policy
delay_policy = stub.delay_policy()
if delay_policy:
delay = calculate_delay(delay_policy)
if delay:
msg = 'apply delay: {0} => {1}'.format(delay_policy, delay)
log.debug(msg)
handler.track['delay'] = delay
trace_response.info(msg)
trace_response.info('found response')
module_system_date = as_date(module_system_date) if module_system_date \
else module_system_date
stub, _ = transform(stub,
stubo_request,
module_system_date=module_system_date,
system_date=as_date(system_date),
function='get/response',
cache=user_cache,
hooks=handler.settings['hooks'],
stage='response',
trace=trace_response,
url_args=url_args)
transfomed_response_text = stub.response_body()[0]
# Note transformed_response_text can be encoded in utf8
if response_text[0] != transfomed_response_text:
trace_response.diff('response:transformed',
dict(response=response_text[0]),
dict(response=transfomed_response_text))
return transfomed_response_text
message = "You must supply a Name to create a new bookmark"
except StuboException, e:
error_message = "Error: {0}".format(e.title)
response = get_bookmarks(handler)
status = get_session_status(handler, all_hosts=False).get(hostname)
active = {}
if status:
for scenario_name, session_info in status.iteritems():
sessions = session_info[0]
for session in sessions:
session_name = session['session']
if session['status'] == 'playback':
stateful_stubs = [
x for x in session['stubs'] if len(
StubCache(x, scenario_name,
session).response_ids()) > 1
]
if stateful_stubs:
if scenario_name not in active:
active[scenario_name] = [session_name]
else:
active[scenario_name].append(session_name)
if not active:
message = '{0} does not have any active playback sessions'.format(
hostname)
return dict(bookmarks=response['data'],
active=active,
message=message,
error_message=error_message,
page_name='Bookmarks')
def match(request, session, trace, system_date, url_args, hooks,
module_system_date=None):
"""Returns the stats of a request match process
:param request: source stubo request
:param session: cached session payload associated with this request
:param module_system_date: optional system date of an external module
"""
request_text = request.request_body()
scenario_key = session['scenario']
session_name = session['session']
log.debug(u'match: request_text={0}'.format(request_text))
trace.info('system_date={0}, module_system_date={1}'.format(
system_date, module_system_date))
stats = []
if 'stubs' not in session or not len(session['stubs']):
if session.get('status') != 'playback':
raise exception_response(400,
title="session {0} not in playback mode for scenario "
"{1}".format(session_name, scenario_key))
raise exception_response(500,
title="no stubs found in session {0} for {1}, status={2}".format(
session_name, scenario_key, session.get('status')))
stub_count = len(session['stubs'])
trace.info(u'matching against {0} stubs'.format(stub_count))
for stub_number in range(stub_count):
trace.info('stub ({0})'.format(stub_number))
stub = StubCache(session['stubs'][stub_number], scenario_key,
session_name)
source_stub = copy.deepcopy(stub)
request_copy = copy.deepcopy(request)
stub, request_copy = transform(stub,
request_copy,
module_system_date=module_system_date,
system_date=system_date,
function='get/response',
cache=session.get('ext_cache'),
hooks=hooks,
stage='matcher',
trace=trace,
url_args=url_args)
trace.info('finished transformation')
if source_stub != stub:
trace.diff('stub ({0}) was transformed'.format(stub_number),
source_stub.payload, stub.payload)
trace.info('stub ({0}) was transformed into'.format(stub_number),
stub.payload)
if request_copy != request:
trace.diff('request was transformed', request_copy.request_body(),
request.request_body())
trace.info('request was transformed into', request_copy.request_body())
matcher = StubMatcher(trace)
hits = matcher.match(request_copy, stub)
stats.append(((hits, stub_number), stub))
if hits == stub.number_of_matchers():
# without most_matchers_win support
trace.info(u"stub '{0}' matched".format(stub_number))
break
# sort by hits (desc), stub_number (asc)
# to match against 1. greatest hits or 2. first stub to get a hit
return sorted(stats, key=lambda k: (k[0][0], -k[0][1]), reverse=True)
def get_response(handler, session_name):
request = handler.request
stubo_request = StuboRequest(request)
cache = Cache(get_hostname(request))
if cache.blacklisted():
raise exception_response(400, title="Sorry the host URL '{0}' has been "
"blacklisted. Please contact Stub-O-Matic support.".format(cache.host))
scenario_key = cache.find_scenario_key(session_name)
scenario_name = scenario_key.partition(':')[-1]
handler.track.scenario = scenario_name
request_id = stubo_request.id()
module_system_date = handler.get_argument('system_date', None)
url_args = handler.track.request_params
if not module_system_date:
# LEGACY
module_system_date = handler.get_argument('stubbedSystemDate', None)
trace_matcher = TrackTrace(handler.track, 'matcher')
user_cache = handler.settings['ext_cache']
# check cached requests
cached_request = cache.get_request(scenario_name, session_name, request_id)
if cached_request:
response_ids, delay_policy_name, recorded, system_date, module_info, request_index_key = cached_request
else:
retry_count = 5 if handler.settings.get('is_cluster', False) else 1
session, retries = cache.get_session_with_delay(scenario_name,
session_name,
retry_count=retry_count,
retry_interval=1)
if retries > 0:
log.warn("replication was slow for session: {0} {1}, it took {2} "\
"secs!".format(scenario_key, session_name, retries+1))
if session['status'] != 'playback':
raise exception_response(500,
title='cache status != playback. session={0}'.format(session))
system_date = session['system_date']
if not system_date:
raise exception_response(500,
title="slave session {0} not available for scenario {1}".format(
session_name, scenario_key))
session['ext_cache'] = user_cache
result = match(stubo_request, session, trace_matcher,
as_date(system_date),
url_args=url_args,
hooks=handler.settings['hooks'],
module_system_date=module_system_date)
if not result[0]:
raise exception_response(400,
title='E017:No matching response found')
_, stub_number, stub = result
response_ids = stub.response_ids()
delay_policy_name = stub.delay_policy_name()
recorded = stub.recorded()
module_info = stub.module()
request_index_key = add_request(session, request_id, stub, system_date,
stub_number,
handler.settings['request_cache_limit'])
if not stub.response_body():
_response = stub.get_response_from_cache(request_index_key)
stub.set_response_body(_response['body'])
if delay_policy_name:
stub.load_delay_from_cache(delay_policy_name)
if cached_request:
stub = StubCache({}, scenario_key, session_name)
stub.load_from_cache(response_ids, delay_policy_name, recorded,
system_date, module_info, request_index_key)
trace_response = TrackTrace(handler.track, 'response')
if module_info:
trace_response.info('module used', str(module_info))
response_text = stub.response_body()
if not response_text:
raise exception_response(500, title='Unable to find response in '
'cache using session: {0}:{1}, response_ids: {2}'.format(
scenario_key, session_name, response_ids))
# get latest delay policy
delay_policy = stub.delay_policy()
if delay_policy:
delay = Delay.parse_args(delay_policy)
if delay:
delay = delay.calculate()
msg = 'apply delay: {0} => {1}'.format(delay_policy, delay)
log.debug(msg)
handler.track['delay'] = delay
trace_response.info(msg)
trace_response.info('found response')
module_system_date = as_date(module_system_date) if module_system_date \
else module_system_date
stub, _ = transform(stub,
stubo_request,
module_system_date=module_system_date,
system_date=as_date(system_date),
function='get/response',
cache=user_cache,
hooks=handler.settings['hooks'],
stage='response',
trace=trace_response,
url_args=url_args)
transfomed_response_text = stub.response_body()[0]
# Note transformed_response_text can be encoded in utf8
if response_text[0] != transfomed_response_text:
trace_response.diff('response:transformed',
dict(response=response_text[0]),
dict(response=transfomed_response_text))
if stub.response_status() != 200:
handler.set_status(stub.response_status())
if stub.response_headers():
for k, v in stub.response_headers().iteritems():
handler.set_header(k, v)
return transfomed_response_text
def get_response(handler, session_name):
# getting request value
request = handler.request
stubo_request = StuboRequest(request)
cache = Cache(get_hostname(request))
scenario_key = cache.find_scenario_key(session_name)
scenario_name = scenario_key.partition(':')[-1]
handler.track.scenario = scenario_name
# request_id - computed hash
request_id = stubo_request.id()
module_system_date = handler.get_argument('system_date', None)
url_args = handler.track.request_params
if not module_system_date:
# LEGACY
module_system_date = handler.get_argument('stubbedSystemDate', None)
trace_matcher = TrackTrace(handler.track, 'matcher')
user_cache = handler.settings['ext_cache']
# check cached requests
cached_request = cache.get_request(scenario_name, session_name, request_id)
if cached_request:
response_ids, delay_policy_name, recorded, system_date, module_info, request_index_key = cached_request
else:
retry_count = 5 if handler.settings.get('is_cluster', False) else 1
session, retries = cache.get_session_with_delay(
scenario_name,
session_name,
retry_count=retry_count,
retry_interval=1)
if retries > 0:
log.warn(
"replication was slow for session: {0} {1}, it took {2} secs!".
format(scenario_key, session_name, retries + 1))
if session['status'] != 'playback':
raise exception_response(
500,
title='cache status != playback. session={0}'.format(session))
system_date = session['system_date']
if not system_date:
raise exception_response(
500,
title="slave session {0} not available for scenario {1}".
format(session_name, scenario_key))
session['ext_cache'] = user_cache
result = match(stubo_request,
session,
trace_matcher,
as_date(system_date),
url_args=url_args,
hooks=handler.settings['hooks'],
module_system_date=module_system_date)
if not result[0]:
raise exception_response(400,
title='E017:No matching response found')
_, stub_number, stub = result
response_ids = stub.response_ids()
delay_policy_name = stub.delay_policy_name()
recorded = stub.recorded()
module_info = stub.module()
request_index_key = add_request(
session, request_id, stub, system_date, stub_number,
handler.settings['request_cache_limit'])
if not stub.response_body():
_response = stub.get_response_from_cache(request_index_key)
stub.set_response_body(_response['body'])
if delay_policy_name:
stub.load_delay_from_cache(delay_policy_name)
if cached_request:
stub = StubCache({}, scenario_key, session_name)
stub.load_from_cache(response_ids, delay_policy_name, recorded,
system_date, module_info, request_index_key)
trace_response = TrackTrace(handler.track, 'response')
if module_info:
trace_response.info('module used', str(module_info))
response_text = stub.response_body()
if not response_text:
raise exception_response(
500,
title='Unable to find response in cache using session: {0}:{1}, '
'response_ids: {2}'.format(scenario_key, session_name,
response_ids))
# get latest delay policy
delay_policy = stub.delay_policy()
if delay_policy:
delay = Delay.parse_args(delay_policy)
if delay:
delay = delay.calculate()
msg = 'apply delay: {0} => {1}'.format(delay_policy, delay)
log.debug(msg)
handler.track['delay'] = delay
trace_response.info(msg)
trace_response.info('found response')
module_system_date = as_date(module_system_date) if module_system_date \
else module_system_date
stub, _ = transform(stub,
stubo_request,
module_system_date=module_system_date,
system_date=as_date(system_date),
function='get/response',
cache=user_cache,
hooks=handler.settings['hooks'],
stage='response',
trace=trace_response,
url_args=url_args)
transfomed_response_text = stub.response_body()[0]
# Note transformed_response_text can be encoded in utf8
if response_text[0] != transfomed_response_text:
trace_response.diff('response:transformed',
dict(response=response_text[0]),
dict(response=transfomed_response_text))
if stub.response_status() != 200:
handler.set_status(stub.response_status())
if stub.response_headers():
for k, v in stub.response_headers().iteritems():
handler.set_header(k, v)
return transfomed_response_text
