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
