iflow-mcp_democratize-technology-chronos-mcp 2.0.0__py3-none-any.whl

tests/unit/test_models.py

@@ -0,0 +1,95 @@
+"""
+Unit tests for Chronos MCP models
+"""
+
+from datetime import datetime
+
+import pytest
+import pytz
+
+from chronos_mcp.models import (
+    Account,
+    AccountStatus,
+    Attendee,
+    AttendeeRole,
+    AttendeeStatus,
+    Calendar,
+    Event,
+)
+
+
+class TestAccount:
+    def test_account_creation(self, sample_account):
+        """Test creating an account model"""
+        assert sample_account.alias == "test_account"
+        assert sample_account.username == "testuser"
+        assert sample_account.password == "testpass"
+        assert sample_account.status == AccountStatus.UNKNOWN
+
+    def test_account_without_password(self):
+        """Test creating account without password"""
+        account = Account(
+            alias="no_pass", url="https://caldav.example.com", username="user"
+        )
+        assert account.password is None
+
+    def test_account_url_validation(self):
+        """Test URL validation"""
+        with pytest.raises(ValueError):
+            Account(alias="bad_url", url="not-a-url", username="user")
+
+
+class TestCalendar:
+    def test_calendar_creation(self, sample_calendar):
+        """Test creating a calendar model"""
+        assert sample_calendar.uid == "cal-123"
+        assert sample_calendar.name == "Test Calendar"
+        assert sample_calendar.color == "#FF0000"
+        assert not sample_calendar.read_only
+
+    def test_calendar_minimal(self):
+        """Test calendar with minimal fields"""
+        cal = Calendar(uid="minimal", name="Minimal Calendar", account_alias="test")
+        assert cal.description is None
+        assert cal.color is None
+
+
+class TestEvent:
+    def test_event_creation(self, sample_event):
+        """Test creating event"""
+        assert sample_event.summary == "Test Event"
+        assert sample_event.all_day is False
+        assert sample_event.attendees == []
+
+    def test_all_day_event(self):
+        """Test all-day event creation"""
+        event = Event(
+            uid="all-day-123",
+            summary="All Day Event",
+            start=datetime(2025, 7, 5, tzinfo=pytz.UTC),
+            end=datetime(2025, 7, 6, tzinfo=pytz.UTC),
+            all_day=True,
+            calendar_uid="cal-123",
+            account_alias="test",
+        )
+        assert event.all_day is True
+
+    def test_event_with_attendees(self):
+        """Test event with attendees"""
+        attendee = Attendee(
+            email="attendee@example.com",
+            name="Test Attendee",
+            role=AttendeeRole.REQ_PARTICIPANT,
+            status=AttendeeStatus.ACCEPTED,
+        )
+        event = Event(
+            uid="meeting-123",
+            summary="Meeting",
+            start=datetime.now(pytz.UTC),
+            end=datetime.now(pytz.UTC),
+            attendees=[attendee],
+            calendar_uid="cal-123",
+            account_alias="test",
+        )
+        assert len(event.attendees) == 1
+        assert event.attendees[0].email == "attendee@example.com"

tests/unit/test_race_conditions.py

