def setUp(self):
super(EventTestCase, self).setUp()
# Group admin
self.user = User(username='******',
email='*****@*****.**',
first_name='Turanga',
last_name='Leela')
self.user.set_password('password')
self.user.clean_and_save()
# Non-Group admin
self.nonadmin_user = User(username='******',
email='*****@*****.**',
first_name='Zapp',
last_name='Brannigan')
self.nonadmin_user.set_password('password')
self.nonadmin_user.clean_and_save()
self.group = Group.objects.create(
name='Planet Express',
slug='planet-express',
description='A simple delivery company',
contact_name='Professor Farnseworth',
contact_email='*****@*****.**',
contact_url='https://planetexpress.nyc',
admin=self.user
)
def _get_or_create_user(self):
if User.objects.filter(username=self.username).exists():
return User.objects.get(username=self.username)
user = User(username=self.username, email=self.email)
user.set_password(self.password)
user.save()
return user
def user_can_edit(*, user: User, amendment: models.Amendment) -> bool:
"""Determine if a user can edit (or delete) an amendment, given their rights and its status"""
return (
user.has_perm('amendment.edit_finance')
or user.has_perm('amendment.approve')
and user.username == amendment.approver
and amendment.status_id in (models.AmendmentStatuses.RAISED, models.AmendmentStatuses.APPROVED)
or user.username == amendment.requested_by
and amendment.status_id == models.AmendmentStatuses.RAISED
)
def user_can_edit(self, user: User) -> bool:
"""Checks if a user has edit (and delete) permissions on the object"""
if self.status_id == Statuses.RAISED:
return user.has_perm(
'tutor_payment.raise') and self.raised_by == user
if self.status_id == Statuses.APPROVED:
return user.has_perm('tutor_payment.approve')
if self.status_id == Statuses.TRANSFERRED:
return user.has_perm('tutor_payment.transfer')
return False
def test_email_uniqueness(self):
guy = User(username='******', email='*****@*****.**')
guy.set_password('password')
guy.save()
gal = User(username='******', email='*****@*****.**')
gal.set_password('password')
with self.assertRaises(ValidationError) as ec:
gal.clean_and_save()
self.assertIn('email', ec.exception.error_dict)
class LoginUITest(NycTreesSeleniumTestCase):
def setUp(self):
super(LoginUITest, self).setUp()
self.user = User(username='******', email='*****@*****.**')
self.user.set_password('password')
self.user.save()
def test_login(self):
self.get('/accounts/login/')
self.wait_for_textbox_then_type('[name="username"]',
self.user.username)
self.wait_for_textbox_then_type('[name="password"]', 'password')
self.click('form input[type="submit"]')
def setUpTestData(cls):
"""Prep an invoice"""
cls.user = User(username='******')
cls.invoice = factories.InvoiceFactory()
fee = FeeFactory(amount=100)
cls.enrolment = EnrolmentFactory(module=fee.module)
transaction = finance_services.add_enrolment_fee(
enrolment_id=cls.enrolment.id, fee_id=fee.id, user=cls.user)
services.attach_transaction_to_invoice(transaction=transaction,
invoice=cls.invoice)
def user_can_delete(self, *, user: User) -> bool:
"""Determine if a user is allowed to remove an entry from the ledger"""
return (
# Devs can always delete
user.has_perm('finance.delete_ledger')
# Same-day, own-entry deletion for others
or self.created_by == user.username
and self.timestamp.date() == date.today()
# No deleting fee items attached to invoices
and
not (hasattr(self, 'invoice_ledger') and not self.type.is_cash))
def post(self, request):
form = CreateUserForm.create_from_request(request)
if not form.is_valid():
raise ValidationException(request, form)
if not request.user.has_perm('core.add_user'):
raise ProblemDetailException(request,
_("Insufficient permissions"),
status=HTTPStatus.FORBIDDEN)
if User.objects.filter(email=form.cleaned_data['email']).exists():
raise ProblemDetailException(
request,
_("User with same email already exists"),
status=HTTPStatus.CONFLICT)
user = User()
form.populate(user)
user.set_password(form.cleaned_data['password'])
user.save()
return SingleResponse(request,
user,
serializer=UserSerializer.Base,
status=HTTPStatus.CREATED)
def setUpTestData(cls):
"""Prep an invoice with two enrolments with £50 and £100 outstanding
Todo: figure out a concise way to do this
"""
cls.user = User(username='******')
cls.invoice = factories.InvoiceFactory()
fees = [FeeFactory(amount=50), FeeFactory(amount=100)]
cls.enrolments = [EnrolmentFactory(module=fee.module) for fee in fees]
for fee, enrolment in zip(fees, cls.enrolments):
transaction = finance_services.add_enrolment_fee(
enrolment_id=enrolment.id, fee_id=fee.id, user=cls.user)
services.attach_transaction_to_invoice(transaction=transaction,
invoice=cls.invoice)
def handle(self, *args, **options):
with open('media/csv/users.csv') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
user = User()
user.id = int(row['ID'])
user.username = row['user_login']
user.email = row['user_email']
user.date_joined = row['user_registered']
user.first_name = row['display_name'].split(' ')[0]
user.last_name = row['display_name'].split(' ')[-1]
user.save()
with open('media/csv/posts.csv') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
post = Post()
post.id = int(row['ID'])
post.title = row['post_title']
post.content = row['post_content']
post.published_at = row['post_date']
post.slug = row['post_name']
post.user_id = row['post_author']
post.save()
with open('media/csv/comments.csv') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
comment = ThreadedComment()
comment.id = int(row['comment_ID'])
comment.object_pk = row['comment_post_ID']
comment.content_type_id = 15
comment.site_id = 1
comment.user_name = row['comment_author']
comment.user_email = row['comment_author_email']
comment.user_url = row['comment_author_url']
comment.ip_address = row['comment_author_IP']
comment.submit_date = row['comment_date']
comment.comment = row['comment_content']
if row['comment_parent'] != '0':
comment.parent_id = row['comment_parent']
if row['user_id'] != '0':
comment.user_id = row['user_id']
comment.save()
def setUp(self):
super(RsvpForEventUITest, self).setUp()
self.user2 = User(username='******',
email='*****@*****.**',
first_name='Bender',
last_name='Rodríguez')
self.user2.set_password('password')
self.user2.clean_and_save()
self.event = Event.objects.create(group=self.group,
title="The event",
slug="the-event",
contact_email="*****@*****.**",
address="123 Main St",
location=CENTRAL_PARK,
max_attendees=100,
begins_at=now(),
ends_at=now())
def post(self, request):
form = UserForms.Create.create_from_request(request)
if not form.is_valid():
raise ValidationException(request, form)
password = form.cleaned_data.get('password')
role = form.cleaned_data.get('role')
user = User()
form.fill(user)
user.set_password(password)
user.username = user.email
assign_role(user, role.name)
user.is_active = False
user.save()
return SingleResponse(request,
user,
status=HTTPStatus.CREATED,
serializer=UserSerializer.Base)
def email_personnel_change(
*,
model: Union[Address, Student, Tutor],
initial_values: dict,
changed_data: list[str],
user: User,
) -> bool:
"""Emails the personnel office when a change is detected in a tutor's name, address or bank details"""
# Discern update source
if isinstance(model, Tutor):
fields = [
'bankname',
'branchaddress',
'accountname',
'sortcode',
'accountno',
'swift',
'iban',
'other_bank_details',
]
tutor = model
elif isinstance(model, Address):
fields = ['line1', 'line2', 'line3', 'town', 'state', 'country', 'postcode']
tutor = model.student.tutor
elif isinstance(model, Student):
fields = ['firstname', 'surname', 'title']
tutor = model.tutor
else:
raise TypeError('Invalid type for argument `model`')
# Build change log
changes = [(f, initial_values.get(f), getattr(model, f)) for f in fields if f in changed_data]
if not changes or not _notifiable(tutor):
# No email sent
return False
# Email personnel
context = {
'person': tutor.student,
'updated_by': user.get_full_name(),
'changes': changes,
'canonical_url': settings.CANONICAL_URL,
}
message = render_to_string(template_name='email/personnel_info_change.html', context=context)
mail.send_mail(
recipient_list=[settings.SUPPORT_EMAIL if settings.DEBUG else settings.PERSONNEL_EMAIL],
from_email=settings.DEFAULT_FROM_EMAIL,
subject='Tutor details update',
message=strip_tags(message),
html_message=message,
)
# Email tutor when account or sortcode changes
tutor_email = tutor.student.get_default_email()
if tutor_email and ('accountno' in changed_data or 'sortcode' in changed_data):
context = {
'firstname': tutor.student.firstname,
'account': tutor.accountno,
'sortcode': tutor.sortcode,
}
message = render_to_string(template_name='email/tutor_info_change.html', context=context)
mail.send_mail(
recipient_list=[settings.SUPPORT_EMAIL if settings.DEBUG else tutor_email],
from_email=settings.DEFAULT_FROM_EMAIL,
subject='Department for Continuing Education - payroll information',
message=strip_tags(message),
html_message=message,
)
return True
def setUp(self):
super(LoginUITest, self).setUp()
self.user = User(username='******', email='*****@*****.**')
self.user.set_password('password')
self.user.save()
def create(self, validated_data):
user = User(**validated_data)
user.set_password(validated_data['password'])
user.save()
return user
def resolve_permissions(data: User):
return data.get_all_permissions()
class RsvpForEventUITest(EventTestCase):
def setUp(self):
super(RsvpForEventUITest, self).setUp()
self.user2 = User(username='******',
email='*****@*****.**',
first_name='Bender',
last_name='Rodríguez')
self.user2.set_password('password')
self.user2.clean_and_save()
self.event = Event.objects.create(group=self.group,
title="The event",
slug="the-event",
contact_email="*****@*****.**",
address="123 Main St",
location=CENTRAL_PARK,
max_attendees=100,
begins_at=now(),
ends_at=now())
@property
def event_detail_url(self):
return self.event.get_absolute_url()
def get_event_page(self):
self.get(self.event_detail_url)
def test_rsvp(self):
self.assertEqual(EventRegistration.objects.all().count(), 0)
self.login(self.user2.username)
self.get_event_page()
self.wait_for_text("RSVP")
self.click('#rsvp')
self.wait_for_text("RSVPed")
self.assertEqual(EventRegistration.objects.all().count(), 1)
self.assertEqual(EventRegistration.objects.all()[0].user,
self.user2)
self.assertEqual(EventRegistration.objects.all()[0].event,
self.event)
def test_cancel_rsvp(self):
EventRegistration.objects.create(user=self.user2, event=self.event)
self.login(self.user2.username)
self.get_event_page()
self.wait_for_text("1 / 100")
self.click('#rsvp')
self.wait_for_text("0 / 100")
self.assertEqual(EventRegistration.objects.all().count(), 0)
def test_group_admin_sees_admin_button(self):
self.login(self.user.username)
self.get_event_page()
self.wait_for_text("Admin")
def test_user_not_logged_in_can_rsvp(self):
self.get_event_page()
self.wait_for_text("0 / 100")
self.click('#rsvp')
expected_url = (self.live_server_url + reverse('login') + '?next=' +
self.event_detail_url)
self.assertEqual(expected_url, self.sel.current_url)
self.wait_for_textbox_then_type('[name="username"]',
self.user2.username)
self.wait_for_textbox_then_type('[name="password"]', 'password')
self.click('form input[type="submit"]')
expected_url = self.live_server_url + self.event_detail_url
self.assertEqual(expected_url, self.sel.current_url)
self.wait_for_text("0 / 100")
self.click('#rsvp')
self.wait_for_text("1 / 100")
def test_at_capacity(self):
self.event.max_attendees = 1
self.event.save()
EventRegistration.objects.create(user=self.user, event=self.event)
self.login(self.user2.username)
self.get_event_page()
self.wait_for_text("At Capacity")
self.click('#rsvp') # clicking should do nothing
self.wait_for_text("At Capacity")
def test_user_not_logged_in_at_capacity(self):
self.event.max_attendees = 1
self.event.save()
EventRegistration.objects.create(user=self.user, event=self.event)
self.get_event_page()
self.wait_for_text("At Capacity")
self.click('#rsvp') # clicking should do nothing
self.wait_for_text("At Capacity")