def store(self, request: Request, auth: Auth, validate: Validator,
view: View):
user = User.all()
email = User.lists('email')
pw = User.lists('password')
errors = request.validate(validate.required(['email', 'password']),
validate.email('email'))
#checks for errors in login inputs and redirects user back to login page.
if errors:
return request.back().with_errors(errors).with_input()
elif request.input('email') not in email and request.input(
'password') not in pw:
return request.back().with_errors(
{'email': ["Email and password not found. Please register."]})
#check to see if user already had an account which they may have closed/cancelled and need to register for a new account or reactivate account.
if user.where('email',
request.input('email')).where('cancelled', 'Yes'):
# cancelled = True
user_id = User.where('email',
request.input('email')).get().pluck('id')
return request.redirect('/reregister/' + str(user_id[0]))
#logins user if no errors and account has not been closed/cancelled before
if auth.login(request.input('email'), request.input('password')):
return request.redirect('/')
# returns back to login page if email or password are incorrect
return request.back().with_errors(
{'email': ["Email or password is incorrect"]})
def update(self, view: View, request: Request, validate: Validator, mail: Mail):
schedule_date_info = request.input('date')
customer = request.user()
#checking that all required fields are entered and no errors are found.
errors = request.validate(
validate.required(['service_type', 'name', 'address']))
if errors:
return request.back().with_errors(errors)
if not schedule_date_info[0] or not schedule_date_info[1]:
request.session.flash('success', "The service date and service time is required.")
return request.back()
update_schedule = Schedule.where('id', '=', request.param('slug')).update(service=request.input('service_type'),
service_date=schedule_date_info[0], service_time=schedule_date_info[1])
#need to changed this variable to current new updated info to send in email confirmation.
customer_schedule = Schedule.get().last()
#sends email with pool appointment schedule details
mail.subject('Pool Appointment Update Confirmation').to(customer.email).template('mail/appt_confirm', {'service_id': request.param('slug'), 'service': customer_schedule.service,
'service_date':customer_schedule.service_date, 'service_time':customer_schedule.service_time}).send()
request.session.flash('success', 'Your appointment has been updated! A confirmation email has been sent.')
return request.redirect('/')
def send(self, view: View, request: Request, auth: Auth,
validate: Validator, mail: Mail):
email_list = User.lists('email')
email = request.input('email')
encoded_jwt = jwt.encode(
{
'email': email,
'httpMethod': 'GET'
},
'secret',
algorithm='HS256',
).decode('utf-8')
errors = request.validate(validate.required('email'),
validate.email('email'))
if errors:
return request.back().with_errors(errors)
if email not in email_list:
return request.back().with_errors({
'error':
['We can not find your email. Please enter correct email']
})
else:
message = 'Please visit {}/password/reset/get/{} to reset your password'.format(
env('APP_URL', 'http://localhost:8000'), encoded_jwt)
mail.subject('Reset Password Instructions').to(email).send(message)
request.session.flash(
'success',
'An email has been sent. Please follow the instructions in the email to reset your password.'
)
return request.redirect('login'), email
def reregister(self, request: Request, validate: Validator, auth: Auth):
today_date = date.today()
errors = request.validate(
validate.required([
'firstname', 'lastname', 'address', 'email', 'username',
'password', 'cell_phone'
]),
validate.email('email'),
validate.strong(
'password',
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False))
if errors:
return request.back().with_errors(errors).with_input()
if request.input('password') != request.input('password_confirm'):
return request.back().with_errors({
'error':
['Passwords do not match. Please make sure passwords match']
})
User.where(
'id',
request.param('id')).update(firstname=request.input('firstname'))
User.where(
'id',
request.param('id')).update(lastname=request.input('lastname'))
User.where(
'id', request.param('id')).update(address=request.input('address'))
User.where(
'id',
request.param('id')).update(cell_phone=request.input('cell_phone'))
User.where('id',
request.param('id')).update(email=request.input('email'))
User.where(
'id',
request.param('id')).update(username=request.input('username'))
User.where('id', request.param('id')).update(
password=password(request.input('password')))
User.where('id', request.param('id')).update(cancelled='No')
User.where('id', request.param('id')).update(re_activated='Yes')
User.where('id', request.param('id')).update(reactivated_on=today_date)
auth.login(request.input('email'), request.input('password'))
request.session.flash(
'success',
'Your account has been reactivated. Thank you for trusing us again.'
)
return request.redirect('/')
def store(
self,
request: Request,
mail_manager: MailManager,
auth: Auth,
validate: Validator,
):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
errors = request.validate(
validate.required(["name", "email", "password"]),
validate.email("email"),
validate.strong(
"password",
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False,
),
)
if User.where('email', request.input("email")).limit(1).first():
print('error', errors)
errors.merge({'email': ["Email was used by someone else"]})
print('error', errors)
# return request.back().with_errors(errors).with_input()
if errors:
return request.back().with_errors(errors).with_input()
user = auth.register({
"name": request.input("name"),
"password": request.input("password"),
"email": request.input("email"),
})
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if auth.login(request.input("email"), request.input("password")):
# Redirect to the homepage
return request.redirect("/home")
# Login failed. Redirect to the register page.
return request.back().with_input()
def update(self, request: Request, validate: Validator, auth: Auth,
view: View):
user = User.all()
customer = request.user()
email = User.lists('email')
user_name = User.lists('username')
#Checks to see if updated email or username already exists
if request.input('email') != customer.email:
if request.input('email') in email:
return request.back().with_errors({
'error':
['{} already exists'.format(request.input('email'))]
})
elif request.input('username') != customer.username:
if request.input('username') in user_name:
return request.back().with_errors({
'error':
['{} already exists'.format(request.input('username'))]
})
#Inputs to update customer information
user.where(
'id',
customer.id).first().update(firstname=request.input('firstname'))
user.where(
'id',
customer.id).first().update(lastname=request.input('lastname'))
user.where(
'id', customer.id).first().update(address=request.input('address'))
user.where(
'id',
customer.id).first().update(cell_phone=request.input('cell_phone'))
user.where('id',
customer.id).first().update(email=request.input('email'))
user.where(
'id',
customer.id).first().update(username=request.input('username'))
#Checks that all information is filled out properly
errors = request.validate(
validate.required(
['firstname', 'lastname', 'address', 'email', 'username']),
validate.email('email'))
if errors:
return request.back().with_errors(errors).with_input()
else:
request.session.flash(
'success', 'Your account has been successfully updated.')
return request.redirect('account')
def update(self, view: View, request: Request, auth: Auth,
validate: Validator):
user = User.all()
pws = User.lists('password')
customer = request.user()
pw = customer.password
if bcrypt.checkpw(bytes(request.input('password'), 'utf-8'),
bytes(pw, 'utf-8')) == False:
return request.back().with_errors(
{'error': ['Please enter correct old password']})
new_password = request.input('new_password')
confirm_password = request.input('confirm_password')
for pws in pws:
if bcrypt.checkpw(bytes(request.input('new_password'), 'utf-8'),
bytes(pws, 'utf-8')):
return request.back().with_errors({
'error': [
'Password already exists. Please create a new password.'
]
})
errors = request.validate(
validate.required(['password', 'new_password',
'confirm_password']),
validate.strong('new_password',
length=8,
special=1,
uppercase=1,
breach=False)
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
)
if errors:
return request.back().with_errors(errors).with_input()
elif new_password != confirm_password:
return request.back().with_errors({
'error':
['New password and confirm new password do not match!']
})
else:
user.where(
'id',
customer.id).first().update(password=password(new_password))
request.session.flash(
'success', 'Your password has been successfully updated.')
return request.redirect('account')
def register(self, request: Request, auth: Auth, validate: Validator):
""" register a new administrator and also checks that form is filled out properly without errors and checks to see if email, passwords, and
usernames alread exits"""
email = Administrator.lists('admin_email')
user_name = Administrator.lists('admin_username')
pw = Administrator.lists('password')
#check to see if emails or usernames already exist
accounts = [email, user_name]
inputs = [request.input('admin_email'), request.input('admin_username')]
for input in inputs:
for account in accounts:
if inputs[0] in accounts[0] and inputs[1] in accounts[1]:
return request.back().with_errors({'error': ['{} and {} already exists'.format(inputs[0], inputs[1])]})
elif input in account:
return request.back().with_errors({'error': ['{} already exists'.format(input)]})
#checking to see if password already exists
for pw in pw:
if bcrypt.checkpw(bytes(request.input('admin_password'), 'utf-8'), bytes(pw, 'utf-8')):
return request.back().with_errors({'error': ['Password already exists. Please create a new password.']})
#checking for user entry errors when registering as an Administrator
errors = request.validate(
validate.required(['admin_name', 'admin_cell_phone', 'admin_address', 'admin_email', 'admin_username', 'admin_password']),
validate.email('admin_email'),
validate.strong('admin_password', length=8, special=1, uppercase=1)
)
if errors:
return request.back().with_errors(errors).with_input()
#when everything above checks out ok, then go ahead and insert data in Administrator table
else:
encoded_jwt = jwt.encode({'email': request.input('admin_email')},os.getenv('KEY') ,algorithm='HS256')
encrypted_password = password(request.input('admin_password'))
Administrator.insert(admin_name=request.input('admin_name'),
admin_cell_phone=request.input('admin_cell_phone'),
admin_address=request.input('admin_address'),
admin_email=request.input('admin_email'),
admin_username=request.input('admin_username'),
password=encrypted_password,
remember_token=encoded_jwt)
return request.redirect('/admin')
def update(self, request: Request, validate: Validator):
errors = request.validate(
validate.required("password"),
# TODO: only available in masonite latest versions (which are not compatible with Masonite 2.2)
validate.strong(
"password",
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False,
),
)
if errors:
return request.back().with_errors(errors)
user = (
AUTH["guards"]["web"]["model"]
.where("remember_token", request.param("token"))
.first()
)
if user:
user.password = bcrypt_password(request.input("password"))
user.save()
return request.redirect("/login")
def send(self, request: Request, session: Session, mail: Mail,
validate: Validator):
errors = request.validate(validate.required('email'),
validate.email('email'))
if errors:
return request.back().with_errors(errors)
email = request.input('email')
user = AUTH['guards']['web']['model'].where('email', email).first()
if user:
if not user.remember_token:
user.remember_token = str(uuid.uuid4())
user.save()
message = 'Please visit {}/password/{}/reset to reset your password'.format(
env('SITE', 'http://localhost:8000'), user.remember_token)
mail.subject('Reset Password Instructions').to(
user.email).send(message)
session.flash(
'success',
'If we found that email in our system then the email has been sent. Please follow the instructions in the email to reset your password.'
)
return request.redirect('/password')
def send(self, request: Request, session: Session, mail: Mail,
validate: Validator):
errors = request.validate(validate.required("email"),
validate.email("email"))
if errors:
return request.back().with_errors(errors)
email = request.input("email")
user = AUTH["guards"]["web"]["model"].where("email", email).first()
if user:
if not user.remember_token:
user.remember_token = str(uuid.uuid4())
user.save()
message = "Please visit {}/password/{}/reset to reset your password".format(
env("SITE", "http://localhost:8000"), user.remember_token)
mail.subject("Reset Password Instructions").to(
user.email).send(message)
session.flash(
"success",
"If we found that email in our system then the email has been sent. Please follow the instructions in the email to reset your password.",
)
return request.redirect("/password")
def send(self, request: Request, session: Session, mail: Mail,
validate: Validator):
errors = request.validate(validate.required("email"),
validate.email("email"))
if errors:
request.session.flash("error", errors)
return request.back()
email = request.input("email")
user = AUTH["model"].where("email", email).first()
if user:
if not user.remember_token:
user.remember_token = str(uuid.uuid4())
user.save()
link = "{}/users/reset-password/{}".format(
request.environ["HTTP_HOST"], user.remember_token)
mail.subject("{}: Reset Your Password".format(
config("application.name"))).template(
"users/password-reset-email", {
"name": user.name,
"link": link
}).to(user.email).send()
session.flash("success", self.reset_message)
return request.redirect("/")
def once(self, request: Request, validate: Validator, mail: Mail):
email = request.input('email')
encoded_jwt = jwt.encode({'email': email, 'httpMethod': 'GET'}, 'secret', algorithm='HS256', ).decode('utf-8')
errors = request.validate(
validate.required(['service_type', 'name', 'address', 'email', 'cell_phone']))
if errors:
return request.back().with_errors(errors)
OneTimeService.insert({
'service': request.input('service_type'),
'customer_name': request.input('name'),
'address': request.input('address'),
'service_date': request.input('date')[0],
'service_time': request.input('date')[1],
"email": request.input('email'),
'cell_phone': request.input('cell_phone'),
'remember_token': encoded_jwt
})
email = request.input('email')
encoded_jwt = jwt.encode({'email': email, 'httpMethod': 'GET'}, 'secret', algorithm='HS256', ).decode('utf-8')
mail.subject('Pool Appointment Confirmation').to(request.input('email')).template('mail/appt_confirm_guest', {'service': request.input('service_type'),
'service_date': request.input('date')[0], 'service_time': request.input('date')[1], 'token': encoded_jwt }).send()
request.session.flash('success', 'Your appointment has been successfully scheduled! A confirmation email has been sent.')
return request.redirect('/')
def update(self, request: Request, validate: Validator):
errors = request.validate(
validate.required("password"),
validate.confirmed("password"),
validate.length(
"password",
min=config("auth.password_min_length"),
max=config("auth.password_max_length"),
),
)
if errors:
request.session.flash("error", errors)
return request.back()
user = AUTH["model"].where("remember_token",
request.param("token")).first()
if user:
user.password = bcrypt_password(request.input("password"))
user.remember_token = None
user.save()
if request.user():
auth.sign_out()
request.session.flash(
"success", "Your password has been reset. Login below.")
return request.redirect("/users/sign-in")
def store(self, request: Request, mail_manager: MailManager, auth: Auth,
validate: Validator, event: Event):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
errors = request.validate(
validate.required(["name", "email", "password"]),
validate.email("email"),
validate.strong(
"password",
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False,
),
)
if errors:
return request.back().with_errors(errors).with_input()
user = auth.register({
"name": request.input("name"),
"password": request.input("password"),
"email": request.input("email"),
})
# fire signup event to set is_admin column
event.fire('user.signedup', user=user, isAdmin=False)
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if auth.login(user.email, request.input("password")):
# Redirect to the homepage
return request.redirect("/home")
# Login failed. Redirect to the register page.
return request.back().with_input()
def cancel(sef, request: Request, auth: Auth, validate: Validator,
mail: Mail):
user = User.all()
customer = request.user()
pw = customer.password
reason = request.input('radio')
confirm_password = request.input('password')
#checking that all required fields are entered and no errors are found.
errors = request.validate(
validate.required(
['radio', 'password'],
messages={'radio': "Please choose a reason for cancelling."}))
if errors:
return request.back().with_errors(errors)
elif not bcrypt.checkpw(bytes(confirm_password, 'utf-8'),
bytes(pw, 'utf-8')):
return request.back().with_errors(
{'error': ["Are you sure that's the right password?"]})
user_id = user.where('id', customer.id).first()
# User.where('id', customer.id).where_null('cancelled').update(cancelled='Yes')
User.where('id', customer.id).update(cancelled="Yes")
CancelledAccount.insert({
'user_id': user_id.id,
'cancel_reason': request.input('radio'),
'suggestions': request.input('suggestion')
})
request.session.flash(
'success',
'Your account has been successfully cancelled. Thank you for your business.'
)
mail.send_from('*****@*****.**').subject(
'Cancellation Confirmation').to(customer.email).template(
'mail/cancel_member', {
'title': 'Kennedy Pools & Supplies'
}).send()
auth.logout()
return request.redirect('/')
def login(self, request: Request, session: SessionManager,
validate: Validator):
tech = Technician.all()
tech_emails = Technician.lists('pool_tech_email')
pool_tech_user = tech.where('pool_tech_email',
request.input('email')).first()
pw = tech.where('password', request.input('password')).first()
errors = request.validate(
validate.required(['email', 'password']), validate.email('email'),
validate.strong('password', length=8, special=1, uppercase=1))
#checks for errors in login inputs and redirects user back to login page.
if errors:
return request.back().with_errors(errors).with_input()
#checks to see if admin enters correct email/password credentials and if no admin account exits and needs to register for one.
if request.input('email') not in tech_emails:
if not any(
bcrypt.checkpw(bytes(request.input('password'), 'utf-8'),
bytes(pw, 'utf-8'))
for pw in Technician.lists('password')):
return request.back().with_errors({
'email': [
'Credentials not found. Please register as a new pool technician.'
]
})
else:
return request.back().with_errors(
{'email': ['Email is incorrect!']})
elif pool_tech_user and not bcrypt.checkpw(
bytes(request.input('password'), 'utf-8'),
bytes(pool_tech_user.password, 'utf-8')):
return request.back().with_errors(
{'email': ['Password is incorrect!']})
else:
session.driver('cookie').set('key', 'value')
return request.redirect('/tech/dashboard/')
def store(self, request: Request, mail_manager: MailManager, auth: Auth,
validate: Validator):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
errors = request.validate(
validate.required(['name', 'email', 'password']),
validate.email('email'),
validate.strong(
'password',
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False))
if errors:
return request.back().with_errors(errors).with_input()
user = auth.register({
'name': request.input('name'),
'password': request.input('password'),
'email': request.input('email'),
})
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if auth.login(request.input('email'), request.input('password')):
# Redirect to the homepage
return request.redirect('/home')
# Login failed. Redirect to the register page.
return request.back().with_input()
def schedule(self, view: View, request: Request, validate: Validator, mail: Mail):
user = User.all()
customer = request.user()
name = request.input('name')
address = request.input('address')
schedule_date_info = request.input('date')
path = request.path
#checking that all required fields are entered and no errors are found.
errors = request.validate(
validate.required(['service_type', 'name', 'address']))
if errors:
return request.back().with_errors(errors)
if not schedule_date_info[0] or not schedule_date_info[1]:
request.session.flash('success', "The service date and service time is required.")
return request.back()
schedule_id = user.where('id', customer.id).first()
Schedule.insert({
'schedule_id': schedule_id.id,
'service': request.input('service_type'),
'service_date': schedule_date_info[0],
'service_time': schedule_date_info[1],
'customer_name': request.input('name')
})
#getting the schedules table data
customer_schedule = Schedule.get().last()
#sends email with pool appointment schedule details
mail.subject('Pool Appointment Confirmation').to(customer.email).template('mail/appt_confirm', {'service_id': customer_schedule.id, 'service': customer_schedule.service,
'service_date':customer_schedule.service_date, 'service_time':customer_schedule.service_time}).send()
request.session.flash('success', 'Your appointment has been successfully scheduled! A confirmation email has been sent.')
return request.redirect('/')
def reset(
self,
view: View,
request: Request,
validate: Validator,
):
new_password = request.input('new_password')
pws = User.lists('password')
decoded_token = jwt.decode(request.param('id'),
'secret',
algorithm='HS256')
user_email = decoded_token['email']
for pw in pws:
if bcrypt.checkpw(bytes(request.input('new_password'), 'utf-8'),
bytes(pw, 'utf-8')):
return request.back().with_errors({
'error': [
'Password already exists. Please create a new password.'
]
})
errors = request.validate(
validate.required('new_password'),
validate.strong('new_password',
length=8,
special=1,
uppercase=1,
breach=False)
) # breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
if errors:
return request.back().with_errors(errors).with_input()
else:
AUTH['guards']['web']['model'].where(
'email',
user_email).first().update(password=password(new_password))
request.session.flash(
'success', 'Your password has been successfully updated.')
return request.redirect('login')
def store(self, request: Request, auth: Auth, validate: Validator):
"""Login the user.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
auth {masonite.auth.auth} -- The Masonite auth class.
validate {masonite.validator.Validator} -- The Masonite Validator class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
errors = request.validate(
validate.required(["email", "password"]),
validate.email("email"),
)
if errors:
return request.back().with_errors(errors).with_input()
if auth.login(request.input("email"), request.input("password")):
return request.redirect("/home")
return request.back().with_errors({"email": ["Email or password is incorrect"]})
def contact(self, request: Request, auth: Auth, validate: Validator, mail: Mail):
user_email = request.user().email
message = request.input('contact')
message_subject = request.input('subject')
errors = request.validate(
validate.required(['subject', 'contact']),
)
if errors:
return request.back().with_errors(errors)
else:
mail.send_from(user_email).subject(message_subject).to('*****@*****.**').send(message)
request.session.flash('success', 'Your message has been successfully sent!')
return request.redirect('/')
def update(self, request: Request, validate: Validator):
errors = request.validate(
validate.required('password'),
# TODO: only available in masonite latest versions (which are not compatible with Masonite 2.2)
validate.strong(
'password',
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False))
if errors:
return request.back().with_errors(errors)
user = AUTH['guards']['web']['model'].where(
'remember_token', request.param('token')).first()
if user:
user.password = bcrypt_password(request.input('password'))
user.save()
return request.redirect('/login')
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')
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'
def register(self, request: Request, auth: Auth, validate: Validator,
mail: Mail):
""" register a new customer and also checks that form is filled out properly without errors and checks to see if email, passwords, and
usernames alread exits"""
email = User.lists('email')
user_name = User.lists('username')
pws = User.lists('password')
errors = request.validate(
validate.required([
'firstname', 'lastname', 'address', 'email', 'username',
'password', 'cell_phone'
]),
validate.email('email'),
validate.strong(
'password',
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False))
#Will display what errors where committed when filling out registration form.
if errors:
return request.back().with_errors(errors).with_input()
#check to see if emails or usernames already exist
accounts = [email, user_name]
inputs = [request.input('email'), request.input('username')]
for input in inputs:
for account in accounts:
if inputs[0] in accounts[0] and inputs[1] in accounts[1]:
return request.back().with_errors({
'error': [
'{} and {} already exists'.format(
inputs[0], inputs[1])
]
})
elif input in account:
return request.back().with_errors(
{'error': ['{} already exists'.format(input)]})
# checking to see if password already exists
for pw in pws:
if bcrypt.checkpw(bytes(request.input('password'), 'utf-8'),
bytes(pw, 'utf-8')):
return request.back().with_errors({
'error': [
'Password already exists. Please create a new password.'
]
})
if request.input('password') != request.input('password_confirm'):
return request.back().with_errors({
'error':
['Passwords do not match. Please make sure passwords match']
})
#This registers a new account
user = auth.register({
'firstname': request.input('firstname'),
'lastname': request.input('lastname'),
'address': request.input('address'),
'cell_phone': request.input('cell_phone'),
'email': request.input('email'),
'username': request.input('username'),
'password': request.input('password')
})
#Checking to see if all inputs on registration form are in correct format.
#Will send an email confirming account has been created.
mail.send_from(
'*****@*****.**').subject('Account Confirmation').to(
request.input('email')).template('mail/mail').send()
# Login the user
if auth.login(request.input('email'), request.input('password')):
# Redirect to the homepage
return request.redirect('/')
return request.back().with_input()
