def test_generate_all_meetings(self):
now = timezone.now()
self.assertEqual(Reminder.objects.all().count(), 0)
sg = StudyGroup.objects.all()[0]
sg.start_date = now - datetime.timedelta(days=3)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
self.assertEqual(StudyGroupMeeting.objects.all().count(),0)
generate_all_meetings(sg)
self.assertEqual(StudyGroupMeeting.objects.all().count(),6)
def test_dont_generate_reminder_4days_before(self):
# Make sure we don't generate a reminder more than 3 days before
now = timezone.now()
self.assertEqual(Reminder.objects.all().count(), 0)
sg = StudyGroup.objects.all()[0]
sg.start_date = now - datetime.timedelta(days=3)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 0)
def test_no_reminders_for_future_studygroups(self):
now = timezone.now()
self.assertEqual(Reminder.objects.all().count(), 0)
# Make sure we don't generate a reminder for future study groups
sg = StudyGroup.objects.all()[0]
sg.start_date = now + datetime.timedelta(days=2, weeks=1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 0)
def test_no_reminders_for_old_studygroups(self):
now = timezone.now()
self.assertEqual(Reminder.objects.all().count(), 0)
# Make sure we don't generate a reminder for old study groups
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = now - datetime.timedelta(days=5, weeks=7)
sg.meeting_time = sg.start_date.time()
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 0)
def test_get_learning_circles_last_meeting(self):
sg = StudyGroup.objects.get(pk=1)
sg.start_date = datetime.date(2019,5,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
c = Client()
resp = c.get('/api/learningcircles/?scope=completed')
data = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.json()["count"], 1)
self.assertEqual(data["items"][0]["last_meeting_date"], "2019-05-15")
def test_application_welcome_message(self):
c = Client()
study_group = StudyGroup.objects.get(pk=1)
study_group.timezone = 'America/Chicago'
with freeze_time("2015-03-06 18:55:34"):
generate_all_meetings(study_group)
resp = c.post('/en/signup/foo-bob-1/', self.APPLICATION_DATA)
self.assertRedirects(resp, '/en/signup/1/success/')
self.assertEqual(Application.objects.active().count(), 1)
# Make sure notification was sent
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to[0], self.APPLICATION_DATA['email'])
self.assertEqual(mail.outbox[0].cc[0], study_group.facilitator.email)
self.assertIn(
'The first meeting will be on Monday, 23 March at 6:30 p.m.',
mail.outbox[0].body)
def post(self, request, *args, **kwargs):
study_group = self.get_object()
profile = study_group.facilitator.profile
if profile.email_confirmed_at is None:
messages.warning(self.request, _("You need to confirm your email address before you can publish a learning circle."));
else:
messages.success(self.request, _("Your learning circle has been published."));
study_group.draft = False
study_group.save()
generate_all_meetings(study_group)
url = reverse_lazy('studygroups_view_study_group', args=(self.kwargs.get('study_group_id'),))
if self.get_object().facilitator == self.request.user:
url = reverse_lazy('studygroups_facilitator')
return http.HttpResponseRedirect(url)
def test_generate_all_meetings(self):
now = timezone.now()
self.assertEqual(Reminder.objects.all().count(), 0)
sg = StudyGroup.objects.get(pk=1)
sg.timezone = 'US/Central'
sg.start_date = now.date() + datetime.timedelta(days=3)
sg.meeting_time = datetime.time(16,0)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
self.assertEqual(StudyGroupMeeting.objects.all().count(),0)
generate_all_meetings(sg)
self.assertEqual(StudyGroupMeeting.objects.all().count(),6)
self.assertEqual(sg.next_meeting().meeting_datetime().tzinfo.zone, 'US/Central')
for meeting in StudyGroupMeeting.objects.all():
self.assertEqual(meeting.meeting_datetime().time(), datetime.time(16,0))
def test_dont_send_automatic_reminder_for_old_meeting(self, send_message):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = datetime.date(2010, 3, 10)
sg.meeting_time = datetime.time(18, 0)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
with freeze_time("2010-03-06 18:55:34"):
generate_all_meetings(sg)
data = self.APPLICATION_DATA
data['study_group'] = sg
application = Application(**data)
application.save()
accept_application(application)
# There should be 6 unsent reminders
self.assertEqual(
Reminder.objects.filter(sent_at__isnull=True).count(), 6)
mail.outbox = []
with freeze_time("2010-03-08 18:55:34"):
send_reminders()
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].to[0], data['email'])
self.assertEqual(mail.outbox[1].to[0], '*****@*****.**')
self.assertFalse(send_message.called)
# Only 5 unsent reminders now
self.assertEqual(
Reminder.objects.filter(sent_at__isnull=True).count(), 5)
reminder = Reminder.objects.filter(sent_at__isnull=True).order_by(
'study_group_meeting__meeting_date').first()
self.assertEqual(reminder.study_group_meeting.meeting_date,
datetime.date(2010, 3, 17))
# Make sure we don't send unsent reminders after a meeting has happened
mail.outbox = []
with freeze_time("2010-03-18 18:55:34"):
send_reminders()
self.assertEqual(len(mail.outbox), 0)
self.assertEqual(
Reminder.objects.filter(sent_at__isnull=True).count(), 5)
def post(self, request, *args, **kwargs):
study_group = self.get_object()
post_schema = _make_learning_circle_schema(request)
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {"status": "error", "errors": errors})
# update learning circle
end_date = data.get('start_date') + datetime.timedelta(weeks=data.get('weeks') - 1)
published = False
# only publish a learning circle for a user with a verified email address
draft = data.get('draft', True)
if draft == False and request.user.profile.email_confirmed_at != None:
published = study_group.draft == True
study_group.draft = False
study_group.course = data.get('course')
study_group.description = data.get('description')
study_group.venue_name = data.get('venue_name')
study_group.venue_address = data.get('venue_address')
study_group.venue_details = data.get('venue_details')
study_group.venue_website = data.get('venue_website', '')
study_group.city = data.get('city')
study_group.latitude = data.get('latitude')
study_group.longitude = data.get('longitude')
study_group.place_id = data.get('place_id', '')
study_group.start_date = data.get('start_date')
study_group.end_date = end_date
study_group.meeting_time = data.get('meeting_time')
study_group.duration = data.get('duration')
study_group.timezone = data.get('timezone')
study_group.image = data.get('image')
study_group.signup_question = data.get('signup_question', '')
study_group.facilitator_goal = data.get('facilitator_goal', '')
study_group.facilitator_concerns = data.get('facilitator_concerns', '')
study_group.save()
# generate all meetings if the learning circle has been published
if published:
generate_all_meetings(study_group)
study_group_url = settings.DOMAIN + reverse('studygroups_signup', args=(slugify(study_group.venue_name, allow_unicode=True), study_group.id,))
return json_response(request, { "status": "updated", "url": study_group_url });
def test_send_learner_reminder_ics(self, send_message):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = now - datetime.timedelta(days=5)
sg.meeting_time = sg.start_date.time()
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.attach_ics = True
sg.save()
sg = StudyGroup.objects.get(pk=1)
data = self.APPLICATION_DATA
data['study_group'] = sg
application = Application(**data)
accept_application(application)
application.save()
mail.outbox = []
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
self.assertEqual(len(mail.outbox), 1)
send_reminder(reminder)
self.assertEqual(len(mail.outbox),
3) # should be sent to facilitator & application
self.assertEqual(mail.outbox[1].to[0], data['email'])
self.assertFalse(send_message.called)
self.assertIn(
'{0}/{1}/rsvp/?user=test%40mail.com&study_group=1&meeting_date={2}&attending=yes&sig='
.format(
settings.DOMAIN, get_language(),
urllib.parse.quote(
sg.next_meeting().meeting_datetime().isoformat())),
mail.outbox[1].alternatives[0][0])
self.assertIn(
'{0}/{1}/rsvp/?user=test%40mail.com&study_group=1&meeting_date={2}&attending=no&sig='
.format(
settings.DOMAIN, get_language(),
urllib.parse.quote(
sg.next_meeting().meeting_datetime().isoformat())),
mail.outbox[1].alternatives[0][0])
self.assertIn(
'{0}/{1}/optout/confirm/?user='******'VEVENT', mail.outbox[1].attachments[0].get_payload())
def test_generate_reminder_3days_before(self):
# Make sure we generate a reminder less than three days before
now = timezone.now()
sg = StudyGroup.objects.all()[0]
sg.start_date = now - datetime.timedelta(days=5)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
self.assertEqual(reminder.study_group_meeting.meeting_time, next_meeting_date(sg))
#TODO check that email was sent to site admin
#TODO test with unicode in generated email subject
# Make sure we do it only once
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
def test_send_reminder_sms(self, send_message):
now = timezone.now()
sg = StudyGroup.objects.all()[0]
sg.start_date = now - datetime.timedelta(days=5)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
data = self.APPLICATION_DATA
data['study_group'] = sg
data['contact_method'] = Application.TEXT
application = Application(**data)
application.save()
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
send_reminder(reminder)
self.assertEqual(len(mail.outbox), 1)
#self.assertEqual(mail.outbox[0].subject, mail_data['email_subject'])
self.assertFalse(send_message.called)
def test_receive_sms(self):
# Test receiving a message
signup_data = self.APPLICATION_DATA.copy()
signup_data['mobile'] = '+12812347890'
c = Client()
resp = c.post('/en/signup/foo-bob-1/', signup_data)
self.assertRedirects(resp, '/en/signup/1/success/')
self.assertEqual(Application.objects.active().count(), 1)
mail.outbox = []
url = '/en/receive_sms/'
sms_data = {
'Body':
'The first study group for GED® Prep Math will meet next Thursday, May 7th, from 6:00 pm-7:45 pm at Edgewater on the 2nd floor. Feel free to bring a study buddy!',
'From': '+12812347890'
}
sg = StudyGroup.objects.get(pk=1)
sg.meeting_set.delete()
sg.start_date = datetime.date(2017, 10, 1)
sg.end_date = datetime.date(2017, 10, 1) + datetime.timedelta(weeks=6)
generate_all_meetings(sg)
with freeze_time("2017-10-24 17:55:34"):
resp = c.post(url, sms_data)
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(mail.outbox[0].subject.find(signup_data['name']) > 0)
self.assertTrue(mail.outbox[0].subject.find(signup_data['mobile']) > 0)
self.assertIn(
StudyGroup.objects.get(pk=1).facilitator.email, mail.outbox[0].to)
self.assertIn('admin@localhost', mail.outbox[0].bcc)
mail.outbox = []
with freeze_time("2018-10-24 17:55:34"):
resp = c.post(url, sms_data)
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(mail.outbox[0].subject.find(signup_data['mobile']) > 0)
self.assertNotIn(
StudyGroup.objects.get(pk=1).facilitator.email, mail.outbox[0].to)
self.assertIn('admin@localhost', mail.outbox[0].to)
def post(self, request):
post_schema = _make_learning_circle_schema(request)
data = json.loads(request.body)
data, errors = schema.validate(post_schema, data)
if errors != {}:
return json_response(request, {"status": "error", "errors": errors})
# create learning circle
end_date = data.get('start_date') + datetime.timedelta(weeks=data.get('weeks') - 1)
study_group = StudyGroup(
course=data.get('course'),
facilitator=request.user,
description=data.get('description'),
venue_name=data.get('venue_name'),
venue_address=data.get('venue_address'),
venue_details=data.get('venue_details'),
venue_website=data.get('venue_website', ''),
city=data.get('city'),
latitude=data.get('latitude'),
longitude=data.get('longitude'),
place_id=data.get('place_id', ''),
start_date=data.get('start_date'),
end_date=end_date,
meeting_time=data.get('meeting_time'),
duration=data.get('duration'),
timezone=data.get('timezone'),
image=data.get('image'),
signup_question=data.get('signup_question', ''),
facilitator_goal=data.get('facilitator_goal', ''),
facilitator_concerns=data.get('facilitator_concerns', '')
)
# only update value for draft if the use verified their email address
if request.user.profile.email_confirmed_at != None:
study_group.draft = data.get('draft', True)
study_group.save()
# generate all meetings if the learning circle has been published
if study_group.draft == False:
generate_all_meetings(study_group)
study_group_url = settings.DOMAIN + reverse('studygroups_signup', args=(slugify(study_group.venue_name, allow_unicode=True), study_group.id,))
return json_response(request, { "status": "created", "url": study_group_url });
def test_send_reminder_sms(self, send_message):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = now - datetime.timedelta(days=5)
sg.meeting_time = sg.start_date.time()
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
data = self.APPLICATION_DATA
data['study_group'] = sg
application = Application(**data)
application.save()
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
send_reminder(reminder)
self.assertEqual(len(mail.outbox), 1)
#self.assertEqual(mail.outbox[0].subject, mail_data['email_subject'])
self.assertFalse(send_message.called)
def test_generate_reminder_4days_before(self):
# Make sure we generate a reminder less than 4 days before
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = now.date() + datetime.timedelta(days=3)
sg.meeting_time = now.time()
sg.end_date = now.date() + datetime.timedelta(weeks=5, days=3)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
self.assertEqual(sg.studygroupmeeting_set.active().count(), 6)
self.assertTrue(sg.next_meeting().meeting_datetime() - now < datetime.timedelta(days=4))
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
#TODO check that email was sent to site admin
#TODO test with unicode in generated email subject
# Make sure we do it only once
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
def test_send_reminder_email(self, send_message):
now = timezone.now()
sg = StudyGroup.objects.all()[0]
sg.start_date = now - datetime.timedelta(days=5)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
data = self.APPLICATION_DATA
data['study_group'] = sg
application = Application(**data)
accept_application(application)
application.save()
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
self.assertEqual(len(mail.outbox), 1)
send_reminder(reminder)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[1].to[0], data['email'])
self.assertFalse(send_message.called)
self.assertIn('https://chicago.p2pu.org/{0}/rsvp/?user=test%40mail.com&study_group=1&meeting_date={1}&attending=yes&sig='.format(get_language(), urllib.quote(sg.next_meeting().meeting_time.isoformat())), mail.outbox[1].body)
self.assertIn('https://chicago.p2pu.org/{0}/rsvp/?user=test%40mail.com&study_group=1&meeting_date={1}&attending=no&sig='.format(get_language(), urllib.quote(sg.next_meeting().meeting_time.isoformat())), mail.outbox[1].body)
def test_get_learning_circles_no_meetings(self):
# has meetings
sg = StudyGroup.objects.get(pk=1)
sg.start_date = datetime.date(2019,6,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# no meetings, start_date in past
sg = StudyGroup.objects.get(pk=2)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
# no meetings, start_date in future
sg = StudyGroup.objects.get(pk=3)
sg.start_date = datetime.date(2019,6,2)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
c = Client()
resp = c.get('/api/learningcircles/?signup=open')
result = resp.json()
print(result)
self.assertEqual(resp.status_code, 200)
self.assertEqual(result["count"], 2)
self.assertEqual(result["items"][0]["id"], 1)
self.assertEqual(result["items"][0]["last_meeting_date"], '2019-06-15')
self.assertEqual(result["items"][1]["id"], 3)
self.assertEqual(result["items"][1]["last_meeting_date"], '2019-06-02')
def test_send_facilitator_learner_survey_prompt(self):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = datetime.date(2010, 1, 1)
sg.meeting_time = datetime.time(18, 15)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
last_meeting = sg.meeting_set.active().order_by(
'meeting_date', 'meeting_time').last()
self.assertEqual(last_meeting.meeting_date, datetime.date(2010, 2, 5))
self.assertEqual(last_meeting.meeting_time, datetime.time(18, 15))
self.assertEqual(sg.meeting_set.active().count(), 6)
self.assertEqual(Reminder.objects.all().count(), 0)
with freeze_time("2010-02-06 18:30:00"):
send_facilitator_learner_survey_prompt(sg)
self.assertEqual(len(mail.outbox), 0)
with freeze_time("2010-02-07 17:30:00"):
send_facilitator_learner_survey_prompt(sg)
self.assertEqual(len(mail.outbox), 0)
with freeze_time("2010-02-07 19:30:00"):
send_facilitator_learner_survey_prompt(sg)
self.assertEqual(len(mail.outbox), 0)
with freeze_time("2010-02-07 18:30:00"):
send_facilitator_learner_survey_prompt(sg)
self.assertEqual(len(mail.outbox), 1)
self.assertIn(
'{0}/en/studygroup/{1}/facilitator_survey/'.format(
settings.DOMAIN, sg.uuid), mail.outbox[0].body)
self.assertIn(sg.facilitator.email, mail.outbox[0].to)
def test_generate_reminder_with_long_name_and_location(self):
# Make sure we generate a reminder less than 4 days before
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.venue_name = 'This is a very long venue name to test for sms reminders that are longer than a 160 caracters long'
sg.venue_details = 'This is an even longer venue detail field. I am almost 100% certain this will be cut off. What do you think'
sg.start_date = now.date() + datetime.timedelta(days=3)
sg.meeting_time = now.time()
sg.end_date = now.date() + datetime.timedelta(weeks=5, days=3)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
self.assertEqual(sg.studygroupmeeting_set.active().count(), 6)
self.assertTrue(sg.next_meeting().meeting_datetime() - now < datetime.timedelta(days=4))
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
#TODO check that email was sent to site admin
#TODO test with unicode in generated email subject
# Make sure we do it only once
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
def test_generate_finished_studygroup_survey_email(self):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = datetime.date(2010, 1, 1)
sg.meeting_time = datetime.time(18, 0)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
last_meeting = sg.meeting_set.active().order_by(
'meeting_date', 'meeting_time').last()
self.assertEqual(last_meeting.meeting_date, datetime.date(2010, 2, 5))
self.assertEqual(last_meeting.meeting_time, datetime.time(18, 0))
self.assertEqual(sg.meeting_set.active().count(), 6)
self.assertEqual(Reminder.objects.all().count(), 0)
# freeze time to 6 days after last
with freeze_time("2010-02-11 17:55:34"):
send_facilitator_survey(sg)
self.assertEqual(len(mail.outbox), 0)
# freeze time to 8 days after last
with freeze_time("2010-02-13 17:55:34"):
send_facilitator_survey(sg)
self.assertEqual(len(mail.outbox), 0)
# freeze time to 7 days after last
with freeze_time("2010-02-12 17:55:34"):
send_facilitator_survey(sg)
self.assertEqual(len(mail.outbox), 1)
self.assertIn(
'https://example.net/en/studygroup/{0}/facilitator_survey/'.
format(sg.id), mail.outbox[0].body)
self.assertIn(sg.facilitator.email, mail.outbox[0].to)
def test_facilitator_reminder_email_links(self, send_message):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = now - datetime.timedelta(days=5)
sg.meeting_time = sg.start_date.time()
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
data = self.APPLICATION_DATA
data['study_group'] = sg
application = Application(**data)
accept_application(application)
application.save()
mail.outbox = []
generate_all_meetings(sg)
generate_reminder(sg)
self.assertEqual(Reminder.objects.all().count(), 1)
reminder = Reminder.objects.all()[0]
self.assertEqual(len(mail.outbox), 1)
mail.outbox = []
send_reminder(reminder)
self.assertEqual(len(mail.outbox),
2) # should be sent to facilitator & application
self.assertEqual(mail.outbox[0].to[0], data['email'])
self.assertEqual(mail.outbox[1].to[0], sg.facilitator.email)
self.assertFalse(send_message.called)
self.assertNotIn(
'https://example.net/{0}/rsvp/'.format(get_language()),
mail.outbox[1].body)
self.assertIn(
'https://example.net/{0}/facilitator/'.format(get_language()),
mail.outbox[1].body)
self.assertNotIn(
'https://example.net/{0}/optout/confirm/?user='.format(
get_language()), mail.outbox[1].body)
def test_get_learning_circles_signup_open(self):
# open for signup
sg = StudyGroup.objects.get(pk=1)
sg.start_date = datetime.date(2019,6,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# closed for signup because it's set as closed
sg = StudyGroup.objects.get(pk=2)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = False
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# closed for signup because the last meeting is in the past
sg = StudyGroup.objects.get(pk=3)
sg.start_date = datetime.date(2019,5,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# doesn't show up in results because it's in draft
sg = StudyGroup.objects.get(pk=4)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.draft = True
sg.save()
c = Client()
# open for signup
resp = c.get('/api/learningcircles/?signup=open')
result = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(result["count"], 1)
self.assertEqual(result["signup_open_count"], 1)
self.assertEqual(result["signup_closed_count"], 2)
self.assertEqual(result['items'][0]['signup_open'], True)
# closed for signup
resp = c.get('/api/learningcircles/?signup=closed')
self.assertEqual(resp.status_code, 200)
result = resp.json()
self.assertEqual(result["count"], 2)
self.assertEqual(result["signup_open_count"], 1)
self.assertEqual(result["signup_closed_count"], 2)
self.assertEqual(result['items'][0]['signup_open'], False)
self.assertEqual(result['items'][1]['signup_open'], False)
def test_get_learning_cirlces_order(self):
sg = StudyGroup.objects.get(pk=1)
sg.start_date = datetime.date(2019,5,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
sg = StudyGroup.objects.get(pk=2)
sg.start_date = datetime.date(2019,5,8)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
sg = StudyGroup.objects.get(pk=3)
sg.start_date = datetime.date(2019,5,15)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
sg = StudyGroup.objects.get(pk=4)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
c = Client()
# ordered by first meeting date (asc)
resp = c.get('/api/learningcircles/?order=first_meeting_date')
result = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(result["count"], 4)
self.assertEqual(result['items'][0]['id'], 1)
self.assertEqual(result['items'][1]['id'], 2)
# ordered by last meeting date (desc)
resp = c.get('/api/learningcircles/?order=last_meeting_date')
self.assertEqual(resp.status_code, 200)
result = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(result["count"], 4)
self.assertEqual(result['items'][0]['id'], 4)
self.assertEqual(result['items'][1]['id'], 3)
def test_get_learning_circles_status_closed_completed(self):
# closed upcoming
sg = StudyGroup.objects.get(pk=1)
sg.start_date = datetime.date(2019,6,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = False
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# closed in progress
sg = StudyGroup.objects.get(pk=2)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = False
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# closed in past (should be completed status)
sg = StudyGroup.objects.get(pk=3)
sg.start_date = datetime.date(2019,4,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = False
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
# open in past (should be completed status)
sg = StudyGroup.objects.get(pk=4)
sg.start_date = datetime.date(2019,4,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.signup_open = True
sg.save()
c = Client()
resp = c.get('/api/learningcircles/')
result = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(result["count"], 4)
self.assertEqual(result["signup_open_count"], 0)
self.assertEqual(result["signup_closed_count"], 4)
self.assertEqual(result['items'][0]['status'], 'closed')
self.assertEqual(result['items'][1]['status'], 'closed')
self.assertEqual(result['items'][2]['status'], 'completed')
self.assertEqual(result['items'][3]['status'], 'completed')
def test_send_learner_surveys(self):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = datetime.date(2010, 1, 1)
sg.meeting_time = datetime.time(18, 0)
sg.end_date = sg.start_date + datetime.timedelta(weeks=6)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
data = dict(self.APPLICATION_DATA)
data['study_group'] = sg
data['email'] = '*****@*****.**'
application = Application(**data)
application.save()
accept_application(application)
data = dict(self.APPLICATION_DATA)
data['study_group'] = sg
data['email'] = '*****@*****.**'
application = Application(**data)
accept_application(application)
application.save()
mail.outbox = []
last_meeting = sg.meeting_set.active().order_by(
'meeting_date', 'meeting_time').last()
self.assertEqual(last_meeting.meeting_date, datetime.date(2010, 2, 12))
self.assertEqual(last_meeting.meeting_time, datetime.time(18))
self.assertEqual(sg.meeting_set.active().count(), 7)
self.assertEqual(sg.application_set.active().count(), 2)
# freeze time to 5 minutes before
with freeze_time("2010-02-05 17:55:34"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 0)
# 10 minutes after start
with freeze_time("2010-02-05 18:10:34"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 0)
# 25 minutes after start
with freeze_time("2010-02-05 18:25:34"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 2)
self.assertIn('*****@*****.**',
mail.outbox[0].to + mail.outbox[1].to)
self.assertIn('*****@*****.**',
mail.outbox[0].to + mail.outbox[1].to)
a1 = Application.objects.get(email=mail.outbox[0].to[0])
self.assertIn(
'https://example.net/en/studygroup/{}/survey/?learner={}'.
format(sg.uuid, a1.uuid), mail.outbox[0].body)
mail.outbox = []
# 40 minutes after start
with freeze_time("2010-02-05 18:40:34"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 0)
def test_send_final_learning_circle_report_email(self):
organizer = create_user('*****@*****.**', 'organ', 'test', '1234',
False)
facilitator = create_user('*****@*****.**', 'faci', 'test', 'password',
False)
StudyGroup.objects.filter(pk=1).update(facilitator=facilitator)
team = Team.objects.create(name='test team')
TeamMembership.objects.create(team=team,
user=organizer,
role=TeamMembership.ORGANIZER)
TeamMembership.objects.create(team=team,
user=facilitator,
role=TeamMembership.MEMBER)
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = datetime.date(2010, 1, 1)
sg.meeting_time = datetime.time(18, 0)
sg.end_date = sg.start_date + datetime.timedelta(weeks=5)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
data = dict(self.APPLICATION_DATA)
data['study_group'] = sg
data['email'] = '*****@*****.**'
application = Application(**data)
application.save()
accept_application(application)
mail.outbox = []
last_meeting = sg.meeting_set.active().order_by(
'meeting_date', 'meeting_time').last()
self.assertEqual(last_meeting.meeting_date, datetime.date(2010, 2, 5))
self.assertEqual(last_meeting.meeting_time, datetime.time(18, 0))
self.assertEqual(sg.meeting_set.active().count(), 6)
self.assertEqual(Reminder.objects.all().count(), 0)
# send time is 7 days after the last meeting
with freeze_time("2010-02-12 17:30:00"):
send_final_learning_circle_report(sg)
self.assertEqual(len(mail.outbox), 0)
# freeze time to 2 hours after send time
with freeze_time("2010-02-12 19:30:00"):
send_final_learning_circle_report(sg)
self.assertEqual(len(mail.outbox), 0)
# freeze time to 30 minutes after send time
with freeze_time("2010-02-12 18:30:00"):
send_final_learning_circle_report(sg)
self.assertIn(application.email, mail.outbox[0].bcc)
self.assertIn(facilitator.email, mail.outbox[0].bcc)
self.assertIn(organizer.email, mail.outbox[0].bcc)
self.assertEqual(len(mail.outbox[0].bcc), 3)
self.assertIn(
'{0}/en/studygroup/{1}/report/'.format(settings.DOMAIN, sg.id),
mail.outbox[0].body)
def test_send_learner_surveys(self):
now = timezone.now()
sg = StudyGroup.objects.get(pk=1)
sg.timezone = now.strftime("%Z")
sg.start_date = datetime.date(2010, 1, 1)
sg.meeting_time = datetime.time(18, 0)
sg.end_date = sg.start_date + datetime.timedelta(weeks=6)
sg.save()
sg = StudyGroup.objects.get(pk=1)
generate_all_meetings(sg)
data = dict(self.APPLICATION_DATA)
data['study_group'] = sg
data['email'] = '*****@*****.**'
application = Application(**data)
application.save()
accept_application(application)
data = dict(self.APPLICATION_DATA)
data['study_group'] = sg
data['email'] = '*****@*****.**'
application = Application(**data)
accept_application(application)
application.save()
mail.outbox = []
last_meeting = sg.meeting_set.active().order_by(
'meeting_date', 'meeting_time').last()
self.assertEqual(last_meeting.meeting_date, datetime.date(2010, 2, 12))
self.assertEqual(last_meeting.meeting_time, datetime.time(18))
self.assertEqual(sg.meeting_set.active().count(), 7)
self.assertEqual(sg.application_set.active().count(), 2)
# too soon
with freeze_time("2010-02-12 16:30:00"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 0)
# too late
with freeze_time("2010-02-12 18:30:00"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 0)
with freeze_time("2010-02-12 17:30:00"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 2)
self.assertIn('*****@*****.**',
mail.outbox[0].to + mail.outbox[1].to)
self.assertIn('*****@*****.**',
mail.outbox[0].to + mail.outbox[1].to)
a1 = Application.objects.get(email=mail.outbox[0].to[0])
self.assertIn(
'{0}/en/studygroup/{1}/survey/?learner={2}'.format(
settings.DOMAIN, sg.uuid, a1.uuid), mail.outbox[0].body)
mail.outbox = []
# way too late
with freeze_time("2010-02-13 19:00:00"):
send_learner_surveys(sg)
self.assertEqual(len(mail.outbox), 0)
def form_valid(self, form):
return_value = super().form_valid(form)
if form.date_changed and self.object.draft == False:
self.object.meeting_set.delete()
generate_all_meetings(self.object)
return return_value
def form_valid(self, form):
self.object = form.save()
generate_all_meetings(self.object)
return http.HttpResponseRedirect(self.get_success_url())
def test_get_learning_circles_by_scope(self):
sg = StudyGroup.objects.get(pk=1)
sg.start_date = datetime.date(2019,6,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
sg = StudyGroup.objects.get(pk=2)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
sg = StudyGroup.objects.get(pk=3)
sg.start_date = datetime.date(2019,5,1)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.save()
sg.refresh_from_db()
generate_all_meetings(sg)
sg = StudyGroup.objects.get(pk=4)
sg.start_date = datetime.date(2019,5,30)
sg.end_date = sg.start_date + datetime.timedelta(weeks=2)
sg.draft = True
sg.save()
c = Client()
# active scope
resp = c.get('/api/learningcircles/?scope=active&draft=true')
data = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(data["count"], 3)
self.assertEqual(data["items"][0]["id"], 1)
self.assertEqual(data["items"][1]["id"], 2)
self.assertEqual(data["items"][2]["id"], 4)
self.assertEqual(data["items"][2]["draft"], True)
# upcoming scope
resp = c.get('/api/learningcircles/?scope=upcoming&draft=true')
data = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(data["count"], 2)
self.assertEqual(data["items"][0]["id"], 1)
self.assertEqual(data["items"][1]["id"], 4)
# current scope
resp = c.get('/api/learningcircles/?scope=current')
data = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.json()["count"], 1)
self.assertEqual(data["items"][0]["id"], 2)
# completed scope
resp = c.get('/api/learningcircles/?scope=completed')
data = resp.json()
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.json()["count"], 1)
self.assertEqual(data["items"][0]["id"], 3)
