def test_list(self):
"""
Tests for profile.list
"""
def people_match_account(client, response, testcase):
# client.previous_request is only available
# in patched test client.
if hasattr(client, 'previous_request'):
people = response.context[0]['object_list']
expected = Person.objects.filter(account = client.previous_request.account)
assert len(people) == len(expected)
for p in people:
assert p in expected
security.check(self, LIST_PATH)
#-------------------------------------------------
# The list is displayed.
#-------------------------------------------------
self.assertState(
'GET/POST',
LIST_PATH,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
people_match_account,
effects.rendered('account/person_list.html'),
effects.status(200),
]
)
def test_edit_account(self):
security.check(self, EDIT_ACCOUNT_PATH)
#-------------------------------------------------
# Show the form when no params
#-------------------------------------------------
self.assertState('GET/POST', EDIT_ACCOUNT_PATH, [
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
], [
effects.status(200),
effects.rendered('account/account_form.html'),
])
#-------------------------------------------------
# Show the form when invalid params
#-------------------------------------------------
self.assertState('POST', EDIT_ACCOUNT_PATH, [
causes.valid_domain,
causes.owner_logged_in,
causes.params(domain='---', ),
], [
effects.status(200),
effects.rendered('account/account_form.html'),
])
#-------------------------------------------------
# If everything's valid, changes are saved
# The user is redirected to the subdomain.domain
#-------------------------------------------------
edit_account_params = dict(
subdomain='newname',
domain=settings.ACCOUNT_DOMAINS[1][0],
name='newname',
timezone=settings.ACCOUNT_TIME_ZONES[1][0],
)
self.assertState('POST', EDIT_ACCOUNT_PATH, [
causes.valid_domain,
causes.owner_logged_in,
causes.params(**edit_account_params),
], [
effects.field_value(Account, {'pk': 1}, **edit_account_params),
effects.redirected_to_url('http://%s.%s/account/' %
(edit_account_params['subdomain'],
settings.ACCOUNT_DOMAINS[1][0])),
])
def test_reset_password(self):
"""
Tests for person_views.reset_password
"""
def email_contains_password(client, response, testcase):
""" Checks that the password of the default user is in
the first email in the outbox. """
person = Person.objects.get(username="******")
self.assertEqual(mail.outbox[0].to, [person.email])
pattern = re.compile("assword: *(.{7})\n")
matches = pattern.search(mail.outbox[0].body)
new_password = matches.group(1)
testcase.assertTrue(person.check_password(new_password))
self.assertState(
"GET/POST", RESET_PATH, [causes.person_not_logged_in, causes.invalid_domain], [effects.status(404)]
)
self.assertState("GET/POST", RESET_PATH, [causes.person_logged_in, causes.valid_domain], [effects.status(403)])
self.assertState(
"GET",
RESET_PATH,
[causes.person_not_logged_in, causes.valid_domain],
[effects.rendered("account/reset_password_form.html"), effects.status(200)],
)
self.assertState(
"POST",
RESET_PATH,
[causes.person_not_logged_in, causes.valid_domain, causes.invalid_username],
[effects.outbox_len(0), effects.rendered("account/reset_password_form.html")],
)
self.assertState(
"POST",
RESET_PATH,
[causes.person_not_logged_in, causes.valid_domain, causes.valid_username],
[
effects.outbox_len(1),
email_contains_password,
effects.rendered("account/reset_password_success.html"),
effects.status(200),
],
)
def test_signup(self):
#-------------------------------------------------
# If ssl is not on for GET, redirect to ssl page
#-------------------------------------------------
self.assertState('GET', CREATE_PATH % 1, [
causes.no_domain,
causes.no_parameters,
], [effects.redirected(CREATE_PATH % 1, status=301, ssl=True)])
#-------------------------------------------------
# If ssl is not on for POST, 403 Forbidden
#-------------------------------------------------
self.assertState('POST', CREATE_PATH % 1, [
causes.no_domain,
causes.no_parameters,
], [effects.status(403)])
#-------------------------------------------------
# You can't sign up from a domain belonging
# to an account.
#-------------------------------------------------
self.assertState('GET/POST', CREATE_PATH % 0, [
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
], [
effects.status(404),
])
#-------------------------------------------------
# Show the signup form
#-------------------------------------------------
self.assertState('GET/POST', CREATE_PATH % 0, [
causes.ssl,
causes.no_domain,
causes.no_parameters,
], [effects.rendered('account/signup_form.html'),
effects.status(200)])
#-------------------------------------------------
# If the subscription level is invaid, show 404
#-------------------------------------------------
self.assertState(
'GET/POST',
CREATE_PATH % 789, # 789 is invalid subscription level
[
causes.ssl,
causes.no_domain,
causes.no_parameters,
],
[effects.status(404)])
#-------------------------------------------------
# If the subscription level is free, a credit
# card is not required.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 0, # 0 is Free Account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
],
[
effects.redirected_to_url("http://%s/" % domain),
effects.exists(
Account,
subdomain=signup_params_no_cc['subdomain'],
domain=signup_params_no_cc['domain'],
),
effects.exists(Person, email='*****@*****.**'),
effects.person_has_role('account_admin', username='******'),
])
#-------------------------------------------------
# If the subscription level is NOT free, a credit
# card IS required.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
],
[
effects.rendered('account/signup_form.html'),
effects.does_not_exist(Person, email='*****@*****.**'),
effects.does_not_exist(
Account,
subdomain=signup_params_no_cc['subdomain'],
domain=signup_params_no_cc['domain'],
),
effects.status(200)
])
#-------------------------------------------------
# If everything validates, create a person, account
# and recurring payment.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
causes.params(**cc_params),
],
[
effects.redirected_to_url("http://%s/" % domain),
effects.exists(
Account,
subdomain=signup_params_no_cc['subdomain'],
domain=signup_params_no_cc['domain'],
),
effects.exists(Person, email='*****@*****.**'),
effects.person_has_role('account_admin', username='******'),
effects.exists(RecurringPayment, name='billy bob'),
])
#-------------------------------------------------
# If the gateway returns an unrecognized response,
# show a special message & email the administrator.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl, delete_test_account, causes.no_domain,
causes.params(**signup_params_no_cc),
causes.params(**cc_params), payment_response_error
],
[
effects.outbox_len(1),
effects.rendered('account/payment_create_error.html'),
])
#-------------------------------------------------
# If the gateway does not accept the payment info,
# show the form.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
causes.params(**cc_params),
payment_request_error,
],
[
effects.rendered('account/signup_form.html'),
effects.status(200)
])
def test_reset_password(self):
"""
Tests for person_views.reset_password
"""
def email_contains_password(client, response, testcase):
""" Checks that the password of the default user is in
the first email in the outbox. """
person = Person.objects.get(username = '******')
self.assertEqual(
mail.outbox[0].to,
[person.email],
)
pattern = re.compile('assword: *(.{7})\n')
matches = pattern.search(mail.outbox[0].body)
new_password = matches.group(1)
testcase.assertTrue(
person.check_password(new_password)
)
self.assertState(
'GET/POST',
RESET_PATH,
[
causes.person_not_logged_in,
causes.invalid_domain,
],
[
effects.status(404),
]
)
self.assertState(
'GET/POST',
RESET_PATH,
[
causes.person_logged_in,
causes.valid_domain,
],
[
effects.status(403),
]
)
self.assertState(
'GET',
RESET_PATH,
[
causes.person_not_logged_in,
causes.valid_domain,
],
[
effects.rendered('account/reset_password_form.html'),
effects.status(200),
]
)
self.assertState(
'POST',
RESET_PATH,
[
causes.person_not_logged_in,
causes.valid_domain,
causes.invalid_username,
],
[
effects.outbox_len(0),
effects.rendered('account/reset_password_form.html'),
]
)
self.assertState(
'POST',
RESET_PATH,
[
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_username,
],
[
effects.outbox_len(1),
email_contains_password,
effects.rendered('account/reset_password_success.html'),
effects.status(200),
]
)
def test_login(self):
"""
Tests for person_views.login
"""
#-------------------------------------------------
# If ssl is not on for GET, redirect to ssl page
#-------------------------------------------------
self.assertState(
'GET',
LOGIN_PATH,
[
causes.valid_domain,
],
[
effects.redirected(LOGIN_PATH, status = 301, ssl = True)
]
)
#-------------------------------------------------
# If ssl is not on for POST, 403 Forbidden
#-------------------------------------------------
self.assertState(
'POST',
LOGIN_PATH,
[
causes.valid_domain,
],
[
effects.status(403)
]
)
self.assertState(
'GET/POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.no_login_parameters,
],
[
effects.not_logged_in,
effects.rendered('account/login_form.html'),
effects.status(200),
]
)
self.assertState(
'GET/POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.invalid_domain,
],
[
effects.not_logged_in,
effects.status(404),
]
)
self.assertState(
'GET/POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.no_domain,
],
[
effects.not_logged_in,
effects.status(404),
]
)
self.assertState(
'GET/POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_logged_in,
causes.valid_domain,
],
[
effects.logged_in,
effects.status(403),
]
)
self.assertState(
'POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_login_parameters,
causes.remember_me_not_checked,
],
[
effects.logged_in,
effects.redirected('/'),
effects.logged_in, # Make sure we're still logged in after redirect.
effects.session_expires_on_close,
]
)
self.assertState(
'POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_login_parameters,
causes.account_inactive,
],
[
effects.logged_in,
effects.redirected('/account/inactive/'),
]
)
self.assertState(
'POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_admin_login_parameters,
causes.account_inactive,
],
[
effects.person_logged_in(pk = 2),
effects.redirected('/account/change_payment_method/'),
]
)
self.assertState(
'POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_login_parameters,
causes.remember_me_checked,
causes.account_active,
],
[
effects.logged_in,
effects.redirected('/'),
effects.logged_in,
effects.session_persists_after_close,
]
)
self.assertState(
'POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.invalid_login_parameters,
causes.account_active,
],
[
effects.not_logged_in,
effects.rendered('account/login_form.html'),
effects.status(200),
]
)
self.assertState(
'GET/POST',
LOGIN_PATH,
[
causes.ssl,
causes.person_logged_in,
causes.mismatched_domain,
causes.no_login_parameters,
causes.account_active,
],
[
effects.not_logged_in,
effects.rendered('account/login_form.html'),
effects.status(200),
]
)
############################
# Edit account Tests
############################
def test_edit_account(self):
security.check(self, EDIT_ACCOUNT_PATH)
#-------------------------------------------------
# Show the form when no params
#-------------------------------------------------
self.assertState(
'GET/POST',
EDIT_ACCOUNT_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
],
[
effects.status(200),
effects.rendered('account/account_form.html'),
]
)
#-------------------------------------------------
# Show the form when invalid params
#-------------------------------------------------
self.assertState(
'POST',
EDIT_ACCOUNT_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
causes.params(
domain = '---',
),
],
[
effects.status(200),
effects.rendered('account/account_form.html'),
]
)
#-------------------------------------------------
# If everything's valid, changes are saved
# The user is redirected to the subdomain.domain
#-------------------------------------------------
edit_account_params = dict(
subdomain = 'newname',
domain = settings.ACCOUNT_DOMAINS[1][0],
name = 'newname',
timezone = settings.ACCOUNT_TIME_ZONES[1][0],
)
self.assertState(
'POST',
EDIT_ACCOUNT_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
causes.params(**edit_account_params),
],
[
effects.field_value(
Account,
{'pk': 1},
**edit_account_params
),
effects.redirected_to_url(
############################
# Upgrade Tests
############################
def test_upgrade(self):
security.check(self, UPGRADE_PATH % 2, causes.ssl)
security.require_ssl(self, UPGRADE_PATH % 2)
#-------------------------------------------------
# Show Form
#-------------------------------------------------
self.assertState(
'GET',
UPGRADE_PATH % 2,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
],
[
effects.rendered('account/upgrade_form.html')
]
)
#-------------------------------------------------
# If invalid subscription level, 404 - Not Found
#-------------------------------------------------
self.assertState(
'GET/POST',
UPGRADE_PATH % 666,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
],
[
effects.status(404)
]
)
#-------------------------------------------------
# If account alreay has subscription label, 403 - Forbidden
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 1,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
],
[
effects.status(403)
]
)
#-------------------------------------------------
# If everything is valid, and the account has a
# RecurringPayment, change level and change payment
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 2,
[
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
],
[
gateway_change_called,
effects.redirected('/account/'),
subscription_level_is(2)
]
)
#-------------------------------------------------
# If the account has an inactive RecurringPayment,
# new CC info is required
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 2,
[
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_inactive_payment_method,
causes.params(**change_payment_method_params)
],
[
gateway_change_called,
effects.redirected('/account/'),
subscription_level_is(2)
]
)
#-------------------------------------------------
# If the account does not have a RecurringPayment,
# credit card params are required.
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 2,
[
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
],
[
effects.rendered('account/upgrade_form.html'),
subscription_level_is(1)
]
)
#-------------------------------------------------
# If the account doesn't have a RecurringPayment,
# and you've provided billing information, change
# subscription level.
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 2,
[
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
causes.params(**change_payment_method_params)
],
[
gateway_start_called,
effects.redirected('/account/'),
subscription_level_is(2)
]
)
#-------------------------------------------------
# If the gateway returns an unrecognized response,
# show a special message & email the administrator.
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 2,
[
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
causes.params(**change_payment_method_params),
payment_response_error,
],
[
effects.outbox_len(1),
effects.rendered('account/payment_create_error.html'),
subscription_level_is(1)
]
)
#-------------------------------------------------
# If the gateway does not accept the payment info,
# show the form.
#-------------------------------------------------
self.assertState(
'POST',
UPGRADE_PATH % 2,
[
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
causes.params(**change_payment_method_params),
payment_request_error,
],
def test_edit_self(self):
#-------------------------------------------------
# You have to be logged in to edit yourself
#-------------------------------------------------
self.assertState(
'GET/POST',
EDIT_SELF_PATH,
[
causes.person_not_logged_in,
causes.valid_domain,
],
[
effects.redirected('/person/login/', ssl = True),
]
)
#-------------------------------------------------
# You have to be using an account to edit yourself.
#-------------------------------------------------
self.assertState(
'GET/POST',
EDIT_SELF_PATH,
[
causes.invalid_domain,
],
[
effects.status(404)
]
)
#-------------------------------------------------
# Show the form
#-------------------------------------------------
self.assertState(
'GET',
EDIT_SELF_PATH,
[
causes.person_logged_in,
causes.valid_domain,
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.status(200),
]
)
#-------------------------------------------------
# Submitting invalid data shows the form
#-------------------------------------------------
self.assertState(
'POST',
EDIT_SELF_PATH,
[
causes.person_logged_in,
causes.valid_domain,
causes.params(
first_name = 'mary',
last_name = 'sue',
email = '---',
),
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.status(200),
]
)
#-------------------------------------------------
# Submitting valid data changes the record.
# But if you're not an admin, you can't edit your roles.
#-------------------------------------------------
self.assertState(
'POST',
EDIT_SELF_PATH,
[
causes.person_logged_in,
causes.valid_domain,
causes.params(
first_name = 'mary',
last_name = 'sue',
email = '*****@*****.**',
role_set = ['1', '13'],
),
],
[
effects.person_has_password(1, 'password'),
effects.person_does_not_have_role('account_admin', pk=1),
effects.person_does_not_have_role('consultant', pk=1),
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.status(200),
]
)
#-------------------------------------------------
# Submitting valid data changes the record.
# If your're an admin, you CAN edit your roles
# with the exception that you CAN NOT remove your
# own admin priveledges.
#-------------------------------------------------
self.assertState(
'POST',
EDIT_SELF_PATH,
[
causes.owner_logged_in,
causes.valid_domain,
causes.params(
username = "******",
first_name = 'mary',
last_name = 'sue',
email = '*****@*****.**',
role_set = ['14'],
),
],
[
effects.person_has_password(2, 'password'),
effects.person_has_role('janitor', pk=2),
effects.person_has_role('account_admin', pk=2),
effects.redirected('/person/'),
]
)
#-------------------------------------------------
# If the user provides a new password, it will be changed
#-------------------------------------------------
self.assertState(
'POST',
EDIT_SELF_PATH,
[
causes.person_logged_in,
causes.valid_domain,
causes.params(
username = '******',
first_name = 'starr',
last_name = 'horne',
email = '*****@*****.**',
new_password = '******',
new_password_confirm = 'newone',
),
],
[
effects.person_has_password(1, 'newone'),
def test_upgrade(self):
security.check(self, UPGRADE_PATH % 2, causes.ssl)
security.require_ssl(self, UPGRADE_PATH % 2)
#-------------------------------------------------
# Show Form
#-------------------------------------------------
self.assertState('GET', UPGRADE_PATH % 2, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
], [effects.rendered('account/upgrade_form.html')])
#-------------------------------------------------
# If invalid subscription level, 404 - Not Found
#-------------------------------------------------
self.assertState('GET/POST', UPGRADE_PATH % 666, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
], [effects.status(404)])
#-------------------------------------------------
# If account alreay has subscription label, 403 - Forbidden
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 1, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
], [effects.status(403)])
#-------------------------------------------------
# If everything is valid, and the account has a
# RecurringPayment, change level and change payment
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 2, [
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
], [
gateway_change_called,
effects.redirected('/account/'),
subscription_level_is(2)
])
#-------------------------------------------------
# If the account has an inactive RecurringPayment,
# new CC info is required
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 2, [
causes.ssl,
account_has_subscription_level(1), causes.valid_domain,
causes.owner_logged_in, account_has_inactive_payment_method,
causes.params(**change_payment_method_params)
], [
gateway_change_called,
effects.redirected('/account/'),
subscription_level_is(2)
])
#-------------------------------------------------
# If the account does not have a RecurringPayment,
# credit card params are required.
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 2, [
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
], [
effects.rendered('account/upgrade_form.html'),
subscription_level_is(1)
])
#-------------------------------------------------
# If the account doesn't have a RecurringPayment,
# and you've provided billing information, change
# subscription level.
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 2, [
causes.ssl,
account_has_subscription_level(1), causes.valid_domain,
causes.owner_logged_in, account_has_no_payment_method,
causes.params(**change_payment_method_params)
], [
gateway_start_called,
effects.redirected('/account/'),
subscription_level_is(2)
])
#-------------------------------------------------
# If the gateway returns an unrecognized response,
# show a special message & email the administrator.
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 2, [
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
causes.params(**change_payment_method_params),
payment_response_error,
], [
effects.outbox_len(1),
effects.rendered('account/payment_create_error.html'),
subscription_level_is(1)
])
#-------------------------------------------------
# If the gateway does not accept the payment info,
# show the form.
#-------------------------------------------------
self.assertState('POST', UPGRADE_PATH % 2, [
causes.ssl,
account_has_subscription_level(1),
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
causes.params(**change_payment_method_params),
payment_request_error,
], [
effects.rendered('account/upgrade_form.html'),
effects.status(200)
])
############################
# Signup Tests
############################
def test_signup(self):
#-------------------------------------------------
# If ssl is not on for GET, redirect to ssl page
#-------------------------------------------------
self.assertState(
'GET',
CREATE_PATH % 1,
[
causes.no_domain,
causes.no_parameters,
],
[
effects.redirected(CREATE_PATH % 1, status = 301, ssl = True)
]
)
#-------------------------------------------------
# If ssl is not on for POST, 403 Forbidden
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1,
[
causes.no_domain,
causes.no_parameters,
],
[
effects.status(403)
]
)
#-------------------------------------------------
# You can't sign up from a domain belonging
# to an account.
#-------------------------------------------------
self.assertState(
'GET/POST',
CREATE_PATH % 0,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
],
[
effects.status(404),
]
)
#-------------------------------------------------
# Show the signup form
#-------------------------------------------------
self.assertState(
'GET/POST',
CREATE_PATH % 0,
[
causes.ssl,
causes.no_domain,
causes.no_parameters,
],
[
effects.rendered('account/signup_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If the subscription level is invaid, show 404
#-------------------------------------------------
self.assertState(
'GET/POST',
CREATE_PATH % 789, # 789 is invalid subscription level
[
causes.ssl,
causes.no_domain,
causes.no_parameters,
],
[
effects.status(404)
]
)
#-------------------------------------------------
# If the subscription level is free, a credit
# card is not required.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 0, # 0 is Free Account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
],
[
effects.redirected_to_url(
"http://%s/" % domain
),
effects.exists(
Account,
subdomain = signup_params_no_cc['subdomain'],
domain = signup_params_no_cc['domain'],
),
effects.exists(Person, email = '*****@*****.**'),
effects.person_has_role('account_admin', username = '******'),
]
)
#-------------------------------------------------
# If the subscription level is NOT free, a credit
# card IS required.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
],
[
effects.rendered('account/signup_form.html'),
effects.does_not_exist(Person, email = '*****@*****.**'),
effects.does_not_exist(
Account,
subdomain = signup_params_no_cc['subdomain'],
domain = signup_params_no_cc['domain'],
),
effects.status(200)
]
)
#-------------------------------------------------
# If everything validates, create a person, account
# and recurring payment.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
causes.params(**cc_params),
],
[
effects.redirected_to_url(
"http://%s/" % domain
),
effects.exists(
Account,
subdomain = signup_params_no_cc['subdomain'],
domain = signup_params_no_cc['domain'],
),
effects.exists(Person, email = '*****@*****.**'),
effects.person_has_role('account_admin', username = '******'),
effects.exists(RecurringPayment, name = 'billy bob'),
]
)
#-------------------------------------------------
# If the gateway returns an unrecognized response,
# show a special message & email the administrator.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
causes.params(**cc_params),
payment_response_error
],
[
effects.outbox_len(1),
effects.rendered('account/payment_create_error.html'),
]
)
#-------------------------------------------------
# If the gateway does not accept the payment info,
# show the form.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH % 1, # 1 is Silver (pay) account
[
causes.ssl,
delete_test_account,
causes.no_domain,
causes.params(**signup_params_no_cc),
causes.params(**cc_params),
payment_request_error,
],
def test_login(self):
"""
Tests for person_views.login
"""
# -------------------------------------------------
# If ssl is not on for GET, redirect to ssl page
# -------------------------------------------------
self.assertState(
"GET", LOGIN_PATH, [causes.valid_domain], [effects.redirected(LOGIN_PATH, status=301, ssl=True)]
)
# -------------------------------------------------
# If ssl is not on for POST, 403 Forbidden
# -------------------------------------------------
self.assertState("POST", LOGIN_PATH, [causes.valid_domain], [effects.status(403)])
self.assertState(
"GET/POST",
LOGIN_PATH,
[causes.ssl, causes.person_not_logged_in, causes.valid_domain, causes.no_login_parameters],
[effects.not_logged_in, effects.rendered("account/login_form.html"), effects.status(200)],
)
self.assertState(
"GET/POST",
LOGIN_PATH,
[causes.ssl, causes.person_not_logged_in, causes.invalid_domain],
[effects.not_logged_in, effects.status(404)],
)
self.assertState(
"GET/POST",
LOGIN_PATH,
[causes.ssl, causes.person_not_logged_in, causes.no_domain],
[effects.not_logged_in, effects.status(404)],
)
self.assertState(
"GET/POST",
LOGIN_PATH,
[causes.ssl, causes.person_logged_in, causes.valid_domain],
[effects.logged_in, effects.status(403)],
)
self.assertState(
"POST",
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_login_parameters,
causes.remember_me_not_checked,
],
[
effects.logged_in,
effects.redirected("/"),
effects.logged_in, # Make sure we're still logged in after redirect.
effects.session_expires_on_close,
],
)
self.assertState(
"POST",
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_login_parameters,
causes.account_inactive,
],
[effects.logged_in, effects.redirected("/account/inactive/")],
)
self.assertState(
"POST",
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_admin_login_parameters,
causes.account_inactive,
],
[effects.person_logged_in(pk=2), effects.redirected("/account/change_payment_method/")],
)
self.assertState(
"POST",
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.valid_login_parameters,
causes.remember_me_checked,
causes.account_active,
],
[effects.logged_in, effects.redirected("/"), effects.logged_in, effects.session_persists_after_close],
)
self.assertState(
"POST",
LOGIN_PATH,
[
causes.ssl,
causes.person_not_logged_in,
causes.valid_domain,
causes.invalid_login_parameters,
causes.account_active,
],
[effects.not_logged_in, effects.rendered("account/login_form.html"), effects.status(200)],
)
self.assertState(
"GET/POST",
LOGIN_PATH,
[
causes.ssl,
causes.person_logged_in,
causes.mismatched_domain,
causes.no_login_parameters,
causes.account_active,
],
[effects.not_logged_in, effects.rendered("account/login_form.html"), effects.status(200)],
)
def test_create(self):
"""
Tests for profile.create
"""
security.check(self, CREATE_PATH, causes.ssl)
#-------------------------------------------------
# The person form is displayed
#-------------------------------------------------
self.assertState(
'GET',
CREATE_PATH,
[
causes.ssl,
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.status(200),
]
)
#-------------------------------------------------
# If input errors, the person form is displayed
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH,
[
causes.ssl,
causes.owner_logged_in,
causes.valid_domain,
causes.invalid_create_person_parameters,
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.form_errors('form'),
effects.status(200),
]
)
#-------------------------------------------------
# Password is required for create.
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH,
[
causes.ssl,
causes.owner_logged_in,
causes.valid_domain,
causes.params(**create_person_parameters_without_password),
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.form_errors('form'),
effects.status(200),
]
)
#-------------------------------------------------
# If everything is valid, create the person
#-------------------------------------------------
self.assertState(
'POST',
CREATE_PATH,
[
causes.ssl,
causes.alters(Person),
causes.owner_logged_in,
causes.valid_domain,
causes.params(**create_person_parameters),
],
[
effects.created(Person),
effects.redirected('/person/list/'),
]
)
def test_destroy(self):
"""
Tests for profile.destroy
"""
security.check(self, DESTROY_PATH)
self.assertState(
'GET',
DESTROY_PATH,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.rendered('account/confirm_destroy.html')
]
)
self.assertState(
'POST',
DESTROY_PATH_INVALID,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.status(404),
]
)
self.assertState(
'POST',
DESTROY_PATH_MISMATCH,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.status(404),
]
)
self.assertState(
'POST',
DESTROY_PATH,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.does_not_exist(Person, id = 1),
effects.redirected('/person/list/')
]
)
self.assertState(
'POST',
DESTROY_PATH_OWNER,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.exists(Person, id = 2),
effects.status(403)
def test_change_payment_method(self):
security.check_account_inactive_ok(self, CHANGE_PM_PATH, causes.ssl)
security.require_ssl(self, CHANGE_PM_PATH)
#-------------------------------------------------
# The form is shown
#-------------------------------------------------
self.assertState('GET/POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
], [
effects.rendered('account/payment_method_form.html'),
effects.status(200)
])
#-------------------------------------------------
# The form is shown if input is invalid
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl, causes.valid_domain, causes.owner_logged_in,
causes.no_parameters,
causes.params(first_name='billy',
last_name='bob',
card_number='411111111111',
card_expiration=None)
], [
effects.rendered('account/payment_method_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If input is valid, a RecurringPayment is created
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(first_name='billy',
last_name='bob',
card_number='411111111111',
card_expiration=date.today()),
account_has_no_payment_method,
], [
effects.exists(RecurringPayment, account__subdomain='starr'),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If input is valid, and a RecurringPayment exists,
# the old RecurringPayment is deleted and a new one
# is created.
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
], [
gateway_cancel_called, new_payment_starts_when_old_one_stops,
effects.exists(RecurringPayment, account__pk=1),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If we get a PeymentRequestError, it means that
# the user probably entered some invalid info.
# If the payment gateway returned this error, a
# RecurringPayment is NOT created.
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_no_payment_method,
payment_request_error,
], [
gateway_cancel_called,
effects.does_not_exist(
RecurringPayment,
account__pk=1,
),
effects.does_not_exist(RecurringPayment, name='billy bob'),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If we get a PeymentRequestError, it means that
# the user probably entered some invalid info.
# If the payment gateway returned this error, AND a
# RecurringPayment exists for the account, do NOT
# delete it.
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
payment_request_error,
], [
gateway_cancel_called,
effects.exists(
RecurringPayment,
account__pk=1,
),
effects.count(1, RecurringPayment, name='Bob Jones'),
effects.count(0, RecurringPayment, name='billy bob'),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If there is a PaymentResponse error, it means
# we couldn't understand the response from the
# gateway. So a special error page is displayed
# and the administrator is emailed.
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
payment_response_error,
], [
gateway_cancel_called,
effects.exists(
RecurringPayment,
account__pk=1,
),
effects.outbox_len(1),
effects.count(1, RecurringPayment, name='Bob Jones'),
effects.count(0, RecurringPayment, name='billy bob'),
effects.rendered('account/payment_create_error.html'),
effects.status(200)
])
#-------------------------------------------------
# If there is a PaymentResponse error when canceling
# an existing payment, it is very bad. It means that
# the customer will be billed twice! So we diaplay a
# special error message, and email the administrator.
#-------------------------------------------------
self.assertState('POST', CHANGE_PM_PATH, [
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
payment_response_error_on_cancel,
], [
gateway_cancel_called,
effects.exists(
RecurringPayment,
account__pk=1,
),
effects.outbox_len(1),
effects.count(0, RecurringPayment, name='Bob Jones'),
effects.count(1, RecurringPayment, name='billy bob'),
effects.rendered('account/payment_cancel_error.html'),
effects.status(200)
])
def test_cancel_payment_method(self):
security.check(self, CANCEL_PM_PATH)
#-------------------------------------------------
# If the account does NOT have a RecurringPayment,
# then the account is deactivated immediately.
#-------------------------------------------------
self.assertState('POST', CANCEL_PM_PATH, [
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
], [
effects.field_value(Account, {'pk': 1}, active=False),
effects.redirected('/account/reactivate_free_account/')
])
#-------------------------------------------------
# If the account has a RecurringPayment, show the form
#-------------------------------------------------
self.assertState('GET', CANCEL_PM_PATH, [
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
], [
effects.field_value(Account, {'pk': 1}, active=True),
effects.rendered('account/payment_cancel_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If the account does not have a RecurringPayment, show the form
#-------------------------------------------------
self.assertState('GET', CANCEL_PM_PATH, [
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
], [
effects.field_value(Account, {'pk': 1}, active=True),
effects.rendered('account/payment_cancel_form.html'),
effects.status(200)
])
#-------------------------------------------------
# If the form is posted, and a payment exists, the
# payment is canceled. Note that it is not deleted.
# Instead, the inactive flag is set, which triggers
# the account for suspension whenever payment runs
# out.
#-------------------------------------------------
self.assertState('POST', CANCEL_PM_PATH, [
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
], [
effects.field_value(Account, {'pk': 1}, active=True),
effects.redirected('/account/'),
effects.count(1, RecurringPayment, account__pk=1),
payment_is_inactive,
])
#-------------------------------------------------
# If a gateway error is returned on cancel, show
# the error page and email admin
#-------------------------------------------------
self.assertState('POST', CANCEL_PM_PATH, [
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
payment_response_error_on_cancel,
], [
effects.field_value(Account, {'pk': 1}, active=True),
effects.outbox_len(1),
effects.rendered('account/payment_cancel_error.html'),
effects.count(1, RecurringPayment, account__pk=1),
payment_is_active,
])
############################
# Change Payment Method Tests
############################
def test_change_payment_method(self):
security.check_account_inactive_ok(self, CHANGE_PM_PATH, causes.ssl)
security.require_ssl(self, CHANGE_PM_PATH)
#-------------------------------------------------
# The form is shown
#-------------------------------------------------
self.assertState(
'GET/POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
],
[
effects.rendered('account/payment_method_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# The form is shown if input is invalid
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(
first_name = 'billy',
last_name = 'bob',
card_number = '411111111111',
card_expiration = None
)
],
[
effects.rendered('account/payment_method_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If input is valid, a RecurringPayment is created
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(
first_name = 'billy',
last_name = 'bob',
card_number = '411111111111',
card_expiration = date.today()
),
account_has_no_payment_method,
],
[
effects.exists(
RecurringPayment,
account__subdomain = 'starr'
),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If input is valid, and a RecurringPayment exists,
# the old RecurringPayment is deleted and a new one
# is created.
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
],
[
gateway_cancel_called,
new_payment_starts_when_old_one_stops,
effects.exists(RecurringPayment, account__pk = 1),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If we get a PeymentRequestError, it means that
# the user probably entered some invalid info.
# If the payment gateway returned this error, a
# RecurringPayment is NOT created.
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_no_payment_method,
payment_request_error,
],
[
gateway_cancel_called,
effects.does_not_exist(
RecurringPayment,
account__pk = 1,
),
effects.does_not_exist(
RecurringPayment,
name = 'billy bob'
),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If we get a PeymentRequestError, it means that
# the user probably entered some invalid info.
# If the payment gateway returned this error, AND a
# RecurringPayment exists for the account, do NOT
# delete it.
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
payment_request_error,
],
[
gateway_cancel_called,
effects.exists(
RecurringPayment,
account__pk = 1,
),
effects.count(1, RecurringPayment, name = 'Bob Jones'),
effects.count(0, RecurringPayment, name = 'billy bob'),
effects.rendered('account/payment_method_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If there is a PaymentResponse error, it means
# we couldn't understand the response from the
# gateway. So a special error page is displayed
# and the administrator is emailed.
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
payment_response_error,
],
[
gateway_cancel_called,
effects.exists(
RecurringPayment,
account__pk = 1,
),
effects.outbox_len(1),
effects.count(1, RecurringPayment, name = 'Bob Jones'),
effects.count(0, RecurringPayment, name = 'billy bob'),
effects.rendered('account/payment_create_error.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If there is a PaymentResponse error when canceling
# an existing payment, it is very bad. It means that
# the customer will be billed twice! So we diaplay a
# special error message, and email the administrator.
#-------------------------------------------------
self.assertState(
'POST',
CHANGE_PM_PATH,
[
causes.ssl,
causes.valid_domain,
causes.owner_logged_in,
causes.no_parameters,
causes.params(**change_payment_method_params),
account_has_payment_method,
payment_response_error_on_cancel,
],
[
gateway_cancel_called,
effects.exists(
RecurringPayment,
account__pk = 1,
),
effects.outbox_len(1),
effects.count(0, RecurringPayment, name = 'Bob Jones'),
############################
# Cancel Payment Method Tests
############################
def test_cancel_payment_method(self):
security.check(self, CANCEL_PM_PATH)
#-------------------------------------------------
# If the account does NOT have a RecurringPayment,
# then the account is deactivated immediately.
#-------------------------------------------------
self.assertState(
'POST',
CANCEL_PM_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
],
[
effects.field_value(Account, {'pk': 1}, active = False),
effects.redirected('/account/reactivate_free_account/')
]
)
#-------------------------------------------------
# If the account has a RecurringPayment, show the form
#-------------------------------------------------
self.assertState(
'GET',
CANCEL_PM_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
],
[
effects.field_value(Account, {'pk': 1}, active = True),
effects.rendered('account/payment_cancel_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If the account does not have a RecurringPayment, show the form
#-------------------------------------------------
self.assertState(
'GET',
CANCEL_PM_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
account_has_no_payment_method,
],
[
effects.field_value(Account, {'pk': 1}, active = True),
effects.rendered('account/payment_cancel_form.html'),
effects.status(200)
]
)
#-------------------------------------------------
# If the form is posted, and a payment exists, the
# payment is canceled. Note that it is not deleted.
# Instead, the inactive flag is set, which triggers
# the account for suspension whenever payment runs
# out.
#-------------------------------------------------
self.assertState(
'POST',
CANCEL_PM_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
],
[
effects.field_value(Account, {'pk': 1}, active = True),
effects.redirected('/account/'),
effects.count(1, RecurringPayment, account__pk = 1),
payment_is_inactive,
]
)
#-------------------------------------------------
# If a gateway error is returned on cancel, show
# the error page and email admin
#-------------------------------------------------
self.assertState(
'POST',
CANCEL_PM_PATH,
[
causes.valid_domain,
causes.owner_logged_in,
account_has_payment_method,
payment_response_error_on_cancel,
],
[
effects.field_value(Account, {'pk': 1}, active = True),
effects.outbox_len(1),
effects.rendered('account/payment_cancel_error.html'),
def test_edit(self):
security.check(self, EDIT_PATH)
#-------------------------------------------------
# Show the form
#-------------------------------------------------
self.assertState(
'GET',
EDIT_PATH,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.status(200),
]
)
#-------------------------------------------------
# If the person does not exist, 404
#-------------------------------------------------
self.assertState(
'GET/POST',
EDIT_PATH_INVALID,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.status(404),
]
)
#-------------------------------------------------
# If the person does not belong to the account 404
#-------------------------------------------------
self.assertState(
'GET/POST',
EDIT_PATH_MISMATCH,
[
causes.owner_logged_in,
causes.valid_domain,
],
[
effects.status(404),
]
)
#-------------------------------------------------
# If invalid input, show form
#-------------------------------------------------
self.assertState(
'POST',
EDIT_PATH,
[
causes.owner_logged_in,
causes.valid_domain,
causes.invalid_create_person_parameters,
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.form_errors('form'),
effects.status(200),
]
)
#-------------------------------------------------
# If valid, save changes
#-------------------------------------------------
self.assertState(
'POST',
EDIT_PATH,
[
causes.alters(Person),
causes.owner_logged_in,
causes.valid_domain,
causes.params(
username = '******',
new_password = '',
new_password_confirm = '',
first_name = 'bob',
last_name = 'jones',
email = '*****@*****.**',
),
],
[
effects.field_value(Person, {'pk':1}, first_name = 'bob'),
effects.person_has_password(1, 'password'),
effects.redirected('/person/list/'),
]
)
#-------------------------------------------------
# If valid, save changes
#-------------------------------------------------
self.assertState(
'POST',
EDIT_PATH,
[
causes.alters(Person),
causes.owner_logged_in,
causes.valid_domain,
causes.params(
username = '******',
new_password = '******',
new_password_confirm = 'anewpassword',
first_name = 'bob',
last_name = 'jones',
email = '*****@*****.**',
),
],
[
effects.person_has_password(1, 'anewpassword'),
effects.field_value(Person, {'pk':1}, first_name = 'bob'),
effects.redirected('/person/list/'),
]
)
#-------------------------------------------------
# Edit does not require pasword, does not change
# if one is not provided.
#-------------------------------------------------
self.assertState(
'POST',
EDIT_PATH,
[
causes.alters(Person),
causes.owner_logged_in,
causes.valid_domain,
causes.params(
username = '******',
new_password = '',
new_password_confirm = '',
first_name = 'bob',
last_name = 'jones',
email = '*****@*****.**',
),
],
[
effects.person_has_password(1, 'anewpassword'),
effects.field_value(Person, {'pk':1}, first_name = 'bob'),
effects.redirected('/person/list/'),
]
)
#-------------------------------------------------
# If passwords didn't match, show form
#-------------------------------------------------
self.assertState(
'POST',
EDIT_PATH,
[
causes.alters(Person),
causes.owner_logged_in,
causes.valid_domain,
causes.params(
username = '******',
new_password = '******',
new_password_confirm = 'does_not_match',
first_name = 'bob',
last_name = 'jones',
email = '*****@*****.**',
),
],
[
effects.rendered('account/person_form.html'),
effects.context('form', type = forms.BaseForm),
effects.form_errors('form'),
effects.status(200),