fix: handle async client in add_organizer() no-arg path

add_organizer() without arguments called self.client.principal()
directly.  On an AsyncDAVClient that method is a coroutine function, so
the call returned a coroutine object and the subsequent .get_vcal_address()
raised AttributeError.  Fix by delegating to _async_add_organizer() when
is_async_client, following the same dual-mode pattern used by set_relation()
and load().  Extract _set_organizer() to avoid duplicating the two-liner
that pops and re-adds the ORGANIZER property.

Add _async_get_vcal_address() to Principal so that _async_add_organizer()
can await the property lookups (get_display_name, calendar-user-address-set,
CalendarUserType) that get_vcal_address() performs synchronously.

Also add missing unit tests:
- test_add_organizer_principal_object: cover the Principal-object argument
  path (isinstance(organizer, _Principal)), which had no coverage.
- test_add_organizer_explicit_arg_is_sync_safe_for_async_client: explicit
  arg is pure in-memory and must not require awaiting even for async clients.
- test_add_organizer_no_arg_returns_coroutine_for_async_client: the no-arg
  path must return a coroutine (not raise AttributeError) for async clients.
- test_add_organizer_no_arg_async_awaited_sets_organizer: awaiting that
  coroutine must actually set the ORGANIZER field.

Add sync integration test testAddOrganizer to RepeatedFunctionalTestsBaseClass
covering all three argument forms (no-arg, email string, vCalAddress).  The
no-arg sub-test is skipped on servers that do not expose
scheduling.calendar-user-address-set.

Add async integration test test_add_organizer_no_arg to
AsyncFunctionalTestsBaseClass in tests/test_async_integration.py.  It
verifies that add_organizer() returns a coroutine for async clients, that
awaiting it sets ORGANIZER, and that the resulting address matches the
principal's own vCalAddress.  Also skipped when
scheduling.calendar-user-address-set is not supported.

Note: the two callers that invoke add_organizer() without arguments
(Calendar.freebusy_request and Calendar.save_with_invites in collection.py)
are not themselves async-aware, so they will still malfunction when used
via an async client — but that is a pre-existing limitation of those methods,
not something introduced here.

Prompt: The new logic in add_organizer, is it well-enough covered by test
code?  Is there a symmetry in the async and sync behaviour?  Is there a
symmetry between the sync and async tests?  Fix the missing tests, including
async tests and particularly a test to expose the async bug.  Come with
suggestions on how to solve the async problem.

Followup-prompt: In the previous commit a fix was applied, but the commit
message says that only the test framework was modified.  Please amend the
commit.

Followup-prompt: The previous commit did not add any integration tests.
Please add some integration tests (including async tests) and amend the
commit.

Followup-prompt: Keep the commit message in imperative mood.

Followup-prompt: Async tests should be in tests/test_async_integration.py.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tobixen

caldav/calendarobjectresource.py

@@ -182,12 +182,18 @@ def add_organizer(self, organizer=None) -> None:
         * A plain email address string (``"mailto:"`` is prepended automatically)
 
         Any pre-existing ORGANIZER field is removed before the new one is added.
