def test_get_customer__no_create(self):
user = PersonFactory()
self.assertEqual(user.stripe_test_customer_id, '')
customer = stripe_get_customer(user, TEST, create=False)
self.assertIsNone(customer)
user.refresh_from_db()
self.assertEqual(user.stripe_test_customer_id, '')
def test_saved_card_payment_form(self, stripe_prep, stripe_charge):
stripe_charge.return_value = STRIPE_CHARGE
person = PersonFactory(stripe_test_customer_id='FAKE_CUSTOMER_ID')
order = OrderFactory(person=person)
event = order.event
card = CardFactory(is_saved=True)
person.cards.add(card)
person.save()
form = SavedCardPaymentForm(order, Decimal('42.15'), data={'card': card.pk})
self.assertTrue(form.is_bound)
self.assertFalse(form.errors)
stripe_charge.assert_called_once_with(
card.stripe_card_id,
amount=Decimal('42.15'),
event=event,
order=order,
customer='FAKE_CUSTOMER_ID'
)
self.assertEqual(stripe_prep.call_count, 0)
txn = form.save()
self.assertIsInstance(txn, Transaction)
self.assertEqual(txn.event, event)
self.assertEqual(txn.amount, Decimal('42.15'))
self.assertEqual(txn.application_fee, Decimal('1.05'))
self.assertEqual(txn.processing_fee, Decimal('1.52'))
def test_dwolla_payment_form_handles_valueerror(self, oauth_refresh,
dwolla_get_sources):
oauth_refresh.return_value = {
'error': 'access_denied',
'error_description': 'Arbitrary error code.'
}
dwolla_get_sources.return_value = DWOLLA_SOURCES
order = OrderFactory()
order.event.organization.dwolla_test_account = DwollaOrganizationAccountFactory(
access_token_expires=timezone.now() - timedelta(1))
order.event.organization.save()
person = PersonFactory()
person.dwolla_test_account = DwollaUserAccountFactory()
person.save()
pin = '1234'
source = 'Balance'
form = DwollaPaymentForm(order=order,
amount=Decimal('42.15'),
data={
'dwolla_pin': pin,
'source': source
},
user=person)
self.assertTrue(form.is_bound)
self.assertTrue(form.errors)
self.assertEqual(form.errors['__all__'],
[oauth_refresh.return_value['error_description']])
def setUp(self):
self.factory = RequestFactory()
self.person = PersonFactory(
first_name="Conan",
last_name="O'Brien",
)
self.event = EventFactory()
self.order = OrderFactory(
event=self.event,
person=self.person,
)
TransactionFactory(
event=self.event,
order=self.order,
amount=130,
)
self.item = ItemFactory(
event=self.event,
name='Multipass',
)
self.item_option1 = ItemOptionFactory(
price=100,
item=self.item,
name='Gold',
)
self.order.add_to_cart(self.item_option1)
self.bought_item = self.order.bought_items.all()[0]
def test_get_customer__no_create(self):
user = PersonFactory()
self.assertEqual(user.stripe_test_customer_id, '')
customer = stripe_get_customer(user, TEST, create=False)
self.assertIsNone(customer)
user.refresh_from_db()
self.assertEqual(user.stripe_test_customer_id, '')
def setUp(self):
self.person = PersonFactory(stripe_test_customer_id='FAKE_CUSTOMER_ID')
self.order = OrderFactory(person=self.person)
self.event = self.order.event
self.card = CardFactory(is_saved=True)
self.person.cards.add(self.card)
self.person.save()
def test_full_send_and_timestamp(self):
owner = PersonFactory(notify_new_purchases=Person.NOTIFY_DAILY)
editor = PersonFactory(notify_new_purchases=Person.NOTIFY_DAILY)
organization = OrganizationFactory()
OrganizationMember.objects.create(
person=owner,
organization=organization,
role=OrganizationMember.OWNER,
)
OrganizationMember.objects.create(
person=editor,
organization=organization,
role=OrganizationMember.EDIT,
)
event = EventFactory(organization=organization)
TransactionFactory(event=event, transaction_type=Transaction.PURCHASE)
self.assertEqual(len(mail.outbox), 0)
self.command.handle()
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject,
'[Dancerfly] New purchases for your events!')
self.assertIn(event.name, mail.outbox[0].body)
self.assertIn(event.name, mail.outbox[0].alternatives[0][0])
self.assertEqual(mail.outbox[1].subject,
'[Dancerfly] New purchases for your events!')
self.assertIn(event.name, mail.outbox[1].body)
self.assertIn(event.name, mail.outbox[1].alternatives[0][0])
owner = Person.objects.get(pk=owner.pk)
self.assertIsNotNone(owner.last_new_purchases_digest_sent)
editor = Person.objects.get(pk=editor.pk)
self.assertIsNotNone(editor.last_new_purchases_digest_sent)
def test_dwolla_charge__user(self):
event = EventFactory(api_type=Event.TEST,
application_fee_percent=Decimal('2.5'))
event.organization.dwolla_test_account = DwollaOrganizationAccountFactory(
)
event.organization.save()
self.assertTrue(event.dwolla_connected())
dwolla_prep(Event.TEST)
person = PersonFactory()
person.dwolla_test_account = DwollaUserAccountFactory()
person.save()
order = OrderFactory(person=person, event=event, code='dwoll1')
charge = dwolla_charge(
account=person.dwolla_test_account,
amount=42.15,
order=order,
event=event,
pin=settings.DWOLLA_TEST_USER_PIN,
source='Balance',
)
self.assertIsInstance(charge, dict)
self.assertEqual(charge["Type"], "money_received")
self.assertEqual(len(charge['Fees']), 1)
self.assertEqual(charge["Notes"],
"Order {} for {}".format(order.code, event.name))
txn = Transaction.from_dwolla_charge(charge, event=event)
# 42.15 * 0.025 = 1.05
self.assertEqual(Decimal(txn.application_fee), Decimal('1.05'))
# 0.25
self.assertEqual(Decimal(txn.processing_fee), Decimal('0'))
refund = dwolla_refund(order=order,
event=event,
payment_id=txn.remote_id,
amount=txn.amount,
pin=settings.DWOLLA_TEST_ORGANIZATION_PIN)
self.assertIsInstance(refund, dict)
self.assertEqual(refund["Amount"], txn.amount)
refund_info = transactions.info(
tid=str(refund['TransactionId']),
alternate_token=event.organization.get_dwolla_account(
event.api_type).get_token())
self.assertEqual(refund_info["Notes"],
"Order {} for {}".format(order.code, event.name))
refund_txn = Transaction.from_dwolla_refund(refund, txn, event=event)
self.assertEqual(refund_txn.amount, -1 * txn.amount)
self.assertEqual(refund_txn.application_fee, 0)
self.assertEqual(refund_txn.processing_fee, 0)
def test_for_request__code__authed_other_authed(self):
"""An authenticated user can't access orders created by anyone else."""
event = EventFactory()
person = PersonFactory()
person2 = PersonFactory()
order = OrderFactory(event=event, person=person2)
request = self.factory.get('/')
self._add_session(request)
Order.objects._set_session_code(request, event, order.code)
request.user = person
with self.assertRaises(Order.DoesNotExist):
Order.objects.for_request(event, request, create=False)
def test_not_member(self):
person = PersonFactory()
event = EventFactory()
with self.assertNumQueries(1):
self.assertEqual(
person.get_all_permissions(event.organization),
set(),
)
with self.assertNumQueries(0):
self.assertFalse(person.has_perm('view', event.organization))
self.assertFalse(person.has_perm('edit', event.organization))
self.assertFalse(person.has_perm('change_permissions', event.organization))
def test_superuser(self):
person = PersonFactory(is_superuser=True)
event = EventFactory()
with self.assertNumQueries(0):
self.assertEqual(
person.get_all_permissions(event.organization),
set(('view', 'edit', 'change_permissions')),
)
with self.assertNumQueries(0):
self.assertTrue(person.has_perm('view', event.organization))
self.assertTrue(person.has_perm('edit', event.organization))
self.assertTrue(person.has_perm('change_permissions', event.organization))
def test_get_customer(self):
user = PersonFactory()
self.assertEqual(user.stripe_test_customer_id, '')
customer = stripe_get_customer(user, TEST)
user.refresh_from_db()
self.assertEqual(user.stripe_test_customer_id, customer.id)
self.assertEqual(customer.email, user.email)
new_customer = stripe_get_customer(user, TEST)
self.assertEqual(new_customer.id, customer.id)
user.refresh_from_db()
self.assertEqual(user.stripe_test_customer_id, customer.id)
def test_comped__sends_email(self):
"""A successful completion with fully-comped items should send a receipt email and an alert email."""
organization = OrganizationFactory()
owner = PersonFactory()
OrganizationMember.objects.create(
person=owner,
organization=organization,
role=OrganizationMember.OWNER,
)
event = EventFactory(
collect_housing_data=False,
organization=organization,
)
order = OrderFactory(event=event)
item = ItemFactory(event=event)
item_option = ItemOptionFactory(price=100, item=item)
discount = DiscountFactory(amount=100,
discount_type='percent',
event=event,
item_options=[item_option])
order.add_to_cart(item_option)
order.add_to_cart(item_option)
order.add_discount(discount)
view = SummaryView()
view.request = self.factory.post('/')
view.request.user = AnonymousUser()
view.event = event
view.order = order
self.assertEqual(len(mail.outbox), 0)
response = view.post(view.request)
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 2)
def setUp(self):
self.person = PersonFactory()
event = EventFactory()
owner = PersonFactory()
OrganizationMember.objects.create(
person=owner,
organization=event.organization,
role=OrganizationMember.OWNER,
)
self.order = OrderFactory(event=event, person=self.person)
transaction = TransactionFactory(event=event, order=self.order,
amount=130)
item = ItemFactory(event=event, name='Multipass')
item_option1 = ItemOptionFactory(price=100, item=item, name='Gold')
item_option2 = ItemOptionFactory(price=60, item=item, name='Silver')
discount = DiscountFactory(amount=30, discount_type='percent',
event=event, item_options=[item_option1])
self.order.add_to_cart(item_option1)
self.order.add_to_cart(item_option2)
self.order.add_discount(discount)
self.order.mark_cart_paid(transaction)
self.mailer = OrderAlertMailer(transaction, site='dancerfly.com',
secure=True)
self.event_name = event.name
self.discount_amount = format_money(discount.amount, event.currency)
self.total_amount = format_money(transaction.amount, event.currency)
self.option1 = '{0} ({1})'.format(item.name, item_option1.name)
self.option2 = '{0} ({1})'.format(item.name, item_option1.name)
self.item_price = format_money(item_option1.price, event.currency)
def setUp(self):
self.person = PersonFactory()
event = EventFactory()
self.order = OrderFactory(event=event, person=self.person)
transaction = TransactionFactory(event=event,
order=self.order,
amount=130)
item = ItemFactory(event=event, name='Multipass')
item_option1 = ItemOptionFactory(price=100, item=item, name='Gold')
item_option2 = ItemOptionFactory(price=60, item=item, name='Silver')
discount = DiscountFactory(amount=30,
discount_type='percent',
event=event,
item_options=[item_option1])
self.order.add_to_cart(item_option1)
self.order.add_to_cart(item_option2)
self.order.add_discount(discount)
self.order.mark_cart_paid(transaction)
self.mailer = OrderReceiptMailer(transaction,
site='dancerfly.com',
secure=True)
self.event_name = event.name
self.discount_amount = format_money(discount.amount, event.currency)
self.total_amount = format_money(transaction.amount, event.currency)
self.option1 = '{0} ({1})'.format(item.name, item_option1.name)
self.option2 = '{0} ({1})'.format(item.name, item_option1.name)
self.item_price = format_money(item_option1.price, event.currency)
def setUp(self):
self.factory = RequestFactory()
self.person = PersonFactory(
first_name="Conan",
last_name="O'Brien",
)
self.event = EventFactory()
self.order = OrderFactory(
event=self.event,
person=self.person,
)
TransactionFactory(
event=self.event,
order=self.order,
amount=130,
)
self.item = ItemFactory(
event=self.event,
name='Multipass',
)
self.item_option1 = ItemOptionFactory(
price=100,
item=self.item,
name='Gold',
)
self.order.add_to_cart(self.item_option1)
self.bought_item = self.order.bought_items.all()[0]
def test_payment__sends_email(self):
"""A successful payment should send a receipt email and an alert email."""
organization = OrganizationFactory(check_payment_allowed=True)
owner = PersonFactory()
OrganizationMember.objects.create(
person=owner,
organization=organization,
role=OrganizationMember.OWNER,
)
event = EventFactory(
collect_housing_data=False,
organization=organization,
check_postmark_cutoff=timezone.now().date(),
)
order = OrderFactory(event=event)
item = ItemFactory(event=event)
item_option = ItemOptionFactory(price=100, item=item)
order.add_to_cart(item_option)
order.add_to_cart(item_option)
view = SummaryView()
view.request = self.factory.post('/', {'check': 1})
view.request.user = AnonymousUser()
view.event = event
view.order = order
self.assertEqual(len(mail.outbox), 0)
response = view.post(view.request)
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 2)
def setUp(self):
self.person = PersonFactory(stripe_test_customer_id='FAKE_CUSTOMER_ID')
self.order = OrderFactory(person=self.person)
self.event = self.order.event
self.card = CardFactory(is_saved=True)
self.person.cards.add(self.card)
self.person.save()
def set_up_view(self, orderer=None, is_confirmed=False):
organization = OrganizationFactory(check_payment_allowed=True)
OrganizationMember.objects.create(
person=PersonFactory(),
organization=organization,
role=OrganizationMember.OWNER,
)
event = EventFactory(
collect_housing_data=False,
organization=organization,
check_postmark_cutoff=timezone.now().date() + timedelta(1),
)
item = ItemFactory(event=event)
item_option = ItemOptionFactory(price=100, item=item)
receiver = PersonFactory()
order_kwargs = dict(event=event)
if orderer:
order_kwargs['person'] = orderer
order = OrderFactory(**order_kwargs)
order.add_to_cart(item_option)
transaction = TransactionFactory(event=event,
order=order,
is_confirmed=is_confirmed)
order.mark_cart_paid(transaction)
# The BoughtItem should be in the correct state if we've set up this
# test Order correctly.
self.assertEqual(order.bought_items.first().status, BoughtItem.BOUGHT)
view = TransferView()
view.kwargs = dict(
event_slug=event.slug,
organization_slug=organization.slug,
)
view.request = self.factory.post(
'/',
dict(
bought_item=order.bought_items.first().pk,
email=receiver.email,
))
view.request.user = orderer if orderer else AnonymousUser()
view.event = event
view.order = order
view.workflow = RegistrationWorkflow(order=order, event=event)
view.current_step = view.workflow.steps.get(view.current_step_slug)
return view
def test_subject_apostrophe(self):
event = EventFactory(name="Han & Leia's Wedding!")
self.person = PersonFactory(first_name="Ma'ayan", last_name="Plaut")
self.event_name = event.name
self.order = OrderFactory(event=event, person=self.person)
transaction = TransactionFactory(event=event,
order=self.order,
amount=130)
self.mailer = OrderAlertMailer(transaction,
site='dancerfly.com',
secure=True)
subject = self.mailer.render_subject(self.mailer.get_context_data())
expected_subject = (
'[{event_name}] New purchase by {person_name}'.format(
event_name=self.event_name,
person_name=self.person.get_full_name()))
self.assertEqual(subject, expected_subject)
def test_organization__view(self):
person = PersonFactory()
event = EventFactory()
OrganizationMember.objects.create(
person=person,
organization=event.organization,
role=OrganizationMember.VIEW,
)
with self.assertNumQueries(2):
self.assertEqual(
person.get_all_permissions(event),
set(('view',)),
)
with self.assertNumQueries(0):
self.assertTrue(person.has_perm('view', event))
self.assertFalse(person.has_perm('edit', event))
self.assertFalse(person.has_perm('change_permissions', event))
def test_organization__edit(self):
person = PersonFactory()
event = EventFactory()
OrganizationMember.objects.create(
person=person,
organization=event.organization,
role=OrganizationMember.EDIT,
)
with self.assertNumQueries(1):
self.assertEqual(
person.get_all_permissions(event),
set(('view', 'edit', 'change_permissions')),
)
with self.assertNumQueries(0):
self.assertTrue(person.has_perm('view', event))
self.assertTrue(person.has_perm('edit', event))
self.assertTrue(person.has_perm('change_permissions', event))
def test_event__edit(self):
person = PersonFactory()
event = EventFactory()
EventMember.objects.create(
person=person,
event=event,
role=EventMember.EDIT,
)
with self.assertNumQueries(2):
self.assertEqual(
person.get_all_permissions(event),
set(('view', 'edit')),
)
with self.assertNumQueries(0):
self.assertTrue(person.has_perm('view', event))
self.assertTrue(person.has_perm('edit', event))
self.assertFalse(person.has_perm('change_permissions', event))
def test_event__view(self):
person = PersonFactory()
event = EventFactory()
EventMember.objects.create(
person=person,
event=event,
role=EventMember.VIEW,
)
with self.assertNumQueries(1):
self.assertEqual(
person.get_all_permissions(event.organization),
set(),
)
with self.assertNumQueries(0):
self.assertFalse(person.has_perm('view', event.organization))
self.assertFalse(person.has_perm('edit', event.organization))
self.assertFalse(person.has_perm('change_permissions', event.organization))
def test_queryset_distinct(self):
"""
For authenticated users, make sure the qs is distinct.
Specifically, having multiple additional editors on
the event shouldn't cause duplication issues.
"""
person = PersonFactory()
editor1 = PersonFactory()
editor2 = PersonFactory()
editor3 = PersonFactory()
event = EventFactory(collect_housing_data=False)
EventMember.objects.create(
person=editor1,
event=event,
role=EventMember.EDIT,
)
EventMember.objects.create(
person=editor2,
event=event,
role=EventMember.EDIT,
)
EventMember.objects.create(
person=editor3,
event=event,
role=EventMember.EDIT,
)
order = OrderFactory(event=event, person=person)
# Set up three attendees to trigger duplication.
AttendeeFactory(order=order)
AttendeeFactory(order=order)
AttendeeFactory(order=order)
item = ItemFactory(event=event)
item_option = ItemOptionFactory(price=100, item=item)
order.add_to_cart(item_option)
order.add_to_cart(item_option)
viewset = BoughtItemViewSet()
viewset.request = self.factory.get('/')
viewset.request.user = person
qs = viewset.get_queryset()
self.assertEqual(len(qs), 2)
self.assertEqual(set(qs), set(order.bought_items.all()))
def test_pending_payment_transfer_fails(self):
"""A transfer on an item with unconfirmed transactions should be prohibited."""
view = self.set_up_view(
orderer=PersonFactory(),
is_confirmed=False,
)
view.post(view.request)
self.assertEqual(len(mail.outbox), 0)
def test_viewable_by__public_unpublished__owner(self):
event = EventFactory(is_published=False, privacy=Event.PUBLIC)
person = PersonFactory()
OrganizationMember.objects.create(
person=person,
organization=event.organization,
role=OrganizationMember.OWNER,
)
self.assertTrue(event.viewable_by(person))
def test_adjust_datetime(self):
request = self.factory.get('/')
request.user = PersonFactory()
td = timedelta(days=3)
old_date = datetime(2015, 10, 2, 5, 5, 5)
old_event = EventFactory(start_date=date(2015, 10, 5))
new_event = EventFactory(start_date=old_event.start_date + td)
form = EventCreateForm(request)
new_date = form._adjust_date(old_event, new_event, old_date)
self.assertEqual(new_date, old_date + td)
def setUp(self):
self.person = PersonFactory()
self.event = EventFactory()
self.item = ItemFactory(event=self.event, name='Multipass')
self.order = OrderFactory(event=self.event, person=self.person)
self.item_option1 = ItemOptionFactory(price=100, item=self.item, name='Gold')
self.item_option2 = ItemOptionFactory(price=100, item=self.item, name='Gold')
self.bought_item1 = BoughtItem.objects.create(item_option=self.item_option1, order=self.order, price=Decimal(0), status=BoughtItem.BOUGHT)
self.bought_item2 = BoughtItem.objects.create(item_option=self.item_option2, order=self.order, price=Decimal(0), status=BoughtItem.BOUGHT)
self.txn = TransactionFactory(amount=Decimal("20"), order=self.order)
self.txn.bought_items.add(self.bought_item1, self.bought_item2)
def test_for_request__code__authed_anon(self):
"""Authenticated users cannot access orders created by anonymous users
without the code stored in the session.
"""
event = EventFactory()
person = PersonFactory()
OrderFactory(event=event, person=None)
request = self.factory.get('/')
self._add_session(request)
request.user = person
with self.assertRaises(Order.DoesNotExist):
Order.objects.for_request(event, request, create=False)
def test_for_request__authed(self):
"""An authenticated user will automatically get their own order."""
event = EventFactory()
person = PersonFactory()
order = OrderFactory(event=event, person=person)
request = self.factory.get('/')
request.user = person
fetched, created = Order.objects.for_request(event,
request,
create=False)
self.assertFalse(created)
self.assertEqual(fetched, order)
def setUp(self):
self.factory = RequestFactory()
self.organization = OrganizationFactory()
self.owner = PersonFactory()
self.owner_member = OrganizationMember.objects.create(
organization=self.organization,
person=self.owner,
role=OrganizationMember.OWNER,
)
self.editor = PersonFactory()
self.editor_member = OrganizationMember.objects.create(
organization=self.organization,
person=self.editor,
role=OrganizationMember.EDIT,
)
self.request = self.factory.get('/')
self.request.user = self.owner
SessionMiddleware().process_request(self.request)
MessageMiddleware().process_request(self.request)
self.view = OrganizationRemoveMemberView()
def setUp(self):
self.factory = RequestFactory()
self.view = MergeOrderView()
event = EventFactory(collect_housing_data=True)
item = ItemFactory(event=event)
item_option = ItemOptionFactory(price=100, item=item)
self.person = PersonFactory()
self.order1 = OrderFactory(event=event, person=self.person)
self.order2 = OrderFactory(event=event,
person=None,
email=self.person.email)
self.tr1 = TransactionFactory(event=event, order=self.order1)
self.tr2 = TransactionFactory(event=event, order=self.order2)
self.order1.add_to_cart(item_option)
self.order1.mark_cart_paid(self.tr1)
self.order2.add_to_cart(item_option)
self.order2.add_to_cart(item_option)
self.order2.mark_cart_paid(self.tr2)
self.att1 = AttendeeFactory(
order=self.order1,
bought_items=self.order1.bought_items.all(),
email='*****@*****.**')
self.att2 = AttendeeFactory(
order=self.order2,
bought_items=self.order2.bought_items.all(),
email='*****@*****.**')
self.housing2 = EventHousingFactory(
event=event,
order=self.order2,
contact_name='Picard',
contact_email='*****@*****.**',
contact_phone='111-111-1111',
public_transit_access=True,
person_prefer='Dr. Crusher',
person_avoid='Wesley Crusher')
self.attendee1 = AttendeeFactory(order=self.order1)
self.attendee2 = AttendeeFactory(order=self.order2)
self.view.request = self.factory.post('/', {'pk': self.order2.pk})
self.view.request.user = self.person
setattr(self.view.request, 'session', 'session')
messages = FallbackStorage(self.view.request)
setattr(self.view.request, '_messages', messages)
def test_subject__transfer(self):
person = PersonFactory(first_name="Conan", last_name="O'Brien")
event = EventFactory()
order = OrderFactory(event=event, person=person)
TransactionFactory(event=event, order=order, amount=130)
item = ItemFactory(event=event, name='Multipass')
item_option1 = ItemOptionFactory(price=100, item=item, name='Gold')
order.add_to_cart(item_option1)
boughtitem = order.bought_items.all()[0]
request = self.factory.get('/')
request.user = person
invite, created = TransferInvite.get_or_create(
request=request,
email='*****@*****.**',
content=boughtitem,
)
invite.send()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
"{} wants to transfer an item to you".format(
person.get_full_name()))
def test_subject_apostrophe(self):
event = EventFactory(name="Han & Leia's Wedding!")
self.person = PersonFactory(first_name="Ma'ayan", last_name="Plaut")
self.event_name = event.name
self.order = OrderFactory(event=event, person=self.person)
transaction = TransactionFactory(event=event, order=self.order, amount=130)
self.mailer = OrderAlertMailer(transaction, site='dancerfly.com',
secure=True)
subject = self.mailer.render_subject(self.mailer.get_context_data())
expected_subject = ('[{event_name}] New purchase by {person_name}'
.format(event_name=self.event_name,
person_name=self.person.get_full_name()))
self.assertEqual(subject, expected_subject)
def test_invite(self):
view = InviteAcceptView()
event = EventFactory()
invite = InviteFactory(content_id=event.pk,
kind=EventInvite.slug,
user=PersonFactory(first_name="Conan",
last_name="O'Brien"))
view.content = event
view.request = RequestFactory().get('/')
view.request.user = PersonFactory(email=invite.email,
confirmed_email=invite.email)
self._add_session(view.request)
with mock.patch.object(wraps=Order.objects.for_request,
target=Order.objects,
attribute='for_request') as for_request:
view.get(view.request, code=invite.code)
for_request.assert_called_once_with(create=True,
request=view.request,
event=view.content)
orders = Order.objects.all()
self.assertEqual(len(orders), 1)
self.assertEqual(orders[0].person, view.request.user)
def test_dolla_charge__negative(self):
event = EventFactory(api_type=Event.TEST,
application_fee_percent=Decimal('2.5'))
event.organization.dwolla_test_account = DwollaOrganizationAccountFactory(
)
event.organization.save()
self.assertTrue(event.dwolla_connected())
dwolla_prep(Event.TEST)
person = PersonFactory()
person.dwolla_test_account = DwollaUserAccountFactory()
person.save()
order = OrderFactory(person=person, event=event, code='dwoll1')
with self.assertRaises(InvalidAmountException):
dwolla_charge(
account=person.dwolla_test_account,
amount=-1.00,
order=order,
event=event,
pin=settings.DWOLLA_TEST_USER_PIN,
source='Balance',
)
class OrderSearchTestCase(APITestCase):
def setUp(self):
self.person = PersonFactory(password='******', is_superuser=True)
self.client.login(username=self.person.email, password='******')
self.event = EventFactory()
self.order = OrderFactory(event=self.event)
def test_get__no_permissions(self):
self.person.is_superuser = False
self.person.save()
response = self.client.get(
'/api/v1/ordersearch/', {
'event': self.event.pk,
},
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_get__no_event(self):
response = self.client.get(
'/api/v1/ordersearch/',
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
def test_get__with_event(self):
event2 = EventFactory()
OrderFactory(event=event2)
response = self.client.get(
'/api/v1/ordersearch/', {
'event': self.event.pk,
},
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], self.order.pk)
def test_queryset_distinct(self):
"""
For authenticated users, make sure the qs is distinct.
Specifically, having multiple additional editors on
the event shouldn't cause duplication issues.
"""
person = PersonFactory()
editor1 = PersonFactory()
editor2 = PersonFactory()
editor3 = PersonFactory()
event = EventFactory(collect_housing_data=False)
EventMember.objects.create(
person=editor1,
event=event,
role=EventMember.EDIT,
)
EventMember.objects.create(
person=editor2,
event=event,
role=EventMember.EDIT,
)
EventMember.objects.create(
person=editor3,
event=event,
role=EventMember.EDIT,
)
order = OrderFactory(event=event, person=person)
att1 = AttendeeFactory(order=order)
att2 = AttendeeFactory(order=order)
att3 = AttendeeFactory(order=order)
viewset = AttendeeViewSet()
viewset.request = self.factory.get('/')
viewset.request.user = person
qs = viewset.get_queryset()
self.assertEqual(len(qs), 3)
self.assertEqual(set(qs), set((att1, att2, att3)))
def test_organization__view__event__edit(self):
"""Max permission level takes precedence."""
person = PersonFactory()
event = EventFactory()
OrganizationMember.objects.create(
person=person,
organization=event.organization,
role=OrganizationMember.VIEW,
)
EventMember.objects.create(
person=person,
event=event,
role=EventMember.EDIT,
)
with self.assertNumQueries(2):
self.assertEqual(
person.get_all_permissions(event),
set(('view', 'edit')),
)
with self.assertNumQueries(0):
self.assertTrue(person.has_perm('view', event))
self.assertTrue(person.has_perm('edit', event))
self.assertFalse(person.has_perm('change_permissions', event))
class TransferInviteTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.person = PersonFactory(
first_name="Conan",
last_name="O'Brien",
)
self.event = EventFactory()
self.order = OrderFactory(
event=self.event,
person=self.person,
)
TransactionFactory(
event=self.event,
order=self.order,
amount=130,
)
self.item = ItemFactory(
event=self.event,
name='Multipass',
)
self.item_option1 = ItemOptionFactory(
price=100,
item=self.item,
name='Gold',
)
self.order.add_to_cart(self.item_option1)
self.bought_item = self.order.bought_items.all()[0]
def test_email_subject__transfer(self):
request = self.factory.get('/')
request.user = self.person
invite, created = TransferInvite.get_or_create(
request=request,
email='*****@*****.**',
content=self.bought_item,
)
invite.send()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
"{} wants to transfer an item to you".format(
self.person.get_full_name()
),
)
def test_manage_not_allowed__no_order(self):
# A person who isn't signed up for the event
# shouldn't be able to manage it.
person2 = PersonFactory()
request = self.factory.get('/')
request.user = person2
session_middleware = SessionMiddleware()
session_middleware.process_request(request)
instance = Invite.objects.create(
email=person2.email,
user=self.person,
kind='transfer',
content_id=self.bought_item.id,
)
invite = get_invite(request, instance.code, self.bought_item)
self.assertFalse(invite.manage_allowed())
def test_manage_not_allowed__wrong_order(self):
# A person who doesn't have the originating order
# shouldn't be able to manage it.
person2 = PersonFactory()
OrderFactory(
person=person2,
event=self.event,
)
request = self.factory.get('/')
request.user = person2
instance = Invite.objects.create(
email=person2.email,
user=self.person,
kind='transfer',
content_id=self.bought_item.id,
)
invite = get_invite(request, instance.code, self.bought_item)
self.assertFalse(invite.manage_allowed())
def test_manage_allowed(self):
# Owner of a bought item should be able to manage transfer invites.
person2 = PersonFactory()
request = self.factory.get('/')
request.user = self.person
instance = Invite.objects.create(
email=person2.email,
user=self.person,
kind='transfer',
content_id=self.bought_item.id,
)
invite = get_invite(request, instance.code, self.bought_item)
self.assertTrue(invite.manage_allowed())
def setUp(self):
self.person = PersonFactory(password='******', is_superuser=True)
self.client.login(username=self.person.email, password='******')
self.event = EventFactory()
self.order = OrderFactory(event=self.event)
class SavedCardPaymentFormTestCase(TestCase):
def setUp(self):
self.person = PersonFactory(stripe_test_customer_id='FAKE_CUSTOMER_ID')
self.order = OrderFactory(person=self.person)
self.event = self.order.event
self.card = CardFactory(is_saved=True)
self.person.cards.add(self.card)
self.person.save()
@patch('brambling.forms.orders.stripe_charge')
def test_successful_charge(self, stripe_charge):
stripe_charge.return_value = STRIPE_CHARGE
form = SavedCardPaymentForm(self.order, Decimal('42.15'),
data={'card': self.card.pk})
self.assertTrue(form.is_bound)
self.assertFalse(form.errors)
stripe_charge.assert_called_once_with(
self.card.stripe_card_id,
amount=Decimal('42.15'),
event=self.event,
order=self.order,
customer='FAKE_CUSTOMER_ID'
)
txn = form.save()
self.assertIsInstance(txn, Transaction)
self.assertEqual(txn.event, self.event)
self.assertEqual(txn.amount, Decimal('42.15'))
self.assertEqual(txn.application_fee, Decimal('1.05'))
self.assertEqual(txn.processing_fee, Decimal('1.52'))
def test_negative_amount_adds_errors(self):
form = SavedCardPaymentForm(self.order, Decimal('-1.00'),
data={'card': self.card.pk})
self.assertTrue(form.is_bound)
self.assertTrue(form.errors)
self.assertEqual(form.errors['__all__'],
["Cannot charge an amount less than zero."])
@patch('brambling.forms.orders.stripe_charge')
def test_handles_carderror(self, stripe_charge):
error_message = "Hi"
stripe_charge.side_effect = stripe.error.CardError(error_message, 1, 1)
form = SavedCardPaymentForm(order=self.order, amount=Decimal('42.15'),
data={'card': self.card.pk})
self.assertTrue(form.is_bound)
self.assertTrue(form.errors)
self.assertEqual(form.errors['__all__'], [error_message])
@patch('brambling.forms.orders.stripe_charge')
def test_handles_apierror(self, stripe_charge):
error_message = "Hi"
stripe_charge.side_effect = stripe.error.APIError(error_message, 1, 1)
form = SavedCardPaymentForm(order=self.order, amount=Decimal('42.15'),
data={'card': self.card.pk})
self.assertTrue(form.is_bound)
self.assertTrue(form.errors)
self.assertEqual(form.errors['__all__'], [STRIPE_API_ERROR])
@patch('brambling.forms.orders.stripe_charge')
def test_handles_invalidamountexception(self, stripe_charge):
error_message = "Hi"
stripe_charge.side_effect = InvalidAmountException(error_message)
form = SavedCardPaymentForm(order=self.order, amount=Decimal('42.15'),
data={'card': self.card.pk})
self.assertTrue(form.is_bound)
self.assertTrue(form.errors)
self.assertEqual(form.errors['__all__'], [error_message])
@patch('brambling.forms.orders.stripe_charge')
def test_handles_invalidrequesterror(self, stripe_charge):
error_message = "Hi"
stripe_charge.side_effect = stripe.error.InvalidRequestError(error_message, 1)
form = SavedCardPaymentForm(order=self.order, amount=Decimal('42.15'),
data={'card': self.card.pk})
self.assertTrue(form.is_bound)
self.assertTrue(form.errors)
self.assertEqual(form.errors['__all__'], [error_message])
class OrderReceiptMailerTestCase(TestCase):
def setUp(self):
self.person = PersonFactory()
event = EventFactory()
owner = PersonFactory()
OrganizationMember.objects.create(
person=owner,
organization=event.organization,
role=OrganizationMember.OWNER,
)
self.order = OrderFactory(event=event, person=self.person)
transaction = TransactionFactory(event=event, order=self.order,
amount=130)
item = ItemFactory(event=event, name='Multipass')
item_option1 = ItemOptionFactory(price=100, item=item, name='Gold')
item_option2 = ItemOptionFactory(price=60, item=item, name='Silver')
discount = DiscountFactory(amount=30, discount_type='percent',
event=event, item_options=[item_option1])
self.order.add_to_cart(item_option1)
self.order.add_to_cart(item_option2)
self.order.add_discount(discount)
self.order.mark_cart_paid(transaction)
self.mailer = OrderAlertMailer(transaction, site='dancerfly.com',
secure=True)
self.event_name = event.name
self.discount_amount = format_money(discount.amount, event.currency)
self.total_amount = format_money(transaction.amount, event.currency)
self.option1 = '{0} ({1})'.format(item.name, item_option1.name)
self.option2 = '{0} ({1})'.format(item.name, item_option1.name)
self.item_price = format_money(item_option1.price, event.currency)
def test_render_plaintext(self):
body = self.mailer.render_body(self.mailer.get_context_data(),
plaintext=True)
self.assertIn(self.total_amount, body)
self.assertIn(self.option1, body)
self.assertIn(self.option2, body)
self.assertNotIn("outstanding check payments", body)
def test_render_inlined(self):
body = self.mailer.render_body(self.mailer.get_context_data(),
inlined=True)
self.assertIn(self.option1, body)
self.assertIn(self.option2, body)
self.assertIn(self.total_amount, body)
def test_recipients(self):
self.assertSequenceEqual(self.mailer.get_recipients(),
[self.order.event.organization.members.get().email])
def test_recipients__notify_never(self):
person = self.order.event.organization.members.get()
person.notify_new_purchases = 'never'
person.save()
self.assertSequenceEqual(self.mailer.get_recipients(),
[])
def test_recipients__notify_daily(self):
person = self.order.event.organization.members.get()
person.notify_new_purchases = 'daily'
person.save()
self.assertSequenceEqual(self.mailer.get_recipients(),
[])
def test_subject(self):
subject = self.mailer.render_subject(self.mailer.get_context_data())
expected_subject = ('[{event_name}] New purchase by {person_name}'
.format(event_name=self.event_name,
person_name=self.person.get_full_name()))
self.assertEqual(subject, expected_subject)
def test_body_non_inlined_non_plaintext(self):
body = self.mailer.render_body(self.mailer.get_context_data(),
inlined=False, plaintext=False)
self.assertIn(self.option1, body)
self.assertIn(self.option2, body)
self.assertIn(self.total_amount, body)
def test_subject_apostrophe(self):
event = EventFactory(name="Han & Leia's Wedding!")
self.person = PersonFactory(first_name="Ma'ayan", last_name="Plaut")
self.event_name = event.name
self.order = OrderFactory(event=event, person=self.person)
transaction = TransactionFactory(event=event, order=self.order, amount=130)
self.mailer = OrderAlertMailer(transaction, site='dancerfly.com',
secure=True)
subject = self.mailer.render_subject(self.mailer.get_context_data())
expected_subject = ('[{event_name}] New purchase by {person_name}'
.format(event_name=self.event_name,
person_name=self.person.get_full_name()))
self.assertEqual(subject, expected_subject)
