def testPostponementOccurenceLast(self):
request = RequestFactory().get("/test")
request.user = self.user
request.session = {}
event = RecurringEventPage(owner=self.user,
slug="breakfast3",
title="Breakfast-in-bed",
repeat=Recurrence(dtstart=dt.date(
2008, 2, 1),
until=dt.date(2008, 5, 9),
freq=WEEKLY,
byweekday=[SA, SU]),
time_from=dt.time(8),
time_to=dt.time(9))
self.calendar.add_child(instance=event)
postponement = PostponementPage(
owner=self.user,
overrides=event,
except_date=dt.date(2008, 5, 3),
postponement_title="Breakfast in Bed owed from May",
date=dt.date(2008, 5, 24),
time_from=dt.time(8),
time_to=dt.time(9))
event.add_child(instance=postponement)
self.assertIsNone(event.status)
self.assertEqual(
event._nextOn(request),
'<a class="inline-link" href="/events/breakfast3/2008-05-03-postponement/">Saturday 24th of May at 8am</a>'
)
class TestTZ(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(1989, 1, 1),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13, 30),
time_to=dt.time(16),
tz=pytz.timezone("US/Eastern"))
self.calendar.add_child(instance=self.event)
self.cancellation = CancellationPage(
owner=self.user,
overrides=self.event,
except_date=dt.date(1989, 2, 1),
cancellation_title="Meeting Cancelled",
cancellation_details="Cancelled due to lack of interest")
self.event.add_child(instance=self.cancellation)
self.cancellation.save_revision().publish()
@timezone.override("Australia/Sydney")
@freeze_timetz("1989-02-02T06:00:00+11:00")
def testCurrentLocalDt(self):
when = self.cancellation._current_datetime_from
self.assertEqual(when.tzinfo.zone, "Australia/Sydney")
self.assertEqual(when.time(), dt.time(5, 30))
self.assertEqual(when.date(), dt.date(1989, 2, 2))
@timezone.override("Australia/Sydney")
@freeze_timetz("1989-02-02T06:00:00+11:00")
def testFutureLocalDt(self):
when = self.cancellation._future_datetime_from
self.assertIsNone(when)
@timezone.override("Australia/Sydney")
def testPastLocalDt(self):
when = self.cancellation._past_datetime_from
self.assertEqual(when.tzinfo.zone, "Australia/Sydney")
self.assertEqual(when.time(), dt.time(5, 30))
self.assertEqual(when.date(), dt.date(1989, 2, 2))
@timezone.override("Australia/Sydney")
@freeze_timetz("1989-10-01T21:00:00+11:00")
def testCopyFieldsFromParent(self):
self.assertEqual(self.event.next_date, dt.date(1989, 10, 3))
cancellation = CancellationPage(owner=self.user)
cancellation._copyFieldsFromParent(self.event)
self.assertEqual(cancellation.overrides, self.event)
self.assertEqual(cancellation.except_date, dt.date(1989, 10, 2))
class TestPostponementTZ(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('j', '*****@*****.**', 's3(r3t')
self.calendar = GeneralCalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(1990, 1, 1),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13, 30),
time_to=dt.time(16),
tz=pytz.timezone("US/Eastern"))
self.calendar.add_child(instance=self.event)
self.postponement = PostponementPage(
owner=self.user,
overrides=self.event,
postponement_title="Delayed Meeting",
except_date=dt.date(1990, 10, 10),
date=dt.date(1990, 10, 11),
time_from=dt.time(13),
time_to=dt.time(16, 30))
self.event.add_child(instance=self.postponement)
self.postponement.save_revision().publish()
@timezone.override("Pacific/Auckland")
def testLocalTitle(self):
self.assertEqual(self.postponement.title,
"Postponement for Wednesday 10th of October 1990")
self.assertEqual(self.postponement.localTitle,
"Postponement for Thursday 11th of October 1990")
@timezone.override("Asia/Colombo")
def testGetEventsByDay(self):
events = PostponementPage.events.byDay(dt.date(1990, 10, 1),
dt.date(1990, 10, 31))
self.assertEqual(len(events), 31)
evod0 = events[10]
self.assertEqual(evod0.date, dt.date(1990, 10, 11))
self.assertEqual(len(evod0.days_events), 1)
self.assertEqual(len(evod0.continuing_events), 0)
title, page = evod0.days_events[0]
self.assertEqual(title, "Delayed Meeting")
self.assertIs(type(page), PostponementPage)
evod1 = events[11]
self.assertEqual(evod1.date, dt.date(1990, 10, 12))
self.assertEqual(len(evod1.days_events), 0)
self.assertEqual(len(evod1.continuing_events), 1)
title, page = evod1.continuing_events[0]
self.assertEqual(title, "Delayed Meeting")
self.assertIs(type(page), PostponementPage)
def testWhenEver(self):
event = RecurringEventPage(slug="XYZ",
title="Xylophone yacht zombies",
repeat=Recurrence(dtstart=dt.date(
1989, 1, 1),
freq=WEEKLY,
byweekday=[FR]),
time_from=dt.time(19))
self.calendar.add_child(instance=event)
cancellation = CancellationPage(owner=self.user,
overrides=event,
except_date=dt.date(1989, 3, 10),
cancellation_title="Cancelled")
event.add_child(instance=cancellation)
cancellation.save_revision().publish()
self.assertEqual(cancellation.when, "Friday 10th of March 1989 at 7pm")
class TestNoCalendar(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3cr3t')
self.request = RequestFactory().get("/test")
self.request.user = self.user
self.request.session = {}
self.request.site = Site.objects.get(is_default_site=True)
self.group = GroupPage(slug="initech", title="Initech Corporation")
self.home.add_child(instance=self.group)
self.standup = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(2013, 1, 1),
until=dt.date(2013, 5, 31),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13, 30),
time_to=dt.time(16),
uid="initiative+technology")
self.group.add_child(instance=self.standup)
self.postponement = PostponementPage(
owner=self.user,
slug="2013-01-09-postponement",
title="Postponement for Wednesday 16th of October",
overrides=self.standup,
except_date=dt.date(2013, 1, 16),
cancellation_title="Meeting Postponed",
cancellation_details=
"The meeting has been postponed until tomorrow",
postponement_title="A Meeting",
date=dt.date(2013, 1, 17),
time_from=dt.time(13),
time_to=dt.time(16, 30),
details="Yes a test meeting on a Thursday")
self.standup.add_child(instance=self.postponement)
def testGetAllEventsByDay(self):
events = getAllEventsByDay(self.request, dt.date(2013, 1, 1),
dt.date(2013, 1, 31))
self.assertEqual(len(events), 31)
evod2 = events[1]
self.assertEqual(evod2.date, dt.date(2013, 1, 2))
self.assertEqual(len(evod2.all_events), 1)
self.assertEqual(len(evod2.continuing_events), 0)
self.assertEqual(len(evod2.days_events), 1)
class TestPageFormDeutsche(TestCase):
Form = ExtraInfoPage.get_edit_handler().get_form_class()
def setUp(self):
translation.activate('de')
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner = self.user,
slug = "ereignisse",
title = "Ereignisse")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug = "meeting",
title = "Testen Sie Meeting",
repeat = Recurrence(dtstart=dt.date(1988,1,1),
freq=WEEKLY,
byweekday=[MO,WE,FR]),
time_from = dt.time(13),
time_to = dt.time(15,30))
self.calendar.add_child(instance=self.event)
self.info = ExtraInfoPage(owner = self.user,
overrides = self.event,
except_date = dt.date(1999,1,5),
extra_title = "Freitag",
extra_information = "Besonderer Freitag")
self.event.add_child(instance=self.info)
self.info.save_revision().publish()
def tearDown(self):
translation.deactivate()
def testExceptionAlreadyExists(self):
page = ExtraInfoPage(owner=self.user)
form = self.Form({'overrides': self.event,
'except_date': "1999-01-05",
'extra_title': "Es ist Freitag",
'extra_information': rich_text("Besonderer spezieller Freitag")},
instance=page,
parent_page=self.event)
self.assertFalse(form.is_valid())
self.assertDictEqual(form.errors,
{'except_date': ['Dieses Datum enthält bereits zusätzliche information']})
def testLastOccurenceCancelledStatus(self):
event = RecurringEventPage(owner=self.user,
slug="breakfast2",
title="Breakfast-in-bed",
repeat=Recurrence(dtstart=dt.date(
2008, 2, 1),
until=dt.date(2008, 5, 9),
freq=WEEKLY,
byweekday=[SA, SU]),
time_from=dt.time(8),
time_to=dt.time(9))
self.calendar.add_child(instance=event)
cancellation = CancellationPage(
owner=self.user,
overrides=event,
except_date=dt.date(2008, 5, 4),
cancellation_title="Fire in the kitchen",
cancellation_details="The bacon fat is burning")
event.add_child(instance=cancellation)
self.assertEqual(event.status, "finished")
class TestPageForm(TestCase):
Form = ExtraInfoPage.get_edit_handler().get_form_class()
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner = self.user,
slug = "events",
title = "Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug = "test-meeting",
title = "Test Meeting",
repeat = Recurrence(dtstart=dt.date(1988,1,1),
freq=WEEKLY,
byweekday=[MO,WE,FR]),
time_from = dt.time(13),
time_to = dt.time(15,30))
self.calendar.add_child(instance=self.event)
self.info = ExtraInfoPage(owner = self.user,
overrides = self.event,
except_date = dt.date(1999,1,5),
extra_title = "Fri-day",
extra_information = "Special Friday")
self.event.add_child(instance=self.info)
self.info.save_revision().publish()
def testExceptionAlreadyExists(self):
page = ExtraInfoPage(owner=self.user)
form = self.Form({'overrides': self.event,
'except_date': "1999-01-05",
'extra_title': "It's Friday",
'extra_information': rich_text("Special Special Friday")},
instance=page,
parent_page=self.event)
self.assertFalse(form.is_valid())
self.assertDictEqual(form.errors,
{'except_date': ['That date already has extra information']})
def testGetGroupUpcomingEvents(self):
meeting = RecurringEventPage(owner = self.user,
slug = "plan-plan",
title = "Planning to Plan",
repeat = Recurrence(dtstart=dt.date(2018,5,1),
freq=WEEKLY,
byweekday=[TU]),
time_from = dt.time(18,30),
time_to = dt.time(20),
group_page = self.group)
self.calendar.add_child(instance=meeting)
memo = ExtraInfoPage(owner = self.user,
slug = "plan-plan-extra-info",
title = "Extra Information Planning to Plan",
overrides = meeting,
except_date = meeting.next_date,
extra_title = "Gap Analysis",
extra_information = "Analyse your gaps")
meeting.add_child(instance=memo)
events = getGroupUpcomingEvents(self.request, self.group)
self.assertEqual(len(events), 2)
self.assertEqual(events[0].title, "Gap Analysis")
self.assertEqual(events[1].title, "Planning to Plan")
class TestGetEvents(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3cr3t')
self.request = RequestFactory().get("/test")
self.request.user = self.user
self.request.session = {}
self.calendar = GeneralCalendarPage(owner = self.user,
slug = "events",
title = "Events")
self.home.add_child(instance=self.calendar)
self.group = GroupPage(slug = "initech", title = "Initech Corporation")
self.home.add_child(instance=self.group)
self.show = SimpleEventPage(owner = self.user,
slug = "pet-show",
title = "Pet Show",
date = dt.date(2013,1,5),
time_from = dt.time(11),
time_to = dt.time(17,30))
self.calendar.add_child(instance=self.show)
self.party = MultidayEventPage(owner = self.user,
slug = "allnighter",
title = "All Night",
date_from = dt.date(2012,12,31),
date_to = dt.date(2013,1,1),
time_from = dt.time(23),
time_to = dt.time(3))
self.calendar.add_child(instance=self.party)
self.standup = RecurringEventPage(slug = "test-meeting",
title = "Test Meeting",
repeat = Recurrence(dtstart=dt.date(2013,1,1),
until=dt.date(2013,5,31),
freq=WEEKLY,
byweekday=[MO,WE,FR]),
time_from = dt.time(13,30),
time_to = dt.time(16))
self.group.add_child(instance=self.standup)
self.postponement = PostponementPage(owner = self.user,
slug = "2013-01-09-postponement",
title = "Postponement for Wednesday 16th of October",
overrides = self.standup,
except_date = dt.date(2013,1,16),
cancellation_title = "Meeting Postponed",
cancellation_details =
"The meeting has been postponed until tomorrow",
postponement_title = "A Meeting",
date = dt.date(2013,1,17),
time_from = dt.time(13),
time_to = dt.time(16,30),
details = "Yes a test meeting on a Thursday")
self.standup.add_child(instance=self.postponement)
def testGetAllEventsByDay(self):
events = getAllEventsByDay(self.request, dt.date(2013,1,1), dt.date(2013,1,31))
self.assertEqual(len(events), 31)
evod = events[0]
self.assertEqual(evod.date, dt.date(2013,1,1))
self.assertEqual(len(evod.all_events), 1)
self.assertEqual(len(evod.days_events), 0)
self.assertEqual(len(evod.continuing_events), 1)
def testGetAllEventsByWeek(self):
weeks = getAllEventsByWeek(self.request, 2013, 1)
self.assertEqual(len(weeks), 5)
self.assertIsNone(weeks[0][0])
self.assertIsNone(weeks[0][1])
self.assertIsNone(weeks[4][5])
self.assertIsNone(weeks[4][6])
evod = weeks[2][4]
self.assertEqual(evod.date, dt.date(2013,1,17))
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
def testGetAllUpcomingEvents(self):
today = timezone.localdate()
futureEvent = MultidayEventPage(owner = self.user,
slug = "tomorrow",
title = "Tomorrow's Event",
date_from = today + dt.timedelta(days=1),
date_to = today + dt.timedelta(days=3),
time_from = dt.time(17),
time_to = dt.time(10,30))
self.calendar.add_child(instance=futureEvent)
events = getAllUpcomingEvents(self.request, home=self.home)
self.assertEqual(len(events), 1)
title, event = events[0]
self.assertEqual(title, "Tomorrow's Event")
self.assertEqual(event.slug, "tomorrow")
events0 = getAllUpcomingEvents(self.request)
self.assertEqual(len(events0), 1)
def testGetAllPastEvents(self):
events = getAllPastEvents(self.request)
self.assertEqual(len(events), 4)
self.assertEqual(events[0].title, "Test Meeting")
self.assertEqual(events[1].title, "A Meeting")
self.assertEqual(events[2].title, "Pet Show")
self.assertEqual(events[3].title, "All Night")
def testGetGroupUpcomingEvents(self):
meeting = RecurringEventPage(owner = self.user,
slug = "plan-plan",
title = "Planning to Plan",
repeat = Recurrence(dtstart=dt.date(2018,5,1),
freq=WEEKLY,
byweekday=[TU]),
time_from = dt.time(18,30),
time_to = dt.time(20),
group_page = self.group)
self.calendar.add_child(instance=meeting)
memo = ExtraInfoPage(owner = self.user,
slug = "plan-plan-extra-info",
title = "Extra Information Planning to Plan",
overrides = meeting,
except_date = meeting.next_date,
extra_title = "Gap Analysis",
extra_information = "Analyse your gaps")
meeting.add_child(instance=memo)
events = getGroupUpcomingEvents(self.request, self.group)
self.assertEqual(len(events), 2)
self.assertEqual(events[0].title, "Gap Analysis")
self.assertEqual(events[1].title, "Planning to Plan")
class TestPostponement(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('j', '*****@*****.**', 's3(r3t')
self.request = RequestFactory().get("/test")
self.request.user = self.user
self.request.session = {}
self.calendar = GeneralCalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(1990, 1, 1),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13, 30),
time_to=dt.time(16))
self.calendar.add_child(instance=self.event)
self.postponement = PostponementPage(
owner=self.user,
overrides=self.event,
except_date=dt.date(1990, 10, 10),
cancellation_title="Meeting Postponed",
cancellation_details=
"The meeting has been postponed until tomorrow",
postponement_title="A Meeting",
date=dt.date(1990, 10, 11),
time_from=dt.time(13),
time_to=dt.time(16, 30),
details="Yes a test meeting on a Thursday")
self.event.add_child(instance=self.postponement)
self.postponement.save_revision().publish()
def testGetEventsByDay(self):
events = RecurringEventPage.events.byDay(dt.date(1990, 10, 1),
dt.date(1990, 10, 31))
self.assertEqual(len(events), 31)
evod = events[9]
self.assertEqual(evod.date, dt.date(1990, 10, 10))
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
title, page = evod.days_events[0]
self.assertEqual(title, "Meeting Postponed")
self.assertIs(type(page), CancellationPage)
self.assertIs(type(page.postponementpage), PostponementPage)
events = PostponementPage.events.byDay(dt.date(1990, 10, 1),
dt.date(1990, 10, 31))
self.assertEqual(len(events), 31)
evod = events[10]
self.assertEqual(evod.date, dt.date(1990, 10, 11))
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
title, page = evod.days_events[0]
self.assertEqual(title, "A Meeting")
self.assertIs(type(page), PostponementPage)
def testStatus(self):
self.assertEqual(self.postponement.status, "finished")
self.assertEqual(self.postponement.status_text,
"This event has finished.")
now = timezone.localtime()
myday = now.date() + dt.timedelta(1)
friday = myday + dt.timedelta(days=(4 - myday.weekday()) % 7)
futureEvent = PostponementPage(
owner=self.user,
overrides=self.event,
except_date=friday,
cancellation_title="",
cancellation_details="",
postponement_title="Tuesday Meeting",
date=friday + dt.timedelta(days=4),
time_from=dt.time(13, 30),
time_to=dt.time(16),
details="The meeting postponed from last Friday")
self.event.add_child(instance=futureEvent)
self.assertIsNone(futureEvent.status)
self.assertEqual(futureEvent.status_text, "")
def testWhen(self):
self.assertEqual(self.postponement.when,
"Thursday 11th of October 1990 at 1pm to 4:30pm")
def testAt(self):
self.assertEqual(self.postponement.at.strip(), "1pm")
nextDate = self.event.next_date
newDate = nextDate + dt.timedelta(1)
reschedule = PostponementPage(
owner=self.user,
overrides=self.event,
except_date=nextDate,
cancellation_title="",
cancellation_details="",
postponement_title="Early Meeting",
date=newDate,
time_from=dt.time(8, 30),
time_to=dt.time(11),
details="The meeting will be held early tomorrow")
self.event.add_child(instance=reschedule)
nextOn = self.event._nextOn(self.request)
url = "/events/test-meeting/{}-postponement/".format(nextDate)
self.assertEqual(nextOn[:76],
'<a class="inline-link" href="{}">'.format(url))
self.assertEqual(nextOn[-4:], '</a>')
parts = nextOn[76:-4].split()
self.assertEqual(len(parts), 6)
self.assertEqual(parts[0], "{:%A}".format(newDate))
self.assertEqual(int(parts[1][:-2]), newDate.day)
self.assertIn(parts[1][-2:], ["st", "nd", "rd", "th"])
self.assertEqual(parts[2], "of")
self.assertEqual(parts[3], "{:%B}".format(newDate))
self.assertEqual(parts[4], "at")
self.assertEqual(parts[5], "8:30am")
class Test(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3cr3t')
self.request = RequestFactory().get("/test")
self.request.user = self.user
self.request.session = {}
self.calendar = GeneralCalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.group = GroupPage(slug="initech", title="Initech Corporation")
self.home.add_child(instance=self.group)
self.show = SimpleEventPage(owner=self.user,
slug="pet-show",
title="Pet Show",
date=dt.date(2013, 1, 5),
time_from=dt.time(11),
time_to=dt.time(17, 30),
uid="29daefed-fed1-4e47-9408-43ec9b06a06d")
self.calendar.add_child(instance=self.show)
GROUPS = PageViewRestriction.GROUPS
self.friends = Group.objects.create(name="Friends")
self.rendezvous = SimpleEventPage(
owner=self.user,
slug="rendezvous",
title="Private Rendezvous",
date=dt.date(2013, 1, 10),
uid="80af64e7-84e6-40d9-8b4f-7edf92aab9f7")
self.calendar.add_child(instance=self.rendezvous)
self.rendezvous.save_revision().publish()
restriction = PageViewRestriction.objects.create(
restriction_type=GROUPS, page=self.rendezvous)
restriction.groups.set([self.friends])
restriction.save()
self.party = MultidayEventPage(owner=self.user,
slug="allnighter",
title="All Night",
date_from=dt.date(2012, 12, 31),
date_to=dt.date(2013, 1, 1),
time_from=dt.time(23),
time_to=dt.time(3),
uid="initiative+technology")
self.calendar.add_child(instance=self.party)
self.standup = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(2013, 1, 1),
until=dt.date(2013, 5, 31),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13, 30),
time_to=dt.time(16),
uid="initiative+technology")
self.group.add_child(instance=self.standup)
self.postponement = PostponementPage(
owner=self.user,
slug="2013-01-09-postponement",
title="Postponement for Wednesday 16th of October",
overrides=self.standup,
except_date=dt.date(2013, 1, 16),
cancellation_title="Meeting Postponed",
cancellation_details=
"The meeting has been postponed until tomorrow",
postponement_title="A Meeting",
date=dt.date(2013, 1, 17),
time_from=dt.time(13),
time_to=dt.time(16, 30),
details="Yes a test meeting on a Thursday")
self.standup.add_child(instance=self.postponement)
cancelTuesday = CancellationPage(
owner=self.user,
slug="2013-01-01-cancellation",
title="CancellationPage for Tuesday 1st of January",
overrides=self.standup,
except_date=dt.date(2013, 1, 1),
cancellation_title="Meeting Cancelled")
self.standup.add_child(instance=cancelTuesday)
def testGetAllEventsByDay(self):
events = getAllEventsByDay(self.request, dt.date(2013, 1, 1),
dt.date(2013, 1, 31))
self.assertEqual(len(events), 31)
evod1 = events[0]
self.assertEqual(evod1.date, dt.date(2013, 1, 1))
self.assertEqual(len(evod1.all_events), 1)
self.assertEqual(len(evod1.days_events), 0)
self.assertEqual(len(evod1.continuing_events), 1)
evod10 = events[9]
self.assertEqual(evod10.date, dt.date(2013, 1, 10))
self.assertEqual(len(evod10.all_events), 0)
def testAuthGetAllEventsByDay(self):
self.request.user.groups.set([self.friends])
events = getAllEventsByDay(self.request, dt.date(2013, 1, 1),
dt.date(2013, 1, 31))
self.assertEqual(len(events), 31)
evod10 = events[9]
self.assertEqual(evod10.date, dt.date(2013, 1, 10))
self.assertEqual(len(evod10.all_events), 1)
self.assertEqual(len(evod10.days_events), 1)
event = evod10.days_events[0]
self.assertEqual(event.title, "Private Rendezvous")
def testGetAllEventsByWeek(self):
weeks = getAllEventsByWeek(self.request, 2013, 1)
self.assertEqual(len(weeks), 5)
self.assertIsNone(weeks[0][0])
self.assertIsNone(weeks[0][1])
self.assertIsNone(weeks[4][5])
self.assertIsNone(weeks[4][6])
evod = weeks[2][4]
self.assertEqual(evod.date, dt.date(2013, 1, 17))
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
def testGetAllUpcomingEvents(self):
today = timezone.localdate()
futureEvent = MultidayEventPage(owner=self.user,
slug="tomorrow",
title="Tomorrow's Event",
date_from=today + dt.timedelta(days=1),
date_to=today + dt.timedelta(days=3),
time_from=dt.time(17),
time_to=dt.time(10, 30))
self.calendar.add_child(instance=futureEvent)
events = getAllUpcomingEvents(self.request, home=self.home)
self.assertEqual(len(events), 1)
title, event, url = events[0]
self.assertEqual(title, "Tomorrow's Event")
self.assertEqual(event.slug, "tomorrow")
events0 = getAllUpcomingEvents(self.request)
self.assertEqual(len(events0), 1)
@override_settings(JOYOUS_UPCOMING_INCLUDES_STARTED=True)
def testGetAllCurrentEvents(self):
today = timezone.localdate()
futureEvent = MultidayEventPage(owner=self.user,
slug="yesterday",
title="Yesterday's Event",
date_from=today - dt.timedelta(days=1),
date_to=today + dt.timedelta(days=3),
time_from=dt.time(17),
time_to=dt.time(10, 30))
self.calendar.add_child(instance=futureEvent)
events = getAllUpcomingEvents(self.request, home=self.home)
self.assertEqual(len(events), 1)
title, event, url = events[0]
self.assertEqual(title, "Yesterday's Event")
self.assertEqual(event.slug, "yesterday")
events0 = getAllUpcomingEvents(self.request)
self.assertEqual(len(events0), 1)
def testGetAllPastEvents(self):
events = getAllPastEvents(self.request)
self.assertEqual(len(events), 5)
self.assertEqual(events[0].title, "Test Meeting")
self.assertEqual(events[1].title, "A Meeting")
self.assertEqual(events[2].title, "Meeting Postponed")
self.assertEqual(events[3].title, "Pet Show")
self.assertEqual(events[4].title, "All Night")
def testGetGroupUpcomingEvents(self):
meeting = RecurringEventPage(owner=self.user,
slug="plan-plan",
title="Planning to Plan",
repeat=Recurrence(dtstart=dt.date(
2018, 5, 1),
freq=WEEKLY,
byweekday=[TU]),
time_from=dt.time(18, 30),
time_to=dt.time(20),
group_page=self.group)
self.calendar.add_child(instance=meeting)
memo = ExtraInfoPage(owner=self.user,
slug="plan-plan-extra-info",
title="Extra Information Planning to Plan",
overrides=meeting,
except_date=meeting.next_date,
extra_title="Gap Analysis",
extra_information="Analyse your gaps")
meeting.add_child(instance=memo)
events = getGroupUpcomingEvents(self.request, self.group)
self.assertEqual(len(events), 2)
self.assertEqual(events[0].title, "Gap Analysis")
self.assertEqual(events[1].title, "Planning to Plan")
def testGetGroupUpcomingEventsDupGroup(self):
meeting = RecurringEventPage(owner=self.user,
slug="plan-plan",
title="Planning to Plan",
repeat=Recurrence(dtstart=dt.date(
2018, 5, 2),
freq=WEEKLY,
byweekday=[WE]),
time_from=dt.time(18, 30),
time_to=dt.time(20),
group_page=self.group)
self.group.add_child(instance=meeting)
events = getGroupUpcomingEvents(self.request, self.group)
self.assertEqual(len(events), 1)
self.assertEqual(events[0].title, "Planning to Plan")
self.assertEqual(events[0].page.group, self.group)
def testGetGroupUpcomingEvents2Groups(self):
rival = GroupPage(slug="initrode", title="Initrode Corporation")
self.home.add_child(instance=rival)
meeting = RecurringEventPage(owner=self.user,
slug="plan-plan",
title="Planning to Plan",
repeat=Recurrence(dtstart=dt.date(
2018, 5, 2),
freq=WEEKLY,
byweekday=[WE]),
time_from=dt.time(18, 30),
time_to=dt.time(20),
group_page=rival)
self.group.add_child(instance=meeting)
events = getGroupUpcomingEvents(self.request, rival)
self.assertEqual(len(events), 1)
self.assertEqual(events[0].title, "Planning to Plan")
# being a child of self.group trumps having group_page set
self.assertEqual(events[0].page.group, self.group)
events = getGroupUpcomingEvents(self.request, self.group)
self.assertEqual(len(events), 1)
self.assertEqual(events[0].title, "Planning to Plan")
self.assertEqual(events[0].page.group, self.group)
def testGetEventFromUid(self):
event = getEventFromUid(self.request,
"29daefed-fed1-4e47-9408-43ec9b06a06d")
self.assertEqual(event.title, "Pet Show")
def testMultiGetEventFromUid(self):
with self.assertRaises(MultipleObjectsReturned):
getEventFromUid(self.request, "initiative+technology")
def testMissingGetEventFromUid(self):
with self.assertRaises(ObjectDoesNotExist):
getEventFromUid(self.request,
"d12971fb-e694-4a04-aba2-fb1a4a7166b9")
def testAuthGetEventFromUid(self):
with self.assertRaises(PermissionDenied):
event = getEventFromUid(self.request,
"80af64e7-84e6-40d9-8b4f-7edf92aab9f7")
self.request.user.groups.set([self.friends])
event = getEventFromUid(self.request,
"80af64e7-84e6-40d9-8b4f-7edf92aab9f7")
self.assertIsNotNone(event.title)
self.assertEqual(event.title, "Private Rendezvous")
class Test(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner = self.user,
slug = "events",
title = "Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug = "test-meeting",
title = "Test Meeting",
repeat = Recurrence(dtstart=dt.date(1988,1,1),
freq=WEEKLY,
byweekday=[MO,WE,FR]),
time_from = dt.time(13),
time_to = dt.time(15,30))
self.calendar.add_child(instance=self.event)
self.info = ExtraInfoPage(owner = self.user,
overrides = self.event,
except_date = dt.date(1988,11,11),
extra_title = "System Demo",
extra_information = "<h3>System Demo</h3>")
self.event.add_child(instance=self.info)
self.info.save_revision().publish()
def testGetEventsByDay(self):
events = RecurringEventPage.events.byDay(dt.date(1988,11,1),
dt.date(1988,11,30))
self.assertEqual(len(events), 30)
evod = events[10]
self.assertEqual(evod.date, dt.date(1988,11,11))
self.assertEqual(len(evod.all_events), 1)
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
title, page, url = evod.days_events[0]
self.assertEqual(title, "System Demo")
self.assertIs(type(page), ExtraInfoPage)
def testStatus(self):
self.assertEqual(self.info.status, "finished")
self.assertEqual(self.info.status_text, "This event has finished.")
now = timezone.localtime()
myday = now.date() + dt.timedelta(days=1)
friday = myday + dt.timedelta(days=(4-myday.weekday())%7)
futureInfo = ExtraInfoPage(owner = self.user,
overrides = self.event,
except_date = friday,
extra_title = "It's Friday",
extra_information = "Special")
self.event.add_child(instance=futureInfo)
self.assertIsNone(futureInfo.status)
self.assertEqual(futureInfo.status_text, "")
@freeze_timetz("1988-11-11 14:00:00")
def testStatusStarted(self):
self.assertEqual(self.info.status, "started")
self.assertEqual(self.info.status_text, "This event has started.")
def testWhen(self):
self.assertEqual(self.info.when, "Friday 11th of November 1988 at 1pm to 3:30pm")
def testAt(self):
self.assertEqual(self.info.at.strip(), "1pm")
def testCurrentDt(self):
self.assertIsNone(self.info._current_datetime_from)
def testFutureDt(self):
self.assertIsNone(self.info._future_datetime_from)
def testPastDt(self):
self.assertEqual(self.info._past_datetime_from,
datetimetz(1988,11,11,13,0))
def testNeverOccursOn(self):
info = ExtraInfoPage(owner = self.user,
overrides = self.event,
except_date = dt.date(1988,3,1),
extra_title = "Tuesday",
extra_information = "Standard")
self.event.add_child(instance=info)
self.assertIsNone(info._current_datetime_from)
self.assertIsNone(info._future_datetime_from)
self.assertIsNone(info._past_datetime_from)
def testGroup(self):
self.assertIsNone(self.info.group)
def testOverridesRepeat(self):
self.assertEqual(self.info.overrides_repeat, self.event.repeat)
class Test(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(1989, 1, 1),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13),
time_to=dt.time(15, 30))
self.calendar.add_child(instance=self.event)
self.cancellation = CancellationPage(
owner=self.user,
overrides=self.event,
except_date=dt.date(1989, 2, 1),
cancellation_title="Meeting Cancelled",
cancellation_details="Cancelled due to lack of interest")
self.event.add_child(instance=self.cancellation)
self.cancellation.save_revision().publish()
def testGetEventsByDay(self):
hiddenCancellation = CancellationPage(owner=self.user,
overrides=self.event,
except_date=dt.date(1989, 2, 13))
self.event.add_child(instance=hiddenCancellation)
events = RecurringEventPage.events.byDay(dt.date(1989, 2, 1),
dt.date(1989, 2, 28))
self.assertEqual(len(events), 28)
evod1 = events[0]
self.assertEqual(evod1.date, dt.date(1989, 2, 1))
self.assertEqual(len(evod1.days_events), 1)
self.assertEqual(len(evod1.continuing_events), 0)
title, page, url = evod1.days_events[0]
self.assertEqual(title, "Meeting Cancelled")
self.assertIs(type(page), CancellationPage)
evod2 = events[12]
self.assertEqual(evod2.date, dt.date(1989, 2, 13))
self.assertEqual(len(evod2.days_events), 0)
self.assertEqual(len(evod2.continuing_events), 0)
def testOccursOn(self):
self.assertIs(self.event._occursOn(dt.date(1989, 2, 1)), False)
self.assertIs(self.event._occursOn(dt.date(1989, 2, 3)), True)
def testUnexplainedCancellation(self):
self._cancel_1999_02_08()
events = RecurringEventPage.events.byDay(dt.date(1999, 2, 1),
dt.date(1999, 2, 28))
self.assertEqual(len(events), 28)
evod = events[7]
self.assertEqual(evod.date, dt.date(1999, 2, 8))
self.assertEqual(len(evod.days_events), 0)
self.assertEqual(len(evod.continuing_events), 0)
def testUnexplainedCancellationExplained(self):
restriction = self._cancel_1999_02_08()
request = RequestFactory().get("/test")
request.user = self.user
KEY = PageViewRestriction.passed_view_restrictions_session_key
request.session = {KEY: [restriction.id]}
events = RecurringEventPage.events(request).byDay(
dt.date(1999, 2, 1), dt.date(1999, 2, 28))
self.assertEqual(len(events), 28)
evod = events[7]
self.assertEqual(evod.date, dt.date(1999, 2, 8))
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
title, page, url = evod.days_events[0]
self.assertEqual(title, "Restructure Pending")
self.assertIs(type(page), CancellationPage)
def _cancel_1999_02_08(self):
cancellation = CancellationPage(
owner=self.user,
overrides=self.event,
except_date=dt.date(1999, 2, 8),
cancellation_title="Restructure Pending",
cancellation_details="Keep it quiet")
self.event.add_child(instance=cancellation)
PASSWORD = PageViewRestriction.PASSWORD
restriction = PageViewRestriction.objects.create(
restriction_type=PASSWORD, password="******", page=cancellation)
restriction.save()
return restriction
def testStatus(self):
self.assertEqual(self.cancellation.status, "cancelled")
self.assertEqual(self.cancellation.status_text,
"This event has been cancelled.")
now = dt.datetime.now()
myday = now.date() + dt.timedelta(1)
friday = myday + dt.timedelta(days=(4 - myday.weekday()) % 7)
futureCan = CancellationPage(owner=self.user,
overrides=self.event,
except_date=friday,
cancellation_title="",
cancellation_details="")
self.event.add_child(instance=futureCan)
self.assertEqual(futureCan.status, "cancelled")
self.assertEqual(futureCan.status_text,
"This event has been cancelled.")
def testWhen(self):
self.assertEqual(self.cancellation.when,
"Wednesday 1st of February 1989 at 1pm to 3:30pm")
def testWhenEver(self):
event = RecurringEventPage(slug="XYZ",
title="Xylophone yacht zombies",
repeat=Recurrence(dtstart=dt.date(
1989, 1, 1),
freq=WEEKLY,
byweekday=[FR]),
time_from=dt.time(19))
self.calendar.add_child(instance=event)
cancellation = CancellationPage(owner=self.user,
overrides=event,
except_date=dt.date(1989, 3, 10),
cancellation_title="Cancelled")
event.add_child(instance=cancellation)
cancellation.save_revision().publish()
self.assertEqual(cancellation.when, "Friday 10th of March 1989 at 7pm")
def testAt(self):
self.assertEqual(self.cancellation.at.strip(), "1pm")
def testCurrentDt(self):
self.assertIsNone(self.cancellation._current_datetime_from)
def testFutureDt(self):
self.assertIsNone(self.cancellation._future_datetime_from)
def testPastDt(self):
self.assertEqual(self.cancellation._past_datetime_from,
datetimetz(1989, 2, 1, 13, 0))
def testNeverOccursOn(self):
cancellation = CancellationPage(owner=self.user,
overrides=self.event,
except_date=dt.date(1989, 2, 7),
cancellation_title="Tuesday",
cancellation_details="Banner")
self.event.add_child(instance=cancellation)
self.assertIsNone(cancellation._current_datetime_from)
self.assertIsNone(cancellation._future_datetime_from)
self.assertIsNone(cancellation._past_datetime_from)
def testGroup(self):
self.assertIsNone(self.cancellation.group)
def testOverridesRepeat(self):
self.assertEqual(self.cancellation.overrides_repeat, self.event.repeat)
def testGetContext(self):
request = RequestFactory().get("/test")
context = self.cancellation.get_context(request)
self.assertIn('overrides', context)
class Test(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(1989, 1, 1),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13),
time_to=dt.time(15, 30))
self.calendar.add_child(instance=self.event)
self.cancellation = CancellationPage(
owner=self.user,
slug="1989-02-01-cancellation",
title="Cancellation for Wednesday 1st of February",
overrides=self.event,
except_date=dt.date(1989, 2, 1),
cancellation_title="Meeting Cancelled",
cancellation_details="Cancelled due to lack of interest")
self.event.add_child(instance=self.cancellation)
self.cancellation.save_revision().publish()
def testGetEventsByDay(self):
hiddenCancellation = CancellationPage(
owner=self.user,
slug="1989-02-13-cancellation",
title="Cancellation for Monday 13th of February",
overrides=self.event,
except_date=dt.date(1989, 2, 13))
self.event.add_child(instance=hiddenCancellation)
events = RecurringEventPage.events.byDay(dt.date(1989, 2, 1),
dt.date(1989, 2, 28))
self.assertEqual(len(events), 28)
evod1 = events[0]
self.assertEqual(evod1.date, dt.date(1989, 2, 1))
self.assertEqual(len(evod1.days_events), 1)
self.assertEqual(len(evod1.continuing_events), 0)
title, page, url = evod1.days_events[0]
self.assertEqual(title, "Meeting Cancelled")
self.assertIs(type(page), CancellationPage)
evod2 = events[12]
self.assertEqual(evod2.date, dt.date(1989, 2, 13))
self.assertEqual(len(evod2.days_events), 0)
self.assertEqual(len(evod2.continuing_events), 0)
def testUnexplainedCancellation(self):
self._cancel_1999_02_08()
events = RecurringEventPage.events.byDay(dt.date(1999, 2, 1),
dt.date(1999, 2, 28))
self.assertEqual(len(events), 28)
evod = events[7]
self.assertEqual(evod.date, dt.date(1999, 2, 8))
self.assertEqual(len(evod.days_events), 0)
self.assertEqual(len(evod.continuing_events), 0)
def testUnexplainedCancellationExplained(self):
restriction = self._cancel_1999_02_08()
request = RequestFactory().get("/test")
request.user = self.user
KEY = PageViewRestriction.passed_view_restrictions_session_key
request.session = {KEY: [restriction.id]}
events = RecurringEventPage.events(request).byDay(
dt.date(1999, 2, 1), dt.date(1999, 2, 28))
self.assertEqual(len(events), 28)
evod = events[7]
self.assertEqual(evod.date, dt.date(1999, 2, 8))
self.assertEqual(len(evod.days_events), 1)
self.assertEqual(len(evod.continuing_events), 0)
title, page, url = evod.days_events[0]
self.assertEqual(title, "Restructure Pending")
self.assertIs(type(page), CancellationPage)
def _cancel_1999_02_08(self):
cancellation = CancellationPage(
owner=self.user,
slug="1999-02-08-cancellation",
title="Cancellation for Monday 8th of February",
overrides=self.event,
except_date=dt.date(1999, 2, 8),
cancellation_title="Restructure Pending",
cancellation_details="Keep it quiet")
self.event.add_child(instance=cancellation)
PASSWORD = PageViewRestriction.PASSWORD
restriction = PageViewRestriction.objects.create(
restriction_type=PASSWORD, password="******", page=cancellation)
restriction.save()
return restriction
def testStatus(self):
self.assertEqual(self.cancellation.status, "cancelled")
self.assertEqual(self.cancellation.status_text,
"This event has been cancelled.")
now = dt.datetime.now()
myday = now.date() + dt.timedelta(1)
friday = myday + dt.timedelta(days=(4 - myday.weekday()) % 7)
futureCan = CancellationPage(owner=self.user,
slug="fri-cancellation",
title="Cancellation for Friday",
overrides=self.event,
except_date=friday,
cancellation_title="",
cancellation_details="")
self.event.add_child(instance=futureCan)
self.assertEqual(futureCan.status, "cancelled")
self.assertEqual(futureCan.status_text,
"This event has been cancelled.")
def testWhen(self):
self.assertEqual(self.cancellation.when,
"Wednesday 1st of February 1989 at 1pm to 3:30pm")
def testAt(self):
self.assertEqual(self.cancellation.at.strip(), "1pm")
class TestCancellation(TestCase):
def setUp(self):
self.home = Page.objects.get(slug='home')
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.calendar = CalendarPage(owner=self.user,
slug="events",
title="Events")
self.home.add_child(instance=self.calendar)
self.calendar.save_revision().publish()
self.event = RecurringEventPage(slug="test-meeting",
title="Test Meeting",
repeat=Recurrence(
dtstart=dt.date(1989, 1, 1),
freq=WEEKLY,
byweekday=[MO, WE, FR]),
time_from=dt.time(13),
time_to=dt.time(15, 30))
self.calendar.add_child(instance=self.event)
self.cancellation = CancellationPage(
owner=self.user,
slug="1989-02-01-cancellation",
title="Cancellation for Wednesday 1st of February",
overrides=self.event,
except_date=dt.date(1989, 2, 1),
cancellation_title="Meeting Cancelled",
cancellation_details="Cancelled due to lack of interest")
self.event.add_child(instance=self.cancellation)
self.cancellation.save_revision().publish()
def testGetEventsByDay(self):
hiddenCancellation = CancellationPage(
owner=self.user,
slug="1989-02-13-cancellation",
title="Cancellation for Monday 13th of February",
overrides=self.event,
except_date=dt.date(1989, 2, 13))
self.event.add_child(instance=hiddenCancellation)
events = RecurringEventPage.events.byDay(dt.date(1989, 2, 1),
dt.date(1989, 2, 28))
self.assertEqual(len(events), 28)
evod1 = events[0]
self.assertEqual(evod1.date, dt.date(1989, 2, 1))
self.assertEqual(len(evod1.days_events), 1)
self.assertEqual(len(evod1.continuing_events), 0)
title, page = evod1.days_events[0]
self.assertEqual(title, "Meeting Cancelled")
self.assertIs(type(page), CancellationPage)
evod2 = events[12]
self.assertEqual(evod2.date, dt.date(1989, 2, 13))
self.assertEqual(len(evod2.days_events), 0)
self.assertEqual(len(evod2.continuing_events), 0)
def testStatus(self):
self.assertEqual(self.cancellation.status, "cancelled")
self.assertEqual(self.cancellation.status_text,
"This event has been cancelled.")
now = dt.datetime.now()
myday = now.date() + dt.timedelta(1)
friday = myday + dt.timedelta(days=(4 - myday.weekday()) % 7)
futureCan = CancellationPage(owner=self.user,
slug="fri-cancellation",
title="Cancellation for Friday",
overrides=self.event,
except_date=friday,
cancellation_title="",
cancellation_details="")
self.event.add_child(instance=futureCan)
self.assertEqual(futureCan.status, "cancelled")
self.assertEqual(futureCan.status_text,
"This event has been cancelled.")
def testWhen(self):
self.assertEqual(self.cancellation.when,
"Wednesday 1st of February 1989 at 1pm to 3:30pm")
def testAt(self):
self.assertEqual(self.cancellation.at.strip(), "1pm")
