def test_make_all_day(self):
e = Event(begin=0, end=20)
begin = e.begin
e.make_all_day()
self.assertEqual(e.begin, begin)
self.assertEqual(e._end_time, None)
self.assertEqual(e._duration, None)
def test_make_all_day(self):
e = Event(begin=0, end=20)
begin = e.begin
e.make_all_day()
self.assertEqual(e.begin, begin.date())
self.assertEqual(e.end, begin.date())
self.assertEqual(e.duration, timedelta(1))
def test_has_end(self):
e = Event()
self.assertFalse(e.has_end())
e = Event(begin="1993/05/24", duration=10)
self.assertTrue(e.has_end())
e = Event(begin="1993/05/24", end="1999/10/11")
self.assertTrue(e.has_end())
e = Event(begin="1993/05/24")
e.make_all_day()
self.assertFalse(e.has_end())
def test_all_day_outputs_dtstart_value_date(self):
"""All day events should output DTSTART using VALUE=DATE without
time and timezone in order to assume the user's current timezone
refs http://www.kanzaki.com/docs/ical/dtstart.html
http://www.kanzaki.com/docs/ical/date.html
"""
e = Event(begin="2015/12/21")
e.make_all_day()
# no time or tz specifier
self.assertIn('DTSTART;VALUE=DATE:20151221', str(e).splitlines())
def test_all_day_outputs_dtstart_value_date(self):
"""All day events should output DTSTART using VALUE=DATE without
time and timezone in order to assume the user's current timezone
refs http://www.kanzaki.com/docs/ical/dtstart.html
http://www.kanzaki.com/docs/ical/date.html
"""
e = Event(begin="2015/12/21")
e.make_all_day()
# no time or tz specifier
self.assertIn('DTSTART;VALUE=DATE:20151221', str(e).splitlines())
def test_repr(self):
c = Calendar()
self.assertEqual(c.__repr__(), '<Calendar with 0 event and 0 todo>')
c.events.add(Event())
c.todos.add(Todo())
self.assertEqual(c.__repr__(), '<Calendar with 1 event and 1 todo>')
c.events.add(Event())
c.todos.add(Todo())
self.assertEqual(c.__repr__(), '<Calendar with 2 events and 2 todos>')
def test_event(self):
e = Event(begin=0, end=20)
self.assertEqual(e.begin.timestamp, 0)
self.assertEqual(e.end.timestamp, 20)
self.assertTrue(e.has_end())
self.assertFalse(e.all_day)
f = Event(begin=10, end=30)
self.assertTrue(e < f)
self.assertTrue(e <= f)
self.assertTrue(f > e)
self.assertTrue(f >= e)
def test_event(self):
e = Event(begin=0, end=20)
self.assertEqual(e.begin, datetime.fromtimestamp(0, tz=tzutc))
self.assertEqual(e.end, datetime.fromtimestamp(20, tz=tzutc))
self.assertTrue(e.has_end())
self.assertFalse(e.all_day)
f = Event(begin=10, end=30)
self.assertTrue(e < f)
self.assertTrue(e <= f)
self.assertTrue(f > e)
self.assertTrue(f >= e)
def test_cmp_by_start_time_with_end_time(self):
ev1 = Event(begin=dt(2018, 6, 29, 5), end=dt(2018, 6, 29, 7))
ev2 = Event(begin=dt(2018, 6, 29, 6), end=dt(2018, 6, 29, 8))
ev3 = Event(begin=dt(2018, 6, 29, 6))
self.assertLess(ev1, ev2)
self.assertGreaterEqual(ev2, ev1)
self.assertLessEqual(ev1, ev2)
self.assertGreater(ev2, ev1)
self.assertLess(ev3, ev2)
self.assertGreaterEqual(ev2, ev3)
self.assertLessEqual(ev3, ev2)
self.assertGreater(ev2, ev3)
def test_remove_duplicate_diff(self):
l = EventList()
t = arrow.now()
e0 = Event("t0", t.replace(hours=-1), t.replace(hours=+1))
e1 = Event("t0", t.replace(hours=-1), t.replace(hours=+1))
l.append(e0)
l.append(e1)
l._remove_duplicates()
self.assertEqual(2, len(l))
def test_event(self):
e = Event(begin=0, end=20)
self.assertEqual(e.begin.timestamp, 0)
self.assertEqual(e.end.timestamp, 20)
self.assertTrue(e.has_end())
self.assertFalse(e.all_day)
f = Event(begin=10, end=30)
self.assertTrue(e < f)
self.assertTrue(e <= f)
self.assertTrue(f > e)
self.assertTrue(f >= e)
def test_event(self):
e = Event(begin=dt.fromtimestamp(0), end=dt.fromtimestamp(20))
self.assertEqual(e.begin.timestamp(), 0)
self.assertEqual(e.end.timestamp(), 20)
self.assertTrue(e.has_explicit_end)
self.assertFalse(e.all_day)
f = Event(begin=dt.fromtimestamp(10), end=dt.fromtimestamp(30))
self.assertTrue(e < f)
self.assertTrue(e <= f)
self.assertTrue(f > e)
self.assertTrue(f >= e)
def equality(self):
ev1 = Event(begin=dt(2018, 6, 29, 5),
end=dt(2018, 6, 29, 7),
name="my name")
ev2 = ev1.clone()
assert ev1 == ev2
ev2.uid = "something else"
assert ev1 == ev2
ev2.name = "other name"
assert ev1 != ev2
def test_init(self):
e = Event()
self.assertEqual(e.duration, None)
self.assertEqual(e.end, None)
self.assertFalse(e._has_duration())
self.assertFalse(e._has_end())
self.assertEqual(e.begin, None)
self.assertNotEqual(e.uid, None)
self.assertEqual(e.description, None)
self.assertNotEqual(e.created, None)
self.assertEqual(e.location, None)
self.assertEqual(e.url, None)
def test_join_disjoined(self):
# disjoined events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=20))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 50), duration=td(minutes=20))
with pytest.raises(ValueError):
event_a.join(event_b)
with pytest.raises(ValueError):
event_b.join(event_a)
def test_overlapping(self):
c = Calendar()
e = [
Event(begin=datetime(2010, 10, 10), end=datetime(2012, 10, 10)),
Event(begin=datetime(2013, 10, 10), end=datetime(2014, 10, 10)),
Event(begin=datetime(2016, 10, 10), end=datetime(2017, 10, 10)),
]
for ev in e:
c.events.add(ev)
overlap = list(
c.timeline.overlapping(arrow.get(datetime(2011, 10, 10)),
arrow.get(datetime(2015, 10, 10))))
self.assertSequenceEqual(overlap, [e[0]] + [e[1]])
def test_events_setter(self):
c = Calendar(cal1)
e = Event()
c.events = [e]
self.assertEqual(c.events, [e])
def test_eq_len(self):
c0, c1 = Calendar(), Calendar()
e = Event()
c0.events.add(e)
c1.events.add(e)
self.assertEqual(c0, c1)
def test_clone(self):
c0 = Calendar()
e = Event()
c0.events.add(e)
c1 = c0.clone()
self.assertEqual(c0.events, c1.events)
self.assertEqual(c0, c1)
def test_set_slice(self):
fix = [Event(), Event(), Event(), Event(), Event(), Event()]
fix2 = [Event(name="test"), Event(name="test2")]
l = EventList(fix)
l[2:4] = fix2
fix[2:4] = fix2
self.assertSequenceEqual(sorted(fix), sorted(l))
def test_on_strict(self):
c = Calendar()
e = [
Event(begin=datetime(2015, 10, 10)),
Event(begin=datetime(2010, 10, 10)),
Event(begin=datetime(2020, 10, 10)),
Event(begin=datetime(2015, 1, 10)),
Event(begin=datetime(2014, 1, 10), end=datetime(2018, 1, 10)),
]
for ev in e:
c.events.append(ev)
now = (datetime(2015, 10, 10, 12))
on = list(c.timeline.on(now, strict=True))
self.assertSequenceEqual(on, [e[0]])
def test_clone(self):
c0 = Calendar()
e = Event()
c0.events.append(e)
c1 = c0.clone()
self.assertTrue(len(c0.events) == len(c1.events))
self.assertEqual(c0.events[0], c1.events[0])
self.assertEqual(c0, c1)
def test_event_attendee(self):
attendee_a = Attendee(email="*****@*****.**", common_name="Test", rsvp="TRUE")
attendee_b = Attendee(email="*****@*****.**")
event_a = Event(name="Test #1", attendees={attendee_a, attendee_b})
text = str(event_a)
self.assertIn("ATTENDEE;CN=Test;RSVP=TRUE:mailto:[email protected]", text)
self.assertIn("ATTENDEE;[email protected]:mailto:[email protected]", text)
def test_make_all_day2(self):
e = Event(begin="1993/05/24")
begin = arrow.get("1993/05/24")
self.assertEqual(e._begin, begin)
self.assertEqual(e.begin, begin)
self.assertEqual(e._end_time, None)
self.assertEqual(e.end, begin)
e.make_all_day()
self.assertEqual(e._begin, begin)
self.assertEqual(e.begin, begin)
self.assertEqual(e._begin_precision, "day")
self.assertEqual(e._end_time, None)
self.assertEqual(e.end, arrow.get("1993/05/25"))
def test_eq(self):
# TODO : better equality check
c0, c1 = Calendar(), Calendar()
e = Event()
c0.events.add(e)
c1.events.add(e)
self.assertEqual(c0, c1)
def test_now_large(self):
l = EventList()
t = arrow.now()
e = Event("test", t.replace(years=-1), t.replace(years=+1))
l.append(e)
self.assertIn(e, l.now())
def test_now_short(self):
l = EventList()
t = arrow.now()
e = Event("test", t.replace(seconds=-1), t.replace(seconds=+1))
l.append(e)
self.assertIn(e, l.now())
def test_events_eventlist(self):
c = Calendar()
l = EventList()
e = Event()
l.append(e)
c.events = l
self.assertEqual(c.events, [e])
def test_make_all_day2(self):
e = Event(begin="1993/05/24")
begin = arrow.get("1993/05/24")
self.assertEqual(e._begin, begin)
self.assertEqual(e.begin, begin)
self.assertEqual(e._end_time, None)
self.assertEqual(e.end, begin)
e.make_all_day()
self.assertEqual(e._begin, begin)
self.assertEqual(e.begin, begin)
self.assertEqual(e._begin_precision, "day")
self.assertEqual(e._end_time, None)
self.assertEqual(e.end, arrow.get("1993/05/25"))
def test_on(self):
c = Calendar()
e = [
Event(begin=datetime(2015, 10, 10)),
Event(begin=datetime(2010, 10, 10)),
Event(begin=datetime(2020, 10, 10)),
Event(begin=datetime(2015, 1, 10)),
Event(begin=datetime(2014, 1, 10), end=datetime(2018, 1, 10)),
]
for ev in e:
c.events.add(ev)
now = arrow.get(datetime(2015, 10, 10, 12))
on = list(c.timeline.on(now))
self.assertSequenceEqual(on, [e[4], e[0]])
def test_join_intersected(self):
# intersected events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 30), duration=td(minutes=30))
assert event_a.join(event_b).time_equals(Event(name=None, begin=event_a.begin, end=event_b.end))
assert event_b.join(event_a).time_equals(Event(name=None, begin=event_a.begin, end=event_b.end))
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 30), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert event_a.join(event_b).time_equals(Event(name=None, begin=event_b.begin, end=event_a.end))
assert event_b.join(event_a).time_equals(Event(name=None, begin=event_b.begin, end=event_a.end))
def test_intersects_included(self):
# included events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert event_a.intersects(event_b)
assert event_b.intersects(event_a)
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
assert event_a.intersects(event_b)
assert event_b.intersects(event_a)
def test_included(self):
c = Calendar()
e = [
Event(begin=datetime(2015, 10, 10)),
Event(begin=datetime(2010, 10, 10)),
Event(begin=datetime(2020, 10, 10)),
Event(begin=datetime(2015, 1, 10)),
Event(begin=datetime(2014, 1, 10), end=datetime(2018, 1, 10)),
]
for ev in e:
c.events.add(ev)
included = list(
c.timeline.included(arrow.get(datetime(2013, 10, 10)),
arrow.get(datetime(2017, 10, 10))))
self.assertSequenceEqual(included, [e[3]] + [e[0]])
def test_make_all_day3(self):
begin = arrow.get("2018-12-23")
end = arrow.get("2018-12-25")
e = Event(begin=begin, end=end)
self.assertEqual(e._begin, begin)
self.assertEqual(e.begin, begin)
self.assertEqual(e._end_time, end)
self.assertEqual(e.end, end)
e.make_all_day()
self.assertEqual(e._begin, arrow.get("2018-12-23"))
self.assertEqual(e.begin, arrow.get("2018-12-23"))
self.assertEqual(e._begin_precision, "day")
self.assertEqual(e._end_time, arrow.get("2018-12-26"))
self.assertEqual(e.end, arrow.get("2018-12-26"))
def test_at_is_later(self):
l = EventList()
t = arrow.now()
instant = arrow.now().replace(minutes=+1)
e = Event("test", t.replace(seconds=-1), t.replace(seconds=+59))
l.append(e)
self.assertNotIn(e, l.at(instant))
def test_at_is_now(self):
l = EventList()
t = arrow.now()
instant = arrow.now()
e = Event("test", t.replace(seconds=-1), t.replace(seconds=+1))
l.append(e)
self.assertIn(e, l.at(instant))
def test_eventlist_move(self):
e = Event()
c = Calendar()
c.events.append(e)
d = Calendar(events=c.events)
self.assertIs(c.events, d.events)
self.assertSequenceEqual([e], d.events)
self.assertIs(e, d.events[0])
def test_getitem_arrow(self):
l = EventList()
t = arrow.get("20130303T101010")
e = Event("t", t.replace(hours=-1), t.replace(hours=+1))
l.append(e)
t = t.format('YYYY-MM-DD')
self.assertEqual([e], l[t])
def test_or(self):
g = Event(begin=0, end=10) | Event(begin=10, end=20)
self.assertEqual(g, (None, None))
g = Event(begin=0, end=20) | Event(begin=10, end=30)
self.assertEqual(tuple(map(lambda x: x.timestamp, g)), (10, 20))
g = Event(begin=0, end=20) | Event(begin=5, end=15)
self.assertEqual(tuple(map(lambda x: x.timestamp, g)), (5, 15))
g = Event() | Event()
self.assertEqual(g, (None, None))
def test_clone(self):
c0 = Calendar()
e = Event()
t = Todo()
c0.events.append(e)
c0.todos.append(t)
c1 = c0.clone()
self.assertEqual(c0.events, c1.events)
self.assertEqual(c0.todos, c1.todos)
self.assertEqual(c0, c1)
def test_duration(self):
e = Event()
self.assertIsNone(e.duration)
e1 = Event(begin="1993/05/24")
e1.make_all_day()
self.assertEqual(e1.duration, timedelta(days=1))
e2 = Event(begin="1993/05/24", end="1993/05/30")
self.assertEqual(e2.duration, timedelta(days=6))
e3 = Event(begin="1993/05/24", duration=timedelta(minutes=1))
self.assertEqual(e3.duration, timedelta(minutes=1))
e4 = Event(begin="1993/05/24")
self.assertEqual(e4.duration, timedelta(seconds=1))
e5 = Event(begin="1993/05/24")
e5.duration = {'days': 6, 'hours': 2}
self.assertEqual(e5.end, arrow.get("1993/05/30T02:00"))
self.assertEqual(e5.duration, timedelta(hours=146))
def test_duration(self):
e = Event()
self.assertIsNone(e.duration)
birthday = Event(begin="1993/05/24")
self.assertEqual(birthday.duration, timedelta(days=1))
vacation = Event(begin="1993/05/24", end="1993/05/30")
self.assertEqual(vacation.duration, timedelta(days=7))
e3 = Event(begin=datetime(1993, 5, 24, 12),
duration=timedelta(minutes=1))
self.assertEqual(e3.duration, timedelta(minutes=1))
e4 = Event(begin=datetime(1993, 5, 24, 12))
self.assertEqual(e4.duration, timedelta(seconds=1))
e5 = Event(begin=datetime(1993, 5, 24, 12))
e5.duration = {'days': 6, 'hours': 2}
self.assertEqual(e5.end, parse_date_or_datetime("1993/05/30T14:00"))
self.assertEqual(e5.duration, timedelta(hours=146))
def test_join_disjoined(self):
# disjoined events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=20))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 50), duration=td(minutes=20))
with pytest.raises(ValueError):
event_a.join(event_b)
with pytest.raises(ValueError):
event_b.join(event_a)
def test_escapte_output(self):
e = Event()
e.name = "Hello, with \\ spechial; chars and \n newlines"
e.location = "Here; too"
e.description = "Every\nwhere ! Yes, yes !"
e.created = arrow.Arrow(2013, 1, 1)
e.uid = "empty-uid"
eq = CRLF.join(("BEGIN:VEVENT",
"DTSTAMP:20130101T000000Z",
"SUMMARY:Hello\\, with \\\\ spechial\\; chars and \\n newlines",
"DESCRIPTION:Every\\nwhere ! Yes\\, yes !",
"LOCATION:Here\\; too",
"UID:empty-uid",
"END:VEVENT"))
self.assertEqual(str(e), eq)
def test_escape_output(self):
e = Event()
e.name = "Hello, with \\ spechial; chars and \n newlines"
e.location = "Here; too"
e.description = "Every\nwhere ! Yes, yes !"
e.created = datetime(2013, 1, 1, tzinfo=tzutc)
e.uid = "empty-uid"
output = str(e).splitlines()
self.assertEqual(output[0], "BEGIN:VEVENT")
self.assertEqual(output[-1], "END:VEVENT")
eq = set(("DTSTAMP:20130101T000000Z",
"SUMMARY:Hello\\, with \\\\ spechial\\; chars and \\n newlines",
"DESCRIPTION:Every\\nwhere ! Yes\\, yes !",
"LOCATION:Here\\; too",
"UID:empty-uid"))
self.assertEqual(set(output[1:-1]), eq)
def test_join(self):
# disjoined events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=20))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 50), duration=td(minutes=20))
with pytest.raises(ValueError):
event_a.join(event_b)
with pytest.raises(ValueError):
event_b.join(event_a)
# intersected events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 30), duration=td(minutes=30))
assert event_a.join(event_b) == Event(name=None, uid=event_a.uid, begin=event_a.begin, end=event_b.end)
assert event_b.join(event_a) == Event(name=None, uid=event_b.uid, begin=event_a.begin, end=event_b.end)
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 30), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert event_a.join(event_b) == Event(name=None, uid=event_a.uid, begin=event_b.begin, end=event_a.end)
assert event_b.join(event_a) == Event(name=None, uid=event_b.uid, begin=event_b.begin, end=event_a.end)
# included events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert event_a.join(event_b) == Event(name=None, uid=event_a.uid, begin=event_a.begin, end=event_a.end)
assert event_b.join(event_a) == Event(name=None, uid=event_b.uid, begin=event_a.begin, end=event_a.end)
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
assert event_a.join(event_b) == Event(name=None, uid=event_a.uid, begin=event_b.begin, end=event_b.end)
assert event_b.join(event_a) == Event(name=None, uid=event_b.uid, begin=event_b.begin, end=event_b.end)
event = Event(uid='0', name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event.join(event)
assert event == Event(uid='0', name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
def test_always_uid(self):
e = Event()
e.uid = None
self.assertIn('UID:', str(e))
def test_intersects_disjoined(self):
# disjoined events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=20))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 50), duration=td(minutes=20))
assert not event_a.intersects(event_b)
assert not event_b.intersects(event_a)
def test_end_with_prescision(self):
e = Event(begin="1999/10/10")
e._begin_precision = "day"
self.assertEqual(e.end, arrow.get("1999/10/11"))
def test_end_before_begin(self):
e = Event(begin="2013/10/10")
with self.assertRaises(ValueError):
e.end = "1999/10/10"
def test_begin_after_end(self):
e = Event(end="19991010")
with self.assertRaises(ValueError):
e.begin = "2013/10/10"
def test_intersects(self):
# disjoined events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=20))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 50), duration=td(minutes=20))
assert False == event_a.intersects(event_b)
assert False == event_b.intersects(event_a)
# intersected events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 30), duration=td(minutes=30))
assert True == event_a.intersects(event_b)
assert True == event_b.intersects(event_a)
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 30), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert True == event_a.intersects(event_b)
assert True == event_b.intersects(event_a)
# included events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert True == event_a.intersects(event_b)
assert True == event_b.intersects(event_a)
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
assert True == event_a.intersects(event_b)
assert True == event_b.intersects(event_a)
def test_all_day_repr(self):
e = Event(name='plop', begin="1999/10/10")
e.make_all_day()
self.assertEqual(repr(e), "<all-day Event 'plop' 1999-10-10>")
def test_join_included(self):
# included events
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
assert event_a.join(event_b).time_equals(Event(name=None, begin=event_a.begin, end=event_a.end))
assert event_b.join(event_a).time_equals(Event(name=None, begin=event_a.begin, end=event_a.end))
event_a = Event(name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event_b = Event(name='Test #2', begin=dt(2016, 6, 10, 20, 00), duration=td(minutes=60))
assert event_a.join(event_b).time_equals(Event(name=None, begin=event_b.begin, end=event_b.end))
assert event_b.join(event_a).time_equals(Event(name=None, begin=event_b.begin, end=event_b.end))
event = Event(uid='0', name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
event.join(event)
assert event == Event(uid='0', name='Test #1', begin=dt(2016, 6, 10, 20, 10), duration=td(minutes=30))
