def update(self, request: Request, response: Response):
channel = -1
level = -1
try:
print(f' channel 0: {request.all()["0"]}')
channel = 0
level = int(request.all()["0"])
except KeyError:
try:
print(f' channel 1: {request.all()["1"]}')
channel = 1
level = int(request.all()["1"])
except KeyError:
print('channel not found')
print(f' setting channel: {channel} to value: {level}')
try:
set_lights(channel, level)
message = 'OK'
except Exception:
message = 'connection error'
# return request.all()
return response.redirect('/')
def store(self, request: Request, mail_manager: MailManager):
ok, errors = self.validate_input(request.all())
if not ok:
display = ''
for error in errors:
request.session.flash(
error, '{0} {1} \n\n\n'.format(error.title(),
errors[error][0]))
return request.redirect('/register')
user = auth.AUTH['model'].create(
name=request.input('name'),
password=bcrypt_password(request.input('password')),
email=request.input('email'),
)
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if Auth(request).login(request.input(auth.AUTH['model'].__auth__),
request.input('password')):
# Redirect to the homepage
return request.redirect('/')
# Login failed. Redirect to the register page.
return request.redirect('/register')
def handle(self, request: Request):
"""
Entry Point for all webhooks
"""
# Turn the hook into a method call
handler = request.input("type").split(".")
handler = "handle_" + "_".join(handler)
if hasattr(self, handler):
return getattr(self, handler)(request.all())
return "Webhook Not Supported"
def sortData(self, view: View, request: Request):
#this is the function in which we sort data we have created an algorithm that sorts all type of data strings,integers... and it returns them as a list of lists
#in order to see the algorithm please go to storage->public->sorting.py
request = request.all(internal_variables=False)
#the controller gets the request from the route and passes it after sorting the data sortBy is the variable responsible of getting what type of data the user would like
#to see such as by total cases, total deaths etc...
liste = self.list
sortBy = request['sortlist']
state = request['state']
if state == 'asc':
value = 1
else:
value = 0
stats = sorting.tri_selection(liste, value, sortBy)
return view.render('Covid-19/worldStats', {'stats': stats})
def show(self, request: Request, view: View):
"""Manual Testing
For manual testing, go to this route: /hashid/test/l9avmeG?id=l9avmeG&name=1
you should see: {'id': 10, 'name': 'Joe'}
Arguments:
request {masonite.request.Request} -- The Masonite request object.
Returns:
dict
"""
from src.masonite.contrib.essentials.helpers import hashid
assert request.param('id') == 10, "parameter of 'id' should be 10"
assert request.all() == {
'id': 10,
'name': 'Joe'
}, "should be a dictionary containing {'id': 10, 'name': 'Joe'}"
assert callable(view.dictionary['hashid']
), 'hashid in the view should be a callable'
return request.all()
def update(self, request: Request, response: Response):
"""Logic to update data from a given model
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
record = self.model.where('id', request.param('id'))
params = request.all()
del params['login_id'], params['login_token']
try:
record.update(params)
except Exception as e:
return {'error': str(e)}
return {
} #self.model.where('id', request.param('id')).get().serialize()
def create(self, request: Request):
del request.request_variables['csrf_token']
# if POST /api/users
proxy = self.__auth__()
for field, value in request.all().items():
if value:
print(field)
if field == 'password':
setattr(proxy, field, password(request.input('password')))
else:
setattr(proxy, field, value)
proxy.save()
return request.redirect('/dashboard/management')
def create(self, request: Request, response: Response):
"""Logic to create data from a given model
"""
if AdminMiddleware(request, response).checkpw_resource() == False:
return response.json(None, status=403)
try:
params = request.all()
del params['login_id'], params['login_token']
config_model = AdminController.get_model_row_by_model_name(
self.model.__doc__.split(' ')[0])
new_model = self.model()
for key, value in params.items():
try:
setattr(new_model, key, value)
except Exception as e:
print(e)
new_model.save()
except Exception as e:
return {'error': str(e)}
return new_model
class TestRequest:
def setup_method(self):
self.request = Request(wsgi_request).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
def test_request_is_callable(self):
""" Request should be callable """
if callable(self.request):
assert True
def test_request_input_should_return_input_on_get_request(self):
assert self.request.input('application') == 'Masonite'
assert self.request.input('application', 'foo') == 'Masonite'
def test_request_input_should_return_default_when_not_exists(self):
assert self.request.input('foo', 'bar') == 'bar'
def test_request_all_should_return_params(self):
assert self.request.all() == {'application': 'Masonite'}
def test_request_all_without_internal_request_variables(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
assert self.request.all() == {
'__token': 'testing',
'application': 'Masonite'
}
assert self.request.all(internal_variables=False) == {
'application': 'Masonite'
}
def test_request_has_should_return_bool(self):
assert self.request.has('application') == True
assert self.request.has('shouldreturnfalse') == False
def test_request_has_should_accept_multiple_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
assert self.request.has('application') == True
assert self.request.has('shouldreturnfalse') == False
assert self.request.has('__token') == True
assert self.request.has('__token', 'shouldreturnfalse') == False
assert self.request.has('__token', 'application') == True
assert self.request.has('__token', 'application',
'shouldreturnfalse') == False
def test_request_set_params_should_return_self(self):
assert self.request.set_params({'value': 'new'}) == self.request
assert self.request.url_params == {'value': 'new'}
def test_request_param_returns_parameter_set_or_false(self):
self.request.set_params({'value': 'new'})
assert self.request.param('value') == 'new'
assert self.request.param('nullvalue') == False
def test_request_appends_cookie(self):
assert self.request.cookie('appendcookie', 'value') == self.request
assert 'appendcookie' in self.request.environ['HTTP_COOKIE']
def test_request_sets_and_gets_cookies(self):
self.request.cookie('setcookie', 'value')
assert self.request.get_cookie('setcookie') == 'value'
def test_request_sets_expiration_cookie_2_months(self):
self.request.cookies = []
self.request.cookie('setcookie_expiration',
'value',
expires='2 months')
time = cookie_expire_time('2 months')
assert self.request.get_cookie('setcookie_expiration') == 'value'
assert 'Expires={0}'.format(time) in self.request.cookies[0][1]
def test_delete_cookie(self):
self.request.cookies = []
self.request.cookie('delete_cookie', 'value')
assert self.request.get_cookie('delete_cookie') == 'value'
self.request.delete_cookie('delete_cookie')
assert not self.request.get_cookie('delete_cookie')
def test_delete_cookie_with_wrong_key(self):
self.request.cookies = []
self.request.cookie('cookie', 'value')
self.request.key('wrongkey_TXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
assert self.request.get_cookie('cookie') is None
def test_redirect_returns_request(self):
assert self.request.redirect('newurl') == self.request
assert self.request.redirect_url == '/newurl'
def test_request_no_input_returns_false(self):
assert self.request.input('notavailable') == False
def test_request_mini_field_storage_returns_single_value(self):
storages = {'test': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == '1'
def test_request_mini_field_storage_doesnt_return_brackets(self):
storages = {'test[]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == '1'
def test_request_mini_field_storage_index(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test[index]') == '1'
def test_request_mini_field_storage_with_dot_notation(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test.index') == '1'
def test_request_mini_field_storage_returns_a_list(self):
storages = {
'test':
[MiniFieldStorage('key', '1'),
MiniFieldStorage('key', '2')]
}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == ['1', '2']
def test_request_get_cookies_returns_cookies(self):
assert self.request.get_cookies() == self.request.cookies
def test_request_set_user_sets_object(self):
assert self.request.set_user(object) == self.request
assert self.request.user_model == object
assert self.request.user() == object
def test_request_loads_app(self):
app = App()
app.bind('Request', self.request)
app.make('Request').load_app(app)
assert self.request.app() == app
assert app.make('Request').app() == app
def test_request_gets_input_from_container(self):
container = App()
container.bind('Application', application)
container.bind('Providers', providers)
container.bind('WSGI', object)
container.bind('Environ', wsgi_request)
for provider in container.make('Providers').PROVIDERS:
container.resolve(provider().load_app(container).register)
container.bind('Response', 'test')
container.bind('WebRoutes', [
Get().route('url', None),
Get().route('url/', None),
Get().route('url/@firstname', None),
])
container.bind('Response', 'Route not found. Error 404')
for provider in container.make('Providers').PROVIDERS:
located_provider = provider().load_app(container)
container.resolve(provider().load_app(container).boot)
assert container.make('Request').input('application') == 'Masonite'
assert container.make('Request').all() == {'application': 'Masonite'}
container.make('Request').environ['REQUEST_METHOD'] = 'POST'
assert container.make('Request').environ['REQUEST_METHOD'] == 'POST'
assert container.make('Request').input('application') == 'Masonite'
def test_redirections_reset(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect('test')
assert request.redirect_url == '/test'
request.reset_redirections()
assert request.redirect_url is False
request.redirect_to('test')
assert request.redirect_url == '/test'
request.reset_redirections()
assert request.redirect_url is False
def test_request_has_subdomain_returns_bool(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
assert request.has_subdomain() is False
assert request.subdomain is None
request.environ['HTTP_HOST'] = 'test.localhost.com'
request.header('TEST', 'set_this')
assert request.header('HTTP_TEST') == 'set_this'
request.header('TEST', 'set_this', http_prefix=None)
assert request.header('TEST') == 'set_this'
def test_redirect_compiles_url(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/test/url'
assert request.compile_route_to_url(route) == '/test/url'
def test_redirect_compiles_url_with_1_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/'
assert request.compile_route_to_url(route) == '/'
def test_request_route_returns_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
assert request.route('test.url') == '/test/url'
assert request.route('test.id', {'id': 1}) == '/test/url/1'
def test_request_route_returns_full_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
assert request.route('test.url',
full=True) == 'http://localhost/test/url'
def test_redirect_compiles_url_with_multiple_slashes(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/url/here'
assert request.compile_route_to_url(route) == '/test/url/here'
def test_redirect_compiles_url_with_trailing_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/url/here/'
assert request.compile_route_to_url(route) == '/test/url/here/'
def test_redirect_compiles_url_with_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id'
params = {
'id': '1',
}
assert request.compile_route_to_url(route, params) == '/test/1'
def test_redirect_compiles_url_with_multiple_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id/@test'
params = {
'id': '1',
'test': 'user',
}
def test_redirect_compiles_url_with_http(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = "http://google.com"
assert request.compile_route_to_url(route) == 'http://google.com'
def test_request_gets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
assert request.header('UPGRADE_INSECURE_REQUESTS') == '1'
assert request.header('RAW_URI') == '/'
assert request.header('NOT_IN') == None
def test_request_sets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'set_this')
assert request.header('HTTP_TEST') == 'set_this'
request.header('TEST', 'set_this', http_prefix=None)
assert request.header('TEST') == 'set_this'
def test_request_gets_all_headers(self):
app = App()
app.bind('Request', Request(wsgi_request))
request = app.make('Request').load_app(app)
request.header('TEST1', 'set_this_item')
request.header('TEST2', 'set_this_item', http_prefix=None)
assert request.get_headers() == [('HTTP_TEST1', 'set_this_item'),
('TEST2', 'set_this_item')]
def test_request_sets_status_code(self):
app = App()
app.bind('Request', self.request)
app.bind('StatusCode', '404 Not Found')
request = app.make('Request').load_app(app)
request.status('200 OK')
assert request.get_status_code() == '200 OK'
def test_request_sets_request_method(self):
wsgi = generate_wsgi()
wsgi['QUERY_STRING'] = '__method=PUT'
request = Request(wsgi)
assert request.has('__method')
assert request.input('__method') == 'PUT'
assert request.get_request_method() == 'PUT'
def test_request_has_should_pop_variables_from_input(self):
self.request.request_variables.update({'key1': 'test', 'key2': 'test'})
self.request.pop('key1', 'key2')
assert self.request.request_variables == {'application': 'Masonite'}
self.request.pop('shouldnotexist')
assert self.request.request_variables == {'application': 'Masonite'}
self.request.pop('application')
assert self.request.request_variables == {}
def test_is_named_route(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
request.path = '/test/url'
assert request.is_named_route('test.url')
request.path = '/test/url/1'
assert request.is_named_route('test.id', {'id': 1})
def test_request_url_from_controller(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', 'TestController@show').name('test.url'),
get('/test/url/@id', 'ControllerTest@show').name('test.id'),
get('/test/url/controller/@id',
TestController.show).name('test.controller'),
])
request = app.make('Request').load_app(app)
assert request.url_from_controller(
'TestController@show') == '/test/url'
assert request.url_from_controller('ControllerTest@show',
{'id': 1}) == '/test/url/1'
assert request.url_from_controller(
TestController.show, {'id': 1}) == '/test/url/controller/1'
def test_contains_for_path_detection(self):
self.request.path = '/test/path'
assert self.request.contains('/test/*')
assert self.request.contains('/test/path')
assert not self.request.contains('/test/wrong')
def test_contains_for_path_with_digit(self):
self.request.path = '/test/path/1'
assert self.request.contains('/test/path/*')
assert self.request.contains('/test/path/*:int')
def test_contains_for_path_with_digit_and_wrong_contains(self):
self.request.path = '/test/path/joe'
assert not self.request.contains('/test/path/*:int')
def test_contains_for_path_with_alpha_contains(self):
self.request.path = '/test/path/joe'
assert self.request.contains('/test/path/*:string')
def test_contains_multiple_asteriks(self):
self.request.path = '/dashboard/user/edit/1'
assert self.request.contains('/dashboard/user/*:string/*:int')
def test_back_returns_correct_url(self):
self.request.path = '/dashboard/create'
self.request.back()
assert self.request.redirect_url == '/dashboard/create'
self.request.back(default='/home')
assert self.request.redirect_url == '/home'
self.request.request_variables = {'__back': '/login'}
self.request.back(default='/home')
assert self.request.redirect_url == '/login'
class TestValidator:
def setup_method(self):
self.request = Request(generate_wsgi())
self.request.request_variables = {'id': '1'}
def test_validator_sets_request(self):
validator = Validator(self.request)
assert validator.request is self.request
def test_email_validator_sets_dictionary(self):
email_validator = Validator(self.request)
email_validator.validate({'id': 1})
assert email_validator.validation_dictionary == {'id': 1}
def test_validator_check_does_not_match(self):
email_validator = Validator(self.request)
email_validator.validate({'id': [Required, Pattern('[a-zA-Z]')]})
assert email_validator.check() is False
def test_validator_check_matches(self):
email_validator = Validator(self.request)
email_validator.validate({'id': [Required, Pattern(r'\d+')]})
assert email_validator.check() is True
def test_validator_error(self):
email_validator = Validator(self.request)
email_validator.validate({'username': [Required]})
assert email_validator.check() is False
assert email_validator.errors()['username'] == 'must be present'
def test_validator_error_without_request(self):
email_validator = Validator()
email_validator.validate({'username': [Required]})
assert email_validator.check({'id': 5}) is False
assert email_validator.errors()['username'] == 'must be present'
def test_validator_check_matches_without_request(self):
email_validator = Validator()
email_validator.validate({'id': [Required, Pattern(r'\d+')]})
assert email_validator.check({'id': '4'}) is True
def test_validator_errors_returns_false(self):
email_validator = Validator()
email_validator.validate({'id': [Required, Pattern(r'\d+')]})
assert email_validator.check({'id': '4'}) is True
assert email_validator.errors() is None
def test_custom_error_message(self):
email_validator = Validator()
email_validator.validate({'id': [Required], 'username': [Required]})
email_validator.messages(
{'id': 'change your id', 'username': '******'})
assert email_validator.check({'tomato': 'true'}) is False
assert email_validator.errors()['id'] == 'change your id'
assert email_validator.errors(
)['username'] == 'dont forget your username'
def test_custom_error_messages_missing_one(self):
email_validator = Validator()
email_validator.validate({'id': [Required]})
email_validator.messages(
{'username': '******'})
assert email_validator.check({'username': '******'}) is False
assert email_validator.errors()['id'] == 'must be present'
def test_validator_length(self):
email_validator = Validator()
email_validator.validate({'id': [Length(0, maximum=2)]})
assert email_validator.check({'id': [1, 2, 3, 4, 5]}) is False
def test_validator_length_with_casted_value(self):
email_validator = CastValidator()
email_validator.test()
assert email_validator.check({'id': '1,2'}) is True
def test_validator_get_with_casted_value(self):
self.request.request_variables = {'id': '1,2'}
email_validator = CastValidator(self.request)
email_validator.test()
assert email_validator.check()
assert email_validator.get('id') == ['1', '2']
assert self.request.all() == {'id': '1,2'}
def test_validator_can_get_validation_error(self):
email_validator = Validator()
email_validator.validate({'id': [Required]})
assert email_validator.check({'name': '1,2'}) is False
assert email_validator.error('id') == 'must be present'
assert email_validator.error('name') == None
class TestRequest(unittest.TestCase):
def setUp(self):
self.app = App()
self.request = Request(wsgi_request).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=').load_app(self.app)
self.app.bind('Request', self.request)
self.response = Response(self.app)
self.app.simple(Response)
def test_request_is_callable(self):
""" Request should be callable """
self.assertIsInstance(self.request, object)
def test_request_input_should_return_input_on_get_request(self):
self.assertEqual(self.request.input('application'), 'Masonite')
self.assertEqual(self.request.input('application', 'foo'), 'Masonite')
def test_request_input_should_return_default_when_not_exists(self):
self.assertEqual(self.request.input('foo', 'bar'), 'bar')
def test_request_all_should_return_params(self):
self.assertEqual(self.request.all(), {'application': 'Masonite'})
def test_request_all_without_internal_request_variables(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.all(), {
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.all(internal_variables=False),
{'application': 'Masonite'})
def test_request_has_should_return_bool(self):
self.assertEqual(self.request.has('application'), True)
self.assertEqual(self.request.has('shouldreturnfalse'), False)
def test_request_has_should_accept_multiple_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.has('application'), True)
self.assertEqual(self.request.has('shouldreturnfalse'), False)
self.assertEqual(self.request.has('__token'), True)
self.assertEqual(self.request.has('__token', 'shouldreturnfalse'),
False)
self.assertEqual(self.request.has('__token', 'application'), True)
self.assertEqual(
self.request.has('__token', 'application', 'shouldreturnfalse'),
False)
def test_request_set_params_should_return_self(self):
self.assertEqual(self.request.set_params({'value': 'new'}),
self.request)
self.assertEqual(self.request.url_params, {'value': 'new'})
def test_request_param_returns_parameter_set_or_false(self):
self.request.set_params({'value': 'new'})
self.assertEqual(self.request.param('value'), 'new')
self.assertEqual(self.request.param('nullvalue'), False)
def test_request_appends_cookie(self):
self.assertEqual(self.request.cookie('appendcookie', 'value'),
self.request)
assert 'appendcookie' in self.request.environ['HTTP_COOKIE']
def test_request_input_can_get_dictionary_elements(self):
self.request.request_variables = {
"user": {
"address": [{
"id": 1,
'street': 'A Street'
}, {
"id": 2,
'street': 'B Street'
}]
}
}
self.assertEqual(self.request.input('user.address.*.id'), [1, 2])
self.assertEqual(self.request.input('user.address.*.street'),
['A Street', 'B Street'])
def test_request_sets_and_gets_cookies(self):
self.request.cookie('setcookie', 'value')
self.assertEqual(self.request.get_cookie('setcookie'), 'value')
def test_request_sets_expiration_cookie_2_months(self):
self.request.cookies = []
self.request.cookie('setcookie_expiration',
'value',
expires='2 months')
time = cookie_expire_time('2 months')
self.assertEqual(self.request.get_cookie('setcookie_expiration'),
'value')
self.assertEqual(
self.request.get_raw_cookie('setcookie_expiration')['expires'],
time)
def test_delete_cookie(self):
self.request.cookies = []
self.request.cookie('delete_cookie', 'value')
self.assertEqual(self.request.get_cookie('delete_cookie'), 'value')
self.request.delete_cookie('delete_cookie')
self.assertFalse(self.request.get_cookie('delete_cookie'))
def test_delete_cookie_with_wrong_key(self):
self.request.cookies = []
self.request.cookie('cookie', 'value')
self.request.key('wrongkey_TXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
self.assertIsNone(self.request.get_cookie('cookie'))
def test_redirect_returns_request(self):
self.assertEqual(self.request.redirect('newurl'), self.request)
self.assertEqual(self.request.redirect_url, '/newurl')
def test_request_no_input_returns_false(self):
self.assertEqual(self.request.input('notavailable'), False)
def test_request_mini_field_storage_returns_single_value(self):
storages = {'test': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), '1')
def test_request_can_get_string_value(self):
storages = {'test': 'value'}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), 'value')
def test_request_can_get_list_value(self):
storages = {'test': ['foo', 'bar']}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), ['foo', 'bar'])
def test_request_mini_field_storage_doesnt_return_brackets(self):
storages = {'test[]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), '1')
def test_request_mini_field_storage_index(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test[index]'), '1')
def test_request_mini_field_storage_with_dot_notation(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test.index'), '1')
def test_request_mini_field_storage_returns_a_list(self):
storages = {
'test':
[MiniFieldStorage('key', '1'),
MiniFieldStorage('key', '2')]
}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), ['1', '2'])
def test_request_get_cookies_returns_cookies(self):
self.assertEqual(self.request.get_cookies(), self.request.cookies)
def test_request_set_user_sets_object(self):
self.assertEqual(self.request.set_user(object), self.request)
self.assertEqual(self.request.user_model, object)
self.assertEqual(self.request.user(), object)
def test_request_loads_app(self):
app = App()
app.bind('Request', self.request)
app.make('Request').load_app(app)
self.assertEqual(self.request.app(), app)
self.assertEqual(app.make('Request').app(), app)
def test_request_gets_input_from_container(self):
container = App()
container.bind('Application', application)
container.bind('Providers', providers)
container.bind('WSGI', object)
container.bind('Environ', wsgi_request)
for provider in container.make('Providers').PROVIDERS:
provider().load_app(container).register()
container.bind('Response', 'test')
container.bind('WebRoutes', [
Get().route('url', 'TestController@show'),
Get().route('url/', 'TestController@show'),
Get().route('url/@firstname', 'TestController@show'),
])
container.bind('Response', 'Route not found. Error 404')
for provider in container.make('Providers').PROVIDERS:
located_provider = provider().load_app(container)
container.resolve(located_provider.boot)
self.assertEqual(
container.make('Request').input('application'), 'Masonite')
self.assertEqual(
container.make('Request').all(), {'application': 'Masonite'})
container.make('Request').environ['REQUEST_METHOD'] = 'POST'
self.assertEqual(
container.make('Request').environ['REQUEST_METHOD'], 'POST')
self.assertEqual(
container.make('Request').input('application'), 'Masonite')
def test_redirections_reset(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect('test')
self.assertEqual(request.redirect_url, '/test')
request.reset_redirections()
self.assertFalse(request.redirect_url)
request.redirect_to('test')
self.assertEqual(request.redirect_url, '/test')
request.reset_redirections()
self.assertFalse(request.redirect_url)
def test_redirect_to_throws_exception_when_no_routes_found(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect_to('test')
request.redirect(name='test')
with pytest.raises(RouteException):
request.redirect_to('notavailable')
with pytest.raises(RouteException):
request.redirect(name='notavailable')
def test_request_has_subdomain_returns_bool(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
self.assertFalse(request.has_subdomain())
self.assertIsNone(request.subdomain)
request.environ['HTTP_HOST'] = 'test.localhost.com'
request.header('TEST', 'set_this')
self.assertEqual(request.header('TEST'), 'set_this')
request.header('TEST', 'set_this', http_prefix=True)
self.assertEqual(request.header('HTTP_TEST'), 'set_this')
def test_redirect_compiles_url(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/test/url'
self.assertEqual(request.compile_route_to_url(route), '/test/url')
def test_redirect_compiles_url_with_1_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/'
self.assertEqual(request.compile_route_to_url(route), '/')
def test_request_route_returns_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
self.assertEqual(request.route('test.url'), '/test/url')
self.assertEqual(request.route('test.id', {'id': 1}), '/test/url/1')
self.assertEqual(request.route('test.id', [1]), '/test/url/1')
with self.assertRaises(RouteException):
self.assertTrue(request.route('not.exists', [1]))
def test_request_route_returns_url_without_passing_args_with_current_param(
self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
request.url_params = {'id': 1}
assert request.route('test.id') == '/test/url/1'
def test_request_redirection(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@testing').name('test.id'),
Get('/test/url/object', TestController.show).name('test.object')
])
request = app.make('Request').load_app(app)
self.assertEqual(
request.redirect('/test/url/@id', {
'id': 1
}).redirect_url, '/test/url/1')
request.redirect_url = None
self.assertEqual(
request.redirect(name='test.url').redirect_url, '/test/url')
request.redirect_url = None
self.assertEqual(
request.redirect(name='test.id', params={
'id': 1
}).redirect_url, '/test/url/1')
request.redirect_url = None
self.assertEqual(
request.redirect(controller='TestController@show').redirect_url,
'/test/url')
request.redirect_url = None
self.assertEqual(
request.redirect(controller=TestController.show).redirect_url,
'/test/url/object')
request.redirect_url = None
self.assertEqual(
request.redirect('some/url').redirect_url, '/some/url')
def test_request_route_returns_full_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
self.assertEqual(request.route('test.url', full=True),
'http://*****:*****@id'
params = {
'id': '1',
}
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1')
def test_redirect_compiles_url_with_list_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id'
params = ['1']
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1')
route = 'test/@id/@user/test/@slug'
params = ['1', '2', '3']
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1/2/test/3')
def test_redirect_compiles_url_with_multiple_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id/@test'
params = {
'id': '1',
'test': 'user',
}
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1/user')
def test_request_compiles_custom_route_compiler(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id:signed'
params = {
'id': '1',
}
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1')
def test_redirect_compiles_url_with_http(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = "http://google.com"
self.assertEqual(request.compile_route_to_url(route),
'http://google.com')
def test_can_get_nully_value(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request._set_standardized_request_variables({
"gateway": "RENDIMENTO",
"request": {
"user": "******"
},
"response": None,
"description": "test only"
})
self.assertEqual(request.input('response'), None)
def test_request_gets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
self.assertEqual(request.header('HTTP_UPGRADE_INSECURE_REQUESTS'), '1')
self.assertEqual(request.header('RAW_URI'), '/')
self.assertEqual(request.header('NOT_IN'), '')
self.assertFalse('text/html' in request.header('NOT_IN'))
def test_request_sets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'set_this')
self.assertEqual(request.header('TEST'), 'set_this')
request.header('TEST', 'set_this', http_prefix=True)
self.assertEqual(request.header('HTTP_TEST'), 'set_this')
def test_request_cant_set_multiple_headers(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'test_this')
request.header('TEST', 'test_that')
self.assertEqual(request.header('TEST'), 'test_that')
def test_request_sets_headers_with_dictionary(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header({
'test_dict': 'test_value',
'test_dict1': 'test_value1'
})
self.assertEqual(request.header('test_dict'), 'test_value')
self.assertEqual(request.header('test_dict1'), 'test_value1')
request.header({
'test_dict': 'test_value',
'test_dict1': 'test_value1'
},
http_prefix=True)
self.assertEqual(request.header('HTTP_test_dict'), 'test_value')
self.assertEqual(request.header('HTTP_test_dict1'), 'test_value1')
def test_request_gets_all_headers(self):
app = App()
app.bind('Request', Request(wsgi_request))
request = app.make('Request').load_app(app)
request.header('TEST1', 'set_this_item')
self.assertEqual(request.get_headers(), [('TEST1', 'set_this_item')])
def test_request_sets_str_status_code(self):
app = App()
app.bind('Request', self.request)
app.bind('StatusCode', 'TestController@show')
request = app.make('Request').load_app(app)
request.status('200 OK')
self.assertEqual(request.get_status_code(), '200 OK')
def test_request_sets_int_status_code(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(request.get_status_code(),
'500 Internal Server Error')
def test_request_gets_int_status(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(request.get_status(), 500)
def test_can_get_code_by_value(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(
request._get_status_code_by_value('500 Internal Server Error'),
500)
def test_is_status_code(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(request.is_status(500), True)
def test_request_sets_invalid_int_status_code(self):
with self.assertRaises(InvalidHTTPStatusCode):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(600)
def test_request_sets_request_method(self):
wsgi = generate_wsgi()
wsgi['QUERY_STRING'] = '__method=PUT'
request = Request(wsgi)
assert request.has('__method')
self.assertEqual(request.input('__method'), 'PUT')
self.assertEqual(request.get_request_method(), 'PUT')
def test_request_has_should_pop_variables_from_input(self):
self.request.request_variables.update({'key1': 'test', 'key2': 'test'})
self.request.pop('key1', 'key2')
self.assertEqual(self.request.request_variables,
{'application': 'Masonite'})
self.request.pop('shouldnotexist')
self.assertEqual(self.request.request_variables,
{'application': 'Masonite'})
self.request.pop('application')
self.assertEqual(self.request.request_variables, {})
def test_is_named_route(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
request.path = '/test/url'
assert request.is_named_route('test.url')
request.path = '/test/url/1'
assert request.is_named_route('test.id', {'id': 1})
def test_route_exists(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
self.assertEqual(request.route_exists('/test/url'), True)
self.assertEqual(request.route_exists('/test/Not'), False)
def test_request_url_from_controller(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'ControllerTest@show').name('test.id'),
Get('/test/url/controller/@id',
TestController.show).name('test.controller'),
])
request = app.make('Request').load_app(app)
self.assertEqual(request.url_from_controller('TestController@show'),
'/test/url')
self.assertEqual(
request.url_from_controller('ControllerTest@show', {'id': 1}),
'/test/url/1')
self.assertEqual(
request.url_from_controller(TestController.show, {'id': 1}),
'/test/url/controller/1')
def test_contains_for_path_detection(self):
self.request.path = '/test/path'
self.assertTrue(self.request.contains('/test/*'))
self.assertTrue(self.request.contains('/test/path'))
self.assertFalse(self.request.contains('/test/wrong'))
def test_contains_for_multiple_paths(self):
self.request.path = '/test/path/5'
self.assertTrue(self.request.contains('/test/*'))
def test_contains_can_return_string(self):
self.request.path = '/test/path/5'
self.assertEqual(self.request.contains('/test/*', show='active'),
'active')
self.assertEqual(self.request.contains('/test/not', show='active'), '')
def test_contains_for_path_with_digit(self):
self.request.path = '/test/path/1'
self.assertTrue(self.request.contains('/test/path/*'))
self.assertTrue(self.request.contains('/test/path/*:int'))
def test_contains_for_path_with_digit_and_wrong_contains(self):
self.request.path = '/test/path/joe'
self.assertFalse(self.request.contains('/test/path/*:int'))
def test_contains_for_path_with_alpha_contains(self):
self.request.path = '/test/path/joe'
self.assertTrue(self.request.contains('/test/path/*:string'))
def test_contains_for_route_compilers(self):
self.request.path = '/test/path/joe'
self.assertTrue(self.request.contains('/test/path/*:signed'))
def test_contains_multiple_asteriks(self):
self.request.path = '/dashboard/user/edit/1'
self.assertTrue(
self.request.contains('/dashboard/user/*:string/*:int'))
def test_request_can_get_input_as_properties(self):
self.request.request_variables = {'test': 'hey'}
self.assertEqual(self.request.test, 'hey')
self.assertEqual(self.request.input('test'), 'hey')
def test_request_can_get_param_as_properties(self):
self.request.url_params = {'test': 'hey'}
self.assertEqual(self.request.test, 'hey')
self.assertEqual(self.request.param('test'), 'hey')
def test_back_returns_correct_url(self):
self.request.path = '/dashboard/create'
self.request.back()
self.assertEqual(self.request.redirect_url, '/dashboard/create')
self.request.back(default='/home')
self.assertEqual(self.request.redirect_url, '/home')
self.request.request_variables = {'__back': '/login'}
self.request.back(default='/home')
self.assertEqual(self.request.redirect_url, '/login')
def test_request_without(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.without('__token'),
{'application': 'Masonite'})
def test_request_only_returns_specified_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.only('application'),
{'application': 'Masonite'})
self.assertEqual(self.request.only('__token'), {'__token': 'testing'})
def test_request_gets_only_clean_output(self):
self.request._set_standardized_request_variables(
{'key': '<img """><script>alert(\'hey\')</script>">'})
self.assertEqual(
self.request.input('key'),
'<img """><script>alert('hey')</script>">'
)
self.assertEqual(self.request.input('key', clean=False),
'<img """><script>alert(\'hey\')</script>">')
def test_request_cleans_all_optionally(self):
self.request._set_standardized_request_variables(
{'key': '<img """><script>alert(\'hey\')</script>">'})
self.assertEqual(
self.request.all()['key'],
'<img """><script>alert('hey')</script>">'
)
self.assertEqual(
self.request.all(clean=False)['key'],
'<img """><script>alert(\'hey\')</script>">')
def test_request_gets_input_with_dotdict(self):
self.request.request_variables = {
"key": {
"user": "******",
"name": "Joe",
"address": {
"street": "address 1"
}
}
}
self.assertEqual(
self.request.input('key')['address']['street'], 'address 1')
self.assertEqual(self.request.input('key.address.street'), 'address 1')
self.assertEqual(self.request.input('key.'), False)
self.assertEqual(self.request.input('key.user'), '1')
self.assertEqual(self.request.input('key.nothing'), False)
self.assertEqual(self.request.input('key.nothing', default='test'),
'test')
def update(self, request: Request):
"""Logic to update data from a given model
"""
record = self.model.find(request.param('id'))
record.update(request.all())
return record
class TestRequest:
def setup_method(self):
self.request = Request(wsgi_request).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
def test_request_is_callable(self):
""" Request should be callable """
if callable(self.request):
assert True
def test_request_input_should_return_input_on_get_request(self):
assert self.request.input('application') == 'Masonite'
def test_request_all_should_return_params(self):
assert self.request.all() == {'application': 'Masonite'}
def test_request_all_without_internal_request_variables(self):
self.request.request_variables.update({'__token': 'testing', 'application': 'Masonite'})
assert self.request.all() == {'__token': 'testing', 'application': 'Masonite'}
assert self.request.all(internal_variables=False) == {'application': 'Masonite'}
def test_request_has_should_return_bool(self):
assert self.request.has('application') == True
assert self.request.has('shouldreturnfalse') == False
def test_request_set_params_should_return_self(self):
assert self.request.set_params({'value': 'new'}) == self.request
assert self.request.url_params == {'value': 'new'}
def test_request_param_returns_parameter_set_or_false(self):
self.request.set_params({'value': 'new'})
assert self.request.param('value') == 'new'
assert self.request.param('nullvalue') == False
def test_request_appends_cookie(self):
assert self.request.cookie('appendcookie', 'value') == self.request
assert 'appendcookie' in self.request.environ['HTTP_COOKIE']
def test_request_sets_and_gets_cookies(self):
self.request.cookie('setcookie', 'value')
assert self.request.get_cookie('setcookie') == 'value'
def test_request_sets_expiration_cookie_2_months(self):
self.request.cookies = []
self.request.cookie('setcookie_expiration', 'value', expires='2 months')
time = cookie_expire_time('2 months')
assert self.request.get_cookie('setcookie_expiration') == 'value'
assert 'Expires={0}'.format(time) in self.request.cookies[0][1]
def test_delete_cookie(self):
self.request.cookies = []
self.request.cookie('delete_cookie', 'value')
assert self.request.get_cookie('delete_cookie') == 'value'
self.request.delete_cookie('delete_cookie')
assert not self.request.get_cookie('delete_cookie')
def test_delete_cookie_with_wrong_key(self):
self.request.cookies = []
self.request.cookie('cookie', 'value')
self.request.key('wrongkey_TXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
assert self.request.get_cookie('cookie') is None
def test_redirect_returns_request(self):
assert self.request.redirect('newurl') == self.request
assert self.request.redirect_url == '/newurl'
def test_request_no_input_returns_false(self):
assert self.request.input('notavailable') == False
def test_request_get_cookies_returns_cookies(self):
assert self.request.get_cookies() == self.request.cookies
def test_request_set_user_sets_object(self):
assert self.request.set_user(object) == self.request
assert self.request.user_model == object
assert self.request.user() == object
def test_request_loads_app(self):
app = App()
app.bind('Request', self.request)
app.make('Request').load_app(app)
assert self.request.app() == app
assert app.make('Request').app() == app
def test_request_gets_input_from_container(self):
container = App()
container.bind('Application', application)
container.bind('Providers', providers)
container.bind('WSGI', object)
container.bind('Environ', wsgi_request)
for provider in container.make('Providers').PROVIDERS:
container.resolve(provider().load_app(container).register)
container.bind('Response', 'test')
container.bind('WebRoutes', [
Get().route('url', None),
Get().route('url/', None),
Get().route('url/@firstname', None),
])
container.bind('Response', 'Route not found. Error 404')
for provider in container.make('Providers').PROVIDERS:
located_provider = provider().load_app(container)
container.resolve(provider().load_app(container).boot)
assert container.make('Request').input('application') == 'Masonite'
assert container.make('Request').all() == {'application': 'Masonite'}
container.make('Request').environ['REQUEST_METHOD'] = 'POST'
assert container.make('Request').environ['REQUEST_METHOD'] == 'POST'
assert container.make('Request').input('application') == 'Masonite'
def test_redirections_reset(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect('test')
assert request.redirect_url == '/test'
request.reset_redirections()
assert request.redirect_url is False
request.redirect_to('test')
assert request.redirect_url == '/test'
request.reset_redirections()
assert request.redirect_url is False
def test_request_has_subdomain_returns_bool(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
assert request.has_subdomain() is False
assert request.subdomain is None
request.environ['HTTP_HOST'] = 'test.localhost.com'
request.header('TEST', 'set_this')
assert request.header('HTTP_TEST') == 'set_this'
request.header('TEST', 'set_this', http_prefix = None)
assert request.header('TEST') == 'set_this'
def test_redirect_compiles_url(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/test/url'
assert request.compile_route_to_url(route) == '/test/url'
def test_redirect_compiles_url_with_1_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/'
assert request.compile_route_to_url(route) == '/'
def test_redirect_compiles_url_with_multiple_slashes(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/url/here'
assert request.compile_route_to_url(route) == '/test/url/here'
def test_redirect_compiles_url_with_trailing_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/url/here/'
assert request.compile_route_to_url(route) == '/test/url/here/'
def test_redirect_compiles_url_with_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id'
params = {
'id': '1',
}
assert request.compile_route_to_url(route, params) == '/test/1'
def test_redirect_compiles_url_with_multiple_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id/@test'
params = {
'id': '1',
'test': 'user',
}
def test_redirect_compiles_url_with_http(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = "http://google.com"
assert request.compile_route_to_url(route) == 'http://google.com'
def test_request_gets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
assert request.header('UPGRADE_INSECURE_REQUESTS') == '1'
assert request.header('RAW_URI') == '/'
assert request.header('NOT_IN') == None
def test_request_sets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'set_this')
assert request.header('HTTP_TEST') == 'set_this'
request.header('TEST', 'set_this', http_prefix = None)
assert request.header('TEST') == 'set_this'
def test_request_gets_all_headers(self):
app = App()
app.bind('Request', Request(wsgi_request))
request = app.make('Request').load_app(app)
request.header('TEST1', 'set_this_item')
request.header('TEST2', 'set_this_item', http_prefix = None)
assert request.get_headers() == [('HTTP_TEST1', 'set_this_item'), ('TEST2', 'set_this_item')]
def test_request_sets_status_code(self):
app = App()
app.bind('Request', self.request)
app.bind('StatusCode', '404 Not Found')
request = app.make('Request').load_app(app)
request.status('200 OK')
assert request.get_status_code() == '200 OK'
def test_request_sets_request_method(self):
wsgi = generate_wsgi()
wsgi['QUERY_STRING'] = '__method=PUT'
request = Request(wsgi)
assert request.has('__method')
assert request.input('__method') == 'PUT'
assert request.get_request_method() == 'PUT'
