Design Calendar Event CRUD with Unit Tests

Calendar Event Service with Unit Tests

Design and implement an in-memory CalendarService class that handles standard CRUD operations for single-user or team calendar events, enforces business validation rules, and includes a comprehensive set of unit tests.

Requirements

Implement the following class interface:

from typing import List, Optional, Dict

class Event:
    def __init__(self, event_id: str, title: str, start_time: int, end_time: int, attendees: List[str]):
        self.id = event_id
        self.title = title
        self.start_time = start_time  # Unix timestamp in seconds
        self.end_time = end_time      # Unix timestamp in seconds
        self.attendees = attendees

class CalendarService:
    def create_event(self, title: str, start_time: int, end_time: int, attendees: List[str]) -> Event:
        """Creates a new event. Raises ValueError if validation fails."""
        pass

    def get_event(self, event_id: str) -> Optional[Event]:
        """Fetches event by ID, or None if not found."""
        pass

    def update_event(self, event_id: str, title: Optional[str] = None, 
                     start_time: Optional[int] = None, end_time: Optional[int] = None,
                     attendees: Optional[List[str]] = None) -> Event:
        """Updates an existing event. Raises ValueError or KeyError on error."""
        pass

    def delete_event(self, event_id: str) -> bool:
        """Deletes an event. Returns True if deleted, False if not found."""
        pass

    def get_events_in_range(self, start_time: int, end_time: int) -> List[Event]:
        """Returns all events that overlap with [start_time, end_time], sorted by start_time ascending."""
        pass

    def find_conflicts(self, user: str, start_time: int, end_time: int, exclude_event_id: Optional[str] = None) -> List[Event]:
        """Returns existing events involving `user` that overlap with [start_time, end_time]."""
        pass

Validation Rules

1. start_time must be strictly less than end_time (start_time < end_time).
2. title must be a non-empty, non-whitespace string.
3. Overlap definition: Two intervals [s1, e1] and [s2, e2] overlap if and only if max(s1, s2) < min(e1, e2) (i.e., touching boundaries e1 == s2 do not overlap).
4. All timestamps are non-negative integers.

Deliverables

1. A complete, clean implementation of CalendarService.
2. A suite of unit tests (using unittest or standard pytest style assertions) covering normal paths, edge cases (boundary touching, missing IDs, invalid times), and partial updates.

Example

service = CalendarService()
e1 = service.create_event("Sprint Planning", 100, 200, ["[email protected]", "[email protected]"])
e2 = service.create_event("1:1 Sync", 200, 300, ["[email protected]"])

# Querying range [150, 250] returns both events because [100, 200] and [200, 300] both overlap [150, 250]
assert len(service.get_events_in_range(150, 250)) == 2

# Touching intervals do not conflict: [100, 200] does not overlap with candidate [200, 250]
assert len(service.find_conflicts("[email protected]", 200, 250, exclude_event_id=e2.id)) == 0