class SendReceiptTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
owner = PersonFactory()
self.event = EventFactory(collect_housing_data=False)
OrganizationMember.objects.create(
person=owner,
organization=self.event.organization,
role=OrganizationMember.OWNER,
)
order = OrderFactory(event=self.event, code='aaaaaaaa')
self.transaction = TransactionFactory(event=self.event, order=order)
item = ItemFactory(event=self.event)
item_option = ItemOptionFactory(price=100, item=item)
order.add_to_cart(item_option)
order.add_to_cart(item_option)
order.mark_cart_paid(self.transaction)
AttendeeFactory(order=order, bought_items=order.bought_items.all())
self.view = SendReceiptView()
self.view.request = self.factory.get('/')
self.view.request.user = owner
def test_txn_not_found(self):
event = self.event
self.view.kwargs = {'payment_pk': 0}
with self.assertRaises(Http404):
self.view.get(self.view.request,
event_slug=event.slug,
organization_slug=event.organization.slug)
def test_txn_not_purchase(self):
event = self.event
self.view.kwargs = {'payment_pk': self.transaction.pk}
self.transaction.transaction_type = Transaction.OTHER
self.transaction.save()
with self.assertRaises(Http404):
self.view.get(self.view.request,
event_slug=event.slug,
organization_slug=event.organization.slug)
def test_successful_send(self):
event = self.event
self.view.kwargs = {'payment_pk': self.transaction.pk}
SessionMiddleware().process_request(self.view.request)
MessageMiddleware().process_request(self.view.request)
response = self.view.get(self.view.request,
event_slug=event.slug,
organization_slug=event.organization.slug)
self.assertEqual(response.status_code, 302)
class SendReceiptTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
owner = PersonFactory()
self.event = EventFactory(collect_housing_data=False)
OrganizationMember.objects.create(
person=owner,
organization=self.event.organization,
role=OrganizationMember.OWNER,
)
order = OrderFactory(event=self.event, code='aaaaaaaa')
self.transaction = TransactionFactory(event=self.event, order=order)
item = ItemFactory(event=self.event)
item_option = ItemOptionFactory(price=100, item=item)
order.add_to_cart(item_option)
order.add_to_cart(item_option)
order.mark_cart_paid(self.transaction)
AttendeeFactory(order=order, bought_items=order.bought_items.all())
self.view = SendReceiptView()
self.view.request = self.factory.get('/')
self.view.request.user = owner
def test_txn_not_found(self):
event = self.event
self.view.kwargs = {'payment_pk': 0}
with self.assertRaises(Http404):
self.view.get(self.view.request, event_slug=event.slug,
organization_slug=event.organization.slug)
def test_txn_not_purchase(self):
event = self.event
self.view.kwargs = {'payment_pk': self.transaction.pk}
self.transaction.transaction_type = Transaction.OTHER
self.transaction.save()
with self.assertRaises(Http404):
self.view.get(self.view.request, event_slug=event.slug,
organization_slug=event.organization.slug)
def test_successful_send(self):
event = self.event
self.view.kwargs = {'payment_pk': self.transaction.pk}
SessionMiddleware().process_request(self.view.request)
MessageMiddleware().process_request(self.view.request)
response = self.view.get(self.view.request, event_slug=event.slug,
organization_slug=event.organization.slug)
self.assertEqual(response.status_code, 302)
class RefundViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.owner = Person.objects.create_user(email="*****@*****.**", password="******")
self.non_owner = Person.objects.create_user(email="*****@*****.**", password="******")
self.event = EventFactory(collect_housing_data=False)
OrganizationMember.objects.create(
person=self.owner,
organization=self.event.organization,
role=OrganizationMember.OWNER,
)
order = OrderFactory(event=self.event, code='aaaaaaaa')
self.transaction = TransactionFactory(event=self.event, order=order)
item = ItemFactory(event=self.event)
item_option = ItemOptionFactory(price=100, item=item)
order.add_to_cart(item_option)
order.add_to_cart(item_option)
order.mark_cart_paid(self.transaction)
AttendeeFactory(order=order, bought_items=order.bought_items.all())
def test_user_no_permissions_get(self):
self.client.login(email="*****@*****.**", password="******")
response = self.client.get(reverse("brambling_event_refund", kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}))
self.assertEqual(response.status_code, 404)
def test_user_no_permissions_post(self):
self.client.login(email="*****@*****.**", password="******")
response = self.client.post(reverse("brambling_event_refund", kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}))
self.assertEqual(response.status_code, 404) # not found
def test_successful_refund_redirect(self):
self.transaction.amount = '40'
self.transaction.save()
self.client.login(email="*****@*****.**", password="******")
data = {
'amount': '20'
}
response = self.client.post(reverse("brambling_event_refund", kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}), data)
self.assertEqual(response.status_code, 302) # temporary redirect
self.assertRedirects(response, reverse("brambling_event_order_detail",
kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
}))
def test_successful_refund_message(self):
self.transaction.amount = '40'
self.transaction.save()
self.client.login(email="*****@*****.**", password="******")
data = {
'amount': '20'
}
response = self.client.post(reverse("brambling_event_refund", kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}), data, follow=True)
ctx_messages = list(response.context['messages'])
self.assertEqual(ctx_messages[0].level, messages.SUCCESS)
@mock.patch('brambling.models.Transaction.refund')
def test_unsuccessful_refund_message(self, refund):
refund.side_effect = ValueError('Terrible value.')
self.transaction.amount = '40'
self.transaction.save()
self.client.login(email="*****@*****.**", password="******")
data = {
'amount': '20'
}
response = self.client.post(reverse("brambling_event_refund", kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}), data, follow=True)
ctx_messages = list(response.context['messages'])
self.assertEqual(ctx_messages[0].level, messages.ERROR)
class TransactionRefundTestCase(TestCase):
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_refund_no_args(self):
self.txn.amount = Decimal("2.00")
self.txn.save()
self.assertEqual(self.txn.get_refundable_amount(), Decimal("2.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 0)
refund = self.txn.refund()
self.assertIsInstance(refund, Transaction)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 1)
def test_refund_no_args__refunded(self):
self.txn.amount = Decimal("2.00")
self.txn.save()
self.assertEqual(self.txn.get_refundable_amount(), Decimal("2.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 0)
refund = self.txn.refund()
self.assertIsInstance(refund, Transaction)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 1)
refund = self.txn.refund()
self.assertIsNone(refund)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 1)
def test_refund__zero_amount_with_item(self):
self.txn.amount = Decimal("0")
self.txn.save()
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0"))
self.assertQuerysetEqual(
self.txn.get_returnable_items(),
[repr(self.bought_item1),
repr(self.bought_item2)])
refund = self.txn.refund()
self.assertIsInstance(refund, Transaction)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(len(self.txn.get_returnable_items()), 0)
def test_refund_partial_amount(self):
self.txn.amount = Decimal("20.00")
self.txn.save()
refund = self.txn.refund(amount=Decimal(10))
self.assertEqual(refund.amount, Decimal(-10))
self.assertEqual(self.txn.get_refundable_amount(), Decimal(10))
def test_refund_one_item(self):
refund = self.txn.refund(bought_items=BoughtItem.objects.filter(
pk=self.bought_item1.pk))
self.bought_item1.refresh_from_db()
self.assertEqual(refund.bought_items.get(), self.bought_item1)
self.assertEqual(self.bought_item1.status, BoughtItem.REFUNDED)
self.assertNotEqual(self.bought_item2, BoughtItem.BOUGHT)
def test_nothing_refund(self):
refund = self.txn.refund(bought_items=BoughtItem.objects.none(),
amount=Decimal("0"))
self.assertIsNone(refund)
def test_excessive_refund_amount(self):
self.txn.amount = Decimal("20.00")
self.txn.save()
with self.assertRaises(ValueError):
self.txn.refund(amount=Decimal("2000.00"))
def test_alien_item_return(self):
alien_order = OrderFactory(event=self.event, person=self.person)
alien_item = BoughtItem.objects.create(item_option=self.item_option1,
price=Decimal(0),
status=BoughtItem.BOUGHT,
order=alien_order)
with self.assertRaises(ValueError):
self.txn.refund(bought_items=BoughtItem.objects.filter(
pk=alien_item.pk))
def test_negative_refund_error(self):
with self.assertRaises(ValueError):
self.txn.refund(amount=Decimal("-20.00"))
@mock.patch('brambling.models.dwolla_refund')
def test_dwolla_refund(self, dwolla_refund):
dwolla_refund.return_value = {
'fundsSource': 'Balance',
'pin': 1234,
'Amount': 20.00,
'oauth_token': 'AN OAUTH TOKEN',
'TransactionId': self.txn.remote_id
}
self.txn.method = Transaction.DWOLLA
self.txn.amount = Decimal("20.00")
self.txn.save()
self.txn.refund(dwolla_pin="1234")
dwolla_refund.assert_called_once_with(order=self.txn.order,
event=self.txn.order.event,
payment_id=self.txn.remote_id,
amount=Decimal("20.00"),
pin="1234")
@mock.patch('brambling.models.Transaction.from_stripe_refund')
@mock.patch('brambling.models.stripe_refund')
def test_stripe_refund(self, stripe_refund, from_stripe_refund):
self.txn.method = Transaction.STRIPE
self.txn.amount = Decimal("20.00")
self.txn.save()
self.txn.refund()
stripe_refund.assert_called_once_with(order=self.txn.order,
event=self.txn.order.event,
payment_id=self.txn.remote_id,
amount=Decimal("20.00"))
class RefundViewTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.owner = Person.objects.create_user(email="*****@*****.**",
password="******")
self.non_owner = Person.objects.create_user(
email="*****@*****.**", password="******")
self.event = EventFactory(collect_housing_data=False)
OrganizationMember.objects.create(
person=self.owner,
organization=self.event.organization,
role=OrganizationMember.OWNER,
)
order = OrderFactory(event=self.event, code='aaaaaaaa')
self.transaction = TransactionFactory(event=self.event, order=order)
item = ItemFactory(event=self.event)
item_option = ItemOptionFactory(price=100, item=item)
order.add_to_cart(item_option)
order.add_to_cart(item_option)
order.mark_cart_paid(self.transaction)
AttendeeFactory(order=order, bought_items=order.bought_items.all())
def test_user_no_permissions_get(self):
self.client.login(email="*****@*****.**", password="******")
response = self.client.get(
reverse("brambling_event_refund",
kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}))
self.assertEqual(response.status_code, 404)
def test_user_no_permissions_post(self):
self.client.login(email="*****@*****.**", password="******")
response = self.client.post(
reverse("brambling_event_refund",
kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}))
self.assertEqual(response.status_code, 404) # not found
def test_successful_refund_redirect(self):
self.transaction.amount = '40'
self.transaction.save()
self.client.login(email="*****@*****.**", password="******")
data = {'amount': '20'}
response = self.client.post(
reverse("brambling_event_refund",
kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
'pk': self.transaction.pk
}), data)
self.assertEqual(response.status_code, 302) # temporary redirect
self.assertRedirects(
response,
reverse("brambling_event_order_detail",
kwargs={
'organization_slug': self.event.organization.slug,
'event_slug': self.event.slug,
'code': self.transaction.order.code,
}))
def test_successful_refund_message(self):
self.transaction.amount = '40'
self.transaction.save()
self.client.login(email="*****@*****.**", password="******")
data = {'amount': '20'}
response = self.client.post(reverse("brambling_event_refund",
kwargs={
'organization_slug':
self.event.organization.slug,
'event_slug':
self.event.slug,
'code':
self.transaction.order.code,
'pk':
self.transaction.pk
}),
data,
follow=True)
ctx_messages = list(response.context['messages'])
self.assertEqual(ctx_messages[0].level, messages.SUCCESS)
@mock.patch('brambling.models.Transaction.refund')
def test_unsuccessful_refund_message(self, refund):
refund.side_effect = ValueError('Terrible value.')
self.transaction.amount = '40'
self.transaction.save()
self.client.login(email="*****@*****.**", password="******")
data = {'amount': '20'}
response = self.client.post(reverse("brambling_event_refund",
kwargs={
'organization_slug':
self.event.organization.slug,
'event_slug':
self.event.slug,
'code':
self.transaction.order.code,
'pk':
self.transaction.pk
}),
data,
follow=True)
ctx_messages = list(response.context['messages'])
self.assertEqual(ctx_messages[0].level, messages.ERROR)
class TransactionRefundTestCase(TestCase):
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_refund_no_args(self):
self.txn.amount = Decimal("2.00")
self.txn.save()
self.assertEqual(self.txn.get_refundable_amount(), Decimal("2.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 0)
refund = self.txn.refund()
self.assertIsInstance(refund, Transaction)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 1)
def test_refund_no_args__refunded(self):
self.txn.amount = Decimal("2.00")
self.txn.save()
self.assertEqual(self.txn.get_refundable_amount(), Decimal("2.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 0)
refund = self.txn.refund()
self.assertIsInstance(refund, Transaction)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 1)
refund = self.txn.refund()
self.assertIsNone(refund)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(self.txn.related_transaction_set.count(), 1)
def test_refund__zero_amount_with_item(self):
self.txn.amount = Decimal("0")
self.txn.save()
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0"))
self.assertQuerysetEqual(self.txn.get_returnable_items(), [repr(self.bought_item1), repr(self.bought_item2)])
refund = self.txn.refund()
self.assertIsInstance(refund, Transaction)
self.assertEqual(self.txn.get_refundable_amount(), Decimal("0.00"))
self.assertEqual(len(self.txn.get_returnable_items()), 0)
def test_refund_partial_amount(self):
self.txn.amount = Decimal("20.00")
self.txn.save()
refund = self.txn.refund(amount=Decimal(10))
self.assertEqual(refund.amount, Decimal(-10))
self.assertEqual(self.txn.get_refundable_amount(), Decimal(10))
def test_refund_one_item(self):
refund = self.txn.refund(bought_items=BoughtItem.objects.filter(pk=self.bought_item1.pk))
self.bought_item1.refresh_from_db()
self.assertEqual(refund.bought_items.get(), self.bought_item1)
self.assertEqual(self.bought_item1.status, BoughtItem.REFUNDED)
self.assertNotEqual(self.bought_item2, BoughtItem.BOUGHT)
def test_nothing_refund(self):
refund = self.txn.refund(bought_items=BoughtItem.objects.none(), amount=Decimal("0"))
self.assertIsNone(refund)
def test_excessive_refund_amount(self):
self.txn.amount = Decimal("20.00")
self.txn.save()
with self.assertRaises(ValueError):
self.txn.refund(amount=Decimal("2000.00"))
def test_alien_item_return(self):
alien_order = OrderFactory(event=self.event, person=self.person)
alien_item = BoughtItem.objects.create(item_option=self.item_option1, price=Decimal(0), status=BoughtItem.BOUGHT, order=alien_order)
with self.assertRaises(ValueError):
self.txn.refund(bought_items=BoughtItem.objects.filter(pk=alien_item.pk))
def test_negative_refund_error(self):
with self.assertRaises(ValueError):
self.txn.refund(amount=Decimal("-20.00"))
@mock.patch('brambling.models.Transaction.from_stripe_refund')
@mock.patch('brambling.models.stripe_refund')
def test_stripe_refund(self, stripe_refund, from_stripe_refund):
self.txn.method = Transaction.STRIPE
self.txn.amount = Decimal("20.00")
self.txn.save()
self.txn.refund()
stripe_refund.assert_called_once_with(order=self.txn.order,
event=self.txn.order.event,
payment_id=self.txn.remote_id,
amount=Decimal("20.00"))
class TransactionRefundFormTestCase(TestCase):
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_exclude_refunded_items(self):
self.bought_item1.status = BoughtItem.REFUNDED
self.bought_item1.save()
data = {
'items': [self.bought_item1.pk, self.bought_item2.pk],
}
form = TransactionRefundForm(self.txn, data)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['items'], [self.bought_item2])
def test_excessive_refund(self):
data = {'amount': "25"}
form = TransactionRefundForm(self.txn, data)
self.assertEqual(len(form.errors.get('amount', [])), 1)
def test_allow_no_values(self):
"Form submits even is amount and items are unset"
data = {}
form = TransactionRefundForm(self.txn, data)
self.assertTrue(form.is_valid())
def test_disallow_zero_values(self):
"Form fails is both items and amount are zero"
data = {'items': [], 'amount': Decimal("0")}
form = TransactionRefundForm(self.txn, data)
self.assertEqual(len(form.non_field_errors()), 1)
def test_dwolla_includes_dwolla_pin(self):
self.txn.method = Transaction.DWOLLA
self.txn.save()
form = TransactionRefundForm(self.txn)
self.assertIn('dwolla_pin', form.fields)
def test_stripe_not_includes_dwolla_pin(self):
self.txn.method = Transaction.STRIPE
self.txn.save()
form = TransactionRefundForm(self.txn)
self.assertNotIn('dwolla_pin', form.fields)
def test_form_items_are_txn_items(self):
form = TransactionRefundForm(self.txn)
self.assertQuerysetEqual(
form.fields['items'].queryset,
[repr(r) for r in self.txn.bought_items.all()]) # WHY
def test_alien_item_refund(self):
alien_order = OrderFactory(event=self.event, person=self.person)
alien_item = BoughtItem.objects.create(item_option=self.item_option1,
price=Decimal(0),
status=BoughtItem.BOUGHT,
order=alien_order)
data = {'items': [alien_item.pk]}
form = TransactionRefundForm(self.txn, data)
self.assertEqual(len(form.errors.get('items', [])), 1)