def setUp(self):
super(OrderPaymentTestCase, self).setUp()
self.init_projects()
self.order = OrderFactory.create()
self.donation = DonationFactory(amount=60, order=self.order)
self.order_payment = OrderPaymentFactory.create(order=self.order)
def test_authorization_action(self, mock_post, create_hash, get_current_host):
"""
Play some posts that Vitepay might fire at us.
"""
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(2000, XOF), order=order)
order_payment = OrderPaymentFactory.create(payment_method='vitepayOrangemoney', order=order)
adapter = VitepayPaymentAdapter(order_payment)
authorization_action = adapter.get_authorization_action()
data = {
u"api_key": u"123",
u"hash": u"123123",
u"redirect": 0,
u"payment": {
u"description": u"Thanks for your donation!",
u"order_id": u"opc-{}".format(order_payment.id),
u"decline_url": u"https://onepercentclub.com/orders/{}/failed".format(order_payment.order.id),
u"p_type": u"orange_money",
u"country_code": u"ML",
u"language_code": u"fr",
u"amount_100": 200000,
u"cancel_url": u"https://onepercentclub.com/orders/{}/failed".format(order_payment.order.id),
u"currency_code": u"XOF",
u"callback_url": u"https://onepercentclub.com/payments_vitepay/status_update/",
u"return_url": u"https://onepercentclub.com/orders/{}/success".format(order_payment.order.id)
}
}
self.assertEqual(mock_post.call_args[0][0], 'https://api.vitepay.com/v1/prod/payments')
self.assertEqual(json.loads(mock_post.call_args[1]['data']), data)
self.assertEqual(mock_post.call_args[1]['headers'], {'Content-Type': 'application/json'})
self.assertEqual(authorization_action['url'], 'https://vitepay.com/some-path-to-pay')
def test_export_rewards_anonymous(self):
request = self.request_factory.get('/')
request.user = MockUser()
project = ProjectFactory.create()
reward = RewardFactory.create(project=project, amount=Money(10, 'EUR'))
reward_order = OrderFactory.create(status='success', user=None)
donation = DonationFactory.create(project=project,
reward=reward,
order=reward_order,
name='test',
amount=Money(100, 'EUR'))
order = OrderFactory.create(status='success')
DonationFactory.create(project=project, order=order)
response = self.project_admin.export_rewards(request, project.id)
reader = csv.DictReader(StringIO.StringIO(response.content))
result = [line for line in reader]
self.assertEqual(len(result), 1)
line = result[0]
self.assertEqual(line['Email'], '')
self.assertEqual(line['Name'], '')
self.assertEqual(line['Order id'], str(reward_order.id))
self.assertEqual(line['Reward'], reward.title)
self.assertEqual(line['Amount'], str(reward.amount))
self.assertEqual(line['Actual Amount'], str(donation.amount))
self.assertEqual(line['Name on Donation'], donation.name)
def setUp(self):
super(PayoutBaseTestCase, self).setUp()
self.init_projects()
# Set up a project ready for payout
self.organization = OrganizationFactory.create()
self.organization.save()
self.project = ProjectFactory.create(organization=self.organization,
amount_asked=50)
self.project_incomplete = ProjectFactory.create(
organization=self.organization, amount_asked=100)
# Update phase to campaign.
self.project.status = ProjectPhase.objects.get(slug='campaign')
self.project.save()
self.project_incomplete.status = ProjectPhase.objects.get(
slug='campaign')
self.project_incomplete.save()
self.order = OrderFactory.create()
self.donation = DonationFactory.create(project=self.project,
order=self.order,
amount=60)
self.donation.save()
self.donation2 = DonationFactory.create(
project=self.project_incomplete, order=self.order, amount=60)
self.donation2.save()
def test_donation_stats_named_donation(self):
self.some_project.status = self.campaign_status
self.some_project.save()
order = OrderFactory.create(user=self.another_user,
status=StatusDefinition.SUCCESS)
self.donation = DonationFactory.create(amount=Money(1000, 'EUR'),
order=order,
project=self.some_project,
fundraiser=None)
order = OrderFactory.create(user=self.another_user,
status=StatusDefinition.SUCCESS)
self.donation = DonationFactory.create(amount=Money(1000, 'EUR'),
order=order,
project=self.some_project,
name='test-name',
fundraiser=None)
self.assertEqual(self.stats.donated_total, Money(2000, 'EUR'))
# People involved:
# - campaigner
# - donator (another_user)
# - donator (another_user on behalve of somebody else)
self.assertEqual(self.stats.people_involved, 3)
self.assertEqual(self.stats.participants, 1)
def setUp(self):
super(TestDonationList, self).setUp()
# Make user 1 a staff user
self.user1.is_staff = True
self.user1.save()
# Create a target project/fundraiser
self.project = ProjectFactory.create(amount_asked=5000, owner=self.user1)
self.project.set_status('campaign')
self.fundraiser = FundRaiserFactory.create(amount=4000, owner=self.user1,
project=self.project)
# Two users make a donations
order1 = OrderFactory.create(user=self.user1)
self.donation1 = DonationFactory.create(amount=15, project=self.project,
fundraiser=self.fundraiser, order=order1)
order1.locked()
order1.succeeded()
# Create the second without fundraiser
order2 = OrderFactory.create(user=self.user2)
self.donation2 = DonationFactory.create(amount=10,
project=self.project, fundraiser=None, order=order2)
order2.locked()
order2.succeeded()
self.fundraiser_donation_list_url = reverse('fund-ticker-list')
def setUp(self):
super(TestRefund, self).setUp()
self.init_projects()
self.project = ProjectFactory.create(status=ProjectPhase.objects.get(
slug='refunded'))
self.order = OrderFactory.create()
self.order_payment = OrderPaymentFactory.create(
order=self.order,
payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'},
)
payment = DocdataPaymentFactory.create(
order_payment=self.order_payment,
payment_cluster_key='123-4',
default_pm='ideal',
total_gross_amount=100)
DonationFactory.create(
project=self.project,
order=self.order,
amount=Money(100, 'EUR'),
)
payment.status = 'authorized'
payment.save()
payment.status = 'settled'
payment.save()
self.project.refresh_from_db()
def test_authorization_action(self, get_current_host, create_hash):
"""
Play some posts that Vitepay might fire at us.
"""
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(2000, NGN), order=order)
order_payment = OrderPaymentFactory.create(payment_method='interswitchWebpay', order=order)
adapter = InterswitchPaymentAdapter(order_payment)
authorization_action = adapter.get_authorization_action()
redirect_url = 'https://onepercentclub.com/payments_interswitch/payment_response/{0}'.format(order_payment.id)
data = {
'hash': '123123',
'product_id': '1234',
'site_redirect_url': redirect_url,
'local_date_time': None,
'txn_ref': '-{0}'.format(order_payment.id),
'cust_name': None,
'currency': '566',
'amount': 200000,
'pay_item_name': None,
'cust_id': None,
'pay_item_id': '123',
'site_name': 'testserver',
'cust_id_desc': None,
'cust_name_desc': None
}
self.assertEqual(authorization_action['url'], 'https://stageserv.interswitchng.com/test_paydirect/pay')
self.assertEqual(authorization_action['payload'], data)
def setUp(self):
super(TestPayoutAdapter, self).setUp()
self.init_projects()
campaign = ProjectPhase.objects.get(slug='campaign')
self.project = ProjectFactory.create(status=campaign,
amount_asked=Money(500, 'EUR'))
order = OrderFactory()
DonationFactory.create_batch(7,
project=self.project,
amount=Money(100, 'EUR'),
order=order)
order.locked()
order.success()
order.save()
order = OrderFactory()
DonationFactory.create_batch(4,
project=self.project,
amount=Money(150, 'USD'),
order=order)
order.locked()
order.success()
order.save()
yesterday = now() - timedelta(days=1)
self.project.deadline = yesterday
self.project.save()
self.mock_response = requests.Response()
self.mock_response.status_code = 200
self.adapter = DoradoPayoutAdapter(self.project)
def test_create_payment_redirect(self, charge, get_current_host):
"""
Test Flutterwave payment that turns to success without otp (one time pin)
"""
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(150000, NGN), order=order)
order_payment = OrderPaymentFactory.create(
payment_method='flutterwaveCreditcard',
order=order,
integration_data=integration_data)
adapter = FlutterwaveCreditcardPaymentAdapter(order_payment)
authorization_action = adapter.get_authorization_action()
self.assertEqual(adapter.payment.amount, '150000.00')
self.assertEqual(adapter.payment.status, 'started')
self.assertEqual(adapter.payment.transaction_reference, 'FLW005')
self.assertEqual(
authorization_action, {
'method': 'get',
'payload': {
'method': 'flutterwave-otp',
'text': redirect_response['data']['responsemessage']
},
'type': 'redirect',
'url': redirect_response['data']['authurl']
})
def test_authorization_action(self, mock_post, create_hash, get_current_host):
"""
Play some posts that Vitepay might fire at us.
"""
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(2000, XOF), order=order)
order_payment = OrderPaymentFactory.create(payment_method="vitepayOrangemoney", order=order)
adapter = VitepayPaymentAdapter(order_payment)
authorization_action = adapter.get_authorization_action()
data = {
u"api_key": u"123",
u"hash": u"123123",
u"redirect": 0,
u"payment": {
u"description": u"Thanks for your donation!",
u"order_id": u"opc-{}".format(order_payment.id),
u"decline_url": u"https://onepercentclub.com/orders/{}/failed".format(order_payment.order.id),
u"p_type": u"orange_money",
u"country_code": u"ML",
u"language_code": u"fr",
u"amount_100": 200000,
u"cancel_url": u"https://onepercentclub.com/orders/{}/failed".format(order_payment.order.id),
u"currency_code": u"XOF",
u"callback_url": u"https://onepercentclub.com/payments_vitepay/status_update/",
u"return_url": u"https://onepercentclub.com/orders/{}/success".format(order_payment.order.id),
},
}
self.assertEqual(mock_post.call_args[0][0], "https://api.vitepay.com/v1/prod/payments")
self.assertEqual(json.loads(mock_post.call_args[1]["data"]), data)
self.assertEqual(mock_post.call_args[1]["headers"], {"Content-Type": "application/json"})
self.assertEqual(authorization_action["url"], "https://vitepay.com/some-path-to-pay")
def setUp(self):
super(PayoutBaseTestCase, self).setUp()
self.init_projects()
# Set up a project ready for payout
self.organization = OrganizationFactory.create()
self.organization.save()
self.project = ProjectFactory.create(organization=self.organization, amount_asked=50)
self.project_incomplete = ProjectFactory.create(organization=self.organization, amount_asked=100)
# Update phase to campaign.
self.project.status = ProjectPhase.objects.get(slug='campaign')
self.project.save()
self.project_incomplete.status = ProjectPhase.objects.get(slug='campaign')
self.project_incomplete.save()
self.order = OrderFactory.create()
self.donation = DonationFactory.create(
project=self.project,
order=self.order,
amount=60
)
self.donation.save()
self.donation2 = DonationFactory.create(
project=self.project_incomplete,
order=self.order,
amount=60
)
self.donation2.save()
def test_results_stats_no_dates(self):
self.page.start_date = None
self.page.end_date = None
self.page.save()
long_ago = now() - timedelta(days=365 * 2)
yesterday = now() - timedelta(days=1)
user = BlueBottleUserFactory(is_co_financer=False)
project = ProjectFactory(created=yesterday, owner=user)
project = ProjectFactory(owner=user)
order1 = OrderFactory(user=user, confirmed=yesterday, status='success')
order1.created = yesterday
order1.save()
order2 = OrderFactory(user=user, confirmed=long_ago, status='success')
order1.created = long_ago
order1.save()
DonationFactory(order=order1, amount=Money(50, 'EUR'), project=project)
DonationFactory(order=order2, amount=Money(50, 'EUR'), project=project)
block = StatsContent.objects.create_for_placeholder(self.placeholder, title='Look at us!')
self.stat1 = StatFactory(type='manual', title='Poffertjes', value=3500, block=block)
self.stat2 = StatFactory(type='donated_total', title='Donations', value=None, block=block)
response = self.client.get(self.url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
stats = response.data['blocks'][0]
self.assertEqual(stats['type'], 'statistics')
self.assertEqual(stats['title'], 'Look at us!')
self.assertEqual(stats['stats'][0]['title'], self.stat1.title)
self.assertEqual(stats['stats'][0]['value'], str(self.stat1.value))
self.assertEqual(stats['stats'][1]['title'], self.stat2.title)
self.assertEqual(stats['stats'][1]['value'], {"amount": Decimal('100'), "currency": "EUR"})
def test_project_donation_list_co_financing_is_unspecified(
self, check_status_psp):
# Co_financing order and donation
order = OrderFactory.create(user=self.user2,
status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=1500, project=self.project3, order=order)
# Anonymous order and donation
anonymous_order = OrderFactory.create(status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=1500,
project=self.project3,
order=anonymous_order,
anonymous=True)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data['count'], 2,
'Donations and anonymous donations should be returned')
self.assertEqual(response.data['results'][0]['amount']['amount'],
1500.00)
self.assertEqual(response.data['results'][1]['amount']['amount'],
1000.00)
def test_refund_created_payment(self):
order = OrderFactory.create()
order_payment = OrderPaymentFactory.create(
order=order,
payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'},
)
DocdataPaymentFactory.create(order_payment=order_payment,
payment_cluster_key='456-4',
payment_cluster_id='test',
default_pm='ideal',
total_gross_amount=100)
DonationFactory.create(
project=self.project,
order=order,
amount=Money(100, 'EUR'),
)
with mock.patch.object(DocdataPaymentAdapter,
'refund_payment',
side_effect=self.mock_side_effect) as refund:
refund_project(connection.tenant, self.project)
self.order = Order.objects.get(pk=self.order.pk)
self.assertEqual(refund.call_count, 1)
self.assertEqual(self.order.status, 'refund_requested')
self.order_payment.payment.status = 'refunded'
self.order_payment.payment.save()
self.order = Order.objects.get(pk=self.order.pk)
self.assertEqual(self.order.status, 'cancelled')
def test_no_duplicate_follow(self):
""" Test that no duplicate followers are created """
self.assertEqual(Follow.objects.count(), 0)
user = BlueBottleUserFactory.create()
order = OrderFactory.create(user=user, status=StatusDefinition.CREATED)
# Make sure to set Fundraiser to None. Otherwise, fundraiser is created
DonationFactory(order=order, amount=35,
project=self.project, fundraiser=None)
order.locked()
order.success()
order.save()
self.assertEqual(Follow.objects.count(), 1)
order = OrderFactory.create(user=user, status=StatusDefinition.CREATED)
# Make sure to set Fundraiser to None. Otherwise, fundraiser is created
DonationFactory(order=order, amount=35,
project=self.project, fundraiser=None)
order.locked()
order.success()
order.save()
self.assertEqual(Follow.objects.count(), 1)
# Make sure to inspect the second Follow object, this is the Follow
# object for the donation
self.assertEqual(Follow.objects.all()[0].followed_object, self.project)
self.assertEqual(Follow.objects.all()[0].user, user)
def pay(self, project, amount):
order = OrderFactory.create()
DonationFactory.create(project=project, order=order, amount=amount)
order.locked()
order.succeeded()
order.save()
return order
def pay(self, project, amount):
order = OrderFactory.create()
DonationFactory.create(project=project, order=order, amount=amount)
order.locked()
order.save()
order.success()
order.save()
return order
def test_create_only_one_payment(self, get_current_host):
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(2000, NGN), order=order)
order_payment = OrderPaymentFactory.create(payment_method='interswitchWebpay', order=order)
InterswitchPaymentAdapter(order_payment)
self.assertEqual(InterswitchPayment.objects.count(), 1)
InterswitchPaymentAdapter(order_payment)
self.assertEqual(InterswitchPayment.objects.count(), 1)
def setUp(self):
super(HomepageEndpointTestCase, self).setUp()
self.init_projects()
self.stats = Statistics()
"""
Create 10 Project instances for one user with half in the campaign phase
and the other half in the done-complete phase
This will create:
- 10 running or realised projects
- 10 campaigners (eg 10 new people involved)
"""
self.user1 = BlueBottleUserFactory.create()
self.campaign_phase = ProjectPhase.objects.get(slug='campaign')
self.plan_phase = ProjectPhase.objects.get(slug='done-complete')
projects = []
for char in 'abcdefghij':
# Put half of the projects in the campaign phase.
if ord(char) % 2 == 1:
project = ProjectFactory.create(title=char * 3, slug=char * 3, status=self.campaign_phase)
else:
project = ProjectFactory.create(title=char * 3, slug=char * 3, status=self.plan_phase)
projects.append(project)
"""
Create 10 TaskMember instances for one project.
This will create:
- 1 realised task
- 1 task owner (eg 1 new person involved)
- 10 task members (eg 10 new people involved)
"""
self.task = TaskFactory.create(project=projects[0], status=Task.TaskStatuses.realized)
for char in 'abcdefghij':
# Put half of the projects in the campaign phase.
if ord(char) % 2 == 1:
task = TaskMemberFactory.create(task=self.task)
else:
task = TaskMemberFactory.create(task=self.task)
"""
Create 10 Donations with half to fundraisers
This will create:
- 10 donations of 1000 (total amount of 10000)
- 10 donators (eg 10 new people involved)
- 5 fundraisers (eg 5 new people involved)
"""
for char in 'abcdefghij':
if ord(char) % 2 == 1:
self.order = OrderFactory.create(status=StatusDefinition.SUCCESS)
self.donation = DonationFactory.create(amount=1000, order=self.order, fundraiser=None)
else:
self.order = OrderFactory.create(status=StatusDefinition.SUCCESS)
self.donation = DonationFactory.create(amount=1000, order=self.order)
def test_single_donation_different_currency(self):
DonationFactory.create(
order=OrderFactory.create(status=StatusDefinition.SUCCESS),
fundraiser=self.fundraiser,
amount=Money(100, 'USD')
)
self.assertEqual(
self.fundraiser.amount_donated,
Money(150, 'EUR')
)
def test_refund_requested(self):
DonationFactory.create(order=self.order)
self.order_payment.started()
self.order_payment.save()
self.order_payment.authorized()
self.order_payment.save()
self.order_payment.refund_requested()
self.assertEqual(self.order.status, StatusDefinition.REFUND_REQUESTED)
def test_single_donation_different_currency(self):
DonationFactory.create(
order=OrderFactory.create(status=StatusDefinition.SUCCESS),
fundraiser=self.fundraiser,
amount=Money(100, 'USD')
)
self.assertEqual(
self.fundraiser.amount_donated,
Money(150, 'EUR')
)
def test_successful_my_project_donation_list(self, check_status_psp):
# Unsuccessful donations should not be shown
order = OrderFactory.create(user=self.user2)
DonationFactory.create(amount=2000, project=self.project3, order=order)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), 1,
'Only the successful donation should be returned')
def setUp(self):
super(TestProjectExport, self).setUp()
self.project = ProjectFactory.create(amount_asked=5000)
self.user = BlueBottleUserFactory.create()
self.orders = OrderFactory.create_batch(7)
for order in self.orders:
DonationFactory.create(project=self.project, order=order)
order_payment = OrderPaymentFactory(order=order)
payment = PaymentFactory(order_payment=order_payment)
payment.status = 'settled'
payment.save()
def test_wallpost_mail_fundraiser(self):
""" Test that the relevant people get an email when the email_followers option is selected for a fundraiser """
# On a Fundraiser page, people who posted to the wall and who donated get an email --> Followers
self.assertEqual(Follow.objects.count(), 0)
# A user creates a fundraiser
fundraiser_person = BlueBottleUserFactory.create()
fundraiser = FundraiserFactory(project=self.project,
owner=fundraiser_person)
# Two people donate to the fundraiser
donator1 = BlueBottleUserFactory.create()
order = OrderFactory.create(user=donator1,
status=StatusDefinition.CREATED)
DonationFactory(order=order, amount=35,
project=self.project,
fundraiser=fundraiser)
order.locked()
order.success()
order.save()
donator2 = BlueBottleUserFactory.create()
order2 = OrderFactory.create(user=donator2,
status=StatusDefinition.CREATED)
DonationFactory(order=order2, amount=35,
project=self.project,
fundraiser=fundraiser)
order2.locked()
order2.success()
order2.save()
# The fundraiser owner creates a wallpost to followers
TextWallpostFactory.create(content_object=fundraiser,
author=fundraiser_person,
text="test_fundraiser",
email_followers=True)
mail_count = 0
self.assertEqual(Follow.objects.count(), 3)
# When the fundraiser sends an email to the followers he doesn't get one himself
receivers = [donator1.email, donator2.email]
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertTrue(email.to[0] in receivers)
receivers.remove(email.to[0])
self.assertEqual(mail_count, 2)
self.assertEqual(receivers, [])
def test_create_success_payment(self):
"""
Test External payment
"""
order = OrderFactory.create()
DonationFactory.create(amount=Money(70, EUR), order=order)
order_payment = OrderPaymentFactory.create(
payment_method='externalMoney', order=order)
order_payment.started()
adapter = ExternalPaymentAdapter(order_payment)
adapter.check_payment_status()
self.assertEqual(adapter.payment.status, 'settled')
def test_tags_generation(self, queue_mock):
project = ProjectFactory.create()
DonationFactory.create(project=project)
wallpost = TextWallpostFactory.create()
expected_tags = {'type': 'wallpost', 'tenant': u'test'}
expected_fields = {'id': wallpost.id, 'user_id': wallpost.author.id}
args, kwargs = queue_mock.call_args
self.assertEqual(kwargs['tags'], expected_tags)
self.assertEqual(kwargs['fields'], expected_fields)
self.assertEqual(kwargs['timestamp'], wallpost.created)
def test_successful_my_project_donation_list(self, check_status_psp):
# Unsuccessful donations should not be shown
order = OrderFactory.create(user=self.user2)
DonationFactory.create(amount=2000, project=self.project3,
order=order)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), 1,
'Only the successful donation should be returned')
def setUp(self):
super(TestProjectDonationList, self).setUp()
self.project3 = ProjectFactory.create(amount_asked=5000,
owner=self.user1)
self.project3.set_status('campaign')
order = OrderFactory.create(user=self.user1, status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=1000, project=self.project3,
order=order)
self.project_donation_list_url = reverse('project-donation-list')
def setUp(self):
super(TestDonationEmails, self).setUp()
self.init_projects()
self.user = BlueBottleUserFactory.create(first_name='user')
self.project_owner = BlueBottleUserFactory.create(
first_name='projectowner')
campaign_status = ProjectPhase.objects.get(slug='campaign')
self.some_project = ProjectFactory.create(owner=self.project_owner,
status=campaign_status)
self.order = OrderFactory.create(
user=self.user,
)
self.recurring_order = OrderFactory.create(
user=self.user,
order_type="recurring"
)
self.donation = DonationFactory.create(
order=self.order,
project=self.some_project,
fundraiser=None
)
self.recurring_donation = DonationFactory.create(
order=self.recurring_order,
project=self.some_project,
fundraiser=None
)
self.fund_order = OrderFactory.create(
user=self.user,
)
self.fund_project = ProjectFactory.create(owner=self.project_owner,
status=campaign_status)
self.fund_owner = BlueBottleUserFactory.create(first_name='fundraiser')
self.fundraiser_project = FundraiserFactory.create(
owner=self.fund_owner,
project=self.fund_project,
)
self.fund_donation = DonationFactory.create(
order=self.fund_order,
project=self.fund_project,
fundraiser=self.fundraiser_project
)
def test_create_payment_incomplete(self, charge, get_current_host):
"""
Test Flutterwave payment throws an error when incomplete data is sent
"""
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(150000, NGN), order=order)
order_payment = OrderPaymentFactory.create(
payment_method='flutterwaveCreditcard',
order=order,
integration_data={'card_number': '123blabla'})
with self.assertRaises(PaymentException):
FlutterwaveCreditcardPaymentAdapter(order_payment)
def test_project_donation_list_no_co_financing(self, check_status_psp):
order = OrderFactory.create(user=self.user2, status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=1500, project=self.project3,
order=order)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug, 'co_financing': 'false'},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1,
'Only donations by co-financers should be returned')
self.assertEqual(response.data['results'][0]['amount'], 1000)
def test_project_donation_list_without_amounts(self, check_status_psp):
setattr(properties, 'SHOW_DONATION_AMOUNTS', False)
order = OrderFactory.create(user=self.user2)
DonationFactory.create(amount=2000, project=self.project3,
order=order)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1,
'Only the successful donation should be returned')
self.assertNotIn('amount', response.data['results'][0])
def test_create_payment_flutter_fail(self, charge, get_current_host):
"""
Make sure we catch errors from Flutterwave
"""
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(150000, NGN), order=order)
order_payment = OrderPaymentFactory.create(
payment_method='flutterwaveCreditcard',
order=order,
integration_data=integration_data)
adapter = FlutterwaveCreditcardPaymentAdapter(order_payment)
with self.assertRaises(PaymentException):
adapter.get_authorization_action()
def test_create_payment(self, get_current_host):
self.init_projects()
order = OrderFactory.create()
DonationFactory.create(amount=Money(2000, NGN), order=order)
order_payment = OrderPaymentFactory.create(payment_method='interswitchWebpay', order=order)
adapter = InterswitchPaymentAdapter(order_payment)
self.assertEqual(adapter.payment.amount, 200000)
# Check generated payload
payload = adapter._get_payload()
self.assertEqual(payload['product_id'], '1234')
self.assertEqual(payload['amount'], 200000)
tenant = connection.tenant
self.assertEqual(payload['txn_ref'], '{0}-{1}'.format(tenant.name, order_payment.id))
def test_successful_project_donation_list_paged(self, check_status_psp):
for i in range(30):
order = OrderFactory.create(user=self.user1, status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=2000, project=self.project3,
order=order)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 31,
'All the donations should be returned')
self.assertEqual(len(response.data['results']), 20)
def setUp(self):
super(TestPayoutExport, self).setUp()
self.project = ProjectFactory.create(amount_asked=5000)
self.user = BlueBottleUserFactory.create()
self.orders = OrderFactory.create_batch(7)
for order in self.orders:
DonationFactory.create(project=self.project, order=order)
order_payment = OrderPaymentFactory(order=order)
payment = PaymentFactory(order_payment=order_payment)
payment.status = 'settled'
payment.save()
self.payout = ProjectPayoutFactory(project=self.project,
amount_payable=Money(125.00, 'EUR'),
amount_raised=Money(175.0, 'EUR'),
status='settled')
def test_successful_project_donation_list(self, check_status_psp):
setattr(properties, 'SHOW_DONATION_AMOUNTS', True)
# Unsuccessful donations should not be shown
order = OrderFactory.create(user=self.user2)
reward = RewardFactory.create(project=self.project3)
DonationFactory.create(amount=2000, project=self.project3, reward=reward,
order=order)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug},
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 1,
'Only the successful donation should be returned')
self.assertIn('amount', response.data['results'][0])
self.assertIn('reward', response.data['results'][0])
def test_journal_created_when_donation_is_made(self):
"""
Create a Donation, and check if it results in a Journal.
Then create a Journal, and check if the Donation is updated.
Do this also for a negative value
"""
self.assertEqual(DonationJournal.objects.all().count(), 0)
self.assertEqual(Member.objects.count(), 2) # self.user and self.project_owner
# creates another user for fundraiser
self.donation = DonationFactory.create(user=self.user,
amount=Decimal('100'),
project=self.project,
order__user=self.user)
self.assertEqual(Member.objects.count(), 4)
# creation of a donation should always result in the creation of a journal
donation_from_db = self._get_only_one_from_db(Donation)
journal_from_db = self._get_only_one_from_db(DonationJournal)
self.assertEqual(journal_from_db.donation, donation_from_db)
self.assertEqual(donation_from_db.amount, Decimal('100'))
self.assertEqual(journal_from_db.amount, Decimal('100'))
# #### Create a Journal, check if it results in an updated Donation ##### #
journal = DonationJournal.objects.create(donation = self.donation,
amount = Decimal('50'))
new_journal_pk = journal.pk
self.assertEqual(DonationJournal.objects.all().count(), 2)
new_journal_from_db = DonationJournal.objects.get(pk=new_journal_pk)
self.assertEqual(new_journal_from_db.user_reference, '*****@*****.**') # should be auto filled with donation user
self.assertEqual(new_journal_from_db.description, '') # should be blank
self.assertEqual(new_journal_from_db.date.date(), date.today()) # date today
self.assertEqual(new_journal_from_db.amount, Decimal('50'))
# the donation should be updated with the amount added via the journal
donation_from_db = self._get_only_one_from_db(Donation)
self.assertEqual(donation_from_db.amount, Decimal('150')) # change to new amount
self._check_if_journal_total_equals_value(new_journal_from_db, donation_from_db.amount)
# Change the Donation, and check if a new Journal is created
donation_from_db.amount = Decimal('145')
donation_from_db.save()
self.assertEqual(DonationJournal.objects.all().count(), 3)
new_journal = DonationJournal.objects.all().last() # the latest is the newest
self.assertEqual(new_journal.amount, Decimal('-5'))
# mastercheck to see if Donation and related Journals addup
self._check_if_journal_total_equals_value(new_journal, Decimal('145'))
# Change the donation without changing the amount, no journal should be created.
donation_from_db = self._get_only_one_from_db(Donation)
self.assertEqual(DonationJournal.objects.all().count(), 3)
donation_from_db.completed = timezone.now()
donation_from_db.save()
self.assertEqual(DonationJournal.objects.all().count(), 3)
def test_more_than_20_not_fully_funded(self):
"""
Test that a campaign with more than 20 euros but is not fully funded,
and hits the deadline gets the status done-incomplete
"""
now = timezone.now()
some_project = ProjectFactory.create(
title="test",
amount_asked=500,
campaign_started=now - timezone.timedelta(days=15),
deadline=now - timezone.timedelta(days=5),
)
order = OrderFactory.create()
donation = DonationFactory.create(project=some_project, order=order, amount=21)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.save()
donation.order.success()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command("cron_status_realised")
project = Project.objects.get(title="test")
self.assertEqual(project.status, self.incomplete)
def test_pledge_paid_not_fully_funded(self):
""" Test amounts for paid donations. """
pledge_order = OrderFactory.create()
pledge = DonationFactory.create(
project=self.project,
order=pledge_order,
amount=30
)
pledge.save()
# Set status of donation to pledged
pledge.order.pledged()
pledge.order.save()
# Update phase to done-completed
self._reload_project()
self.project.status = ProjectPhase.objects.get(slug='done-complete')
self.project.save()
# Fetch payout
payout = ProjectPayout.objects.all()[0]
# Money is safe now, nothing pending
self.assertEquals(payout.amount_raised, Money(90.00, 'EUR'))
self.assertEquals(payout.payout_rule, 'not_fully_funded')
self.assertEquals(payout.amount_payable, Money(48.00, 'EUR'))
self.assertEquals(payout.amount_pledged, Money(30.00, 'EUR'))
self.assertEquals(payout.organization_fee, Money(12.00, 'EUR'))
def test_multiple_donations(self):
DonationFactory.create(
order=OrderFactory.create(status=StatusDefinition.SUCCESS),
fundraiser=self.fundraiser,
amount=Money(100, 'USD')
)
DonationFactory.create(
order=OrderFactory.create(status=StatusDefinition.SUCCESS),
fundraiser=self.fundraiser,
amount=Money(100, 'EUR')
)
self.assertEqual(
self.fundraiser.amount_donated,
Money(250, 'EUR')
)
def setUp(self):
super(TestMyProjectDonationList, self).setUp()
self.project3 = ProjectFactory.create(amount_asked=5000,
owner=self.user1)
self.project3.set_status('campaign')
# User 2 makes a donation
order = OrderFactory.create(user=self.user2)
DonationFactory.create(amount=1000, project=self.project3,
order=order)
order.locked()
order.succeeded()
self.project_donation_list_url = reverse('my-project-donation-list')
def test_status_overfunded_projects(self):
""" Overfunded projects should have status 'done-complete' """
project = ProjectFactory.create(title='test', amount_asked=100)
project.status = ProjectPhase.objects.get(slug='campaign')
project.save()
order = OrderFactory.create()
donation = DonationFactory.create(
project=project,
order=order,
amount=110
)
donation.save()
order.locked()
order.succeeded()
order.save()
project = Project.objects.get(title='test')
project.deadline = timezone.now() - timezone.timedelta(days=1)
project.save()
project = Project.objects.get(title='test')
self.assertEqual(project.status,
ProjectPhase.objects.get(slug='done-complete'))
def test_journal_multicurrency(self):
self.donation = DonationFactory.create(
amount=Money(100, 'EUR'),
project=self.project,
order__user=self.user
)
# We should now have one journal
self.assertEqual(DonationJournal.objects.count(), 1)
# Update the amount to USD
self.donation.amount=Money(100, 'USD')
self.donation.save()
# We should now have 2 journals
self.assertEqual(DonationJournal.objects.count(), 2)
# Update the amount to USD
self.donation.amount=Money(150, 'USD')
self.donation.save()
self.assertEqual(DonationJournal.objects.count(), 3)
for journal in DonationJournal.objects.all():
if journal.amount.currency == Currency('EUR'):
self.assertEqual(journal.get_journal_total(), Money(100, 'EUR'))
else:
self.assertEqual(journal.get_journal_total(), Money(150, 'USD'))
def test_calculate_donation_count(self):
""" Test the counter for the number of donations a user has done """
self.assertEqual(self.user.donation_count, 0)
order = OrderFactory.create(user=self.user)
DonationFactory.create(amount=1000, order=order)
# Only successful or pending orders/donations are counted
self.assertEqual(self.user.donation_count, 0)
# Set donation to pending to be included in count
order.locked()
order.save()
order.pending()
order.save()
self.assertEqual(self.user.donation_count, 1)
def test_pledge_paid_not_fully_funded(self):
""" Test amounts for paid donations. """
pledge_order = OrderFactory.create()
pledge = DonationFactory.create(project=self.project,
order=pledge_order,
amount=30)
pledge.save()
# Set status of donation to pledged
pledge.order.pledged()
pledge.order.save()
# Update phase to done-completed
self.project.refresh_from_db()
self.project.status = ProjectPhase.objects.get(slug='done-complete')
self.project.save()
# Fetch payout
payout = ProjectPayout.objects.all()[0]
# Money is safe now, nothing pending
self.assertEquals(payout.amount_raised, Money(90.00, 'EUR'))
self.assertEquals(payout.payout_rule, 'not_fully_funded')
self.assertEquals(payout.amount_payable, Money(48.00, 'EUR'))
self.assertEquals(payout.amount_pledged, Money(30.00, 'EUR'))
self.assertEquals(payout.organization_fee, Money(12.00, 'EUR'))
def setUp(self):
super(OrderPaymentTestCase, self).setUp()
self.init_projects()
self.order = OrderFactory.create()
self.donation = DonationFactory(amount=60, order=self.order)
self.order_payment = OrderPaymentFactory.create(order=self.order)
def test_no_campaign_started_date(self):
"""
Test that a campaign that never started gets the phase stopped.
"""
now = timezone.now()
some_project = ProjectFactory.create(title='test',
amount_asked=500,
deadline=now -
timezone.timedelta(days=5))
order = OrderFactory.create()
donation = DonationFactory.create(project=some_project,
order=order,
amount=20)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.save()
donation.order.success()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command('cron_status_realised')
project = Project.objects.get(title='test')
self.assertEqual(project.status, self.closed)
def test_more_than_20_not_fully_funded(self):
"""
Test that a campaign with more than 20 euros but is not fully funded,
and hits the deadline gets the status done-incomplete
"""
now = timezone.now()
some_project = ProjectFactory.create(
title='test',
amount_asked=500,
campaign_started=now - timezone.timedelta(days=15),
deadline=now - timezone.timedelta(days=5))
order = OrderFactory.create()
donation = DonationFactory.create(project=some_project,
order=order,
amount=21)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.save()
donation.order.success()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command('cron_status_realised')
project = Project.objects.get(title='test')
self.assertEqual(project.status, self.incomplete)
def test_less_than_20_done_stopped(self):
"""
Test that a campaign with 20 euros or less and hits the deadline gets
the status "Done-stopped"
"""
now = timezone.now()
some_project = ProjectFactory.create(
title='test',
amount_asked=500,
campaign_started=now - timezone.timedelta(days=15),
deadline=now - timezone.timedelta(days=5))
order = OrderFactory.create()
donation = DonationFactory.create(project=some_project,
order=order,
amount=20)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.save()
donation.order.success()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command('cron_status_realised')
project = Project.objects.get(title='test')
self.assertEqual(project.status, self.closed)
def test_no_campaign_started_date(self):
"""
Test that a campaign that never started gets the phase stopped.
"""
now = timezone.now()
some_project = ProjectFactory.create(title='test',
amount_asked=500,
deadline=now - timezone.
timedelta(days=5))
order = OrderFactory.create()
donation = DonationFactory.create(
project=some_project,
order=order,
amount=20
)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.succeeded()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command('cron_status_realised', 'test')
project = Project.objects.get(title='test')
self.assertEqual(project.status, self.closed)
def test_less_than_20_done_stopped(self):
"""
Test that a campaign with 20 euros or less and hits the deadline gets
the status "Done-stopped"
"""
now = timezone.now()
some_project = ProjectFactory.create(title='test',
amount_asked=500,
campaign_started=now - timezone.
timedelta(days=15),
deadline=now - timezone.
timedelta(days=5))
order = OrderFactory.create()
donation = DonationFactory.create(
project=some_project,
order=order,
amount=20
)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.succeeded()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command('cron_status_realised', 'test')
project = Project.objects.get(title='test')
self.assertEqual(project.status, self.closed)
def test_fully_funded(self):
"""
Test that a campaign that is fully funded
and hits the deadline gets the status done-complete
"""
now = timezone.now()
some_project = ProjectFactory.create(title='test',
amount_asked=500,
campaign_started=now - timezone.
timedelta(days=15),
deadline=now - timezone.
timedelta(days=5))
order = OrderFactory.create()
donation = DonationFactory.create(
project=some_project,
order=order,
amount=500
)
donation.save()
# Set status of donation to paid
donation.order.locked()
donation.order.succeeded()
donation.order.save()
some_project.status = self.campaign
some_project.save()
call_command('cron_status_realised', 'test')
project = Project.objects.get(title='test')
self.assertEqual(project.status, self.complete)
def setUp(self):
super(TestDonationEmails, self).setUp()
self.user = BlueBottleUserFactory.create(first_name='user')
self.project_owner = BlueBottleUserFactory.create(first_name='projectowner')
self.some_project = ProjectFactory.create(owner=self.project_owner)
self.order = OrderFactory.create(
user=self.user,
)
self.recurring_order = OrderFactory.create(
user=self.user,
order_type="recurring"
)
self.donation = DonationFactory.create(
order=self.order,
project=self.some_project,
fundraiser=None
)
self.recurring_donation = DonationFactory.create(
order=self.recurring_order,
project=self.some_project,
fundraiser=None
)
self.fund_order = OrderFactory.create(
user=self.user,
)
self.fund_project = ProjectFactory.create(owner=self.project_owner)
self.fund_owner = BlueBottleUserFactory.create(first_name='fundraiser')
self.fundraiser_project = FundraiserFactory.create(
owner=self.fund_owner,
project=self.fund_project,
)
self.fund_donation = DonationFactory.create(
order=self.fund_order,
project=self.fund_project,
fundraiser=self.fundraiser_project
)
def test_successful_my_fundraiser_donation_list(self, check_status_psp):
# Unsuccessful donations should not be shown
order = OrderFactory.create(user=self.user2)
donation = DonationFactory.create(amount=2000, project=self.project4, fundraiser=self.fundraiser, order=order)
response = self.client.get(self.fundraiser_donation_list_url, {'fundraiser': self.fundraiser.pk}, HTTP_AUTHORIZATION=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1, 'Only the successful donation should be returned')
def test_system_wallpost(self, queue_mock):
project = ProjectFactory.create()
donation = DonationFactory.create(project=project)
previous_call_count = queue_mock.call_count
SystemWallpostFactory.create(related_object=donation, content_object=project)
self.assertEqual(queue_mock.call_count, previous_call_count,
'Analytics should not be sent for system wallposts')
def setUp(self):
super(PaymentErrorTests, self).setUp()
self.donation1 = DonationFactory.create(amount=500)
self.donation2 = DonationFactory.create(amount=700)
self.donation3 = DonationFactory.create(amount=5)
self.user1 = self.donation1.order.user
self.user1.first_name = 'Jimmy 1%'
self.user1.save()
self.user1_token = "JWT {0}".format(self.user1.get_jwt_token())
self.user2 = self.donation2.order.user
self.user2.last_name = "Veryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryverylongname"
self.user2.save()
self.user2_token = "JWT {0}".format(self.user2.get_jwt_token())
self.order_payment_url = reverse('manage-order-payment-list')
def setUp(self):
super(TestLatestDonationListApi, self).setUp()
self.user2.is_staff = True
self.user2.save()
self.project = ProjectFactory.create(amount_asked=5000,
owner=self.user1)
self.project.set_status('campaign')
# User 2 makes a donation
order = OrderFactory.create(user=self.user2)
DonationFactory.create(amount=1000, project=self.project,
order=order)
order.locked()
order.save()
order.success()
order.save()