def test_str_multiple_published_speakers(self):
speaker1, _, _ = speaker_testutils.create_test_speaker(
"*****@*****.**", "Test Speaker 1")
talk = Talk.objects.create(
draft_speaker=speaker1,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=self.event,
)
speaker2, _, _ = speaker_testutils.create_test_speaker(
"*****@*****.**", "Test Speaker 2")
TalkDraftSpeaker.objects.create(talk=talk,
draft_speaker=speaker2,
order=2)
published_speaker1 = PublishedSpeaker.objects.copy_from_speaker(
speaker1, self.event)
published_speaker2 = PublishedSpeaker.objects.copy_from_speaker(
speaker2, self.event)
TalkPublishedSpeaker.objects.create(
talk=talk, published_speaker=published_speaker1, order=2)
TalkPublishedSpeaker.objects.create(
talk=talk, published_speaker=published_speaker2, order=1)
self.assertEqual(
"{}".format(talk),
"{}, {} - {}".format(published_speaker2, published_speaker1,
"Test"),
)
def test_save_checks_availability_with_confirmation(self):
event = Event.objects.current_event()
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(draft_speaker=speaker,
event=event,
title="Test talk",
spots=1)
track = Track.objects.create(name="Test track")
talk.publish(track)
user1, _ = attendee_testutils.create_test_user()
attendee1 = Attendee.objects.create(user=user1, event=event)
user2, _ = attendee_testutils.create_test_user("*****@*****.**")
attendee2 = Attendee.objects.create(user=user2, event=event)
form = TalkAddReservationForm(attendee=attendee1, talk=talk, data={})
form.full_clean()
reservation1 = form.save()
self.assertFalse(reservation1.is_waiting)
self.assertFalse(reservation1.is_confirmed)
reservation1.is_confirmed = True
reservation1.save()
form = TalkAddReservationForm(attendee=attendee2, talk=talk, data={})
form.full_clean()
reservation2 = form.save()
self.assertTrue(reservation2.is_waiting)
self.assertFalse(reservation2.is_confirmed)
def test_save(self):
talk_format = TalkFormat.objects.create(name="A Talk", duration=60)
event = Event.objects.create(title="Test event",
slug="test_event",
start_time=now(),
end_time=now())
event.talkform = talk_format
speaker, _, password = speaker_testutils.create_test_speaker()
form = CreateTalkForm(
initial={
"draft_speaker": speaker,
"event": event
},
data={
"draft_speaker": speaker.id,
"event": event.id,
"title": "Test",
"abstract": "Test abstract",
"remarks": "Test remarks",
"talkformat": [talk_format.id],
},
)
talk = form.save(commit=False)
self.assertIsInstance(talk, Talk)
self.assertEqual(talk.draft_speaker, speaker)
def test_str_multiple_draft_speakers(self):
speaker1, _, _ = speaker_testutils.create_test_speaker(
"*****@*****.**", "Test Speaker 1")
talk = Talk.objects.create(
draft_speaker=speaker1,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=self.event,
)
speaker2, _, _ = speaker_testutils.create_test_speaker(
"*****@*****.**", "Test Speaker 2")
TalkDraftSpeaker.objects.create(talk=talk,
draft_speaker=speaker2,
order=2)
self.assertEqual("{}".format(talk),
"{}, {} - {}".format(speaker1, speaker2, "Test"))
def test_send_confirmation_mails_to_remaining_attendees(self):
request = RequestFactory().request()
request.user = self.attendee.user
SessionReservation.objects.create(
talk=self.talk, attendee=self.attendee, is_confirmed=False, is_waiting=False
)
speaker, _, _ = speaker_testutils.create_test_speaker(
email="*****@*****.**", name="Test Speaker 2"
)
talk2 = Talk.objects.create(
event=self.event, title="Test talk 2", draft_speaker=speaker, spots=2
)
track = Track.objects.create(event=self.event, name="Test track 2")
self.talk.publish(track)
SessionReservation.objects.create(
talk=talk2, attendee=self.attendee, is_confirmed=False, is_waiting=False
)
attendence_cancelled.send(
self.__class__, attendee=self.attendee, request=request
)
# no mails sent if there are no pending reservations
self.assertEqual(len(mail.outbox), 0)
# register 2nd attendee with waiting reservations for both talks
user2, _ = attendee_testutils.create_test_user("*****@*****.**")
attendee2 = Attendee.objects.create(user=user2, event=self.event)
reservation = SessionReservation.objects.create(
talk=self.talk, attendee=attendee2, is_confirmed=False, is_waiting=True
)
reservation2 = SessionReservation.objects.create(
talk=talk2, attendee=attendee2, is_confirmed=False, is_waiting=True
)
user3, _ = attendee_testutils.create_test_user("*****@*****.**")
attendee3 = Attendee.objects.create(user=user3, event=self.event)
reservation3 = SessionReservation.objects.create(
talk=talk2, attendee=attendee3, is_confirmed=False, is_waiting=True
)
attendence_cancelled.send(
self.__class__, attendee=self.attendee, request=request
)
# mails sent to waiting attendee
self.assertEqual(len(mail.outbox), 2)
self.assertIn(attendee2.user.email, mail.outbox[0].recipients())
self.assertEqual(len(mail.outbox[0].recipients()), 1)
self.assertIn(attendee2.user.email, mail.outbox[1].recipients())
self.assertEqual(len(mail.outbox[1].recipients()), 1)
reservation.refresh_from_db()
self.assertFalse(reservation.is_waiting)
reservation2.refresh_from_db()
self.assertFalse(reservation2.is_waiting)
reservation3.refresh_from_db()
self.assertTrue(reservation3.is_waiting)
def setUp(self):
event = event_testutils.create_test_event()
speaker, _, _ = speaker_testutils.create_test_speaker()
self.talk = Talk.objects.create(draft_speaker=speaker,
event=event,
title="Test Talk")
track = Track.objects.create(name="Test Track")
self.talk.publish(track)
user, _ = attendee_testutils.create_test_user()
self.attendee = Attendee.objects.create(event=event, user=user)
def test_remove_draft_speaker_if_second_draft_speaker_exists(self):
talk_id = self.talk.id
second_speaker, _, _ = speaker_testutils.create_test_speaker(
"*****@*****.**", "Test Speaker 2")
TalkDraftSpeaker.objects.create(talk=self.talk,
draft_speaker=second_speaker,
order=2)
self.assertEqual(self.talk.draft_speakers.count(), 2)
self.talk.draft_speakers.remove(self.speaker)
self.assertTrue(Talk.objects.filter(id=talk_id).exists())
self.assertEqual(self.talk.draft_speakers.count(), 1)
def setUp(self):
self.event = Event.objects.current_event()
speaker, _, _ = speaker_testutils.create_test_speaker()
self.talk = Talk.objects.create(
event=self.event, title="Test talk", draft_speaker=speaker, spots=2
)
track = Track.objects.create(event=self.event, name="Test track")
self.talk.publish(track)
user, _ = attendee_testutils.create_test_user()
self.attendee = Attendee.objects.create(user=user, event=self.event)
def setUp(self) -> None:
self.speaker, _, _ = speaker_testutils.create_test_speaker()
self.event = create_test_event()
self.talk = Talk.objects.create(
draft_speaker=self.speaker,
event=self.event,
title="An important message",
abstract="A talk",
remarks="",
)
self.assertTrue(
TalkDraftSpeaker.objects.filter(talk_id=self.talk.id).exists())
def setUp(self):
event = create_test_event()
speaker, _, _ = speaker_testutils.create_test_speaker()
self.talk = Talk.objects.create(
draft_speaker=speaker,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=event,
)
self.test_user, _ = attendee_testutils.create_test_user()
self.attendee = Attendee.objects.create(user=self.test_user, event=event)
def test___str__(self):
event = create_test_event()
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(
draft_speaker=speaker, title="Test", abstract="Test abstract", event=event
)
room = Room.objects.create(name="Test Room", event=event)
time_slot = TimeSlot.objects.create(name="Morning", event=event)
talk_slot = TalkSlot.objects.create(room=room, time=time_slot, talk=talk)
self.assertEqual(
str(talk_slot), "{} {} ({})".format(room, time_slot.name, event)
)
def test_reservable_sessions_false_if_no_talks_with_spots(self):
self.event.sessions_published = True
self.event.save()
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = talk_testutils.create_test_talk(speaker=speaker,
event=self.event,
title="Test talk",
spots=0)
track = Track.objects.create(name="Test track")
talk.publish(track)
response = self.client.get("/")
self.assertFalse(response.context["reservable_sessions"])
def test_talkslot_admin_add(self):
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(
draft_speaker=speaker,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=self.event,
)
track = Track.objects.filter(event=self.event).first()
talk.publish(track)
response = self.client.get(reverse("admin:talk_talkslot_add"))
self.assertEquals(response.status_code, 200)
self.assertIn("form", response.context)
self.assertIsInstance(response.context["form"], AddTalkSlotFormStep1)
self.assertTemplateUsed("talk/admin/talkslot_add_form.html")
response = self.client.post(
reverse("admin:talk_talkslot_add"),
{
"add_talk_slot_view-current_step": "0",
"0-event": str(self.event.pk),
"submit": "Submit",
},
)
self.assertEquals(response.status_code, 200)
self.assertIn("form", response.context)
self.assertIsInstance(response.context["form"], AddTalkSlotFormStep2)
self.assertTemplateUsed("talk/admin/talkslot_add_form.html")
time_slot = TimeSlot.objects.filter(event=self.event).first()
room = Room.objects.filter(event=self.event).first()
response = self.client.post(
reverse("admin:talk_talkslot_add"),
{
"add_talk_slot_view-current_step": "1",
"1-talk": str(talk.pk),
"1-time": str(time_slot.pk),
"1-room": str(room.pk),
"submit": "Submit",
},
)
self.assertRedirects(response,
reverse("admin:talk_talkslot_changelist"))
talk_slot = TalkSlot.objects.filter(talk=talk).get()
self.assertEquals(talk_slot.talk_id, talk.id)
self.assertEquals(talk_slot.room_id, room.id)
self.assertEquals(talk_slot.time_id, time_slot.id)
def test_reservable_sessions_true_if_talks_with_spots(self):
self.event.sessions_published = True
self.event.start_time = timezone.now() + timedelta(hours=1)
self.event.end_time = timezone.now() + timedelta(hours=2)
self.event.save()
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = talk_testutils.create_test_talk(speaker=speaker,
event=self.event,
title="Test talk",
spots=10)
track = Track.objects.create(name="Test track")
talk.publish(track)
response = self.client.get("/")
self.assertTrue(response.context["reservable_sessions"])
def test_remove_published_speaker_with_second_speaker(self):
self.talk.draft_speakers.clear()
speaker2, _, _ = speaker_testutils.create_test_speaker(
"*****@*****.**", "Test speaker 2")
published_speaker2 = PublishedSpeaker.objects.copy_from_speaker(
speaker2, self.event)
TalkPublishedSpeaker.objects.create(
talk=self.talk, published_speaker=published_speaker2, order=2)
talk_id = self.talk.id
published_speaker_id = self.published_speaker.id
self.talk.published_speakers.remove(self.published_speaker)
self.assertTrue(Talk.objects.filter(id=talk_id).exists())
self.assertFalse(
TalkPublishedSpeaker.objects.filter(
published_speaker_id=published_speaker_id).exists())
def setUp(self):
event = create_test_event()
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(
draft_speaker=speaker,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=event,
)
track = Track.objects.create(name="Test")
talk.publish(track=track)
user, _ = attendee_testutils.create_test_user()
attendee = Attendee.objects.create(user=user, event=event)
self.reservation = SessionReservation.objects.create(talk=talk,
attendee=attendee)
def setUpTestData(cls):
cls.event = event_testutils.create_test_event(title="Test event")
user1, _ = attendee_testutils.create_test_user("*****@*****.**")
user2, _ = attendee_testutils.create_test_user("*****@*****.**")
cls.attendees = [
Attendee.objects.create(user=user1, event=cls.event),
Attendee.objects.create(user=user2, event=cls.event),
]
speaker, _, _ = speaker_testutils.create_test_speaker()
cls.talk = Talk.objects.create(
draft_speaker=speaker, event=cls.event, title="Test Talk"
)
track = Track.objects.create(name="Test Track")
cls.talk.publish(track)
cls.feedback = AttendeeFeedback.objects.create(
talk=cls.talk, attendee=cls.attendees[0], score=4, comment="Nice try"
)
def setUp(self):
self.event = event_testutils.create_test_event(submission_open=False)
self.speaker, _, _ = speaker_testutils.create_test_speaker()
with open(
os.path.join(os.path.dirname(__file__), 'mu_at_mil_house.jpg'),
'rb') as image:
self.speaker.portrait.save(os.path.basename(image.name), image)
self.published_speaker = PublishedSpeaker.objects.copy_from_speaker(
self.speaker, self.event)
self.track = Track.objects.create(event=self.event, name='Track 1')
self.talk = Talk.objects.create(
published_speaker=self.published_speaker,
title='Something important',
abstract='I have something important to say',
track=self.track,
event=self.event)
self.url = '/{}/speaker/{}/'.format(self.event.slug,
self.published_speaker.slug)
def test_save_without_commit(self):
talk_format = TalkFormat.objects.create(name="A Talk", duration=90)
event = event_testutils.create_test_event()
event.talkformat.add(talk_format)
speaker, _, _ = speaker_testutils.create_test_speaker()
form = CreateTalkForm(
draft_speaker=speaker,
initial={"event": event},
data={
"event": event.id,
"title": "Test",
"abstract": "Test abstract",
"remarks": "Test remarks",
"talkformat": [talk_format.id],
},
)
talk = form.save(commit=False)
self.assertIsInstance(talk, Talk)
self.assertEqual(TalkDraftSpeaker.objects.filter(talk=talk).count(), 0)
def test_get_queryset_with_talks(self):
track = Track.objects.create(name="Hollow talk")
dummy_speaker, _, _ = speaker_testutils.create_test_speaker()
talk1 = Talk.objects.create(
draft_speaker=dummy_speaker,
title="Talk 1",
abstract="Abstract 1",
event=self.event,
track=track,
)
TalkPublishedSpeaker.objects.create(talk=talk1,
published_speaker=self.speakers[0],
order=1)
talk1.draft_speakers.clear()
talk2 = Talk.objects.create(
draft_speaker=dummy_speaker,
title="Talk 2",
abstract="Abstract 2",
event=self.event,
track=track,
)
TalkPublishedSpeaker.objects.create(talk=talk2,
published_speaker=self.speakers[0],
order=1)
talk2.draft_speakers.clear()
talk3 = Talk.objects.create(
draft_speaker=dummy_speaker,
title="Talk 3",
abstract="Abstract 3",
event=self.event,
track=track,
)
TalkPublishedSpeaker.objects.create(talk=talk3,
published_speaker=self.speakers[1],
order=1)
talk3.draft_speakers.clear()
dummy_speaker.delete()
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
speaker_list = response.context["publishedspeaker_list"]
self.assertEqual(len(speaker_list), 2)
self.assertIn(self.speakers[0], speaker_list)
self.assertIn(self.speakers[1], speaker_list)
def setUp(self):
self.event = event_testutils.create_test_event(submission_open=False)
self.speaker, _, _ = speaker_testutils.create_test_speaker()
with open(
os.path.join(os.path.dirname(__file__), "mu_at_mil_house.jpg"),
"rb") as image:
self.speaker.portrait.save(os.path.basename(image.name), image)
self.published_speaker = PublishedSpeaker.objects.copy_from_speaker(
self.speaker, self.event)
self.track = Track.objects.create(event=self.event, name="Track 1")
self.talk = Talk.objects.create(
draft_speaker=self.speaker,
title="Something important",
abstract="I have something important to say",
track=self.track,
event=self.event,
)
TalkPublishedSpeaker.objects.create(
talk=self.talk, published_speaker=self.published_speaker, order=1)
self.url = "/{}/speaker/{}/".format(self.event.slug,
self.published_speaker.slug)
def test_talk_admin_publish_apply(self):
tracks = Track.objects.filter(event=self.event)
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(
draft_speaker=speaker,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=self.event,
)
response = self.client.post(
reverse("admin:talk_talk_changelist"),
{
"action": "publish_talks",
"apply": "Submit",
"_selected_action": [str(talk.pk)],
"selected_track-{}".format(talk.pk): "",
},
)
self.assertRedirects(response, reverse("admin:talk_talk_changelist"))
talk = Talk.objects.get(pk=talk.pk)
self.assertIsNone(talk.track_id)
self.assertFalse(talk.published_speakers.exists())
response = self.client.post(
reverse("admin:talk_talk_changelist"),
{
"action": "publish_talks",
"apply": "Submit",
"_selected_action": [str(talk.pk)],
"selected_track-{}".format(talk.pk): str(tracks[0].pk),
},
)
self.assertRedirects(response, reverse("admin:talk_talk_changelist"))
talk = Talk.objects.get(pk=talk.pk)
self.assertEqual(talk.track, tracks[0])
self.assertTrue(talk.published_speakers.exists())
def test_session_reservation_admin(self):
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(
draft_speaker=speaker,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=self.event,
)
track = Track.objects.filter(event=self.event).first()
talk.publish(track)
user, _ = attendee_testutils.create_test_user("*****@*****.**")
attendee = Attendee.objects.create(user=user, event=self.event)
SessionReservation.objects.create(attendee=attendee, talk=talk)
response = self.client.get(reverse("admin:talk_sessionreservation_changelist"))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.context["cl"].result_count, 1, "should list 1 session registration"
)
self.assertTrue(response.is_rendered)
def test_is_committee_member_is_false_for_speaker(self):
speaker, user, password = speaker_testutils.create_test_speaker()
self.client.login(username=user.email, password=password)
response = self.client.get("/")
self.assertFalse(response.context["is_committee_member"])
def test_parse_speaker(self):
_, user, password = speaker_testutils.create_test_speaker()
self.client.login(username=user.email, password=password)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "base.html")
def test_talk_admin_process_waiting_list(self):
event = Event.objects.current_event()
attendees = []
for a in range(3):
user, _ = attendee_testutils.create_test_user(
"test{}@example.org".format(a)
)
attendees.append(Attendee.objects.create(event=event, user=user))
track = Track.objects.create(event=event, name="Test Track")
speaker, _, _ = speaker_testutils.create_test_speaker()
talk = Talk.objects.create(
draft_speaker=speaker,
title="Test",
abstract="Test abstract",
remarks="Test remarks",
event=event,
spots=2,
)
talk.publish(track)
reservations = [
SessionReservation.objects.create(
attendee_id=attendees[0].id,
talk=talk,
is_confirmed=True,
is_waiting=False,
created=timezone.now() - timedelta(minutes=10),
),
SessionReservation.objects.create(
attendee_id=attendees[1].id,
talk=talk,
is_confirmed=False,
is_waiting=True,
created=timezone.now() - timedelta(minutes=3),
),
SessionReservation.objects.create(
attendee_id=attendees[2].id,
talk=talk,
is_confirmed=False,
is_waiting=True,
created=timezone.now() - timedelta(minutes=5),
),
]
response = self.client.post(
reverse("admin:talk_talk_changelist"),
{"action": "process_waiting_list", "_selected_action": [talk.pk]},
)
self.assertRedirects(response, reverse("admin:talk_talk_changelist"))
reservations[1].refresh_from_db()
self.assertTrue(reservations[1].is_waiting)
reservations[2].refresh_from_db()
self.assertFalse(reservations[2].is_waiting)
self.assertEqual(len(mail.outbox), 1)
self.assertIn(reservations[2].attendee.user.email, mail.outbox[0].recipients())
mail.outbox.clear()
reservations[2].is_confirmed = True
reservations[2].save()
response = self.client.post(
reverse("admin:talk_talk_changelist"),
{"action": "process_waiting_list", "_selected_action": [talk.pk]},
)
self.assertRedirects(response, reverse("admin:talk_talk_changelist"))
reservations[1].refresh_from_db()
self.assertTrue(reservations[1].is_waiting)
self.assertEqual(len(mail.outbox), 0)
