def test_get_entity_string(self):
request = webapp2.Request.blank(
'/datastore/edit/%s?next=http://next/' % self.entity1.key())
response = webapp2.Response()
handler = datastore_viewer.DatastoreEditRequestHandler(
request, response)
handler.render(
'datastore_edit.html', {
'fields':
[('dateprop', 'overflowdatetime',
mox.Regex('^<input class="overflowdatetime".*'
'value="1152921504606846976".*$')),
('intprop', 'int',
mox.Regex('^<input class="int".*value="1".*$')),
('listprop', 'list', mox.Regex(r'\[7L?, 8L?, 9L?\]'))],
'key':
str(self.entity1.key()),
'key_id':
123,
'key_name':
None,
'kind':
'Kind1',
'namespace':
'',
'next':
'http://next/',
'parent_key':
None,
'parent_key_string':
None
})
self.mox.ReplayAll()
handler.get(str(self.entity1.key()))
self.mox.VerifyAll()
def setUp(self):
self.mox = mox.Mox()
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_memcache_stub()
self.testbed.init_app_identity_stub()
self.testbed.init_urlfetch_stub()
self.attachment_data = ""
self._old_gcs_open = cloudstorage.open
cloudstorage.open = fake.gcs_open
services = service_manager.Services(
project=fake.ProjectService(),
config=fake.ConfigService(),
issue=fake.IssueService(),
user=fake.UserService())
self.project = services.project.TestAddProject('proj')
self.servlet = issueattachment.AttachmentPage(
'req', webapp2.Response(), services=services)
services.user.TestAddUser('*****@*****.**', 111)
self.issue = fake.MakeTestIssue(
self.project.project_id, 1, 'summary', 'New', 111)
services.issue.TestAddIssue(self.issue)
self.comment = tracker_pb2.IssueComment(
id=123, issue_id=self.issue.issue_id,
project_id=self.project.project_id, user_id=111,
content='this is a comment')
services.issue.TestAddComment(self.comment, self.issue.local_id)
self.attachment = tracker_pb2.Attachment(
attachment_id=54321, filename='hello.txt', filesize=23432,
mimetype='text/plain', gcs_object_id='/pid/attachments/object_id')
services.issue.TestAddAttachment(
self.attachment, self.comment.id, self.issue.issue_id)
self.orig_sign_attachment_id = attachment_helpers.SignAttachmentID
attachment_helpers.SignAttachmentID = (
lambda aid: 'signed_%d' % aid)
def test_page_request(self):
for i in range(1000):
entity = datastore.Entity('Kind1', id=i + 1, _app=self.app_id)
entity['intprop'] = i
datastore.Put(entity)
request = webapp2.Request.blank('/datastore?kind=Kind1&page=3')
response = webapp2.Response()
handler = datastore_viewer.DatastoreRequestHandler(request, response)
admin_request_handler.AdminRequestHandler(handler).get()
handler.render(
'datastore_viewer.html',
{
'entities':
mox.IgnoreArg(), # Tested with _get_entity_template_data.
'headers':
mox.IgnoreArg(), # Tested with _get_entity_template_data.
'kind': 'Kind1',
'kinds': ['Kind1'],
'message': None,
'namespace': '',
'num_pages': 50,
'order': None,
'order_base_url': '/datastore?kind=Kind1&page=3',
'page': 3,
'paging_base_url': '/datastore?kind=Kind1',
'select_namespace_url':
'/datastore?kind=Kind1&namespace=&page=3',
'show_namespace': False,
'start': 40,
'total_entities': 1000
})
self.mox.ReplayAll()
handler.get()
self.mox.VerifyAll()
def test_get(self):
queue1 = taskqueue_utils.QueueInfo(
name='queue1',
mode=taskqueue_service_pb.TaskQueueMode.PUSH,
rate='10/s',
bucket_size=20,
tasks_in_queue=10,
oldest_eta_usec=-1)
queue2 = taskqueue_utils.QueueInfo(
name='queue1',
mode=taskqueue_service_pb.TaskQueueMode.PUSH,
rate='20/s',
bucket_size=20,
tasks_in_queue=10,
oldest_eta_usec=-1)
queue3 = taskqueue_utils.QueueInfo(
name='queue1',
mode=taskqueue_service_pb.TaskQueueMode.PULL,
rate='20/s',
bucket_size=20,
tasks_in_queue=10,
oldest_eta_usec=-1)
taskqueue_utils.QueueInfo.get().AndReturn([queue1, queue2, queue3])
request = webapp2.Request.blank('/taskqueue')
response = webapp2.Response()
handler = taskqueue_queues_handler.TaskQueueQueuesHandler(
request, response)
handler.render('taskqueue_queues.html', {
'push_queues': [queue1, queue2],
'pull_queues': [queue3]
})
self.mox.ReplayAll()
handler.get()
self.mox.VerifyAll()
def test_namespace_request(self):
entity = datastore.Entity('Kind1',
id=123,
_app=self.app_id,
_namespace='google')
entity['intprop'] = 1
entity['listprop'] = [7, 8, 9]
datastore.Put(entity)
request = webapp2.Request.blank(
'/datastore?kind=Kind1&namespace=google')
response = webapp2.Response()
handler = datastore_viewer.DatastoreRequestHandler(request, response)
admin_request_handler.AdminRequestHandler(handler).get()
handler.render(
'datastore_viewer.html',
{'entities': mox.IgnoreArg(), # Tested with _get_entity_template_data.
'headers': mox.IgnoreArg(), # Tested with _get_entity_template_data.
'kind': 'Kind1',
'kinds': ['Kind1'],
'message': None,
'namespace': 'google',
'num_pages': 1,
'order': None,
'order_base_url': '/datastore?kind=Kind1&namespace=google',
'page': 1,
'paging_base_url': '/datastore?kind=Kind1&namespace=google',
'select_namespace_url':
'/datastore?kind=Kind1&namespace=google',
'show_namespace': True,
'start': 0,
'total_entities': 1})
self.mox.ReplayAll()
handler.get()
self.mox.VerifyAll()
def lockdown_dispatcher(router, request, response):
"""Override dispatch to provide lockdown support
"""
username = settings.LOCKDOWN_USERNAME
password = settings.LOCKDOWN_PASSWORD
# Don't lock down if the URL matches an exception pattern.
unlocked_url = False
for pattern in _default_url_exceptions:
if pattern.search(request.path):
unlocked_url = True
break
if not unlocked_url and not check_auth(request, username, password):
msg = 'Could not verify your access level for that URL. ' \
'You have to login with proper credentials'
resp = webapp2.Response(msg)
resp.set_status(401)
resp.headers['WWW-Authenticate'] = 'Basic realm="Login Required"'
return resp
# Dispatch the request using nacelle's regular dispatcher.
return nacelle_dispatcher(router, request, response)
def test_empty_request_and_empty_datastore(self):
request = webapp2.Request.blank('/datastore')
response = webapp2.Response()
handler = datastore_viewer.DatastoreRequestHandler(request, response)
handler.render('datastore_viewer.html',
{'entities': [],
'headers': [],
'kind': None,
'kinds': [],
'message': None,
'namespace': '',
'num_pages': 0,
'order': None,
'paging_base_url': '/datastore?',
'order_base_url': '/datastore?',
'page': 1,
'select_namespace_url': '/datastore?namespace=',
'show_namespace': False,
'start': 0,
'total_entities': 0})
self.mox.ReplayAll()
handler.get()
self.mox.VerifyAll()
def test_post(self):
self.mox.StubOutWithMock(cron_handler.CronHandler, 'dispatcher')
request = webapp2.Request.blank('/cron',
POST={
'url': '/url',
'target': 'module_name'
})
response = webapp2.Response()
handler = cron_handler.CronHandler(request, response)
admin_request_handler.AdminRequestHandler(handler).post()
handler.dispatcher = self.mox.CreateMock(dispatcher.Dispatcher)
handler.dispatcher.add_request(method='GET',
relative_url='/url',
headers=[('X-AppEngine-Cron', 'true')],
body='',
module_name='module_name',
source_ip='0.1.0.1').AndReturn(
dispatcher.ResponseTuple(
'500 Internal Server Error', [],
''))
self.mox.ReplayAll()
handler.post()
self.mox.VerifyAll()
self.assertEqual(500, response.status_int)
def test_write(self):
var_1 = NoStringOrUnicodeConversion()
var_2 = StringConversion()
var_3 = UnicodeConversion()
rsp = webapp2.Response()
rsp.write(var_1)
rsp.write(var_2)
rsp.write(var_3)
self.assertEqual(rsp.body, webapp2._to_utf8('%rfoobar' % var_1))
rsp = webapp2.Response()
rsp.write(var_1)
rsp.write(var_3)
rsp.write(var_2)
self.assertEqual(rsp.body, webapp2._to_utf8('%rbarfoo' % var_1))
rsp = webapp2.Response()
rsp.write(var_2)
rsp.write(var_1)
rsp.write(var_3)
self.assertEqual(rsp.body, webapp2._to_utf8('foo%rbar' % var_1))
rsp = webapp2.Response()
rsp.write(var_2)
rsp.write(var_3)
rsp.write(var_1)
self.assertEqual(rsp.body, webapp2._to_utf8('foobar%r' % var_1))
rsp = webapp2.Response()
rsp.write(var_3)
rsp.write(var_1)
rsp.write(var_2)
self.assertEqual(rsp.body, webapp2._to_utf8('bar%rfoo' % var_1))
rsp = webapp2.Response()
rsp.write(var_3)
rsp.write(var_2)
rsp.write(var_1)
self.assertEqual(rsp.body, webapp2._to_utf8('barfoo%r' % var_1))
def test_cookie_unicode(self):
import urllib
import base64
# With base64 ---------------------------------------------------------
value = base64.b64encode(u'á'.encode('utf-8'))
rsp = webapp2.Response()
rsp.set_cookie('foo', value)
cookie = rsp.headers.get('Set-Cookie')
req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])
self.assertEqual(req.cookies.get('foo'), value)
self.assertEqual(
base64.b64decode(req.cookies.get('foo')).decode('utf-8'), u'á')
# Without quote -------------------------------------------------------
# Most recent WebOb versions take care of quoting.
# (not the version available on App Engine though)
value = u'föö=bär; föo, bär, bäz=dïng;'
rsp = webapp2.Response()
rsp.set_cookie('foo', value)
cookie = rsp.headers.get('Set-Cookie')
req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])
self.assertEqual(req.cookies.get('foo'), value)
# With quote, hard way ------------------------------------------------
# Here is our test value.
x = u'föö'
# We must store cookies quoted. To quote unicode, we need to encode it.
y = urllib.quote(x.encode('utf8'))
# The encoded, quoted string looks ugly.
self.assertEqual(y, 'f%C3%B6%C3%B6')
# But it is easy to get it back to our initial value.
z = urllib.unquote(y).decode('utf8')
# And it is indeed the same value.
self.assertEqual(z, x)
# Set a cookie using the encoded/quoted value.
rsp = webapp2.Response()
rsp.set_cookie('foo', y)
cookie = rsp.headers.get('Set-Cookie')
self.assertEqual(cookie, 'foo=f%C3%B6%C3%B6; Path=/')
# Get the cookie back.
req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])
self.assertEqual(req.cookies.get('foo'), y)
# Here is our original value, again. Problem: the value is decoded
# before we had a chance to unquote it.
w = urllib.unquote(
req.cookies.get('foo').encode('utf8')).decode('utf8')
# And it is indeed the same value.
self.assertEqual(w, x)
# With quote, easy way ------------------------------------------------
value = u'föö=bär; föo, bär, bäz=dïng;'
quoted_value = urllib.quote(value.encode('utf8'))
rsp = webapp2.Response()
rsp.set_cookie('foo', quoted_value)
cookie = rsp.headers.get('Set-Cookie')
req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])
cookie_value = req.str_cookies.get('foo')
unquoted_cookie_value = urllib.unquote(cookie_value).decode('utf-8')
self.assertEqual(cookie_value, quoted_value)
self.assertEqual(unquoted_cookie_value, value)
def get(self):
ret = webapp2.Response()
ret.set_status(200)
return ret
def requestInitialize(handler, url):
request_vars = webapp2.Request.blank(url)
handler.initialize(request_vars, webapp2.Response())
setattr(handler, "is_initialized", True)
def handle_exception(request, response, exception):
return webapp2.Response(body="Hello, custom response world!")
def textres(content, **kwargs):
headers = {}
if "type" in kwargs:
headers['Content-Type'] = kwargs["type"]
return webapp2.Response(content, headers=headers)
def get(self):
client = SheriffConfigClient()
ok, err_msg = client.Update()
if not ok:
return webapp2.Response('FAILED: %s' % err_msg)
return webapp2.Response('OK')
def test_uri_for(self):
class Handler(webapp2.RequestHandler):
def get(self, *args, **kwargs):
pass
req = webapp2.Request.blank('http://localhost:80/')
req.route = webapp2.Route('')
req.route_args = tuple()
req.route_kwargs = {}
req.app = app
app.set_globals(app=app, request=req)
handler = Handler(req, webapp2.Response())
handler.app = app
for func in (handler.uri_for, ):
self.assertEqual(func('home'), '/')
self.assertEqual(func('home', foo='bar'), '/?foo=bar')
self.assertEqual(func('home', _fragment='my-anchor', foo='bar'),
'/?foo=bar#my-anchor')
self.assertEqual(func('home', _fragment='my-anchor'),
'/#my-anchor')
self.assertEqual(func('home', _full=True), 'http://localhost:80/')
self.assertEqual(func('home', _full=True, _fragment='my-anchor'),
'http://localhost:80/#my-anchor')
self.assertEqual(func('home', _scheme='https'),
'https://localhost:80/')
self.assertEqual(func('home', _scheme='https', _full=False),
'https://localhost:80/')
self.assertEqual(
func('home', _scheme='https', _fragment='my-anchor'),
'https://localhost:80/#my-anchor')
self.assertEqual(func('methods'), '/methods')
self.assertEqual(func('methods', foo='bar'), '/methods?foo=bar')
self.assertEqual(func('methods', _fragment='my-anchor', foo='bar'),
'/methods?foo=bar#my-anchor')
self.assertEqual(func('methods', _fragment='my-anchor'),
'/methods#my-anchor')
self.assertEqual(func('methods', _full=True),
'http://localhost:80/methods')
self.assertEqual(
func('methods', _full=True, _fragment='my-anchor'),
'http://localhost:80/methods#my-anchor')
self.assertEqual(func('methods', _scheme='https'),
'https://localhost:80/methods')
self.assertEqual(func('methods', _scheme='https', _full=False),
'https://localhost:80/methods')
self.assertEqual(
func('methods', _scheme='https', _fragment='my-anchor'),
'https://localhost:80/methods#my-anchor')
self.assertEqual(
func('route-test', year='2010', month='07', name='test'),
'/2010/07/test')
self.assertEqual(
func('route-test',
year='2010',
month='07',
name='test',
foo='bar'), '/2010/07/test?foo=bar')
self.assertEqual(
func('route-test',
_fragment='my-anchor',
year='2010',
month='07',
name='test',
foo='bar'), '/2010/07/test?foo=bar#my-anchor')
self.assertEqual(
func('route-test',
_fragment='my-anchor',
year='2010',
month='07',
name='test'), '/2010/07/test#my-anchor')
self.assertEqual(
func('route-test',
_full=True,
year='2010',
month='07',
name='test'), 'http://localhost:80/2010/07/test')
self.assertEqual(
func('route-test',
_full=True,
_fragment='my-anchor',
year='2010',
month='07',
name='test'),
'http://localhost:80/2010/07/test#my-anchor')
self.assertEqual(
func('route-test',
_scheme='https',
year='2010',
month='07',
name='test'), 'https://localhost:80/2010/07/test')
self.assertEqual(
func('route-test',
_scheme='https',
_full=False,
year='2010',
month='07',
name='test'), 'https://localhost:80/2010/07/test')
self.assertEqual(
func('route-test',
_scheme='https',
_fragment='my-anchor',
year='2010',
month='07',
name='test'),
'https://localhost:80/2010/07/test#my-anchor')
def test_flashes(self):
# Round 1 -------------------------------------------------------------
req = webapp2.Request.blank("/")
req.app = app
store = sessions.SessionStore(req)
session = store.get_session(factory=self.factory)
flashes = session.get_flashes()
self.assertEqual(flashes, [])
session.add_flash("foo")
rsp = webapp2.Response()
store.save_sessions(rsp)
# Round 2 -------------------------------------------------------------
cookies = rsp.headers.get("Set-Cookie")
req = webapp2.Request.blank("/", headers=[("Cookie", cookies)])
req.app = app
store = sessions.SessionStore(req)
session = store.get_session(factory=self.factory)
flashes = session.get_flashes()
self.assertEqual(flashes, [["foo", None]])
flashes = session.get_flashes()
self.assertEqual(flashes, [])
session.add_flash("bar")
session.add_flash("baz", "important")
rsp = webapp2.Response()
store.save_sessions(rsp)
# Round 3 -------------------------------------------------------------
cookies = rsp.headers.get("Set-Cookie")
req = webapp2.Request.blank("/", headers=[("Cookie", cookies)])
req.app = app
store = sessions.SessionStore(req)
session = store.get_session(factory=self.factory)
flashes = session.get_flashes()
self.assertEqual(flashes, [["bar", None], ["baz", "important"]])
flashes = session.get_flashes()
self.assertEqual(flashes, [])
rsp = webapp2.Response()
store.save_sessions(rsp)
# Round 4 -------------------------------------------------------------
cookies = rsp.headers.get("Set-Cookie")
req = webapp2.Request.blank("/", headers=[("Cookie", cookies)])
req.app = app
store = sessions.SessionStore(req)
session = store.get_session(factory=self.factory)
flashes = session.get_flashes()
self.assertEqual(flashes, [])
def myfunction(request, *args, **kwargs):
return webapp2.Response('Hello, custom response world!')
def response_ok_raw(self, message):
response = webapp2.Response(message)
response.set_status(self.HTTP_OK)
return response
def set_headers():
rsp = webapp2.Response()
rsp.headers = 'foo'
return rsp.headers
def myhandler(request, *args, **kwargs):
return webapp2.Response('hello')
def setUp(self):
super(SubNotifyTest, self).setUp()
self.handler = swarming.SubNotify(response=webapp2.Response())
def hello(request):
users=user.query().fetch()
return webapp2.Response(template.render("index.html", {"user":users}))
def my_view(request, *args, **kwargs):
return webapp2.Response('Hello, function world!')
def signup(request):
return webapp2.Response(template.render("signup.html", None))
def other_view(request, *args, **kwargs):
return webapp2.Response('Hello again, function world!')
def setUp(self):
request = webapp2.Request.blank('/settings')
response = webapp2.Response()
self.handler = users.SettingsHandler(request, response)
def one_more_view(request, *args, **kwargs):
self.assertEqual(args, ())
self.assertEqual(kwargs, {'foo': 'bar'})
return webapp2.Response('Hello you too!')
def jsonres(content):
return webapp2.Response(json.dumps(content))
def response_ok(self, data={}):
response = webapp2.Response(json.dumps(data))
response.set_status(self.HTTP_OK)
return response
