I'll need 'session' objects for both Google and Outlook. Sessions can do the following:

• Start-up
• Shut-down
• Give me the full calendar
• Make the full calendar look like this

I'm deliberately keeping sessions as stupid as possible. -------------------------------------------- OBSOLETE CONTENT FOLLOWS

---

Now I'll begin to flesh out Calendar.merge. For starters, I'll create an AbstractCalendar class and specialize it into GoogleCalendar and OutlookCalendar. Calendars will support the following methods (for now):

• load
• merge
• assign
• persist
• entry_count

Load and persist will return the specialized object; merge will return the abstract calendar. Since I'm doing test-first, I'll need to implement the pseudo-code shown below. For starters, I'll implement the simplest (stupidest) algorithm of rebuilding a calendar store from scratch on calls to the assign+persist methods. Test the 'shape' of the load method:

1. validate that load returns a GoogleCalendar when called on a GoogleCalendar.
2. Validate that load returns an OutlookCalendar when called on an OutlookCalendar
3. Validate that load fails when called on an AbstractCalendar
4. Validate that load returns a GoogleCalendar when called on an AbstractCalendar, constructed as a GoogleCalendar. Oops! Wait... That only makes sense with a statically typed language.

Test the load method's ability to retrieve mocked data:

1. Validate that load returns a GoogleCalendar with 0 entries when called on a GoogleCalendar with mocks to return 0 entries.
2. Validate that load returns an OutlookCalendar with 0 entries when called on an OutlookCalendar with mocks to return 0 entries.
3. validate that load returns a GoogleCalendar with 3 entries when called on a GoogleCalendar with mocks to return 3 entries.
4. Validate that load returns an OutlookCalendar with 3 entries when called on an OutlookCalendar with mocks to return 3 entries.
5. Validate that load throws an appropriate error when called on a GoogleCalendar with no network connection.
6. Validate that load throws an appropriate error when called on an OutlookCalendar when OutlookCalendar can't connect to the Calendar folder in Outlook.

Test the merge method:

1. Merging 2 OutlookCalendars with 3 non-overlapping entries in each yields an AbstractCalendar with 6 entries.
2. Merging 2 GoogleCalendars with 3 non-overlapping entries in each yields an AbstractCalendar with 6 entries.
3. Merging 2 OutlookCalendars with 3 overlapping entries in each yields an AbstractCalendar with 3 entries.
4. Merging 2 GoogleCalendars with 3 overlapping entries in each yields an AbstractCalendar with 3 entries.
5. Merging 2 OutlookCalendars with 3 entries (two of which overlap) in each yields an AbstractCalendar with 4 entries.
6. Merging 2 GoogleCalendars with 3 entries (one of which overlaps) in each yields an AbstractCalendar with 5 entries.
7. Merging an OutlookCalendar with 3 entries into a GoogleCalendar with 3 entries (two of which overlap) yields an AbstractCalendar with 4 entries.
8. Merging a GoogleCalendar with 3 entries into an OutlookCalendar with 3 entries (one of which overlaps) yields an AbstractCalendar with 5 entries.

Test the assign method:

1. Assigning an AbstractCalendar with 0 entries to a GoogleCalendar with 0 entries yields a GoogleCalendar with 0 entries.
2. Assigning an AbstractCalendar with 0 entries to an OutlookCalendar with 0 entries yields an OutlookCalendar with 0 entries.
3. Assigning an AbstractCalendar with 0 entries to a GoogleCalendar with 3 entries yields a GoogleCalendar with 0 entries.
4. Assigning an AbstractCalendar with 0 entries to an OutlookCalendar with 3 entries yields an OutlookCalendar with 0 entries.
5. Assigning an AbstractCalendar with 2 entries to a GoogleCalendar yields a GoogleCalendar with 2 entries.
6. Assigning an AbstractCalendar with 3 entries to an OutlookCalendar yields an OutlookCalendar with 3 entries.
7. Assigning a GoogleCalendar with 3 entries to a GoogleCalendar yields a GoogleCalendar with 3 entries.
8. Assigning an OutlookCalendar with 2 entries to an OutlookCalendar yields an OutlookCalendar with 2 entries.
9. Assigning a GoogleCalendar with 3 entries to an OutlookCalendar yields an OutlookCalendar with 3 entries.
10. Assigning an OutlookCalendar with 2 entries to a GoogleCalendar yields a GoogleCalendar with 2 entries.

Test the persist method using mocks:

1. Persisting an empty AbstractCalendar throws an appropriate error.
2. Persisting an empty OutlookCalendar proceeds without throwing an error, makes 1 call to the delete-everything-in-Outlook mock, and zero calls to the add-to-Outlook mock and the replace-in-Outlook mock.
3. Persisting an empty GoogleCalendar proceeds without throwing an error, makes 1 call to the delete-everything-in-Google mock, and zero calls to the add-to-Google mock and the replace-in-Google mock.
4. Persisting a non-empty AbstractCalendar throws an appropriate error.
5. Persisting an OutlookCalendar with 3 entries proceeds without throwing an error, makes 1 call to the delete-everything-in-Outlook mock, and three calls to the add-to-Outlook mock and zero to the replace-in-Outlook mock.
6. Persisting a GoogleCalendar with 2 entries proceeds without throwing an error, makes 1 call to the delete-everything-in-Google mock, and 3 calls to the add-to-Google mock and zero to the replace-in-Google mock.

Note: entry_count will get fully tested in the above tests.