+
+        For async clients, when *organizer* is omitted the method returns a
+        coroutine that must be awaited.  When an explicit *organizer* is supplied
+        the method is always synchronous (pure in-memory, no network call).
         """
         from .collection import Principal as _Principal  ## avoid circular import
 
         if organizer is None:
             if self.client is None:
                 raise ValueError("Unexpected value None for self.client")
+            if self.is_async_client:
+                return self._async_add_organizer()
             organizer_obj = self.client.principal().get_vcal_address()
         elif isinstance(organizer, _Principal):
             organizer_obj = organizer.get_vcal_address()
@@ -201,6 +207,15 @@ def add_organizer(self, organizer=None) -> None:
         else:
             raise ValueError(f"Unsupported organizer type: {type(organizer)!r}")
 
+        self._set_organizer(organizer_obj)
+
+    async def _async_add_organizer(self) -> None:
+        """Async implementation of add_organizer() for async clients."""
+        principal = await self.client.principal()
+        self._set_organizer(await principal._async_get_vcal_address())
+
+    def _set_organizer(self, organizer_obj: vCalAddress) -> None:
+        """Write the ORGANIZER property onto the icalendar component (sync, no I/O)."""
         ievent = self.icalendar_component
         ievent.pop("organizer", None)
         ievent.add("organizer", organizer_obj)

caldav/collection.py

@@ -396,6 +396,22 @@ def get_vcal_address(self) -> "vCalAddress":
         ret.params["cutype"] = vText(cutype)
         return ret
 
+    async def _async_get_vcal_address(self) -> "vCalAddress":
+        """Async counterpart of get_vcal_address() for use with AsyncDAVClient."""
+        from icalendar import vCalAddress, vText
+
+        cn = await self.get_display_name()
+        addresses_el = await self.get_property(cdav.CalendarUserAddressSet(), parse_props=False)
+        if addresses_el is None:
+            raise error.NotFoundError("No calendar user addresses given from server")
+        assert not [x for x in addresses_el if x.tag != dav.Href().tag]
+        addresses = sorted(list(addresses_el), key=lambda x: -int(x.get("preferred", 0)))
+        cutype = await self.get_property(cdav.CalendarUserType())
+        ret = vCalAddress(addresses[0].text)
+        ret.params["cn"] = vText(cn)
+        ret.params["cutype"] = vText(cutype)
+        return ret
+
     @property
     def calendar_home_set(self):
         if not self._calendar_home_set:

tests/test_async_integration.py

@@ -439,6 +439,37 @@ async def test_todos_method(self, async_task_list: Any) -> None:
         assert len(todos) >= 1
         assert all(isinstance(t, AsyncTodo) for t in todos)
 
+    @pytest.mark.asyncio
+    async def test_add_organizer_no_arg(self, async_client: Any, async_calendar: Any) -> None:
+        """add_organizer() without args returns a coroutine and sets ORGANIZER (issue #524).
+
+        Verifies the async fix: on an AsyncDAVClient principal() is a coroutine
+        function, so add_organizer() must await it via _async_add_organizer()
+        rather than calling it synchronously (which would raise AttributeError
+        on the returned coroutine object).
+        """
+        from caldav import Event
+
+        self.skip_unless_support("scheduling.calendar-user-address-set")
+
+        principal = await async_client.principal()
+        expected_vcal = await principal._async_get_vcal_address()
+
+        event = Event(client=async_client, data=ev1(), parent=async_calendar)
+
+        ## Must return a coroutine, not raise AttributeError
+        coro = event.add_organizer()
+        assert asyncio.iscoroutine(coro), (
+            f"add_organizer() on async client must return a coroutine, got {type(coro)}"
+        )
+        await coro
+
+        org = event.icalendar_component.get("organizer")
+        assert org is not None, "ORGANIZER must be set after awaiting add_organizer()"
+        assert str(org) == str(expected_vcal), (
+            f"ORGANIZER {org!r} should match the principal's address {expected_vcal!r}"
+        )
+
 
 # ==================== Dynamic Test Class Generation ====================
 #

tests/test_caldav.py

@@ -1263,6 +1263,46 @@ def testSchedulingInfo(self):
         calendar_user_address_set = self.principal.calendar_user_address_set()
         me_a_participant = self.principal.get_vcal_address()
 
+    def testAddOrganizer(self):
+        """add_organizer() sets ORGANIZER from the current principal (issue #524).
+
+        Tests three paths:
+        - no-arg: principal is looked up from the client (requires
+          scheduling.calendar-user-address-set).
+        - explicit email string: pure in-memory, no server interaction.
+        - explicit vCalAddress: pure in-memory, no server interaction.
+        """
+        from icalendar import vCalAddress
+
+        cal = self._fixCalendar()
+        event = Event(
+            client=self.caldav,
+            data=ev1,
+            parent=cal,
+        )
+
+        ## ---- explicit string arg (pure in-memory, always runs) ----
+        event.add_organizer("organizer@example.com")
+        org = event.icalendar_component.get("organizer")
+        assert org is not None, "ORGANIZER should be set after add_organizer(string)"
+        assert "organizer@example.com" in str(org)
+
+        ## ---- explicit vCalAddress arg ----
+        addr = vCalAddress("mailto:addr@example.com")
+        event.add_organizer(addr)
+        org = event.icalendar_component.get("organizer")
+        assert str(org) == "mailto:addr@example.com"
+
+        ## ---- no-arg: uses current principal ----
+        self.skip_unless_support("scheduling.calendar-user-address-set")
+        event.add_organizer()
+        org = event.icalendar_component.get("organizer")
+        assert org is not None, "ORGANIZER should be set when add_organizer() uses principal"
+        principal_addresses = self.principal.calendar_user_address_set()
+        assert any(addr in str(org) for addr in principal_addresses), (
+            f"ORGANIZER {org!r} should contain one of the principal's addresses {principal_addresses!r}"
+        )
+
     def testIssue399ChangeAttendeeStatusUsernameEmailFallback(self):
         """change_attendee_status() works when the attendee is identified
         by the client username rather than calendar_user_address_set() (issue #399).

tests/test_caldav_unit.py

@@ -2190,12 +2190,76 @@ def test_set_relation_returns_coroutine_for_async_client(self):
         result.close()
 
     def test_accept_invite_raises_not_implemented_for_async_client(self):
-        """accept_invite() must raise NotImplementedError for async clients (not silently fail)."""
+        """accept_invite() must raise Notimplemented for async clients (not silently fail)."""
         client, calendar = self._make_async_client_and_calendar()
         event = Event(client=client, url="/calendar/ev1.ics", data=ev1, parent=calendar)
         with pytest.raises(NotImplementedError):
             event.accept_invite()
 
+    def test_add_organizer_explicit_arg_is_sync_safe_for_async_client(self):
+        """add_organizer(explicit_arg) is pure in-memory: no network call, no await needed.
+        It must work correctly even when the client is an async client."""
+        from icalendar import vCalAddress
+
+        client, calendar = self._make_async_client_and_calendar()
+        event = Event(client=client, url="/calendar/ev1.ics", data=ev1, parent=calendar)
+        event.add_organizer("organizer@example.com")
+        organizer = event.icalendar_component.get("organizer")
+        assert "organizer@example.com" in str(organizer)
+
+    def test_add_organizer_no_arg_returns_coroutine_for_async_client(self):
+        """add_organizer() without args must return a coroutine for async clients.
+
+        Bug: today the code calls self.client.principal().get_vcal_address() without
+        checking is_async_client first.  On an AsyncDAVClient, principal() is a
+        coroutine function, so principal() returns a coroutine object.  Calling
+        .get_vcal_address() on that coroutine raises AttributeError instead of
+        returning a usable coroutine to the caller.
+        """
+        import asyncio
+
+        from icalendar import vCalAddress
+
+        client, calendar = self._make_async_client_and_calendar()
+        event = Event(client=client, url="/calendar/ev1.ics", data=ev1, parent=calendar)
+
+        async def async_principal():
+            p = mock.MagicMock()
+            p._async_get_vcal_address = mock.AsyncMock(
+                return_value=vCalAddress("mailto:me@example.com")
+            )
+            return p
+
+        client.principal = async_principal
+
+        result = event.add_organizer()
+        assert asyncio.iscoroutine(result), (
+            f"expected a coroutine from add_organizer() on async client, got {type(result)}"
+        )
+        result.close()
+
+    def test_add_organizer_no_arg_async_awaited_sets_organizer(self):
+        """Awaiting add_organizer() without args on async client must set ORGANIZER correctly."""
+        import asyncio
+
+        from icalendar import vCalAddress
+
+        client, calendar = self._make_async_client_and_calendar()
+        event = Event(client=client, url="/calendar/ev1.ics", data=ev1, parent=calendar)
+
+        async def async_principal():
+            p = mock.MagicMock()
+            p._async_get_vcal_address = mock.AsyncMock(
+                return_value=vCalAddress("mailto:me@example.com")
+            )
+            return p
+
+        client.principal = async_principal
+
+        asyncio.run(event.add_organizer())
+        organizer = event.icalendar_component.get("organizer")
+        assert str(organizer) == "mailto:me@example.com"
+
 
 class TestRateLimitHelpers:
     """Unit tests for the shared rate-limit helper functions in caldav.lib.error."""
@@ -2867,6 +2931,18 @@ def test_add_organizer_no_arg_no_client_raises(self):
         with pytest.raises(ValueError):
             ev.add_organizer()
 
+    def test_add_organizer_principal_object(self):
+        """Passing a Principal object directly calls get_vcal_address() on it."""
+        from icalendar import vCalAddress
+
+        ev = self._make_event()
+        mock_principal = mock.MagicMock(spec=Principal)
+        mock_principal.get_vcal_address.return_value = vCalAddress("mailto:organizer@example.com")
+        ev.add_organizer(mock_principal)
+        organizer = ev.icalendar_component.get("organizer")
+        assert str(organizer) == "mailto:organizer@example.com"
+        mock_principal.get_vcal_address.assert_called_once()
+
 
 class TestChangeAttendeeStatusFallback:
     """Unit tests for change_attendee_status() fallback when calendar_user_address_set() is unavailable.