def test_default_language(self): """Verify that language_menu_options[0] is used as the default.""" request = setup_request('/haiti/start') handler = main.Main(request, webapp.Response()) assert handler.env.lang == 'en' # first language in the options list assert django.utils.translation.get_language() == 'en' config.set_for_repo('haiti', language_menu_options=['fr', 'ht', 'es']) request = setup_request('/haiti/start') handler = main.Main(request, webapp.Response()) assert handler.env.lang == 'fr' # first language in the options list assert django.utils.translation.get_language() == 'fr'
def test_unicode_cookie(self): """see http://stackoverflow.com/questions/6839922/unicodedecodeerror-is-raised-when-getting-a-cookie-in-google-app-engine """ import urllib # This is the value we want to set. initial_value = u'äëïöü' # WebOb version that comes with SDK doesn't quote cookie values. # So we have to do it. quoted_value = urllib.quote(initial_value.encode('utf-8')) rsp = webapp.Response() rsp.headers['Set-Cookie'] = 'app=%s; Path=/' % quoted_value cookie = rsp.headers.get('Set-Cookie') req = webapp.Request.blank('/', headers=[('Cookie', cookie)]) # The stored value is the same quoted value from before. stored_value = req.cookies.get('app') self.assertEqual(stored_value, quoted_value) # And we can get the initial value unquoting and decoding. final_value = urllib.unquote( stored_value.encode('utf-8')).decode('utf-8') self.assertEqual(final_value, initial_value)
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 _invoke_local(self, method, data=""): handler = ProxyHandler() req = webapp.Request.blank(self.url) req.route = webapp.BaseRoute(None) req.route_args = () req.route_kwargs = {} req.method = method if data != None: req.body = data handler.initialize(req, webapp.Response()) handler.dispatch() result = handler.response if re.match('image/.*', result.headers['Content-Type']): # TODO(jpolitz): is this sufficient wrapping? class Wrapper(object): def __init__(self): self.content = result.body self.content_was_truncated = False self.status_code = 200 self.headers = result.headers self.final_url = capURL return Wrapper() else: return self.cap_server.data_post_process(result.body)
def handle_body(self, method, body): """Runs a test of a webapp.RequestHandler with a POST body. Args: method: The HTTP method to invoke for this test. body: The body payload bytes. """ from google.appengine.ext import webapp before_software = os.environ.get('SERVER_SOFTWARE') before_auth_domain = os.environ.get('AUTH_DOMAIN') before_email = os.environ.get('USER_EMAIL') os.environ['wsgi.url_scheme'] = 'http' os.environ['SERVER_NAME'] = 'example.com' os.environ['SERVER_PORT'] = '' try: if not before_software: os.environ['SERVER_SOFTWARE'] = 'Development/1.0' if not before_auth_domain: os.environ['AUTH_DOMAIN'] = 'example.com' if not before_email: os.environ['USER_EMAIL'] = '' self.resp = webapp.Response() self.req = create_test_request(method, body) handler = self.handler_class() handler.initialize(self.req, self.resp) getattr(handler, method.lower())() logging.info('%r returned status %d: %s', self.handler_class, self.response_code(), self.response_body()) finally: del os.environ['SERVER_SOFTWARE'] del os.environ['AUTH_DOMAIN'] del os.environ['USER_EMAIL']
def test_shiftjis_get(self): """Tests Shift-JIS encoding of GET query parameters.""" request = setup_request( '/japan/results?charsets=shift_jis&query=%8D%B2%93%A1&role=seek&') handler = main.Main(request, webapp.Response()) assert handler.env.charset == 'shift_jis' assert request.charset == 'shift_jis' assert request.get('query') == u'\u4F50\u85E4'
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 test_shiftjis_post(self): """Tests Shift-JIS encoding of POST query parameters.""" request = setup_request('/japan/post?') request.body = 'charsets=shift_jis&given_name=%8D%B2%93%A1' request.method = 'POST' handler = main.Main(request, webapp.Response()) assert handler.env.charset == 'shift_jis' assert request.charset == 'shift_jis' assert request.get('given_name') == u'\u4F50\u85E4'
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 _init_http(self, method, url): self.request = webapp.Request.blank(url, environ={'REQUEST_METHOD': method}) #self.request.set_status = lambda x: self.request.status self.response = webapp.Response( ) #webob.Response(request=self.request)) self.dispatcher = Dispatcher() self.dispatcher.initialize(self.request, self.response) interceptor.intercept = lambda kw: None if method == 'GET': self.dispatcher.get() else: self.dispatcher.post()
def test_content_security_policy_for_react(self): """Verify CSP is set when the React UI is enabled.""" config.set(enable_react_ui=True) request = setup_request('/') response = webapp.Response() handler = main.Main(request, response) with patch('utils.generate_random_key') as generate_random_key_mock: generate_random_key_mock.return_value = 'totallyrandomkey' handler.get() assert 'Content-Security-Policy' in response.headers assert ('nonce-totallyrandomkey' in response.headers['Content-Security-Policy']) assert 'nonce="totallyrandomkey"' in response.body
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 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 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 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 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 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