def test_filters(self):
request = bottle.BaseRequest(
environ={'QUERY_STRING': 'status=A&status=B,C&other=2'})
expected = {'status': ['A', 'B', 'C'], 'other': '2'}
results = rest.process_params(request,
filter_fields=['status', 'other'])
self.assertEqual(results, expected)
def setUp(self):
"""Set up references to files needed for testing.
"""
# These tests are meant to be fired off from the rest_api folder
self.email = '*****@*****.**'
self.slicer = SlicerFactory.SLIC3R
self.version = Slic3rWrappers.VERSION097
self.request = bottle.BaseRequest()
self.model_filename = 'tests/test.stl'
f = open(self.model_filename, 'r')
self.model = bottle.FormsDict()
self.model.file = f
self.model_raw = f.read()
self.model_filename = 'test.stl'
f.close()
self.config_filename = 'tests/test.ini'
g = open(self.config_filename, 'r')
self.config = bottle.FormsDict()
self.config.file = g
self.config_raw = g.read()
self.config_filename = 'test.ini'
g.close()
logging.info('start tests')
def test_dfaults(self):
request = bottle.BaseRequest(
environ={'QUERY_STRING': 'status=INACTIVE'})
defaults = {'status': 'ACTIVE', 'size': 1}
results = rest.process_params(request,
filter_fields=defaults.keys(),
defaults=defaults)
self.assertEqual(results, {'status': 'INACTIVE', 'size': 1})
def __call__(self, environ, start_response):
request = bottle.BaseRequest(environ)
if self.input_name in request.POST:
method = request.POST[self.input_name].upper()
if method in ['GET', 'POST', 'PUT', 'DELETE']:
environ['REQUEST_METHOD'] = method
return self.app(environ, start_response)
def test_loop_bottle_request(self):
import base64
import bottle
from bottle import tob
from bottle import touni
import wsgiref.util
payload = b'token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmb28iOiJiYXIifQ.6OIg9riYNt9tZ2aMM_CK6TyMKN3OAk0j1W2XDfqfYPU'
e = {}
wsgiref.util.setup_testing_defaults(e)
e['wsgi.input'].write(payload)
e['wsgi.input'].seek(0)
e['REQUEST_METHOD'] = "POST"
e['CONTENT_TYPE'] = "application/x-www-form-urlencoded; charset=utf-8"
e['CONTENT_LENGTH'] = str(len(payload))
e['HTTP_AUTHORIZATION'] = 'basic %s' % touni(base64.b64encode(tob('%s:%s' % ('foobar', 'barsecret'))))
request = bottle.BaseRequest(e)
for i in range(0, loop_iterations):
self.assertAuth(request)
def validate_user_token(self):
if not self._user_auth_middleware:
# following config forces keystone middleware to always return the
# result back in HTTP_X_IDENTITY_STATUS env variable
conf_info = self._conf_info.copy()
conf_info['delay_auth_decision'] = True
self._user_auth_middleware = auth_token.AuthProtocol(
self.token_valid, conf_info)
if not self._user_auth_middleware:
return False, (403, six.ensure_str(" Permission denied"))
request_attrs = {
'REQUEST_METHOD': get_request().route.method,
'bottle.app': get_request().environ['bottle.app'],
}
if 'HTTP_X_AUTH_TOKEN' in get_request().environ:
request_attrs['HTTP_X_AUTH_TOKEN'] =\
get_request().environ['HTTP_X_AUTH_TOKEN'].encode("ascii")
elif 'HTTP_X_USER_TOKEN' in get_request().environ:
request_attrs['HTTP_X_USER_TOKEN'] =\
get_request().environ['HTTP_X_USER_TOKEN'].encode("ascii")
else:
return False, (400,
six.ensure_str("User token needed for validation"))
b_req = bottle.BaseRequest(request_attrs)
# get permissions in internal context
orig_context = get_context()
i_req = ApiInternalRequest(b_req.url, b_req.urlparts, b_req.environ,
b_req.headers, None, None)
set_context(ApiContext(internal_req=i_req))
try:
token_info = self._user_auth_middleware(
get_request().headers.environ, self.start_response)
finally:
set_context(orig_context)
return True, token_info
def test_strange(self):
request = bottle.BaseRequest(environ={'QUERY_STRING': ',,\n??&&'})
with self.assertRaises(bottle.HTTPError):
rest.process_params(request)
def test_blank(self):
request = bottle.BaseRequest(environ={'QUERY_STRING': ''})
results = rest.process_params(request)
self.assertEqual(results, {})
def test_invalid(self):
request = bottle.BaseRequest(environ={'QUERY_STRING': 'foo=bar'})
with self.assertRaises(bottle.HTTPError):
rest.process_params(request)
def test_text(self):
request = bottle.BaseRequest(environ={'QUERY_STRING': 'q=txt'})
results = rest.process_params(request)
self.assertEqual(results, {'q': ['txt']})
def test_standard(self):
request = bottle.BaseRequest(
environ={'QUERY_STRING': 'limit=100&offset=0&facets=status'})
results = rest.process_params(request)
self.assertEqual(results, {})
def test_sort(self):
request = bottle.BaseRequest(
environ={'QUERY_STRING': 'sort=up&sort=-down'})
expected = {'sort': ['up', '-down']}
self.assertEqual(rest.process_params(request), expected)