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 setUp(self):
super(PaymentFlutterwaveApiTests, self).setUp()
self.init_projects()
self.user = BlueBottleUserFactory.create()
self.user_token = "JWT {0}".format(self.user.get_jwt_token())
campaign = ProjectPhase.objects.get(slug='campaign')
self.project_ngn = ProjectFactory(amount_needed=Money(100000, 'NGN'),
currencies=['USD', 'NGN'],
status=campaign)
self.project_kes = ProjectFactory(amount_needed=Money(100000, 'KES'),
currencies=['USD', 'KES'],
status=campaign)
def setUp(self):
super(TestSimpleProjectSurveyAggregation, self).setUp()
self.init_projects()
self.project = ProjectFactory()
self.project_2 = ProjectFactory()
self.survey = SurveyFactory(title='test survey', active=True)
self.response = ResponseFactory.create(
project=self.project,
survey=self.survey
)
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_search_for_specific_date_with_event_task(self):
"""
Search for tasks taking place on a specific date
when there is an event-type task.
"""
later = self.now + timezone.timedelta(days=3)
event_task_3 = TaskFactory.create(
status='open',
type='event',
project=ProjectFactory(deadline=later),
deadline=later,
people_needed=1)
search_date = {'start': str(later)}
response = self.client.get(self.task_url,
search_date,
token=self.some_token)
# The result should include ongoing_task_1, ongoing_task_3 and
# event_task_3 because its on the deadline date
ids = [self.ongoing_task_1.id, self.ongoing_task_3.id, event_task_3.id]
self.assertEquals(response.data['count'], 3)
self.assertIn(response.data['results'][0]['id'], ids)
self.assertIn(response.data['results'][1]['id'], ids)
self.assertIn(response.data['results'][2]['id'], ids)
def setUp(self):
self.init_projects()
campaign = ProjectPhase.objects.get(slug='campaign')
incomplete = ProjectPhase.objects.get(slug='done-incomplete')
complete = ProjectPhase.objects.get(slug='done-complete')
self.project1 = ProjectFactory(status=complete)
self.project1.created = '2017-03-18 00:00:00.000000+00:00'
self.project1.save()
self.project2 = ProjectFactory(status=campaign)
self.project2.created = '2017-03-12 00:00:00.000000+00:00'
self.project2.save()
self.project3 = ProjectFactory(status=incomplete)
self.project3.created = '2017-03-01 00:00:00.000000+00:00'
self.project3.save()
self.project4 = ProjectFactory(status=campaign)
self.project4.created = '2017-03-20 00:00:00.000000+00:00'
self.project4.save()
def setUp(self):
super(OrganizationModelTest, self).setUp()
self.init_projects()
for name in ['test', 'tast', 'tist', 'tust']:
organization = OrganizationFactory.create(name=name)
ProjectFactory(organization=organization)
OrganizationMemberFactory.create(organization=organization)
def test_results_project_images(self):
yesterday = now() - timedelta(days=1)
done_complete = ProjectPhase.objects.get(slug='done-complete')
ProjectFactory(campaign_ended=yesterday, status=done_complete)
ProjectFactory(campaign_ended=yesterday, status=done_complete)
ProjectImagesContent.objects.create_for_placeholder(self.placeholder, title='Nice pics')
response = self.client.get(self.url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['title'], self.page.title)
self.assertEqual(response.data['description'], self.page.description)
images = response.data['blocks'][0]
self.assertEqual(images['type'], 'project_images')
self.assertEqual(images['title'], 'Nice pics')
self.assertEqual(len(images['images']), 2)
def setUp(self):
super(TestProjectStatusUpdate, self).setUp()
self.init_projects()
self.theme = ProjectThemeFactory(slug='test-theme')
self.project = ProjectFactory(theme=self.theme)
self.task = TaskFactory(project=self.project)
self.survey = SurveyFactory(link='https://example.com/survey/1/', active=True)
def setUp(self):
super(LocationAdminTest, self).setUp()
self.init_projects()
self.location = Location.objects.create(
name='Amsterdam',
position='52.3702157,52.3702157'
)
self.site = AdminSite()
self.admin = LocationAdmin(Location, self.site)
ProjectFactory(location=self.location)
def setUp(self):
super(TestSurveyGizmoAdapter, self).setUp()
self.init_projects()
self.theme = ProjectThemeFactory(slug='test-theme')
self.project = ProjectFactory()
self.task = TaskFactory(project=self.project)
self.survey = SurveyFactory(remote_id='test-id',
last_synced=timezone.now())
def setUp(self):
super(AdminMergeOrganizationsTest, self).setUp()
self.init_projects()
for name in ['test', 'tast', 'tist']:
organization = OrganizationFactory.create(name=name)
ProjectFactory(
title='project for {}'.format(name),
organization=organization
)
self.admin_url = reverse('admin:organizations_organization_changelist')
self.client.force_login(BlueBottleUserFactory.create(is_staff=True, is_superuser=True))
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_results_projects(self):
self.project = ProjectFactory()
block = ProjectsContent.objects.create_for_placeholder(self.placeholder)
block.projects.add(self.project)
response = self.client.get(self.url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['title'], self.page.title)
self.assertEqual(response.data['description'], self.page.description)
projects = response.data['blocks'][0]
self.assertEqual(projects['type'], 'projects')
self.assertEqual(projects['projects'][0]['title'], self.project.title)
def setUp(self):
super(FollowTests, self).setUp()
self.init_projects()
self.some_user = BlueBottleUserFactory.create()
self.another_user = BlueBottleUserFactory.create()
self.phase1 = ProjectPhaseFactory.create(
slug='realised') # Required model for bb_payouts signals
self.project = ProjectFactory(owner=self.some_user, status=self.phase1)
self.task = TaskFactory.create(
author=self.project.owner,
project=self.project,
)
def test_wallpost_mail_task(self):
""" Test that the relevant people get an email when the email_followers option is selected for a task """
# On a task page, the task members, task owners, get an email --> Followers
project_owner = BlueBottleUserFactory.create()
project2 = ProjectFactory(owner=project_owner, status=self.phase1)
task_owner1 = BlueBottleUserFactory.create()
task = TaskFactory.create(
author=task_owner1,
project=project2
)
task_member_1 = TaskMemberFactory(task=task)
task_member_2 = TaskMemberFactory(task=task)
mail.outbox = []
self.assertEqual(Follow.objects.count(), 5)
for follower in Follow.objects.all():
if follower.user != task_owner1:
self.assertTrue(follower.followed_object in (task, task.project))
TextWallpostFactory.create(content_object=task,
author=task_owner1,
text="test2",
email_followers=True)
mail_count = 0
receivers = [task_member_1.member.email, task_member_2.member.email]
for email in mail.outbox:
if "New wallpost on" in email.subject:
mail_count += 1
self.assertTrue(email.to[0] in receivers)
receivers.remove(email.to[0])
self.assertEqual(mail_count, 2)
self.assertEqual(receivers, [])
def test_filtering_on_wallpost_list(self):
authenticated = Group.objects.get(name='Authenticated')
authenticated.permissions.remove(
Permission.objects.get(codename='api_read_mediawallpost'))
authenticated.permissions.add(
Permission.objects.get(codename='api_read_own_mediawallpost'))
MediaWallpostFactory.create(content_object=self.task)
MediaWallpostFactory.create(content_object=self.project)
MediaWallpostFactory.create(content_object=self.fundraiser)
MediaWallpostFactory.create(content_object=ProjectFactory(
owner=self.other_user))
response = self.client.get(self.media_wallpost_url,
token=self.owner_token)
self.assertEqual(response.data['count'], 3)
response = self.client.get(self.media_wallpost_url,
token=self.other_token)
self.assertEqual(response.data['count'], 1)
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 test_project_export(self):
project = ProjectFactory(title='Just an example')
CustomProjectFieldSettings.objects.create(name='Extra Info')
field = CustomProjectFieldSettings.objects.create(name='How is it')
CustomProjectField.objects.create(project=project,
value='This is nice!',
field=field)
export_action = self.project_admin.actions[0]
response = export_action(self.project_admin, self.request,
self.project_admin.get_queryset(self.request))
data = response.content.split("\r\n")
headers = data[0].split(",")
data = data[1].split(",")
# Test basic info and extra field are in the csv export
self.assertEqual(headers[0], 'title')
self.assertEqual(headers[28], 'Extra Info')
self.assertEqual(data[0], 'Just an example')
self.assertEqual(data[28], '')
self.assertEqual(data[29], 'This is nice!')
def test_amount_needed(self):
project = ProjectFactory(amount_asked=Money(100, 'EUR'))
self.assertEqual(self.project_admin.amount_needed_i18n(project),
Money(100, 'EUR'))
def test_amount_needed_with_more_extra(self):
project = ProjectFactory(amount_asked=Money(100, 'EUR'),
amount_extra=Money(150, 'EUR'))
self.assertEqual(self.project_admin.amount_needed_i18n(project),
Money(0, 'EUR'))
def setUp(self):
super(LipishaProjectAddOnTest, self).setUp()
self.init_projects()
self.project = ProjectFactory()
self.project_url = reverse('project_detail', args=[self.project.slug])
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)
