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_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 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 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 test_create_follow_donation_with_login(self):
"""
Test that a Follow object is created if a user does a donation
to a project with login during donation flow
"""
self.assertEqual(Follow.objects.count(), 0)
order = OrderFactory.create(
user=None,
status=StatusDefinition.CREATED
)
# Make sure to set Fundraiser to None. Otherwise, a fundraiser is created
DonationFactory(
order=order,
amount=35,
project=self.project,
fundraiser=None)
order.user = self.another_user
order.locked()
order.success()
order.save()
self.assertEqual(Follow.objects.count(), 1)
self.assertEqual(Follow.objects.all()[0].followed_object, self.project)
self.assertEqual(Follow.objects.all()[0].user, self.another_user)
def test_donation_update_order_change_currency(self,
mock_check_status_psp):
""" Test that an update to a donation where the order does has status CREATED produces 200 OK response"""
order = OrderFactory.create(user=self.user,
status=StatusDefinition.CREATED)
donation = DonationFactory(order=order, amount=Money(100, 'USD'))
updated_donation = {
"project": donation.project.slug,
"order": order.id,
"amount": {
'amount': 200,
'currency': 'EUR'
}
}
self.assertEqual(Donation.objects.count(), 1)
response = self.client.put(reverse('manage-donation-detail',
kwargs={'pk': donation.id}),
updated_donation,
token=self.user_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Donation.objects.count(), 1)
self.assertEqual(response.data['amount'], {
'currency': 'EUR',
'amount': Decimal(200)
})
def setUp(self):
super(TestPledgeMails, self).setUp()
self.init_projects()
self.user = BlueBottleUserFactory(can_pledge=True)
self.project_owner = BlueBottleUserFactory(username='******',
email='*****@*****.**',
password='******')
self.organization = OrganizationFactory.create(name='test_org',
slug='test_org')
self.project = ProjectFactory(owner=self.project_owner,
organization=self.organization,
title='Project 1',
amount_needed=1111,
amount_asked=1111)
self.order = OrderFactory.create(user=self.user)
self.donation = DonationFactory(amount=60,
order=self.order,
project=self.project,
fundraiser=None)
self.order_payment = OrderPaymentFactory.create(
order=self.order, payment_method='pledgeStandard')
self.order_payment.pledged()
self.order_payment.save()
def test_project_systemwallpost_admin(self):
project = ProjectFactory.create()
donation = DonationFactory(project=project)
self.wallpost = MediaWallpostFactory.create(content_object=project,
donation=donation)
url = reverse('admin:wallposts_mediawallpost_change',
args=(self.wallpost.id, ))
response = self.client.get(url)
self.assertEqual(response.status_code, 200, response.content)
self.assertContains(response, project.title)
def test_results_supporters(self):
yesterday = now() - timedelta(days=1)
co_financer = BlueBottleUserFactory(is_co_financer=True)
user = BlueBottleUserFactory(is_co_financer=False)
project = ProjectFactory(created=yesterday, owner=user)
order1 = OrderFactory(user=co_financer, confirmed=yesterday, status='success')
order2 = OrderFactory(user=co_financer, confirmed=yesterday, status='success')
order3 = OrderFactory(user=user, confirmed=yesterday, status='success')
DonationFactory(order=order1, amount=Money(50, 'EUR'), project=project)
DonationFactory(order=order2, amount=Money(50, 'EUR'), project=project)
DonationFactory(order=order3, amount=Money(50, 'EUR'), project=project)
SupporterTotalContent.objects.create_for_placeholder(self.placeholder)
response = self.client.get(self.url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
block = response.data['blocks'][0]
self.assertEqual(block['type'], 'supporter_total')
self.assertEqual(len(block['co_financers']), 1)
self.assertEqual(block['co_financers'][0]['total']['amount'], 100)
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 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_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)
def test_not_follow_own_donation_project(self):
""" Test that a user making a donation to its own project does not become a follower """
self.assertEqual(Follow.objects.count(), 0)
order = OrderFactory.create(user=self.some_user,
status=StatusDefinition.CREATED)
# Make sure that no fundraisers are created. A new fundraiser will also create a follower
DonationFactory(order=order, amount=35,
project=self.project, fundraiser=None)
order.locked()
order.success()
order.save()
self.assertEqual(Follow.objects.count(), 0)
def test_successfull_anonymous_donation(self):
"""
Test that a SystemWallpost is created without an author when a donation is anonymous
"""
self.assertEqual(SystemWallpost.objects.count(), 0)
order = OrderFactory.create(user=self.user1)
DonationFactory(order=order, amount=35, project=self.project1,
fundraiser=None, anonymous=True)
order.locked()
order.save()
order.success()
order.save()
self.assertEqual(SystemWallpost.objects.count(), 1)
self.assertEqual(SystemWallpost.objects.all()[0].author, None)
self.assertEqual(len(mail.outbox), 2)
def setUp(self):
super(MonthlyDonationAdminTest, self).setUp()
self.app.extra_environ['HTTP_HOST'] = str(self.tenant.domain_url)
self.superuser = BlueBottleUserFactory.create(is_staff=True,
is_superuser=True)
self.init_projects()
self.phase_campaign = ProjectPhase.objects.get(slug='campaign')
self.country = CountryFactory()
self.projects = []
for amount in [500, 100, 1500, 300, 200]:
self.projects.append(
ProjectFactory.create(amount_asked=amount,
status=self.phase_campaign))
# Some donations to get the popularity going
# Top 3 after this should be projects 4, 3, 0
order = OrderFactory()
DonationFactory(order=order, project=self.projects[3], amount=10)
DonationFactory(order=order, project=self.projects[3], amount=100)
DonationFactory(order=order, project=self.projects[3], amount=20)
DonationFactory(order=order, project=self.projects[4], amount=10)
DonationFactory(order=order, project=self.projects[4], amount=70)
DonationFactory(order=order, project=self.projects[0], amount=10)
order.locked()
order.save()
order.success()
order.save()
# Since we force the transitions update_amounts isn't triggered by
# signal, so we run it manually here.
for project in self.projects:
project.update_amounts()
self.user1 = BlueBottleUserFactory.create()
self.user2 = BlueBottleUserFactory.create()
# Create a monthly donor with a preferred project
self.monthly_donor1 = MonthlyDonorFactory(user=self.user1, amount=25)
self.monthly_donor1_project = MonthlyDonorProjectFactory(
donor=self.monthly_donor1, project=self.projects[0])
# Create a monthly donor without preferred projects
self.monthly_donor2 = MonthlyDonorFactory(user=self.user2, amount=100)
Project.update_popularity()
def test_donation_update_same_owner(self, mock_check_status_psp):
""" Test that an update to a donation where the user is the owner produces a 200 OK"""
donation = DonationFactory(order=self.order, amount=35)
updated_donation = {
"project": self.project.slug,
"order": self.order.id,
"amount": 50
}
self.assertEqual(Donation.objects.count(), 1)
response = self.client.put(reverse('manage-donation-detail',
kwargs={'pk': donation.id}),
updated_donation,
token=self.user_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Donation.objects.count(), 1)
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)
BlueBottleUserFactory.create()
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
DonationFactory(order=order, amount=35,
project=self.project, fundraiser=None)
order.locked()
order.success()
order.save()
# Create follower by creating a task owner
task_owner1 = BlueBottleUserFactory.create()
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
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_successfull_fundraiser_donation(self):
"""
Test that a SystemWallpost is created for the fundraiser
wall only when a user does a succesful donation
"""
self.assertEqual(SystemWallpost.objects.count(), 0)
order = OrderFactory.create(user=self.user1)
fundraiser = FundraiserFactory(project=self.project1)
DonationFactory(order=order, amount=35,
project=self.project1, fundraiser=fundraiser)
order.locked()
order.save()
order.success()
order.save()
self.assertEqual(SystemWallpost.objects.count(), 1)
self.assertEqual(SystemWallpost.objects.all()[0].content_object,
fundraiser)
self.assertEqual(SystemWallpost.objects.all()[0].author, order.user)
self.assertEqual(len(mail.outbox), 3)
def test_donation_update_order_new(self, mock_check_status_psp):
""" Test that an update to a donation where the order does has status CREATED produces 200 OK response"""
order = OrderFactory.create(user=self.user,
status=StatusDefinition.CREATED)
donation = DonationFactory(order=order, amount=35)
updated_donation = {
"project": self.project.slug,
"order": order.id,
"amount": 50
}
self.assertEqual(Donation.objects.count(), 1)
response = self.client.put(reverse('manage-donation-detail',
kwargs={'pk': donation.id}),
updated_donation,
token=self.user_token)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Donation.objects.count(), 1)
def test_wallpost_mail_project(self):
"""
Test that the relevant people get an email when the
email_followers option is selected for a project
"""
# On a project page, task owners, fundraisers, and people who donated, get a mail.
# Create a follower by being a task owner
task_owner1 = BlueBottleUserFactory.create()
TaskFactory.create(
author=task_owner1,
project=self.project
)
# Add extra project and owner that should not get any email
project_owner = BlueBottleUserFactory.create()
ProjectFactory(owner=project_owner, status=self.phase1)
# iLeaving a wallpost should not create a follower
commenter = BlueBottleUserFactory.create()
TextWallpostFactory.create(content_object=self.project,
author=commenter,
text="test1",
email_followers=False)
# Create a follower by donating
donator1 = BlueBottleUserFactory.create()
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()
FundraiserFactory(project=self.project, owner=fundraiser_person)
self.assertEqual(Follow.objects.count(), 3)
voter = BlueBottleUserFactory.create()
VoteFactory(voter=voter, project=self.project)
self.assertEqual(Follow.objects.count(), 4)
# 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, voter, task_owner1,
# fundraiser_person, commenter, and donator1
receivers = [voter.email, task_owner1.email, fundraiser_person.email, donator1.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, 4)
self.assertEqual(receivers, [])
def test_wallpost_delete_mail_project(self):
"""
Test that the relevant people don't get an email when the
email_followers option is selected for a project
during wallpost create but is then deleted.
"""
# On a project page, task owners, fundraisers, and people who donated, get a mail.
# Create a follower by being a task owner
task_owner1 = BlueBottleUserFactory.create()
TaskFactory.create(
author=task_owner1,
project=self.project
)
# Add extra project and owner that should not get any email
project_owner = BlueBottleUserFactory.create()
ProjectFactory(owner=project_owner, status=self.phase1)
# iLeaving a wallpost should not create a follower
commenter = BlueBottleUserFactory.create()
TextWallpostFactory.create(content_object=self.project,
author=commenter,
text="test1",
email_followers=False)
# Create a follower by donating
donator1 = BlueBottleUserFactory.create()
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()
FundraiserFactory(project=self.project,
owner=fundraiser_person)
self.assertEqual(Follow.objects.count(), 3)
voter = BlueBottleUserFactory.create()
VoteFactory(voter=voter, project=self.project)
self.assertEqual(Follow.objects.count(), 4)
# 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, voter, task_owner1,
# fundraiser_person, commenter, and donator1
receivers = [voter.email, task_owner1.email,
fundraiser_person.email, donator1.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, 4)
self.assertEqual(receivers, [])
# Setup for mail counting after wallpost delete
mail_count = 0
receivers = [voter.email, task_owner1.email,
fundraiser_person.email, donator1.email]
# This time we can safely reset the email box to 0
mail.outbox = []
# Ember triggers a save to the record before the actual delete
# therefore we can't use the Django delete function. This won't
# trigger the email_follower signal to be fired again. To replicate
# the server behavior we can simply re-save the wallpost record. This
# will cause the signal to fire but with the "created" flag to False.
some_wallpost_2.save()
# Check that no emails about a new wallpost go out
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertTrue(email.to[0] in receivers)
self.assertEqual(mail_count, 0)
def setUp(self):
super(TestEngagementMetricsXls, self).setUp()
self.init_projects()
self.year = datetime.now().year
# Project Phases
done_complete = ProjectPhase.objects.get(slug="done-complete")
done_incomplete = ProjectPhase.objects.get(slug="done-incomplete")
# Users
user1 = BlueBottleUserFactory.create()
# Projects
project1 = ProjectFactory.create(owner=user1, status=done_complete)
ProjectFactory.create(owner=user1, status=done_incomplete)
# Wallposts
TextWallpostFactory.create(content_object=project1,
author=user1,
editor=user1,
text="test1",
email_followers=False)
# Votes
VoteFactory(project=project1, voter=user1)
# Fundraisers
fundraiser = FundraiserFactory(project=project1, owner=user1)
# Donations
order1 = OrderFactory.create(user=user1)
DonationFactory(order=order1, fundraiser=fundraiser, project=project1)
order1.locked()
order1.save()
order1.success()
order1.save()
order2 = OrderFactory.create(user=None)
donation2 = DonationFactory(order=order2,
fundraiser=fundraiser,
project=project1)
donation2.anonymous = True
order2.locked()
order2.save()
order2.success()
order2.save()
# Tasks
task = TaskFactory.create(author=user1,
project=project1,
people_needed=2,
status='realized')
task_member = TaskMemberFactory.create(
time_spent=10,
member=user1,
task=task,
status=TaskMember.TaskMemberStatuses.applied)
task_member.status = TaskMember.TaskMemberStatuses.realized
task_member.save()
# Simulate user Login
jwt_token = user1.get_jwt_token()
task_member_url = reverse('task-member-detail',
kwargs={'pk': task_member.id})
self.client.get(task_member_url, token="JWT {0}".format(jwt_token))
# xls export
self.xls_file_name = 'test.xlsx'
self.xls_file_path = os.path.join(settings.PROJECT_ROOT,
self.xls_file_name)
self.command = EngagementCommand()
