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 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 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)