feat(jmap): add event integration tests; fix UTC start encoding in ical_to_jscal

Author: SashankBhamidi

caldav/jmap/convert/ical_to_jscal.py

@@ -54,8 +54,8 @@ def _dtstart_to_jscal(dtstart_prop) -> tuple[str, str | None, bool]:
         return f"{dt.isoformat()}T00:00:00", None, True
 
     if dt.tzinfo is not None and dt.utcoffset() == timedelta(0):
-        # UTC (Z suffix)
-        return dt.strftime("%Y-%m-%dT%H:%M:%SZ"), None, False
+        # UTC — JSCalendar start is LocalDateTime; express via timeZone="Etc/UTC"
+        return dt.strftime("%Y-%m-%dT%H:%M:%S"), "Etc/UTC", False
 
     if dt.tzinfo is not None:
         # Timezone-aware — prefer the TZID parameter (IANA name) over tzinfo repr

tests/test_jmap_integration.py

@@ -12,15 +12,20 @@
 Test credentials:    user1 / x
 """
 
+import uuid
+from datetime import datetime, timedelta, timezone
+
 import pytest
+import pytest_asyncio
 
 try:
     from niquests.auth import HTTPBasicAuth
 except ImportError:
     from requests.auth import HTTPBasicAuth  # type: ignore[no-redef]
 
-from caldav.jmap import JMAPClient
+from caldav.jmap import AsyncJMAPClient, JMAPClient
 from caldav.jmap.constants import CALENDAR_CAPABILITY
+from caldav.jmap.error import JMAPMethodError
 from caldav.jmap.session import fetch_session
 
 CYRUS_HOST = "localhost"
@@ -47,6 +52,25 @@ def _cyrus_reachable() -> bool:
 )
 
 
+def _minimal_ical(title: str = "Test Event", start: datetime | None = None) -> str:
+    if start is None:
+        start = datetime(2026, 6, 1, 10, 0, 0, tzinfo=timezone.utc)
+    end = start + timedelta(hours=1)
+    uid = str(uuid.uuid4())
+    return (
+        "BEGIN:VCALENDAR\r\n"
+        "VERSION:2.0\r\n"
+        "PRODID:-//test//test//EN\r\n"
+        "BEGIN:VEVENT\r\n"
+        f"UID:{uid}\r\n"
+        f"SUMMARY:{title}\r\n"
+        f"DTSTART:{start.strftime('%Y%m%dT%H%M%SZ')}\r\n"
+        f"DTEND:{end.strftime('%Y%m%dT%H%M%SZ')}\r\n"
+        "END:VEVENT\r\n"
+        "END:VCALENDAR\r\n"
+    )
+
+
 @pytest.fixture(scope="module")
 def client():
     return JMAPClient(url=JMAP_URL, username=CYRUS_USERNAME, password=CYRUS_PASSWORD)
@@ -57,6 +81,47 @@ def session():
     return fetch_session(JMAP_URL, auth=HTTPBasicAuth(CYRUS_USERNAME, CYRUS_PASSWORD))
 
 
+@pytest.fixture(scope="module")
+def calendar_id(client):
+    calendars = client.get_calendars()
+    assert calendars, "Cyrus did not provision any calendars for user1"
+    return calendars[0].id
+
+
+@pytest.fixture
+def created_event_id(client, calendar_id):
+    event_id = client.create_event(calendar_id, _minimal_ical("Integration Test Event"))
+    yield event_id
+    try:
+        client.delete_event(event_id)
+    except Exception:
+        pass
+
+
+@pytest_asyncio.fixture
+async def async_client():
+    return AsyncJMAPClient(url=JMAP_URL, username=CYRUS_USERNAME, password=CYRUS_PASSWORD)
+
+
+@pytest_asyncio.fixture
+async def async_calendar_id(async_client):
+    calendars = await async_client.get_calendars()
+    assert calendars, "Cyrus did not provision any calendars for user1"
+    return calendars[0].id
+
+
+@pytest_asyncio.fixture
+async def async_created_event_id(async_client, async_calendar_id):
+    event_id = await async_client.create_event(
+        async_calendar_id, _minimal_ical("Async Integration Test Event")
+    )
+    yield event_id
+    try:
+        await async_client.delete_event(event_id)
+    except Exception:
+        pass
+
+
 class TestJMAPSessionIntegration:
     def test_session_fetch_returns_api_url(self, session):
         assert session.api_url
@@ -80,3 +145,111 @@ def test_calendars_have_id_and_name(self, client):
         for cal in calendars:
             assert cal.id, f"Calendar missing id: {cal}"
             assert cal.name, f"Calendar has empty name: {cal}"
+
+
+class TestJMAPEventIntegration:
+    def test_event_create_get(self, client, created_event_id):
+        ical = client.get_event(created_event_id)
+        assert "BEGIN:VCALENDAR" in ical
+        assert "Integration Test Event" in ical
+
+    def test_event_update(self, client, created_event_id):
+        client.update_event(created_event_id, _minimal_ical("Updated Title"))
+        fetched = client.get_event(created_event_id)
+        assert "Updated Title" in fetched
+
+    def test_event_delete(self, client, calendar_id):
+        event_id = client.create_event(calendar_id, _minimal_ical("To Be Deleted"))
+        client.delete_event(event_id)
+        with pytest.raises(JMAPMethodError):
+            client.get_event(event_id)
+
+    def test_event_query_time_range(self, client, calendar_id, created_event_id):
+        results = client.search_events(
+            calendar_id=calendar_id,
+            start="2026-06-01T00:00:00",
+            end="2026-06-02T00:00:00",
+        )
+        assert len(results) >= 1
+        assert any("Integration Test Event" in r for r in results)
+
+    def test_event_sync(self, client, calendar_id):
+        token_before = client.get_sync_token()
+        event_id = client.create_event(calendar_id, _minimal_ical("Sync Test Event"))
+        try:
+            added, _modified, _deleted = client.get_objects_by_sync_token(token_before)
+            assert any("Sync Test Event" in a for a in added)
+        finally:
+            client.delete_event(event_id)
+
+    def test_ical_roundtrip(self, client, calendar_id):
+        start = datetime(2026, 7, 15, 9, 0, 0, tzinfo=timezone.utc)
+        event_id = client.create_event(calendar_id, _minimal_ical("Roundtrip Event", start=start))
+        try:
+            fetched = client.get_event(event_id)
+            assert "Roundtrip Event" in fetched
+            assert "20260715" in fetched
+        finally:
+            client.delete_event(event_id)
+
+
+class TestAsyncJMAPEventIntegration:
+    @pytest.mark.asyncio
+    async def test_event_create_get(self, async_client, async_created_event_id):
+        ical = await async_client.get_event(async_created_event_id)
+        assert "BEGIN:VCALENDAR" in ical
+        assert "Async Integration Test Event" in ical
+
+    @pytest.mark.asyncio
+    async def test_event_update(self, async_client, async_created_event_id):
+        await async_client.update_event(
+            async_created_event_id, _minimal_ical("Async Updated Title")
+        )
+        fetched = await async_client.get_event(async_created_event_id)
+        assert "Async Updated Title" in fetched
+
+    @pytest.mark.asyncio
+    async def test_event_delete(self, async_client, async_calendar_id):
+        event_id = await async_client.create_event(
+            async_calendar_id, _minimal_ical("Async To Be Deleted")
+        )
+        await async_client.delete_event(event_id)
+        with pytest.raises(JMAPMethodError):
+            await async_client.get_event(event_id)
+
+    @pytest.mark.asyncio
+    async def test_event_query_time_range(
+        self, async_client, async_calendar_id, async_created_event_id
+    ):
+        results = await async_client.search_events(
+            calendar_id=async_calendar_id,
+            start="2026-06-01T00:00:00",
+            end="2026-06-02T00:00:00",
+        )
+        assert len(results) >= 1
+        assert any("Async Integration Test Event" in r for r in results)
+
+    @pytest.mark.asyncio
+    async def test_event_sync(self, async_client, async_calendar_id):
+        token_before = await async_client.get_sync_token()
+        event_id = await async_client.create_event(
+            async_calendar_id, _minimal_ical("Async Sync Test Event")
+        )
+        try:
+            added, _modified, _deleted = await async_client.get_objects_by_sync_token(token_before)
+            assert any("Async Sync Test Event" in a for a in added)
+        finally:
+            await async_client.delete_event(event_id)
+
+    @pytest.mark.asyncio
+    async def test_ical_roundtrip(self, async_client, async_calendar_id):
+        start = datetime(2026, 7, 15, 9, 0, 0, tzinfo=timezone.utc)
+        event_id = await async_client.create_event(
+            async_calendar_id, _minimal_ical("Async Roundtrip Event", start=start)
+        )
+        try:
+            fetched = await async_client.get_event(event_id)
+            assert "Async Roundtrip Event" in fetched
+            assert "20260715" in fetched
+        finally:
+            await async_client.delete_event(event_id)

tests/test_jmap_unit.py

@@ -1011,7 +1011,8 @@ def test_minimal_event(self):
         result = ical_to_jscal(ical)
         assert result["uid"] == "test-uid@example.com"
         assert result["title"] == "Test Event"
-        assert result["start"] == "2024-06-15T10:00:00Z"
+        assert result["start"] == "2024-06-15T10:00:00"
+        assert result["timeZone"] == "Etc/UTC"
         assert result["duration"] == "PT1H"
 
     def test_all_day_event(self):
@@ -1036,8 +1037,8 @@ def test_timezone_aware_event(self):
     def test_utc_event(self):
         ical = _make_ical("DTSTART:20240615T100000Z\r\nDURATION:PT30M\r\nSUMMARY:UTC Event\r\n")
         result = ical_to_jscal(ical)
-        assert result["start"].endswith("Z")
-        assert "timeZone" not in result
+        assert result["start"] == "2024-06-15T10:00:00"
+        assert result["timeZone"] == "Etc/UTC"
 
     def test_duration_from_dtend(self):
         ical = _make_ical(