def my_write(body): if not body: return origin = webapp.Request(environ).get('_origin') if origin: body = self.tmpl % { 'resp': json.dumps(body), 'origin': json.dumps( urlparse.urljoin( webapp.Request(environ).get('_origin'), '/janky.html')) } write(body)
def test_email_fail(self): subject = 'test' to = 'bad_email_address' sender = '*****@*****.**' body = 'stuff' mymox = mox.Mox() mymox.StubOutWithMock(logging, 'error') logging.error('EmailSender (to: %s, subject: %s), ' 'failed with exception %s' % (to, subject, 'exception')) mymox.StubOutWithMock(mail, 'send_mail') mail.send_mail(sender=sender, subject=subject, to=to, body=body).AndRaise(mail_errors.Error('exception')) handler = send_mail.EmailSender() repo = 'haiti' model.Repo(key_name=repo).put() request = webapp.Request( webob.Request.blank('/admin/send_mail?to=%s&subject=%s&sender=%s' % (to, subject, sender)).environ) request.method = 'POST' request.body = 'body=%s' % body handler.initialize(request, webapp.Response()) mymox.ReplayAll() handler.post() # shouldn't raise an error. assert True mymox.VerifyAll()
def init(self, path, host): environ = webob.Request.blank(path).environ environ['HTTP_HOST'] = host request = webapp.Request(environ) response = webapp.Response() self.handler = utils.BaseHandler(request, response, main.setup_env(request))
def get(self, data, check, mutator): response = webapp.Response() request = webapp.Request(data.request.environ) impl = ShipmentTrackingPageImpl(self.renderer, data) impl.initialize(request, response) impl.handle() response = http.HttpResponse(content=response.body) return response
def renderForm(self, data): response = webapp.Response() request = webapp.Request(data.request.environ) shipment_info = self._getShipmentInfo(data) impl = CreateShipmentInfoHandler(self.renderer, data, shipment_info) impl.initialize(request, response) impl.get() return response.body
def initialize_handler( handler_class, action, repo='haiti', environ=None, params=None): model.Repo(key_name=repo).put() params_str = ('?' + urllib.urlencode(params)) if params else '' request = webapp.Request(webob.Request.blank( '/' + repo + '/' + action + params_str, environ=environ).environ) response = webapp.Response() return handler_class(request, response, main.setup_env(request))
def _InitHandler(self, handler, input_data): """Create fake request, response and handler.""" self._request = webapp.Request({ 'wsgi.input': StringIO.StringIO(input_data), 'CONTENT_LENGTH': len(input_data), 'REQUEST_METHOD': 'POST'}) self._response = webapp.Response() handler.initialize(self._request, self._response)
def get(self, data, check, mutator): response = webapp.Response() request = webapp.Request(data.request.environ) cls = decorator.callback_handler() cls.redirect = redirect handler = cls() handler.initialize(request, response) handler.get() response = http.HttpResponse(content=response.body) return response
def initialize_handler( handler_class, action, repo='haiti', environ=None, params=None): """Initialize handler_cless and return initialized handler. """ params_str = ('?' + urllib.urlencode(params)) if params else '' request = webapp.Request(webob.Request.blank( '/' + repo + '/' + action + params_str, environ=environ).environ) response = webapp.Response() return handler_class(request, response, main.setup_env(request))
def setUp(self): BaseTestCase.setUp(self) self.gw = google.WebAppGateway() self.environ = {'wsgi.input': StringIO(), 'wsgi.output': StringIO()} self.request = webapp.Request(self.environ) self.response = webapp.Response() self.gw.initialize(self.request, self.response)
def __call__(self, environ, start_response): """Called by WSGI when a request comes in.""" request = webapp.Request(environ) response = webapp.Response() response.headers[ 'DAV'] = '1,2' # These headers seem to be required for some clients. response.headers['MS-Author-Via'] = 'DAV' try: self.handle_request(environ, request, response) except Exception, e: self.handle_exception(response, e)
def createHandler(self, cls, uri, env=None, auth=False): handler = cls() environ = { 'wsgi.url_scheme': 'http', 'HTTP_HOST': HOST, 'SCRIPT_NAME': uri, } if auth: environ[ 'HTTP_COOKIE'] = 'dev_appserver_login="******"' if env: environ.update(env) request = webapp.Request(environ) response = webapp.Response() handler.initialize(request, response) return handler, request, response
def make_webapp_request(content, handler_init_method=None): """Makes a webapp request for the validator with content as the HTTP POST content. Returns the response.""" if handler_init_method is None: handler_init_method = controller.ValidatorController request = webapp.Request({ 'wsgi.input': StringIO(), 'REQUEST_METHOD': 'POST', 'PATH_INFO': '/validator' }) for key, val in content.items(): request.POST.add(key, val) response = webapp.Response() handler = handler_init_method() handler.initialize(request, response) handler.post() return response
def ResetHandler(self, change_environ=None): """Reset this tests environment with environment changes. Resets the entire test with a new handler which includes some changes to the default request environment. Args: change_environ: Dictionary of values that are added to default environment. """ environment = self.GetEnvironment() environment.update(change_environ or {}) self.request = webapp.Request(environment) self.response = webapp.Response() self.handler = self.CreateRequestHandler() self.handler.initialize(self.request, self.response)
def Reinitialize(self, input='', get=False, path_method='method1', content_type='text/plain'): """Allows reinitialization of test with custom input values and POST. Args: input: Query string or POST input. get: Use GET method if True. Use POST if False. """ self.factory = service_handlers.ServiceHandlerFactory(Service) self.service_handler = service_handlers.ServiceHandler(self.factory, Service()) self.service_handler.remote_method = path_method request_path = '/servicepath' if path_method: request_path += '/' + path_method if get: request_path += '?' + input if get: environ = {'wsgi.input': cStringIO.StringIO(''), 'CONTENT_LENGTH': '0', 'QUERY_STRING': input, 'REQUEST_METHOD': 'GET', 'PATH_INFO': request_path, } self.service_handler.method = 'GET' else: environ = {'wsgi.input': cStringIO.StringIO(input), 'CONTENT_LENGTH': str(len(input)), 'QUERY_STRING': '', 'REQUEST_METHOD': 'POST', 'PATH_INFO': request_path, } self.service_handler.method = 'POST' self.request = webapp.Request(environ) self.response = webapp.Response() self.service_handler.initialize(self.request, self.response) self.service_handler.request.headers['Content-Type'] = content_type
def Test_StartTagSelector_NewUser(self, session): #global _current_session gaesessions._current_session = session request = webapp.Request({ "wsgi.input": StringIO.StringIO(), "CONTENT_LENGTH": 0, "METHOD": "GET", }) request.get = Mock(return_value="Zardoz59") response = webapp.Response() response.out = Mock() #class under test stsc = StartTagSelectorClass() stsc.initialize(request, response) (word_list, autocomplete_list) = stsc.post_worker(FileTagSourceClass('short')) check.ok_(word_list is not None) check.ok_(autocomplete_list is not None)
def __call__(self, environ, start_response): import logging import sys request = webapp.Request(environ) response = webapp.Response() Application.active_instance = self handler = AppHandler() handler.initialize(request, response) groups = [] try: method = environ['REQUEST_METHOD'] if method == 'GET': handler.get(*groups) elif method == 'POST': handler.post(*groups) elif method == 'HEAD': handler.head(*groups) elif method == 'OPTIONS': handler.options(*groups) elif method == 'PUT': handler.put(*groups) elif method == 'DELETE': handler.delete(*groups) elif method == 'TRACE': handler.trace(*groups) else: handler.error(501) except: logging.exception(sys.exc_info()[1]) import sys from drydrop.lib.nice_traceback import show_error show_error(handler, 500) handler.response.wsgi_write(start_response) return ['']
def create_handler(handler_class, method, url, headers={}, input_body=''): """Creates a webapp.RequestHandler instance and request/response objects.""" environ = { 'wsgi.input': StringIO.StringIO(input_body), 'wsgi.errors': sys.stderr, 'REQUEST_METHOD': method, 'SCRIPT_NAME': '', 'PATH_INFO': url, 'CONTENT_TYPE': headers.pop('content-type', ''), 'CONTENT_LENGTH': headers.pop('content-length', ''), } if method == 'GET': environ['PATH_INFO'], environ['QUERY_STRING'] = ((url.split('?', 1) + [''])[:2]) for name, value in headers.iteritems(): fixed_name = name.replace('-', '_').upper() environ['HTTP_' + fixed_name] = value handler = handler_class() request = webapp.Request(environ) response = webapp.Response() handler.initialize(request, response) return handler
def run_task(self, task): """Runs the given task against the pipeline handlers.""" name = task['name'] method = task['method'] url = task['url'] headers = dict(task['headers']) environ = { 'wsgi.input': StringIO.StringIO(base64.b64decode(task['body'])), 'wsgi.errors': sys.stderr, 'REQUEST_METHOD': method, 'SCRIPT_NAME': '', 'PATH_INFO': url, 'CONTENT_TYPE': headers.get('content-type', ''), 'CONTENT_LENGTH': headers.get('content-length', ''), 'HTTP_X_APPENGINE_TASKNAME': name, 'HTTP_X_APPENGINE_QUEUENAME': self.queue_name, } match_url = url if method == 'GET': environ['PATH_INFO'], environ['QUERY_STRING'] = (( url.split('?', 1) + [''])[:2]) match_url = environ['PATH_INFO'] logging.debug('Executing "%s %s" name="%s"', method, url, name) for pattern, handler_class in pipeline.create_handlers_map(): the_match = re.match('^%s$' % pattern, match_url) if the_match: break else: self.fail('No matching handler for "%s %s"' % (method, url)) handler = handler_class() request = webapp.Request(environ) response = webapp.Response() handler.initialize(request, response) getattr(handler, method.lower())(*the_match.groups())
def create_test_request(method, body, *params): """Creates a webapp.Request object for use in testing. Args: method: Method to use for the test. body: The body to use for the request; implies that *params is empty. *params: List of (key, value) tuples to use in the post-body or query string of the request. Returns: A new webapp.Request object for testing. """ assert not (body and params), 'Must specify body or params, not both' from google.appengine.ext import webapp if body: body = StringIO.StringIO(body) encoded_params = '' else: encoded_params = urllib.urlencode(params) body = StringIO.StringIO() body.write(encoded_params) body.seek(0) environ = os.environ.copy() environ.update({ 'QUERY_STRING': '', 'wsgi.input': body, }) if method.lower() == 'get': environ['REQUEST_METHOD'] = method.upper() environ['QUERY_STRING'] = encoded_params else: environ['REQUEST_METHOD'] = method.upper() environ['CONTENT_TYPE'] = 'application/x-www-form-urlencoded' environ['CONTENT_LENGTH'] = str(len(body.getvalue())) return webapp.Request(environ)
def make_request_with_user_agent(agent): url = '/haiti/main' request = webapp.Request(webapp.Request.blank(url).environ) request.headers['user-agent'] = agent return request
def handler_for_url(self, url): request = webapp.Request(webapp.Request.blank(url).environ) response = webapp.Response() handler = utils.BaseHandler(request, response, main.setup_env(request)) return (request, response, handler)
def handler_for_url(self, url): request = webapp.Request(webapp.Request.blank(url).environ) response = webapp.Response() handler = utils.Handler() handler.initialize(request, response) return (request, response, handler)
def setup_request(path): """Constructs a webapp.Request object for a given request path.""" return webapp.Request(webob.Request.blank(path).environ)
def initialize_handler(self, handler): request = webapp.Request(webob.Request.blank(handler.URL).environ) response = webapp.Response() handler.initialize(request, response) return handler
def runQueuedTasks(queueName='default', assertTasks=True, tasksOverride=None, speedup=True, maxRetries=10): """ Ability to run Tasks from unit/integration tests """ # pylint: disable=W0212 # allow access to protected member _IsValidQueue tq = apiproxy_stub_map.apiproxy.GetStub('taskqueue') if assertTasks: assert tq.GetTasks(queueName) retries = {} runList = [] alreadyRun = [] runAgain = True while runAgain: runAgain = False tasks = tasksOverride or tq.GetTasks(queueName) lastRunList = list(runList) for task in tasks: if task['name'] in alreadyRun: continue if maxRetries is not None: if retries.get(task['name'], 0) > maxRetries: continue if task.has_key('eta'): UTC_OFFSET_TIMEDELTA = datetime.datetime.utcnow() - datetime.datetime.now() now = datetime.datetime.utcfromtimestamp(time.time()) eta = datetime.datetime.strptime(task['eta'], "%Y/%m/%d %H:%M:%S") - UTC_OFFSET_TIMEDELTA if speedup and (runList == lastRunList): # nothing ran list loop around, just force this task to speedup the tests pass elif eta > now: runAgain = True continue record = True if task['url'] == constants.DEFAULT_CLEANUP_URL: record = False handler = FSMFanInCleanupHandler() elif task['url'] == constants.DEFAULT_LOG_URL: record = False handler = FSMLogHandler() else: handler = FSMHandler() parts = task['url'].split('?') assert 1 <= len(parts) <= 2 environ = {'PATH_INFO': parts[0]} if len(parts) == 2: environ['QUERY_STRING'] = parts[1] if task['method'] == 'POST': environ['CONTENT_TYPE'] = 'application/x-www-form-urlencoded' environ['REQUEST_METHOD'] = task['method'] handler.request = webapp.Request(environ) handler.response = webapp.Response() if task['method'] == 'POST': handler.request.body = base64.decodestring(task['body']) handler.request.headers[random.choice(['X-AppEngine-TaskName', 'X-Appengine-Taskname'])] = task['name'] if retries.get(task['name']): handler.request.headers[random.choice(['X-AppEngine-TaskRetryCount', 'X-Appengine-Taskretrycount'])] = retries[task['name']] try: {'GET': handler.get, 'POST': handler.post}[task['method']]() # call the correct dispatch runAgain = True alreadyRun.append(task['name']) if record: runList.append(task['name']) except Exception: logging.debug("Error running Task. This would be a 500 error.", exc_info=1) runAgain = True if record: runList.append(task['name']) retries[task['name']] = retries.get(task['name'], 0) + 1 return runList
def buildRequest(method='GET', get_args=None, post_args=None, referrer=None, path=None, cookies=None, host=None, port=None): """ Builds a request suitable for view.initialize(). """ from urllib import urlencode from Cookie import BaseCookie from StringIO import StringIO if not get_args: get_args = {} if not post_args: post_args = {} wsgi = { 'REQUEST_METHOD': method, 'wsgi.url_scheme': 'http', 'SERVER_NAME': 'localhost', 'SERVER_PORT' : '80' } if get_args: wsgi['QUERY_STRING'] = urlencode(get_args) if referrer: wsgi['HTTP_REFERER'] = referrer if path: wsgi['PATH_INFO'] = path if host: wsgi['SERVER_NAME'] = host if port: wsgi['SERVER_PORT'] = str(port) if cookies: if not isinstance(cookies, BaseCookie): raise Exception('cookies, if set, must be a BaseCookie or subclass.') # HACK the replace('"', '') below is super-weird. For some reason, cookies.output is # creating a string like this: # # wallet="ABC" # # when it should be simply # # wallet=ABC # # I'm sure this hack will eventually break and I sincerely apologize to whomever this # affects. wsgi['HTTP_COOKIE'] = cookies.output(header='', sep=';').strip().replace('"', '') request = webapp.Request(wsgi) if post_args: assert method == 'POST', 'method must be POST for post_args' post_body = urlencode(post_args) wsgi['wsgi.input'] = StringIO(post_body) wsgi['CONTENT_LENGTH'] = len(post_body) return request