func (s *ClientSuite) TestEventPutAndGet(c *C) {
// select a timezone
loc, err := time.LoadLocation("America/New_York")
c.Assert(err, IsNil)
// create the event object
oneHourFromNow := time.Now().Add(time.Hour).Truncate(time.Hour).In(loc)
uuid := fmt.Sprintf("test-single-event-%d", oneHourFromNow.Unix())
putEvent := components.NewEventWithDuration(uuid, oneHourFromNow, time.Hour)
putEvent.Summary = "This is a test single event"
// generate an ICS filepath
path := fmt.Sprintf("/%s.ics", uuid)
// save the event to the server, then fetch it back out
if err = s.client.PutEvents(path, putEvent); err != nil {
c.Fatal(err.Error())
} else if getEvents, err := s.client.GetEvents(path); err != nil {
c.Fatal(err.Error())
} else {
// assert that the events match
c.Assert(getEvents, HasLen, 1)
c.Assert(getEvents[0], DeepEquals, putEvent)
}
}
func (s *ClientSuite) TestRecurringEventQuery(c *C) {
// create the master event object
start := time.Now().Truncate(time.Hour).UTC()
uid := fmt.Sprintf("test-recurring-event-%d", start.Unix())
putEvent := components.NewEventWithDuration(uid, start, time.Hour)
putEvent.Summary = "This is a test recurring event"
rule := values.NewRecurrenceRule(values.DayRecurrenceFrequency)
rule.Count = 14 // two weeks of events
putEvent.AddRecurrenceRules(rule)
// create an instance override at one week out
nextWeek := start.AddDate(0, 0, 7)
// start it an hour later, make it go for twice as long
overrideEvent := components.NewEventWithDuration(uid, nextWeek.Add(time.Hour), 2*time.Hour)
// mark it as an override of the recurrence at one week out
overrideEvent.RecurrenceId = values.NewDateTime(nextWeek)
overrideEvent.Summary = "This is a test override event"
// generate an ICS filepath
path := fmt.Sprintf("/%s.ics", uid)
// save the events to the server
if err := s.client.PutEvents(path, putEvent, overrideEvent); err != nil {
c.Fatal(err.Error())
}
// create a query for all events between one week out + days in range
daysInRange := 2
nextWeekEnd := nextWeek.AddDate(0, 0, daysInRange)
query, err := calentities.NewEventRangeQuery(nextWeek, nextWeekEnd)
if err != nil {
c.Fatal(err.Error())
}
// add in a filter for UID so that we don't get back unwanted results
pf := calentities.NewPropertyMatcher(properties.UIDPropertyName, uid)
query.Filter.ComponentFilter.ComponentFilter.PropertyFilter = pf
// send the query to the server
if events, err := s.client.QueryEvents("/", query); err != nil {
c.Fatal(err.Error())
} else {
// since this is a daily recurring event, we should only get back one event for every day in our range
c.Assert(events, HasLen, daysInRange)
for i, event := range events {
// all events should have the same UID
c.Assert(event.UID, Equals, uid)
// all events should have a consistant recurrence ID
day := nextWeek.AddDate(0, 0, i)
offset := values.NewDateTime(day)
c.Assert(event.RecurrenceId, DeepEquals, offset)
if i == 0 {
// the first event is an override, it should start an hour later and be twice as long
c.Assert(event.DateStart, DeepEquals, overrideEvent.DateStart)
c.Assert(event.Duration, DeepEquals, overrideEvent.Duration)
c.Assert(event.Summary, DeepEquals, overrideEvent.Summary)
} else {
// regular occurences should start at the same time as their recurrence ID
c.Assert(event.DateStart, DeepEquals, event.RecurrenceId)
c.Assert(event.Duration, DeepEquals, putEvent.Duration)
c.Assert(event.Summary, DeepEquals, putEvent.Summary)
}
}
}
}