@@ -0,0 +1,202 @@
+"""
+Tests for concurrency and race conditions
+"""
+
+import threading
+import time
+from unittest.mock import Mock, patch
+import pytest
+
+from chronos_mcp.accounts import AccountManager
+
+
+class TestRaceConditions:
+    """Test concurrent access patterns"""
+
+    @patch("chronos_mcp.accounts.DAVClient")
+    def test_concurrent_connection_requests_no_duplicate_disconnect(
+        self, mock_dav_client, mock_config_manager, sample_account
+    ):
+        """Test that staleness check happens inside lock (TOCTOU prevention)
+
+        Race condition scenario WITHOUT fix:
+        1. Thread A checks _is_connection_stale (True) at line 320 OUTSIDE lock
+        2. Thread B acquires lock at line 331, creates fresh connection
+        3. Thread A acquires lock, checks stale at line 323 INSIDE lock (still True from step 1)
+        4. Thread A disconnects fresh connection from step 2
+        5. Thread A reconnects, but data race has occurred
+
+        WITH fix: staleness check must happen INSIDE lock
+        """
+        mock_config_manager.add_account(sample_account)
+        mgr = AccountManager(mock_config_manager)
+        mgr._connection_ttl_minutes = 0.001  # Very short TTL
+
+        # Mock connection
+        call_count = [0]
+        def create_mock_client(*args, **kwargs):
+            call_count[0] += 1
+            mock_client = Mock()
+            mock_client.principal.return_value = Mock()
+            # Add delay to increase race window
+            time.sleep(0.01)
+            return mock_client
+
+        mock_dav_client.side_effect = create_mock_client
+
+        # Create initial connection and make it stale
+        mgr.connect_account("test_account")
+        mgr._connection_timestamps["test_account"] = time.time() - 60
+
+        # Track disconnect calls with timing
+        disconnect_times = []
+        connect_times = []
+        original_disconnect = mgr.disconnect_account
+        original_connect = mgr.connect_account
+
+        def tracked_disconnect(alias):
+            disconnect_times.append(time.time())
+            return original_disconnect(alias)
+
+        def tracked_connect(alias):
+            connect_times.append(time.time())
+            return original_connect(alias)
+
+        mgr.disconnect_account = tracked_disconnect
+        mgr.connect_account = tracked_connect
+
+        # Force race: threads check stale outside lock
+        barrier = threading.Barrier(3)  # Synchronize 3 threads
+
+        def get_conn_with_timing():
+            barrier.wait()  # All threads start simultaneously
+            mgr.get_connection("test_account")
+
+        threads = [threading.Thread(target=get_conn_with_timing) for _ in range(3)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # With race condition: multiple disconnects could happen
+        # Proper fix: staleness check inside lock prevents this
+        # This test documents the issue even if hard to trigger reliably
+        assert len(disconnect_times) <= 1, f"Disconnect called {len(disconnect_times)} times - race detected"
+
+    @patch("chronos_mcp.accounts.DAVClient")
+    def test_connection_staleness_check_under_lock(
+        self, mock_dav_client, mock_config_manager, sample_account
+    ):
+        """Test that staleness check happens inside lock to prevent TOCTOU"""
+        mock_config_manager.add_account(sample_account)
+        mgr = AccountManager(mock_config_manager)
+
+        mock_client = Mock()
+        mock_dav_client.return_value = mock_client
+        mock_principal = Mock()
+        mock_client.principal.return_value = mock_principal
+
+        # Connect initially
+        mgr.connect_account("test_account")
+
+        # Make connection just barely not stale
+        mgr._connection_timestamps["test_account"] = time.time() - (mgr._connection_ttl_minutes * 60 - 1)
+
+        # Concurrent access shouldn't cause issues
+        threads = [threading.Thread(target=lambda: mgr.get_connection("test_account")) for _ in range(5)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # Should still have exactly one connection
+        assert "test_account" in mgr.connections
+        assert mgr.connections["test_account"] is not None
+
+    @patch("chronos_mcp.accounts.DAVClient")
+    def test_get_principal_concurrent_no_duplicate_disconnect(
+        self, mock_dav_client, mock_config_manager, sample_account
+    ):
+        """Test that get_principal() prevents TOCTOU race same as get_connection()"""
+        mock_config_manager.add_account(sample_account)
+        mgr = AccountManager(mock_config_manager)
+        mgr._connection_ttl_minutes = 0.001
+
+        # Mock connection
+        def create_mock_client(*args, **kwargs):
+            mock_client = Mock()
+            mock_client.principal.return_value = Mock()
+            time.sleep(0.01)  # Increase race window
+            return mock_client
+
+        mock_dav_client.side_effect = create_mock_client
+
+        # Create initial connection and make it stale
+        mgr.connect_account("test_account")
+        mgr._connection_timestamps["test_account"] = time.time() - 60
+
+        # Track disconnect calls
+        disconnect_times = []
+        original_disconnect = mgr.disconnect_account
+
+        def tracked_disconnect(alias):
+            disconnect_times.append(time.time())
+            return original_disconnect(alias)
+
+        mgr.disconnect_account = tracked_disconnect
+
+        # Force race with synchronized start
+        barrier = threading.Barrier(3)
+
+        def get_principal_with_timing():
+            barrier.wait()  # All threads start simultaneously
+            mgr.get_principal("test_account")
+
+        threads = [threading.Thread(target=get_principal_with_timing) for _ in range(3)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # Should only disconnect once during reconnect
+        assert len(disconnect_times) <= 1, f"Disconnect called {len(disconnect_times)} times - race detected"
+
+    @patch("chronos_mcp.accounts.DAVClient")
+    def test_mixed_connection_principal_access(
+        self, mock_dav_client, mock_config_manager, sample_account
+    ):
+        """Test concurrent get_connection() and get_principal() don't interfere"""
+        mock_config_manager.add_account(sample_account)
+        mgr = AccountManager(mock_config_manager)
+
+        mock_client = Mock()
+        mock_dav_client.return_value = mock_client
+        mock_principal = Mock()
+        mock_client.principal.return_value = mock_principal
+
+        results = {"connection": [], "principal": []}
+
+        def get_conn():
+            conn = mgr.get_connection("test_account")
+            results["connection"].append(conn is not None)
+
+        def get_princ():
+            princ = mgr.get_principal("test_account")
+            results["principal"].append(princ is not None)
+
+        # Mix of connection and principal requests
+        threads = []
+        for i in range(10):
+            if i % 2 == 0:
+                threads.append(threading.Thread(target=get_conn))
+            else:
+                threads.append(threading.Thread(target=get_princ))
+
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        # All requests should succeed
+        assert all(results["connection"]), "Some connection requests failed"
+        assert all(results["principal"]), "Some principal requests failed"

tests/unit/test_recurring_events.py

@@ -0,0 +1,156 @@
+"""Integration tests for recurring event functionality."""
+
+from datetime import datetime, timedelta, timezone
+from unittest.mock import patch
+
+import pytest
+
+from chronos_mcp.models import Event
+
+# Import the actual function directly
+from chronos_mcp.server import create_recurring_event
+
+
+class TestRecurringEventIntegration:
+    """Test recurring event MCP tools integration."""
+
+    @pytest.mark.asyncio
+    async def test_create_recurring_event_success(self):
+        """Test successful creation of recurring event."""
+        # Mock the event manager
+        mock_event = Event(
+            uid="event-123",
+            summary="Weekly Team Meeting",
+            start=datetime.now(timezone.utc),
+            end=datetime.now(timezone.utc) + timedelta(hours=1),
+            all_day=False,
+            calendar_uid="cal-456",
+            recurrence_rule="FREQ=WEEKLY;BYDAY=MO;COUNT=10",
+            account_alias="default",
+        )
+
+        with patch(
+            "chronos_mcp.server.event_manager.create_event", return_value=mock_event
+        ):
+            # Direct function call
+            result = await create_recurring_event.fn(
+                calendar_uid="cal-456",
+                summary="Weekly Team Meeting",
+                start=datetime.now(timezone.utc).isoformat(),
+                duration_minutes=60,
+                recurrence_rule="FREQ=WEEKLY;BYDAY=MO;COUNT=10",
+                description="Weekly sync meeting",
+                location=None,
+                alarm_minutes=None,
+                attendees_json=None,
+                account=None,
+            )
+        assert result["success"] is True
+        assert result["event"]["uid"] == "event-123"
+        assert result["event"]["summary"] == "Weekly Team Meeting"
+        assert result["event"]["recurrence_rule"] == "FREQ=WEEKLY;BYDAY=MO;COUNT=10"
+
+    @pytest.mark.asyncio
+    async def test_create_recurring_event_invalid_rrule(self):
+        """Test creation fails with invalid RRULE."""
+        # Direct function call
+        result = await create_recurring_event.fn(
+            calendar_uid="cal-456",
+            summary="Invalid Event",
+            start=datetime.now(timezone.utc).isoformat(),
+            duration_minutes=60,
+            recurrence_rule="FREQ=DAILY",  # Missing COUNT or UNTIL
+            description=None,
+            location=None,
+            alarm_minutes=None,
+            attendees_json=None,
+            account=None,
+        )
+
+        assert result["success"] is False
+        assert "must have COUNT or UNTIL" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_create_recurring_event_count_too_high(self):
+        """Test creation fails when COUNT exceeds limit."""
+        # Direct function call
+        result = await create_recurring_event.fn(
+            calendar_uid="cal-456",
+            summary="Too Many Events",
+            start=datetime.now(timezone.utc).isoformat(),
+            duration_minutes=30,
+            recurrence_rule="FREQ=DAILY;COUNT=500",  # Exceeds MAX_COUNT
+            description=None,
+            location=None,
+            alarm_minutes=None,
+            attendees_json=None,
+            account=None,
+        )
+        assert result["success"] is False
+        assert "cannot exceed 365" in result["error"]
+
+    # NOTE: get_recurring_instances function does not exist in server.py
+    # These tests are commented out until the function is implemented
+    # @pytest.mark.asyncio
+    # async def test_get_recurring_instances_success(self):
+    #     """Test successful retrieval of recurring instances."""
+    #     # Mock event with recurrence
+    #     mock_event = Event(
+    #         uid="event-123",
+    #         summary="Daily Standup",
+    #         start=datetime.now(timezone.utc).replace(hour=9, minute=0, second=0, microsecond=0),
+    #         end=datetime.now(timezone.utc).replace(hour=9, minute=15, second=0, microsecond=0),
+    #         all_day=False,
+    #         calendar_uid="cal-456",
+    #         recurrence_rule="FREQ=DAILY;COUNT=5"
+    #     )
+    #
+    #     with patch('chronos_mcp.server.event_manager.get_event', return_value=mock_event):
+    #         start_date = datetime.now(timezone.utc).isoformat()
+    #         end_date = (datetime.now(timezone.utc) + timedelta(days=7)).isoformat()
+    #
+    #         result = await get_recurring_instances(
+    #             calendar_uid="cal-456",
+    #             event_uid="event-123",
+    #             start_date=start_date,
+    #             end_date=end_date
+    #         )
+    #
+    #     assert result["success"] is True
+    #     assert "instances" in result
+    #     assert len(result["instances"]) <= 5  # Limited by COUNT=5
+    #     assert result["recurrence_rule"] == "FREQ=DAILY;COUNT=5"
+    #     # Verify instance structure
+    #     if result["instances"]:
+    #         instance = result["instances"][0]
+    #         assert "start" in instance
+    #         assert "end" in instance
+    #         assert "summary" in instance
+    #         assert instance["summary"] == "Daily Standup"
+    #         assert instance["original_event_uid"] == "event-123"
+
+    # @pytest.mark.asyncio
+    # async def test_get_recurring_instances_non_recurring(self):
+    #     """Test error when event is not recurring."""
+    #     # Mock non-recurring event
+    #     mock_event = Event(
+    #         uid="event-123",
+    #         summary="Single Event",
+    #         start=datetime.now(timezone.utc),
+    #         end=datetime.now(timezone.utc) + timedelta(hours=1),
+    #         all_day=False,
+    #         calendar_uid="cal-456",
+    #         recurrence_rule=None  # No recurrence
+    #     )
+    #
+    #     with patch('chronos_mcp.server.event_manager.get_event', return_value=mock_event):
+    #         result = await get_recurring_instances(
+    #             calendar_uid="cal-456",
+    #             event_uid="event-123",
+    #             start_date=datetime.now(timezone.utc).isoformat(),
+    #             end_date=(datetime.now(timezone.utc) + timedelta(days=7)).isoformat()
+    #         )
+    #
+    #     assert result["success"] is False
+    #     assert "not a recurring event" in result["error"]
+    #     assert result["error_code"] == "VALIDATION_ERROR"

tests/unit/test_rrule.py

@@ -0,0 +1,217 @@
+"""Unit tests for RRULE validation and parsing."""
+
+from datetime import datetime, timedelta, timezone
+
+from chronos_mcp.rrule import MAX_COUNT, MAX_YEARS_AHEAD, RRuleTemplates, RRuleValidator
+
+
+class TestRRuleValidator:
+    """Test RRULE validation logic."""
+
+    def test_valid_daily_with_count(self):
+        """Test valid daily recurrence with count."""
+        is_valid, error = RRuleValidator.validate_rrule("FREQ=DAILY;COUNT=10")
+        assert is_valid is True
+        assert error is None
+
+    def test_valid_weekly_with_until(self):
+        """Test valid weekly recurrence with until date."""
+        until_date = datetime.now(timezone.utc) + timedelta(days=30)
+        rrule = f"FREQ=WEEKLY;UNTIL={until_date.strftime('%Y%m%dT%H%M%SZ')}"
+        is_valid, error = RRuleValidator.validate_rrule(rrule)
+        assert is_valid is True
+        assert error is None
+
+    def test_valid_monthly_with_bymonthday(self):
+        """Test valid monthly recurrence on specific day."""
+        is_valid, error = RRuleValidator.validate_rrule(
+            "FREQ=MONTHLY;BYMONTHDAY=15;COUNT=12"
+        )
+        assert is_valid is True
+        assert error is None
+
+    def test_valid_yearly_recurrence(self):
+        """Test valid yearly recurrence."""
+        is_valid, error = RRuleValidator.validate_rrule("FREQ=YEARLY;COUNT=5")
+        assert is_valid is True
+        assert error is None
+
+    def test_invalid_no_frequency(self):
+        """Test invalid RRULE without frequency."""
+        is_valid, error = RRuleValidator.validate_rrule("COUNT=10")
+        assert is_valid is False
+        assert "must start with FREQ=" in error
+
+    def test_invalid_no_end_condition(self):
+        """Test invalid RRULE without COUNT or UNTIL."""
+        is_valid, error = RRuleValidator.validate_rrule("FREQ=DAILY")
+        assert is_valid is False
+        assert "must have COUNT or UNTIL" in error
+
+    def test_invalid_frequency(self):
+        """Test invalid frequency (SECONDLY not allowed)."""
+        is_valid, error = RRuleValidator.validate_rrule("FREQ=SECONDLY;COUNT=10")
+        assert is_valid is False
+        assert "not allowed" in error
+
+    def test_invalid_count_too_high(self):
+        """Test invalid COUNT exceeding maximum."""
+        is_valid, error = RRuleValidator.validate_rrule(
+            f"FREQ=DAILY;COUNT={MAX_COUNT + 1}"
+        )
+        assert is_valid is False
+        assert f"cannot exceed {MAX_COUNT}" in error
+
+    def test_invalid_count_zero(self):
+        """Test invalid COUNT of zero."""
+        is_valid, error = RRuleValidator.validate_rrule("FREQ=DAILY;COUNT=0")
+        assert is_valid is False
+        assert "must be at least 1" in error
+
+    def test_invalid_until_too_far(self):
+        """Test invalid UNTIL date too far in future."""
+        far_future = datetime.now(timezone.utc).replace(
+            year=datetime.now().year + MAX_YEARS_AHEAD + 1
+        )
+        rrule = f"FREQ=DAILY;UNTIL={far_future.strftime('%Y%m%dT%H%M%SZ')}"
+        is_valid, error = RRuleValidator.validate_rrule(rrule)
+        assert is_valid is False
+        assert f"more than {MAX_YEARS_AHEAD} years" in error
+
+    def test_invalid_until_format(self):
+        """Test invalid UNTIL date format."""
+        is_valid, error = RRuleValidator.validate_rrule("FREQ=DAILY;UNTIL=invalid")
+        assert is_valid is False
+        assert "UNTIL" in error  # Changed to match actual error message
+
+    def test_valid_with_interval(self):
+        """Test valid RRULE with interval."""
+        is_valid, error = RRuleValidator.validate_rrule(
+            "FREQ=WEEKLY;INTERVAL=2;COUNT=10"
+        )
+        assert is_valid is True
+        assert error is None
+
+    def test_invalid_interval_zero(self):
+        """Test invalid interval of zero."""
+        is_valid, error = RRuleValidator.validate_rrule(
+            "FREQ=DAILY;INTERVAL=0;COUNT=10"
+        )
+        assert is_valid is False
+        assert "INTERVAL must be at least 1" in error
+
+    def test_empty_rrule(self):
+        """Test empty RRULE string."""
+        is_valid, error = RRuleValidator.validate_rrule("")
+        assert is_valid is False
+        assert "cannot be empty" in error
+
+
+class TestRRuleExpansion:
+    """Test RRULE expansion to occurrences."""
+
+    def test_expand_daily_occurrences(self):
+        """Test expanding daily occurrences."""
+        start = datetime.now(timezone.utc).replace(
+            hour=10, minute=0, second=0, microsecond=0
+        )
+        occurrences = RRuleValidator.expand_occurrences("FREQ=DAILY;COUNT=5", start)
+
+        assert len(occurrences) == 5
+        # Check dates are consecutive days
+        for i in range(1, 5):
+            assert (
+                occurrences[i].date() == (occurrences[i - 1] + timedelta(days=1)).date()
+            )
+
+    def test_expand_weekly_occurrences(self):
+        """Test expanding weekly occurrences."""
+        start = datetime.now(timezone.utc).replace(
+            hour=14, minute=0, second=0, microsecond=0
+        )
+        occurrences = RRuleValidator.expand_occurrences(
+            "FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=6", start
+        )
+
+        assert len(occurrences) == 6
+
+    def test_expand_with_end_date(self):
+        """Test expanding with end date limit."""
+        start = datetime.now(timezone.utc)
+        end = start + timedelta(days=10)
+
+        occurrences = RRuleValidator.expand_occurrences(
+            "FREQ=DAILY;COUNT=30",  # Would generate 30, but limited by end_date
+            start,
+            end_date=end,
+        )
+        # Should only return occurrences within the 10-day window
+        assert len(occurrences) <= 11  # 10 days + start day
+        assert all(occ <= end for occ in occurrences)
+
+    def test_expand_with_limit(self):
+        """Test expanding with occurrence limit."""
+        start = datetime.now(timezone.utc)
+
+        occurrences = RRuleValidator.expand_occurrences(
+            "FREQ=DAILY;COUNT=1000",  # Large count
+            start,
+            limit=50,
+        )
+
+        assert len(occurrences) == 50
+
+    def test_expand_invalid_rrule(self):
+        """Test expanding invalid RRULE returns empty list."""
+        start = datetime.now(timezone.utc)
+        occurrences = RRuleValidator.expand_occurrences("INVALID", start)
+
+        assert occurrences == []
+
+
+class TestRRuleInfo:
+    """Test RRULE information extraction."""
+
+    def test_get_rrule_info_complete(self):
+        """Test extracting complete RRULE information."""
+        info = RRuleValidator.get_rrule_info(
+            "FREQ=WEEKLY;INTERVAL=2;COUNT=10;BYDAY=MO,WE,FR"
+        )
+        assert info["frequency"] == "WEEKLY"
+        assert info["interval"] == 2
+        assert info["count"] == 10
+        assert info["byday"] == ["MO", "WE", "FR"]
+        assert info["until"] is None
+        assert info["bymonthday"] is None
+
+    def test_get_rrule_info_minimal(self):
+        """Test extracting minimal RRULE information."""
+        info = RRuleValidator.get_rrule_info("FREQ=DAILY;COUNT=5")
+
+        assert info["frequency"] == "DAILY"
+        assert info["interval"] == 1  # Default
+        assert info["count"] == 5
+        assert info["byday"] is None
+        assert info["until"] is None
+
+    def test_get_rrule_info_with_until(self):
+        """Test extracting RRULE with UNTIL."""
+        info = RRuleValidator.get_rrule_info(
+            "FREQ=MONTHLY;UNTIL=20251231T235959Z;BYMONTHDAY=15"
+        )
+
+        assert info["frequency"] == "MONTHLY"
+        assert info["until"] == "20251231T235959Z"
+        assert info["bymonthday"] == [15]
+        assert info["count"] is None
+
+
+class TestRRuleTemplates:
+    """Test RRULE template constants."""
+
+    def test_template_formats(self):
+        """Test that templates have correct format."""
+        assert RRuleTemplates.DAILY_WEEKDAYS == "FREQ=DAILY;BYDAY=MO,TU,WE,TH,FR"
+        assert RRuleTemplates.MONTHLY_LAST_DAY == "FREQ=MONTHLY;BYMONTHDAY=-1"
+        assert "{day}" in RRuleTemplates.WEEKLY_ON_DAY
+        assert "{days}" in RRuleTemplates.WEEKLY_MULTIPLE_DAYS