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'] 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