fix(sharepoint): resolve list item entity type before batched create

ListItem.ensure_type_name queued the create while _entity_type_name was
still unset, so execute_batch serialized the item as SP.ListItem; a
multi-lookup collection was then rejected as an open collection claim.

Queue a deferred barrier after the ListItemEntityTypeFullName read so the
annotation is adopted before the create round is built. Drop the unused
action parameter and cover the cold and cached paths offline.

Refs #717

Author: vgrem

CHANGELOG.md

@@ -59,6 +59,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
   `/_api/$batch` is flagged `batchable = False` and run on its own. Fixes
   `DocumentSet.create(...)` followed by `execute_batch()`
   ([#868](https://github.com/vgrem/office365-rest-python-client/issues/868)).
+- **List item creates in batches:** `ListItem.ensure_type_name` now defers the
+  queued create until `ListItemEntityTypeFullName` is read, so an `add_item` /
+  `update` batched via `execute_batch` is serialized with the correct
+  `SP.Data.<List>ListItem` annotation instead of the open `SP.ListItem` type.
+  Fixes "An open collection property ... was found"
+  ([#717](https://github.com/vgrem/office365-rest-python-client/issues/717)).
 
 ### Internal
 - **Developer onboarding rework:** credentials flow through `tests/settings.py` with

office365/sharepoint/listitems/listitem.py

@@ -787,21 +787,23 @@ def _tax_text_field_loaded(return_type):
 
         tax_field.ensure_property("TextField").after_execute(lambda _: _tax_field_loaded())
 
-    def ensure_type_name(self, target_list, action=None):
-        """Determine metadata annotation for ListItem entity
+    def ensure_type_name(self, target_list) -> Self:
+        """Determine the metadata type annotation for this list item.
+
+        Adopts the target list's ``ListItemEntityTypeFullName`` once it is available.
+        When the list has not resolved it yet, a deferred barrier is queued right after
+        the read, so the annotation is set before any query built afterwards executes
+        -- including inside ``execute_batch``.
 
         Args:
             target_list (office365.sharepoint.lists.list.List): List resource
-            action (() -> None): Event handler
         """
         if self._entity_type_name is None:
+            from office365.runtime.queries.deferred import DeferredOperationQuery
 
             def _list_loaded():
                 self._entity_type_name = target_list.properties["ListItemEntityTypeFullName"]
-                if callable(action):
-                    action()
 
             target_list.ensure_property("ListItemEntityTypeFullName").after_execute(lambda _: _list_loaded())
-        elif callable(action):
-            action()
+            target_list.context.add_query(DeferredOperationQuery(target_list.context))
         return self

tests/unit/test_runtime_batch.py

@@ -662,13 +662,15 @@ def __init__(self, bodies_per_round: list[list[dict]], single_bodies: list[dict]
         self._bodies = bodies_per_round
         self._single_bodies = single_bodies or []
         self.rounds: list[list[str]] = []
+        self.payloads: list[str] = []
         self.singles: list[str] = []
 
     def execute(self, request):
         if "$batch" in request.url:
             payload = request.data
             if isinstance(payload, bytes):
                 payload = payload.decode("utf-8", "replace")
+            self.payloads.append(payload)
             lines = [
                 line.strip()
                 for line in payload.splitlines()
@@ -799,6 +801,55 @@ def test_document_set_create_resolves_deferred_barrier():
     assert transport.singles == ["POST https://contoso.sharepoint.com/_vti_bin/listdata.svc/SharedDocuments HTTP/1.1"]
 
 
+# ── #717: list item entity type must be resolved before the create round ──────
+
+_LIST_TYPE_BODY = {
+    "d": {
+        "__metadata": {"type": "SP.List"},
+        "ListItemEntityTypeFullName": "SP.Data.MyListListItem",
+    }
+}
+
+
+def test_add_item_resolves_entity_type_before_create_round():
+    """#717: the create must not be batched with the list's type-name read.
+
+    The annotation (``SP.Data.<List>ListItem``) is read in one round, then the POST
+    is serialized in a later round; otherwise the server sees a multi-lookup value
+    collection on an ``SP.ListItem`` and rejects it as an open collection.
+    """
+    transport = _ScriptedBatchTransport([[_LIST_TYPE_BODY], [{"d": {}}]])
+    ctx = _sharepoint_ctx(transport)
+    lst = ctx.web.lists.get_by_title("MyList")
+
+    item = lst.add_item({"Title": "A1"})
+    ctx.execute_batch()
+
+    assert len(transport.rounds) == 2, transport.rounds  # noqa: PLR2004
+    assert transport.rounds[0][0].startswith("GET ")
+    assert transport.rounds[1][0].startswith("POST ")
+    assert "/items" in transport.rounds[1][0]
+    assert item.entity_type_name == "SP.Data.MyListListItem"
+    assert "SP.Data.MyListListItem" in transport.payloads[1]
+
+
+def test_add_item_reuses_cached_entity_type_without_reading_it_again():
+    """Once cached, the type annotation is adopted without an extra list read."""
+    transport = _ScriptedBatchTransport([[{"d": {}}]])
+    ctx = _sharepoint_ctx(transport)
+    lst = ctx.web.lists.get_by_title("MyList")
+    lst.set_property("Id", "11111111-2222-3333-4444-555555555555")
+    lst.set_property("ListItemEntityTypeFullName", "SP.Data.MyListListItem")
+
+    item = lst.add_item({"Title": "A1"})
+    ctx.execute_batch()
+
+    assert len(transport.rounds) == 1, transport.rounds
+    assert transport.rounds[0][0].startswith("POST ")
+    assert item.entity_type_name == "SP.Data.MyListListItem"
+    assert "SP.Data.MyListListItem" in transport.payloads[0]
+
+
 def test_document_set_create_drains_all_rounds_async():
     """Async twin of the multi-phase ``DocumentSet.create`` batch chain."""
     transport = _ScriptedBatchTransport([[_FOLDER_BODY], [_LIST_BODY]], single_bodies=[_CREATE_BODY])