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
