def test_match_eval_error(self): from stubo.match import match from stubo.utils.track import TrackTrace trace = TrackTrace(DummyModel(tracking_level='normal'), 'matcher') session = { "session": "first_2", "scenario": "localhost:first", 'status': 'playback', "system_date": "2013-09-05", 'stubs': [{ "matchers": ["{{"], "recorded": "2013-09-05", "response_id": 5, "module": { "system_date": "2013-08-07", "version": 1, "name": "dummy" }, }] } from stubo.exceptions import HTTPClientError from stubo.model.request import StuboRequest request = StuboRequest(DummyModel(body='xxx', headers={})) from stubo.ext.transformer import StuboDefaultHooks url_args = {} with self.assertRaises(HTTPClientError): match(request, session, trace, session.get('system_date'), url_args, StuboDefaultHooks(), None)
def test_raise_on_error_stubo_error(self): from stubo.exceptions import HTTPClientError fetcher = self._make() response = DummyModel(status_code=405, reason="Unknown") response.json = lambda : {'error' : {u'message': 'something went wrong', 'code' : 405}} with self.assertRaises(HTTPClientError): fetcher.raise_on_error(response, "/some/url")
def test_raise_on_error_stubo_error(self): from stubo.exceptions import HTTPClientError fetcher = self._make() response = DummyModel(status_code=405, reason="Unknown") response.json = lambda: {'error': {u'message': 'something went wrong', 'code': 405}} with self.assertRaises(HTTPClientError): fetcher.raise_on_error(response, "/some/url")
def post(self, url, data=None, json=None, **kwargs): if url == 'get/response/cantfindthis': return DummyModel(status_code=400, content='E017') self.posts.append((url, data or json)) return DummyModel(status_code=200, raise_for_status=lambda: 1, headers={"Content-Type": 'application/json; charset=UTF-8'}, json=lambda: "")
def test_response(self): from stubo.ext.xmlutils import XMLMangler mangler = XMLMangler(elements=dict(a=XPathValue('/path/to/a'))) response_mangler = XMLMangler(elements=dict( a=XPathValue('/response', extractor=lambda x: x.upper())), copy_attrs_on_match=True) request = DummyModel(body='<path><to><a>xyz</a></to></path>', headers={}) from stubo.model.stub import Stub, create stub = Stub( create('<path><to><a>xyz</a></to></path>', '<response>abc</response>'), "foo") from stubo.ext.transformer import StuboTemplateProcessor context = dict(stub=stub, template_processor=StuboTemplateProcessor()) putter = self._make(response_mangler=response_mangler, mangler=mangler, request=StuboRequest(request), context=context) putter.doMatcher() response = putter.doResponse() self.assertEqual( response.stub.payload, { 'request': { 'bodyPatterns': { 'contains': [u'<path><to><a>***</a></to></path>'] }, 'method': 'POST' }, 'response': { 'body': u'<response>ABC</response>', 'status': 200 } })
def test_raise_on_error_file_not_found(self): from stubo.exceptions import HTTPClientError fetcher = self._make() response = DummyModel(status_code=404, reason="file not found") with self.assertRaises(HTTPClientError): fetcher.raise_on_error(response, "/some/url")
def test_raise_on_error_unexpected_error(self): from stubo.exceptions import HTTPServerError fetcher = self._make() response = DummyModel(status_code=501, reason="Unknown") with self.assertRaises(HTTPServerError): fetcher.raise_on_error(response, "/some/url")
def _get_best_match(self, request_text, session, trace=None, system_date=None, url_args=None, module_system_date=None): from stubo.match import match from stubo.utils.track import TrackTrace trace = trace or TrackTrace(DummyModel(tracking_level='normal'), 'matcher') from stubo.model.request import StuboRequest request = StuboRequest(DummyModel(body=request_text, headers={'Stubo-Request-Method' : 'POST'})) url_args = url_args or {} from stubo.ext.transformer import StuboDefaultHooks return match(request, session, trace, system_date, url_args, StuboDefaultHooks(), module_system_date=module_system_date)
def get(self, url): if 'stubo/api/put/delay_policy' in url: # special case as this is not implemented as a HTTP GET return self.post(url,"") import os.path url = os.path.basename(url) response = DummyModel(headers={}) if url in globals().keys(): response.content = globals()[url] response.status_code = 200 response.headers = {"Content-Type" : 'text/html; charset=UTF-8'} if url == 'content_not_json_1': response.encoding = 'utf8' response.text = response.content elif url in ('content_not_json_2', 'content_not_json_3'): response.encoding = "" else: response.headers["Content-Type"] = 'application/json; charset=UTF-8' response.json = lambda: response.content else: response.status_code = 404 return response
def test_ctor(self): from stubo.ext.xmlutils import XMLMangler mangler = XMLMangler(elements=dict(a=XPathValue('/path/to/a'))) request = DummyModel(body='<path><to><a>xyz</a></to></path>', headers={}) from stubo.model.stub import Stub, create stub = Stub( create('<path><to><a>xyz</a></to></path>', '<response>abc</response>'), "foo") from stubo.ext.transformer import StuboTemplateProcessor context = dict(stub=stub, template_processor=StuboTemplateProcessor()) getter = self._make(mangler=mangler, request=StuboRequest(request), context=context) self.assertEqual(getter.mangler, mangler)
def test_matcher_strip_ns(self): from stubo.ext.xmlutils import XMLMangler mangler = XMLMangler(elements=dict(a=XPathValue('/path/to/a'))) request = DummyModel(body='<path><to><a>xyz</a></to></path>', headers={}) from stubo.model.stub import Stub, create stub = Stub( create('<path xmlns="http://great.com"><to><a>xyz</a></to></path>', '<response>abc</response>'), "foo") from stubo.ext.transformer import StuboTemplateProcessor context = dict(stub=stub, template_processor=StuboTemplateProcessor()) putter = self._make(mangler=mangler, request=StuboRequest(request), context=context) result = putter.doMatcher() self.assertEqual(result.stub.contains_matchers(), [u'<path><to><a>***</a></to></path>'])
def test_matcher2(self): from stubo.ext.xmlutils import XMLMangler mangler = XMLMangler(elements=dict( a=XPathValue('/path/to/a', extractor=lambda x: x[1:-1]))) request = DummyModel(body='<path><to><a>xyz</a></to></path>', headers={}) from stubo.model.stub import Stub, create stub = Stub( create('<path><to><a>y</a></to></path>', '<response>abc</response>'), "foo") from stubo.ext.transformer import StuboTemplateProcessor context = dict(stub=stub, template_processor=StuboTemplateProcessor()) getter = self._make(mangler=mangler, request=StuboRequest(request), context=context) response = getter.doMatcher() self.assertEqual(response.stub.contains_matchers(), [u'<path><to><a>y</a></to></path>'])
def test_ctor_fails_if_xpath_has_no_extractor(self): from stubo.ext.xmlutils import XMLMangler mangler = XMLMangler(elements=dict(a=XPathValue('/path/to/a'))) response_mangler = XMLMangler(elements=dict(a=XPathValue('/response')), copy_attrs_on_match=True) request = DummyModel(body='<path><to><a>xyz</a></to></path>', headers={}) from stubo.model.stub import Stub, create stub = Stub( create('<path><to><a>xyz</a></to></path>', '<response>abc</response>'), "foo") from stubo.ext.transformer import StuboTemplateProcessor context = dict(stub=stub, template_processor=StuboTemplateProcessor()) with self.assertRaises(ValueError): self._make(response_mangler=response_mangler, mangler=mangler, request=StuboRequest(request), context=context)
def manage_request_api(handler): cache = Cache(get_hostname(handler.request)) action = handler.get_argument('action', None) all_hosts = asbool(handler.get_argument("all_hosts", False)) message = error_message = "" module_info = {} if action is not None: # handle btn action try: name = handler.get_argument('name') # It would be nice to really track these actions handler.track = DummyModel() if action == 'delete': _type = handler.get_argument('type') if _type == 'module': result = delete_module(handler.request, [name]) elif _type == 'delay_policy': result = delete_delay_policy(handler, [name]) elif _type == 'stubs': result = delete_stubs(handler, scenario_name=name, host=all_hosts) else: result = 'error: unexpected action type={0}'.format(_type) elif action == 'end_session': result = end_session(handler, name) elif action == 'end_sessions': result = end_sessions(handler, name) else: result = 'error: unexpected action={0}'.format(action) if 'error' not in result: message = result else: error_message = result except MissingArgumentError, e: error_message = "Error: {0}".format(e) except StuboException, e: error_message = "Error: {0}".format(e.title)
def command_handler_form_request(handler): cmds = handler.get_argument('cmds', None) cmd_file_url = handler.get_argument('cmdfile', None) if not (cmds or cmd_file_url): # TODO: use form validation instead raise exception_response( 400, title="'cmds' or 'cmdFile' parameter not supplied.") log.debug(u'command_handler_form_request: cmd_file={0},cmds={1}'.format( cmd_file_url, cmds)) if cmd_file_url: request = DummyModel(protocol=handler.request.protocol, host=handler.request.host, arguments=handler.request.arguments) response = run_command_file(cmd_file_url, request, handler.settings['static_path']) elif cmds: response = run_commands(handler, cmds) return handler.render_string( "commands.html", page_title='Commands', executed=response['data'].get('executed_commands'))
def post(self): stubo_response = dict(version=version) try: executor = self.settings['process_executor'] cmd_file_url = self.get_argument('cmdfile', None) if not cmd_file_url: # LEGACY cmd_file_url = self.get_argument('cmdFile', None) if not cmd_file_url: raise exception_response( 400, title="'cmdfile' parameter not supplied.") request = DummyModel(protocol=self.request.protocol, host=self.request.host, arguments=self.request.arguments) stubo_response = yield executor.submit( command_handler_request, cmd_file_url, request, self.settings['static_path']) except StuboException, err: stubo_response['error'] = dict(code=err.code, message=err.title) if hasattr(err, 'traceback'): stubo_response['error']['traceback'] = err.traceback self.set_status(err.code)
def _make(self): from stubo.match import StubMatcher from stubo.utils.track import TrackTrace return StubMatcher(TrackTrace(DummyModel(tracking_level='full'), 'matcher'))
def get_stubo_request(self, body=None, **kwargs): from stubo.model.request import StuboRequest from stubo.testing import DummyModel request = DummyModel(body=body or '', headers=dict(**kwargs)) return StuboRequest(request)
def export_playback(self, host, export_payload, files, session, playback_session): playback_payload = export_payload['playback'] scenario_name = playback_payload['scenario'] scenario = u'{0}:{1}'.format(host, scenario_name) runnable_info = dict() tracker = Tracker() last_used = tracker.session_last_used(scenario, playback_session, 'playback') if not last_used: raise exception_response(400, title="Unable to find playback session") runnable_info['last_used'] = dict(remote_ip=last_used['remote_ip'], start_time=str( last_used['start_time'])) playback = tracker.get_last_playback(scenario_name, playback_session, last_used['start_time']) playback = list(playback) if not playback: raise exception_response( 400, title= "Unable to find a playback for scenario='{0}', playback_session='{1}'" .format(scenario_name, playback_session)) number_of_requests = len(playback) runnable_info['number_of_playback_requests'] = number_of_requests for nrequest in range(number_of_requests): track = playback[nrequest] request_text = track.get('request_text') if not request_text: raise exception_response( 400, title= 'Unable to obtain playback details, was full tracking enabled?' ) stubo_request = StuboRequest( DummyModel(headers=track.get('request_headers'), body=request_text)) vars = track.get('request_params') vars.pop('session', None) vars.pop('scenario', None) request_payload = dict(body=stubo_request.body, method=stubo_request.method, host=stubo_request.host, uri=stubo_request.uri, path=stubo_request.path, query=stubo_request.query, headers=stubo_request.headers) request_file_name = '{0}_{1}.request'.format(session, nrequest) files.append( (request_file_name, json.dumps(request_payload, indent=3))) # export a response for comparison stubo_response_text = track['stubo_response'] if not isinstance(stubo_response_text, basestring): stubo_response_text = unicode(stubo_response_text) response_payload = dict(status=track.get('return_code'), body=stubo_response_text, headers=track.get('response_headers')) stubo_response_file_name = '{0}_{1}.stubo_response'.format( session, nrequest) playback_payload['requests'].append( dict(file=request_file_name, vars=vars, response=stubo_response_file_name)) files.append((stubo_response_file_name, json.dumps(response_payload, indent=3))) return runnable_info
def test_raise_on_error_ok(self): fetcher = self._make() response = DummyModel(status_code=200) fetcher.raise_on_error(response, "/some/url")
def _make(self, protocol='http', host='localhost:8001'): from stubo.model.importer import UriLocation return UriLocation(DummyModel(protocol=protocol, host=host))
def get(self, url, verify=False): if 'stubo/api/put/delay_policy' in url: # special case as this is not implemented as a HTTP GET return self.post(url, "") import os.path url = os.path.basename(url) response = DummyModel(headers={}) if url in globals().keys(): response.content = globals()[url] response.status_code = 200 response.headers = {"Content-Type": 'text/html; charset=UTF-8'} if url == 'content_not_json_1': response.encoding = 'utf8' response.text = response.content elif url in ('content_not_json_2', 'content_not_json_3'): response.encoding = "" else: response.headers[ "Content-Type"] = 'application/json; charset=UTF-8' response.json = lambda: response.content else: response.status_code = 404 return response