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 test_supporters(self):
""" Test return value of supporters, users who did a succesful donation """
project = ProjectFactory.create(amount_asked=1000)
user1 = BlueBottleUserFactory.create()
user2 = BlueBottleUserFactory.create()
user3 = BlueBottleUserFactory.create()
order1 = OrderFactory.create(user=user1)
donation1 = DonationFactory(order=order1, amount=20)
order1.locked()
order1.failed()
order2 = OrderFactory.create(user=user2)
donation2 = DonationFactory(order=order2, amount=25)
order2.locked()
order2.succeeded()
order3 = OrderFactory.create(user=user2)
donation3 = DonationFactory(order=order3, amount=30)
order3.locked()
order3.succeeded()
order4 = OrderFactory.create(user=user3)
donation4 = DonationFactory(order=order4, amount=35)
order4.locked()
order4.succeeded()
# User two should be counted once, and user 3 should be counted
self.assertEqual(self.metrics.calculate_supporters(), 2)
def test_total_raised(self):
""" Calculate the total amount raised by successful donations """
project1 = ProjectFactory.create(amount_asked=1000)
project2 = ProjectFactory.create(amount_asked=1000)
user1 = BlueBottleUserFactory.create()
user2 = BlueBottleUserFactory.create()
user3 = BlueBottleUserFactory.create()
order1 = OrderFactory.create(user=user1)
donation1 = DonationFactory(order=order1, amount=10, project=project1)
order1.locked()
order1.failed()
order2 = OrderFactory.create(user=user2)
donation2 = DonationFactory(order=order2, amount=10, project=project1)
order2.locked()
order2.succeeded()
order3 = OrderFactory.create(user=user2)
donation3 = DonationFactory(order=order3, amount=10, project=project2)
order3.locked()
order3.succeeded()
order4 = OrderFactory.create(user=user3)
donation4 = DonationFactory(order=order4, amount=10, project=project1)
order4.locked()
order4.succeeded()
# order2, order3, order4 should be counted
self.assertEqual(self.metrics.calculate_total_raised(), 30)
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 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_no_payment_method_change(self, mock_fetch_status,
mock_transaction):
self.assertEquals(PaymentLogEntry.objects.count(), 1)
# Mock the status check with docdata
mock_fetch_status.return_value = self.create_status_response(
'AUTHORIZED')
order = OrderFactory.create()
order_payment = OrderPaymentFactory.create(
order=order, payment_method='docdataCreditcard')
docdata_payment = DocdataPaymentFactory.create(
order_payment=order_payment,
default_pm='mastercard',
payment_cluster_id='1234',
total_gross_amount=100)
DocdataTransactionFactory.create(payment=docdata_payment,
payment_method='VISA')
c = Client()
merchant_order_id = "{0}-1".format(order_payment.id)
resp = c.get(
reverse('docdata-payment-status-update',
kwargs={'merchant_order_id': merchant_order_id}))
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, 'success')
# Reload the order payment
order_payment = OrderPayment.objects.get(id=order_payment.id)
self.assertEqual(order_payment.payment_method, 'docdataCreditcard')
def setUp(self):
self.order = OrderFactory.create(total=Money(200, 'EUR'))
self.order_payment = OrderPaymentFactory.create(
payment_method='docdata', order=self.order)
PaymentFactory.create(order_payment=self.order_payment)
self.adapter = BasePaymentAdapter(self.order_payment)
def test_no_mail_no_campaign_notifications(self):
""" Test that users who have campaign_notifications turned off don't get email """
task_owner1 = BlueBottleUserFactory.create(campaign_notifications=False)
task = TaskFactory.create(
author=task_owner1,
project=self.project
)
# Add extra project and owner that should not get any email
project_owner = BlueBottleUserFactory.create(campaign_notifications=False)
project2 = ProjectFactory(owner=project_owner, status=self.phase1)
# Create a follower by donating
donator1 = BlueBottleUserFactory.create(campaign_notifications=False)
order = OrderFactory.create(user=donator1, status=StatusDefinition.CREATED)
donation = DonationFactory(order=order, amount=35, project=self.project, fundraiser=None)
# Create a follower by being a fundraiser for the project
fundraiser_person = BlueBottleUserFactory.create(campaign_notifications=False)
fundraiser = FundraiserFactory(project=self.project, owner=fundraiser_person)
self.assertEqual(Follow.objects.count(), 3)
# Project owner creates a wallpost and emails followers
some_wallpost_2 = TextWallpostFactory.create(content_object=self.project, author=self.project.owner, text="test2", email_followers=True)
mail_count = 0
# People who should get an email: self.some_user, task_owner1, fundraiser_person, commenter, and donator1
receivers = []
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertEqual(mail_count, 0)
def setUp(self):
super(PaymentFeeTestCase, 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 setUp(self):
settings.SESSION_ENGINE = 'django.contrib.sessions.backends.file'
engine = import_module(settings.SESSION_ENGINE)
store = engine.SessionStore()
store.save()
self.session = store
self.client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key
self.addCleanup(self._clear_session)
self.user1 = BlueBottleUserFactory.create()
self.user1_token = "JWT {0}".format(self.user1.get_jwt_token())
self.init_projects()
self.project1 = ProjectFactory.create(amount_asked=5000)
self.project1.set_status('campaign')
self.project2 = ProjectFactory.create(amount_asked=3750)
self.project2.set_status('campaign')
self.manage_order_list_url = reverse('manage-order-list')
self.manage_donation_list_url = reverse('manage-donation-list')
self.user = BlueBottleUserFactory.create()
self.user_token = "JWT {0}".format(self.user.get_jwt_token())
self.user2 = BlueBottleUserFactory.create()
self.user2_token = "JWT {0}".format(self.user2.get_jwt_token())
self.project = ProjectFactory.create()
self.order = OrderFactory.create(user=self.user)
def test_incomplete_userdata(self, mock_client):
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
patch.object(DocdataPaymentAdapter, 'create_payment',
fake_create_payment)
user = BlueBottleUserFactory()
self.order = OrderFactory.create(user=user)
self.order_payment = OrderPaymentFactory.create(
order=self.order, payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(order_payment=self.order_payment)
user_data = self.service.adapter.get_user_data()
self.assertEqual(user_data['id'], user.id)
self.assertEqual(user_data['first_name'], user.first_name)
self.assertEqual(user_data['last_name'], user.last_name)
self.assertEqual(user_data['email'], user.email)
self.assertEqual(user_data['street'], 'Unknown')
self.assertEqual(user_data['house_number'], 'Unknown')
self.assertEqual(user_data['postal_code'], 'Unknown')
self.assertEqual(user_data['city'], 'Unknown')
self.assertEqual(user_data['country'], 'NL')
self.assertEqual(user_data['company'], '')
self.assertEqual(user_data['kvk_number'], '')
self.assertEqual(user_data['vat_number'], '')
self.assertEqual(user_data['house_number_addition'], '')
self.assertEqual(user_data['state'], '')
def test_normal_userdata(self, mock_client_create):
mock_client_create.return_value = {'order_key': 123, 'order_id': 123}
mock_create_payment = patch.object(DocdataPaymentAdapter, 'create_payment', fake_create_payment)
user = BlueBottleUserFactory()
holland = CountryFactory(name='Netherlands', alpha2_code='NL')
address = BlueBottleAddressFactory(user=user, line1='Dam 1a', line2='Bovenste bel', city='Amsterdam',
postal_code='1000AA', country=holland)
self.order = OrderFactory.create(user=user)
self.order_payment = OrderPaymentFactory.create(order=self.order, payment_method='docdataIdeal',
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(order_payment=self.order_payment)
user_data = self.service.adapter.get_user_data()
self.assertEqual(user_data['id'], user.id)
self.assertEqual(user_data['first_name'], user.first_name)
self.assertEqual(user_data['last_name'], user.last_name)
self.assertEqual(user_data['email'], user.email)
self.assertEqual(user_data['street'], 'Dam')
self.assertEqual(user_data['house_number'], '1a')
self.assertEqual(user_data['postal_code'], '1000AA')
self.assertEqual(user_data['city'], 'Amsterdam')
self.assertEqual(user_data['country'], 'NL')
self.assertEqual(user_data['company'], '')
self.assertEqual(user_data['kvk_number'], '')
self.assertEqual(user_data['vat_number'], '')
self.assertEqual(user_data['house_number_addition'], '')
self.assertEqual(user_data['state'], '')
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_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 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_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_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_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(DonationApiTestCase, self).setUp()
self.create_session()
self.user1 = BlueBottleUserFactory.create()
self.user1_token = "JWT {0}".format(self.user1.get_jwt_token())
self.init_projects()
self.project1 = ProjectFactory.create(amount_asked=5000)
self.project1.set_status('campaign')
self.project2 = ProjectFactory.create(amount_asked=3750)
self.project2.set_status('campaign')
self.manage_order_list_url = reverse('manage-order-list')
self.manage_donation_list_url = reverse('manage-donation-list')
self.user = BlueBottleUserFactory.create()
self.user_token = "JWT {0}".format(self.user.get_jwt_token())
self.user2 = BlueBottleUserFactory.create(is_co_financer=True)
self.user2_token = "JWT {0}".format(self.user2.get_jwt_token())
self.project = ProjectFactory.create()
self.order = OrderFactory.create(user=self.user)
self.dollar_project = ProjectFactory.create(currencies=['USD'])
self.multi_project = ProjectFactory.create(currencies=['EUR', 'USD', 'NGN'])
def test_wallpost_no_mail(self):
""" Test that followers don't get an email if email_followers is false. Email_followers boolean is false by default on wallpost model"""
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(Follow.objects.count(), 0)
commenter = BlueBottleUserFactory.create()
commenter2 = BlueBottleUserFactory.create()
# Create follower by creating a donation
order = OrderFactory.create(user=self.another_user, status=StatusDefinition.CREATED)
# Make sure to set Fundraiser to None. Otherwise, a fundraiser is created
donation = DonationFactory(order=order, amount=35, project=self.project, fundraiser=None)
# Create follower by creating a task owner
task_owner1 = BlueBottleUserFactory.create()
task = TaskFactory.create(
author=task_owner1,
project=self.project
)
# Verify we have two followers
self.assertEqual(Follow.objects.count(), 2)
# Create a text Wallpost for our dummy project
some_wallpost = TextWallpostFactory.create(content_object=self.project, author=self.project.owner, text="test1", email_followers=False)
self.assertEqual(Follow.objects.count(), 2)
# Some other emails are sent, so we do not compare the mail count. Instead we look at the subject
for email in mail.outbox:
self.assertTrue("New wallpost on" not in email.subject)
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_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(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_no_payment_method_change(self, mock_fetch_status,
mock_transaction):
self.assertEquals(PaymentLogEntry.objects.count(), 1)
# Mock the status check with docdata
mock_fetch_status.return_value = self.create_status_response(
'AUTHORIZED')
order = OrderFactory.create()
order_payment = OrderPaymentFactory.create(
order=order, payment_method='docdataCreditcard')
docdata_payment = DocdataPaymentFactory.create(
order_payment=order_payment,
default_pm='mastercard',
payment_cluster_id='1234',
total_gross_amount=100)
DocdataTransactionFactory.create(payment=docdata_payment,
payment_method='VISA')
c = Client()
merchant_order_id = "{0}-1".format(order_payment.id)
resp = c.get(reverse('docdata-payment-status-update',
kwargs={'merchant_order_id': merchant_order_id}))
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, 'success')
# Reload the order payment
order_payment = OrderPayment.objects.get(id=order_payment.id)
self.assertEqual(order_payment.payment_method, 'docdataCreditcard')
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, a fundraiser is created
donation = DonationFactory(order=order, amount=35, project=self.project, fundraiser=None)
order = OrderFactory.create(user=user, status=StatusDefinition.CREATED)
# Make sure to set Fundraiser to None. Otherwise, a fundraiser is created
donation = DonationFactory(order=order, amount=35, project=self.project, fundraiser=None)
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 test_timeout_task_locked_order(self):
order = OrderFactory.create(status=StatusDefinition.LOCKED)
timeout_locked_order(order, connection.tenant)
order = Order.objects.get(pk=order.pk)
self.assertEqual(order.status, StatusDefinition.FAILED)
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 setUp(self):
super(TestUnauthenticatedDonationCreate, self).setUp()
self.order_anon = OrderFactory.create()
s = self.session
s['new_order_id'] = self.order_anon.pk
s.save()
def test_successful_my_project_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.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), 1, 'Only the successful donation should be returned')
def setUp(self):
super(TestDonationEmails, self).setUp()
self.init_projects()
self.user = BlueBottleUserFactory.create(first_name='user',
last_name='userson')
self.user.address.line1 = "'s Gravenhekje 1A"
self.user.address.city = "Mokum A"
self.user.save()
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_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 pay(self, project, amount):
order = OrderFactory.create()
DonationFactory.create(project=project, order=order, amount=amount)
order.locked()
order.succeeded()
order.save()
return order
def setUp(self):
super(TestUnauthenticatedDonationCreate, self).setUp()
self.order_anon = OrderFactory.create()
s = self.session
s['new_order_id'] = self.order_anon.pk
s.save()
def test_order_time_out_called_once(self):
with mock.patch.object(timeout_new_order,
'apply_async') as apply_async:
order = OrderFactory.create()
order.transition_to(StatusDefinition.LOCKED)
order.save()
apply_async.assert_called_once()
def setUp(self):
self.order = OrderFactory.create()
self.donation = DonationFactory.create(amount=Money(1500, KES), order=self.order)
self.order_payment = OrderPaymentFactory.create(
payment_method='lipishaMpesa',
order=self.order
)
self.adapter = LipishaPaymentAdapter(self.order_payment)
def setUp(self):
super(PaymentsMockTestCase, self).setUp()
self.init_projects()
self.order = OrderFactory.create(total=35)
self.order_payment = OrderPaymentFactory.create(order=self.order, payment_method='mock')
self.service = PaymentService(order_payment=self.order_payment)
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 setUp(self):
super(PaymentsMockTestCase, self).setUp()
self.init_projects()
self.order = OrderFactory.create(total=35)
self.order_payment = OrderPaymentFactory.create(order=self.order,
payment_method='mock')
self.service = PaymentService(order_payment=self.order_payment)
def test_create_orderpayment_user_pledge(self):
""" User that can pledge gets a 201 CREATED"""
order = OrderFactory.create(user=self.user1, total=10)
self.order_payment_data['order'] = order.id
response = self.client.post(reverse('manage-order-payment-list'),
self.order_payment_data,
token=self.user1_token)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_no_success_payment_status_check(self, mock_check_payment_status):
self.order = OrderFactory.create(user=self.user1, total=15)
self.order_payment = OrderPaymentFactory.create(order=self.order,
payment_method='mock')
self.service = PaymentService(order_payment=self.order_payment)
self.client.get(reverse('order-manage-detail',
kwargs={'pk': self.order.id}),
token=self.user1_token)
self.assertEqual(mock_check_payment_status.called, True)
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 test_project_donation_list_co_financing(self, check_status_psp):
order = OrderFactory.create(user=self.user2, status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=1500, project=self.project3,
order=order)
anonymous_order = OrderFactory.create(status=StatusDefinition.SUCCESS)
DonationFactory.create(amount=1000, project=self.project3,
order=anonymous_order, anonymous=True)
response = self.client.get(self.project_donation_list_url,
{'project': self.project3.slug, 'co_financing': 'true'},
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']['amount'], 1500.00)
def test_unchanged_status(self, queue_mock):
order = OrderFactory.create(total=Money(100, 'EUR'))
previous_call_count = queue_mock.call_count
# Update record without changing status
order.type = 'blah'
order.save()
self.assertEqual(previous_call_count, queue_mock.call_count,
'Analytics should only be sent when status changes')
def setUp(self):
self.order = OrderFactory.create()
self.project = ProjectFactory.create(amount_asked=1000)
self.donation = DonationFactory.create(amount=1000,
project=self.project,
order=self.order)
self.order.transition_to(StatusDefinition.LOCKED)
self.order.save()
super(TestOrderUpdateProjectAmount, self).setUp()
def test_task_timeout_locked_order_settled(self):
order = OrderFactory.create(status=StatusDefinition.LOCKED)
order.transition_to(StatusDefinition.SUCCESS)
order.save()
timeout_locked_order(order, connection.tenant)
order = Order.objects.get(pk=order.pk)
self.assertEqual(order.status, StatusDefinition.SUCCESS)
def test_create_orderpayment_user_no_pledge(self):
""" User that can not pledge gets a 403 FORBIDDEN """
order = OrderFactory.create(user=self.user2, total=10)
self.order_payment_data['order'] = order.id
response = self.client.post(reverse('manage-order-payment-list'),
self.order_payment_data,
token=self.user2_token)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
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 test_order_time_out(self):
with mock.patch.object(timeout_new_order,
'apply_async') as apply_async:
order = OrderFactory.create()
args, kwargs = apply_async.call_args
self.assertEqual(args[0], [order, connection.tenant])
self.assertTrue(
kwargs['eta'] - timezone.now() < timedelta(minutes=10))
self.assertTrue(kwargs['eta'] -
timezone.now() > timedelta(minutes=9, seconds=59))
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 setUp(self):
super(TestDonationSignals, self).setUp()
self.user1 = BlueBottleUserFactory.create()
self.user1_token = "JWT {0}".format(self.user1.get_jwt_token())
self.init_projects()
self.project1 = ProjectFactory.create(amount_asked=5000)
self.project1.set_status('campaign')
self.order = OrderFactory.create(user=self.user1)
self.donation = DonationFactory(order=self.order, amount=35,
fundraiser=None, project=self.project1)
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 setUp(self):
super(TestProjectPopularity, self).setUp()
self.init_projects()
self.project = ProjectFactory.create()
VoteFactory.create(project=self.project)
task = TaskFactory.create(project=self.project)
TaskMemberFactory.create(task=task)
order = OrderFactory.create(status=StatusDefinition.SUCCESS)
DonationFactory(order=order, project=self.project)
def test_total_multi_currency(self):
order1 = OrderFactory.create(status=StatusDefinition.SUCCESS)
order2 = OrderFactory.create(status=StatusDefinition.SUCCESS)
for i in range(100, 401, 100):
DonationFactory.create(
project=self.project,
order=order1,
amount=Money(i, 'EUR'),
)
DonationFactory.create(
project=self.project,
order=order2,
amount=Money(i, 'USD'),
)
self.project.update_amounts()
self.assertEqual(self.project.amount_donated.amount, 2500)
self.assertEqual(self.project.amount_needed.amount,
self.project.amount_asked.amount - 2500)
self.assertEqual(self.project.amount_donated.currency,
self.project.amount_asked.currency)
def setUp(self):
self.project = ProjectFactory.create()
LipishaProjectFactory.create(project=self.project,
account_number='424242')
self.interface = LipishaPaymentInterface()
self.order = OrderFactory.create()
self.donation = DonationFactory.create(amount=Money(1500, KES),
order=self.order,
project=self.project)
self.order_payment = OrderPaymentFactory.create(
payment_method='lipishaMpesa', order=self.order)
self.adapter = LipishaPaymentAdapter(self.order_payment)
self.lipisha_update_url = reverse('lipisha-update-payment')
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_success_payment_status_check(self, mock_check_payment_status):
self.order = OrderFactory.create(user=self.user1,
total=15,
status=StatusDefinition.SUCCESS)
self.order_payment = OrderPaymentFactory.create(
order=self.order,
payment_method='mock',
status=StatusDefinition.AUTHORIZED)
self.client.get(reverse('order-manage-detail',
kwargs={'pk': self.order.id}),
token=self.user1_token)
self.assertEqual(mock_check_payment_status.called, False)
def setUp(self, mock_client):
super(TestPaymentLogger, self).setUp()
# Mock response to creating the payment at docdata
instance = mock_client.return_value
instance.create.return_value = {'order_key': 123, 'order_id': 123}
self.order = OrderFactory.create(total=35)
self.order_payment = OrderPaymentFactory.create(
payment_method='docdataIdeal',
order=self.order,
integration_data={'default_pm': 'ideal'})
self.service = PaymentService(self.order_payment)
def test_donation_pledged_stats(self):
self.some_project.status = self.campaign_status
self.some_project.save()
self.order = OrderFactory.create(user=self.another_user,
status=StatusDefinition.PLEDGED)
self.donation = DonationFactory.create(amount=Money(1000, 'EUR'),
order=self.order,
project=self.some_project,
fundraiser=None)
self.assertEqual(self.stats.donated_total, Money(1000, 'EUR'))
self.assertEqual(self.stats.pledged_total, Money(1000, 'EUR'))
def test_no_mail_no_campaign_notifications(self):
"""
Test that users who have campaign_notifications turned off don't get email
"""
task_owner1 = BlueBottleUserFactory.create(campaign_notifications=False)
TaskFactory.create(
author=task_owner1,
project=self.project
)
# Add extra project and owner that should not get any email
project_owner = BlueBottleUserFactory.create(campaign_notifications=False)
ProjectFactory(owner=project_owner, status=self.phase1)
# Create a follower by donating
donator1 = BlueBottleUserFactory.create(campaign_notifications=False)
order = OrderFactory.create(user=donator1,
status=StatusDefinition.CREATED)
DonationFactory(order=order, amount=35,
project=self.project,
fundraiser=None)
order.locked()
order.success()
order.save()
# Create a follower by being a fundraiser for the project
fundraiser_person = BlueBottleUserFactory.create(campaign_notifications=False)
FundraiserFactory(project=self.project,
owner=fundraiser_person)
self.assertEqual(Follow.objects.count(), 3)
# Create follower by voting
voter_person = BlueBottleUserFactory.create(
campaign_notifications=False)
VoteFactory(voter=voter_person, project=self.project)
# Project owner creates a wallpost and emails followers
TextWallpostFactory.create(
content_object=self.project, author=self.project.owner,
text="test2", email_followers=True)
mail_count = 0
# People who should get an email: self.some_user, task_owner1,
# fundraiser_person, commenter, voter and donator1
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertEqual(mail_count, 0)
