def test_two_reminder(self, mail_mock):
""" Test the cron job for a meeting with a single reminder to send.
"""
mail_mock.return_value = None
# Meeting with a reminder
remobj = model.Reminder('H-12', '[email protected]',
'[email protected],[email protected]',
'Come to our test meeting')
remobj.save(self.session)
self.session.flush()
date_sa = datetime.utcnow() + timedelta(hours=12)
date_so = datetime.utcnow() + timedelta(hours=13)
obj = model.Meeting( # id:1
meeting_name='Test meeting with reminder',
meeting_date=date_sa.date(),
meeting_date_end=date_so.date(),
meeting_time_start=date_sa.time(),
meeting_time_stop=date_so.time(),
meeting_information='This is a test meeting with reminder',
calendar_name='test_calendar',
reminder_id=remobj.reminder_id)
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
msgs = fedocal_cron.send_reminder()
self.assertEqual(len(msgs), 1)
self.assertEqual(msgs[0]['To'], '[email protected], [email protected]')
self.assertEqual(msgs[0]['From'], '[email protected]')
def test_no_reminder(self):
""" Test the cron job for run with no reminders.
"""
# Meeting with a reminder but outside the standard offsets
remobj = model.Reminder('H-12', '*****@*****.**',
'root@localhost', 'Come to our test meeting')
remobj.save(self.session)
self.session.flush()
date_sa = datetime.utcnow() + timedelta(hours=15)
date_so = datetime.utcnow() + timedelta(hours=16)
obj = model.Meeting( # id:1
meeting_name='Test meeting with reminder',
meeting_date=date_sa.date(),
meeting_date_end=date_so.date(),
meeting_time_start=date_sa.time(),
meeting_time_stop=date_so.time(),
meeting_information='This is a test meeting with reminder',
calendar_name='test_calendar',
reminder_id=remobj.reminder_id)
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
msgs = fedocal_cron.send_reminder()
self.assertEqual(len(msgs), 0)
def convert_meetings(fed03_sess, fed04_sess):
''' Convert the Meetings from fedocal-0.3.x to fedocal-0.4.0.
'''
cnt = 0
for meeting in fed03_sess.query(F03Meetings).all():
calendarobj = model.Calendar.by_id(fed04_sess, meeting.calendar_name)
if meeting.reminder_id:
reminderobj = model.Reminder.by_id(fed04_sess, meeting.reminder_id)
# Create the meeting
meetingobj = model.Meeting(
meeting_name=meeting.meeting_name,
meeting_date=meeting.meeting_date,
meeting_date_end=meeting.meeting_date_end,
meeting_time_start=meeting.meeting_time_start,
meeting_time_stop=meeting.meeting_time_stop,
meeting_information=meeting.meeting_information,
calendar_name=meeting.calendar_name,
meeting_timezone=meeting.meeting_timezone,
reminder_id=meeting.reminder_id,
meeting_location=meeting.meeting_location,
recursion_frequency=meeting.recursion_frequency,
recursion_ends=meeting.recursion_ends,
full_day=meeting.full_day)
fed04_sess.add(meetingobj)
# Add the managers
meetingobj.add_manager(fed04_sess, meeting.meeting_manager)
fed04_sess.add(meetingobj)
fed04_sess.flush()
cnt += 1
fed04_sess.commit()
print '%s meetings added' % cnt
def test_start_date_delete_meeting_form(self):
""" Test the content of the start_date in the delete meeting form.
"""
self.__setup_calendar()
calendar = model.Calendar.by_id(self.session, 'test_calendar')
# Create a meeting
obj = model.Meeting( # id:1
meeting_name='recursive meeting',
meeting_date=TODAY,
meeting_date_end=TODAY,
meeting_time_start=time(19, 50),
meeting_time_stop=time(20, 50),
meeting_information='This is a test meeting',
calendar_name='test_calendar',
recursion_frequency=14,
recursion_ends=TODAY + timedelta(days=90))
obj.add_manager(self.session, 'pingou,')
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
user = FakeUser(['fi-apprentice'], username='******')
with user_set(fedocal.APP, user):
output = self.app.get('/meeting/delete/1/')
self.assertEqual(output.status_code, 200)
next_date = TODAY + timedelta(days=14)
if date.today() <= TODAY:
next_date = TODAY
# If no date is specified, it returns the next occurence
self.assertTrue('<li>Date: %s</li>' % next_date in output.data)
# If a date in the future is specified, return the next occurence
# for this date
url = '/meeting/delete/1/?from_date=%s' % (TODAY +
timedelta(days=20))
output2 = self.app.get(url)
self.assertEqual(output2.status_code, 200)
self.assertTrue('<li>Date: %s</li>' %
(TODAY + timedelta(days=28)) in output2.data)
# If an exact date in the future is specified, return that date
url = '/meeting/delete/1/?from_date=%s' % (TODAY +
timedelta(days=14))
output2 = self.app.get(url)
self.assertEqual(output2.status_code, 200)
self.assertTrue('<li>Date: %s</li>' % next_date in output.data)
# If an old date in the future is specified, return the first date
output2 = self.app.get('/meeting/delete/1/?from_date=2000-01-01')
self.assertEqual(output2.status_code, 200)
self.assertTrue('<li>Date: %s</li>' % (TODAY) in output2.data)
def add_meeting(
session,
meeting_name,
meeting_manager,
meeting_date,
meeting_date_end,
meeting_time_start,
meeting_time_stop,
meeting_information,
calendarobj,
meeting_timezone='UTC',
reminder_id=None,
meeting_location=None,
recursion_frequency=None,
recursion_ends=None,
full_day=False):
""" Logic to add a meeting to the database.
"""
if not recursion_frequency:
recursion_frequency = None
if not recursion_ends and recursion_frequency:
recursion_ends = date(2025, 12, 31)
# Unless we test directly dbaction we will never hit this as
# fedocallib.add_meeting already covers it
if not meeting_date_end: # pragma: no cover
meeting_date_end = meeting_date
meeting = model.Meeting(
meeting_name=meeting_name,
meeting_date=meeting_date,
meeting_date_end=meeting_date_end,
meeting_time_start=meeting_time_start.time(),
meeting_time_stop=meeting_time_stop.time(),
meeting_timezone=meeting_timezone,
meeting_information=meeting_information,
calendar_name=calendarobj.calendar_name,
reminder_id=reminder_id,
meeting_location=meeting_location,
recursion_frequency=recursion_frequency,
recursion_ends=recursion_ends,
full_day=full_day)
meeting.save(session)
meeting.add_manager(session, meeting_manager)
meeting.save(session)
session.commit()
return meeting
def test_delete_recurring_meeting(self):
""" Test deleting a recurring meeting in the middle of the
recursion.
"""
# Setup info
self.__setup_calendar()
obj = model.Meeting( # id:1
meeting_name='test recurring',
meeting_date=datetime(2014, 9, 1).date(),
meeting_date_end=datetime(2014, 9, 1).date(),
meeting_time_start=time(9, 0),
meeting_time_stop=time(10, 0),
meeting_information='This is a test meeting recurring',
calendar_name='test_calendar',
recursion_frequency=7,
recursion_ends=datetime(2014, 10, 27).date(),
)
obj.add_manager(self.session, 'pingou')
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Before deletion
calendarobj = model.Calendar.by_id(self.session, 'test_calendar')
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 9, 1).date(),
datetime(2014, 10, 27).date())
self.assertEqual(len(meetings), 9)
ids = set([mtg.meeting_id for mtg in meetings])
self.assertEqual(len(ids), 1)
self.assertEqual(list(ids)[0], 1)
dates = [str(mtg.meeting_date) for mtg in meetings]
self.assertEqual(dates, [
'2014-09-01',
'2014-09-08',
'2014-09-15',
'2014-09-22',
'2014-09-29',
'2014-10-06',
'2014-10-13',
'2014-10-20',
'2014-10-27',
])
# Delete meeting in the middle
meeting = model.Meeting.by_id(self.session, 1)
fedocallib.delete_recursive_meeting(self.session,
meeting=meeting,
del_date=datetime(2014, 10,
20).date(),
all_meetings=False)
# After deletion
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 9, 1).date(),
datetime(2014, 10, 27).date())
self.assertEqual(len(meetings), 8)
self.assertEqual(len(ids), 1)
self.assertEqual(list(ids)[0], 1)
dates = [str(mtg.meeting_date) for mtg in meetings]
self.assertEqual(dates, [
'2014-09-01',
'2014-09-08',
'2014-09-15',
'2014-09-22',
'2014-09-29',
'2014-10-06',
'2014-10-13',
'2014-10-27',
])
# Delete meeting after the end of the recursion
meeting = model.Meeting.by_id(self.session, 1)
fedocallib.delete_recursive_meeting(self.session,
meeting=meeting,
del_date=datetime(2015, 10,
20).date(),
all_meetings=False)
# After deletion
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 9, 1).date(),
datetime(2015, 10, 27).date())
self.assertEqual(len(meetings), 8)
self.assertEqual(len(ids), 1)
self.assertEqual(list(ids)[0], 1)
dates = [str(mtg.meeting_date) for mtg in meetings]
self.assertEqual(dates, [
'2014-09-01',
'2014-09-08',
'2014-09-15',
'2014-09-22',
'2014-09-29',
'2014-10-06',
'2014-10-13',
'2014-10-27',
])
# Delete meeting before the start of the recursion
# This will delete the first occurrence of the meeting as it is the
# first one after the date specified.
meeting = model.Meeting.by_id(self.session, 1)
fedocallib.delete_recursive_meeting(self.session,
meeting=meeting,
del_date=datetime(2014, 8,
18).date(),
all_meetings=False)
# After deletion
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 8, 1).date(),
datetime(2015, 10, 27).date())
self.assertEqual(len(meetings), 7)
self.assertEqual(len(ids), 1)
self.assertEqual(list(ids)[0], 1)
dates = [str(mtg.meeting_date) for mtg in meetings]
self.assertEqual(dates, [
'2014-09-08',
'2014-09-15',
'2014-09-22',
'2014-09-29',
'2014-10-06',
'2014-10-13',
'2014-10-27',
])
def test_editing_recurring_meeting_one_day_earlier(self):
""" Test editing moving a meeting one day earlier in a recursion
"""
# Setup info
self.__setup_calendar()
obj = model.Meeting( # id:1
meeting_name='test recurring',
meeting_date=datetime(2014, 9, 1).date(),
meeting_date_end=datetime(2014, 9, 1).date(),
meeting_time_start=time(9, 0),
meeting_time_stop=time(10, 0),
meeting_information='This is a test meeting recurring',
calendar_name='test_calendar',
recursion_frequency=7,
recursion_ends=datetime(2014, 10, 27).date(),
)
obj.add_manager(self.session, 'pingou')
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Before edition
calendarobj = model.Calendar.by_id(self.session, 'test_calendar')
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 9, 1).date(),
datetime(2014, 10, 27).date())
self.assertEqual(len(meetings), 9)
ids = set([mtg.meeting_id for mtg in meetings])
self.assertEqual(list(ids)[0], 1)
dates = [str(mtg.meeting_date) for mtg in meetings]
self.assertEqual(dates, [
'2014-09-01',
'2014-09-08',
'2014-09-15',
'2014-09-22',
'2014-09-29',
'2014-10-06',
'2014-10-13',
'2014-10-20',
'2014-10-27',
])
# Edit meeting in the middle to move it by one day
meeting = model.Meeting.by_id(self.session, 1)
fedocallib.edit_meeting(
session=self.session,
meeting=meeting,
calendarobj=calendarobj,
fas_user=FakeUser(groups=['fi-apprentice'], username='******'),
meeting_name='test recurring',
meeting_date=datetime(2014, 9, 14).date(),
meeting_date_end=datetime(2014, 9, 14).date(),
meeting_time_start=time(9, 0),
meeting_time_stop=time(10, 0),
comanager='pingou',
meeting_information='This is a test meeting recurring',
meeting_location=None,
tzone='UTC',
recursion_frequency=7,
recursion_ends=datetime(2014, 10, 27).date(),
remind_when=None,
reminder_from=None,
remind_who=None,
full_day=False,
edit_all_meeting=False,
admin=False)
# After edition
calendarobj = model.Calendar.by_id(self.session, 'test_calendar')
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 9, 1).date(),
datetime(2014, 10, 27).date())
#self.assertEqual(len(meetings), 9)
ids = set([mtg.meeting_id for mtg in meetings])
#self.assertEqual(list(ids), [1, 2, 3])
dates = [str(mtg.meeting_date) for mtg in meetings]
# One meeting moved by 1 day
self.assertEqual(sorted(dates), [
'2014-09-01',
'2014-09-08',
'2014-09-14',
'2014-09-22',
'2014-09-29',
'2014-10-06',
'2014-10-13',
'2014-10-20',
'2014-10-27',
])
# Edit meeting in the middle to move it by 3 days (earlier)
meeting = model.Meeting.by_id(self.session, 3)
fedocallib.edit_meeting(
session=self.session,
meeting=meeting,
calendarobj=calendarobj,
fas_user=FakeUser(groups=['fi-apprentice'], username='******'),
meeting_name='test recurring',
meeting_date=datetime(2014, 9, 26).date(),
meeting_date_end=datetime(2014, 9, 26).date(),
meeting_time_start=time(9, 0),
meeting_time_stop=time(10, 0),
comanager='pingou',
meeting_information='This is a test meeting recurring',
meeting_location=None,
tzone='UTC',
recursion_frequency=7,
recursion_ends=datetime(2014, 10, 27).date(),
remind_when=None,
reminder_from=None,
remind_who=None,
full_day=False,
edit_all_meeting=False,
admin=False)
# After edition
calendarobj = model.Calendar.by_id(self.session, 'test_calendar')
meetings = fedocallib.get_by_date(self.session, calendarobj,
datetime(2014, 9, 1).date(),
datetime(2014, 10, 27).date())
self.assertEqual(len(meetings), 9)
ids = set([mtg.meeting_id for mtg in meetings])
self.assertEqual(list(ids), [1, 2, 3, 4, 5])
dates = [str(mtg.meeting_date) for mtg in meetings]
# One meeting moved by 3 day
self.assertEqual(sorted(dates), [
'2014-09-01',
'2014-09-08',
'2014-09-14',
'2014-09-22',
'2014-09-26',
'2014-10-06',
'2014-10-13',
'2014-10-20',
'2014-10-27',
])
def test_init_meeting(self):
""" Test the Meeting init function. """
caltest = Calendartests('test_init_calendar')
caltest.session = self.session
caltest.test_init_calendar()
obj = model.Meeting( # id:1
meeting_name='Fedora-fr-test-meeting',
meeting_date=TODAY,
meeting_date_end=TODAY,
meeting_time_start=time(19, 50),
meeting_time_stop=time(20, 50),
meeting_information='This is a test meeting',
calendar_name='test_calendar')
obj.add_manager(self.session, 'pingou, shaiton,')
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
obj = model.Meeting( # id:2
meeting_name='test-meeting2',
meeting_date=TODAY + timedelta(days=10),
meeting_date_end=TODAY + timedelta(days=10),
meeting_time_start=time(14, 15),
meeting_time_stop=time(16, 15),
meeting_information='This is another test meeting',
calendar_name='test_calendar')
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
obj = model.Meeting( # id:3
meeting_name='test-meeting23h59',
meeting_date=TODAY + timedelta(days=20),
meeting_date_end=TODAY + timedelta(days=20),
meeting_time_start=time(23, 00),
meeting_time_stop=time(23, 59),
meeting_information='This is another test meeting',
calendar_name='test_calendar')
obj.add_manager(self.session, ['pingou23h'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Meeting with end_recursion in the past
obj = model.Meeting( # id:4
meeting_name='test-meeting3',
meeting_date=TODAY - timedelta(days=16),
meeting_date_end=TODAY - timedelta(days=16),
meeting_time_start=time(14, 45),
meeting_time_stop=time(16, 35),
meeting_information='Test meeting with past end_recursion.',
calendar_name='test_calendar3',
recursion_frequency=7,
recursion_ends=TODAY - timedelta(days=7))
obj.add_manager(self.session, ['test2'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Two meetings at the same time
obj = model.Meeting( # id:5
meeting_name='test-meeting-st-1',
meeting_date=TODAY + timedelta(days=1),
meeting_date_end=TODAY + timedelta(days=1),
meeting_time_start=time(14, 00),
meeting_time_stop=time(16, 00),
meeting_information='This is a test meeting at the same time',
calendar_name='test_calendar4',
meeting_location='NA')
obj.add_manager(self.session, ['test'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
obj = model.Meeting( # id:6
meeting_name='test-meeting-st-2',
meeting_date=TODAY + timedelta(days=1),
meeting_date_end=TODAY + timedelta(days=1),
meeting_time_start=time(14, 00),
meeting_time_stop=time(16, 00),
meeting_information='This is a second test meeting at the'
' same time',
calendar_name='test_calendar4',
meeting_location='EMEA')
obj.add_manager(self.session, ['test'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Meeting with a recursion
obj = model.Meeting( # id:7
meeting_name='Another test meeting',
meeting_date=TODAY + timedelta(days=10),
meeting_date_end=TODAY + timedelta(days=10),
meeting_time_start=time(2, 00),
meeting_time_stop=time(3, 00),
meeting_information='This is a test meeting with recursion',
calendar_name='test_calendar',
recursion_frequency=7,
recursion_ends=TODAY + timedelta(days=90))
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
obj = model.Meeting( # id:8
meeting_name='Another test meeting2',
meeting_date=TODAY,
meeting_date_end=TODAY,
meeting_time_start=time(12, 00),
meeting_time_stop=time(13, 00),
meeting_information='This is a test meeting with recursion2',
calendar_name='test_calendar',
recursion_frequency=14,
recursion_ends=TODAY + timedelta(days=90))
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Meeting with a reminder
remobj = model.Reminder('H-12', '[email protected]', 'root@localhost',
'Come to our test meeting')
remobj.save(self.session)
self.session.flush()
obj = model.Meeting( # id:9
meeting_name='Test meeting with reminder',
meeting_date=TODAY + timedelta(days=11),
meeting_date_end=TODAY + timedelta(days=11),
meeting_time_start=time(11, 00),
meeting_time_stop=time(12, 00),
meeting_information='This is a test meeting with reminder',
calendar_name='test_calendar',
reminder_id=remobj.reminder_id)
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Meeting with a recursion and reminder
self.session.flush()
remobj = model.Reminder('H-12', '[email protected]', 'root@localhost',
'Come to our test meeting')
remobj.save(self.session)
self.session.flush()
obj = model.Meeting( # id:10
meeting_name='Test meeting with reminder and recursion',
meeting_date=TODAY + timedelta(days=12),
meeting_date_end=TODAY + timedelta(days=12),
meeting_time_start=time(10, 00),
meeting_time_stop=time(11, 00),
meeting_information='This is a test meeting with recursion'
' and reminder',
calendar_name='test_calendar',
reminder_id=remobj.reminder_id,
recursion_frequency=7,
recursion_ends=TODAY + timedelta(days=60))
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
obj = model.Meeting( # id:11
meeting_name='test-meeting-11',
meeting_date=TODAY + timedelta(days=20),
meeting_date_end=TODAY + timedelta(days=20),
meeting_time_start=time(17, 00),
meeting_time_stop=time(18, 00),
meeting_information='This is a second test meeting in EMEA',
calendar_name='test_calendar4',
meeting_location='EMEA')
obj.add_manager(self.session, ['test'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Past meeting with a recursion
obj = model.Meeting( # id:12
meeting_name='Another past test meeting',
meeting_date=TODAY - timedelta(days=14),
meeting_date_end=TODAY - timedelta(days=14),
meeting_time_start=time(4, 00),
meeting_time_stop=time(5, 00),
meeting_information='This is a past meeting with recursion',
calendar_name='test_calendar',
recursion_frequency=7,
recursion_ends=TODAY + timedelta(days=90),
full_day=False)
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Full day meeting
obj = model.Meeting( # id:13
meeting_name='Full-day meeting',
meeting_date=TODAY + timedelta(days=3),
meeting_date_end=TODAY + timedelta(days=3),
meeting_time_start=time(0, 00),
meeting_time_stop=time(23, 59),
meeting_information='This is a full day meeting',
calendar_name='test_calendar',
recursion_frequency=None,
recursion_ends=None,
full_day=True)
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Full day meeting with recursion
obj = model.Meeting( # id:14
meeting_name='Full-day meeting with recursion',
meeting_date=TODAY + timedelta(days=10),
meeting_date_end=TODAY + timedelta(days=10),
meeting_time_start=time(0, 00),
meeting_time_stop=time(23, 59),
meeting_information='Full day meeting with recursion',
calendar_name='test_calendar',
recursion_frequency=7,
recursion_ends=TODAY + timedelta(days=30),
full_day=True)
obj.add_manager(self.session, ['pingou'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
# Full day meeting
obj = model.Meeting( # id:15
meeting_name='Full-day meeting2',
meeting_date=TODAY + timedelta(days=2),
meeting_date_end=TODAY + timedelta(days=3),
meeting_time_start=time(0, 00),
meeting_time_stop=time(23, 59),
meeting_information='Full day meeting 2',
calendar_name='test_calendar2',
full_day=True)
obj.add_manager(self.session, ['toshio'])
obj.save(self.session)
self.session.commit()
self.assertNotEqual(obj, None)
def test_two_reminder(self, smtp_mock, mail_mock):
""" Test the cron job for a meeting with a single reminder to send.
"""
smtp_mock.return_value = FakeSMTP()
mail_mock.return_value = None
# Meeting with a reminder
remobj = model.Reminder('H-12', '[email protected]',
'[email protected],[email protected]',
'Come to our test meeting')
remobj.save(self.session)
self.session.flush()
date_sa = datetime.utcnow() + timedelta(hours=12)
date_so = datetime.utcnow() + timedelta(hours=13)
obj = model.Meeting( # id:1
meeting_name='Test meeting with reminder',
meeting_date=date_sa.date(),
meeting_date_end=date_so.date(),
meeting_time_start=date_sa.time(),
meeting_time_stop=date_so.time(),
meeting_information='This is a test meeting with reminder',
calendar_name='test_calendar',
reminder_id=remobj.reminder_id)
obj.save(self.session)
obj.add_manager(self.session, ['pingou'])
self.session.commit()
self.assertNotEqual(obj, None)
with testing.mock_sends(
api.Message(topic="fedocal.reminder",
body={
'meeting': {
'meeting_id': 1,
'meeting_name':
'Test meeting with reminder',
'meeting_manager': ['pingou'],
'meeting_date': ANY,
'meeting_date_end': ANY,
'meeting_time_start': ANY,
'meeting_time_stop': ANY,
'meeting_timezone': 'UTC',
'meeting_information':
'This is a test meeting with reminder',
'meeting_location': None,
'calendar_name': 'test_calendar'
},
'calendar': {
'calendar_name': 'test_calendar',
'calendar_contact': '*****@*****.**',
'calendar_description':
'This is a test calendar',
'calendar_editor_group': 'fi-apprentice',
'calendar_admin_group':
'infrastructure-main2',
'calendar_status': 'Enabled'
}
})):
msgs = fedocal_cron.send_reminder()
self.assertEqual(len(msgs), 1)
self.assertEqual(msgs[0]['To'], '[email protected], [email protected]')
self.assertEqual(msgs[0]['From'], '[email protected]')
