refactor: use copy.copy + _parse_common_tags in Webhooks.update

Match the convention used by users_endpoint.update and datasources_endpoint.update
so that fields set locally on a WebhookItem are preserved when the server's
update response omits them. Previously the endpoint used
WebhookItem.from_response(...)[0], which returned a fresh item populated only
from server-supplied fields.

- Adds WebhookItem._parse_common_tags matching the pattern in UserItem and
  WorkbookItem (name refers to XML common tags, not user-facing tags).
- Adds test_update_preserves_locally_set_fields_omitted_by_server exercising
  the local-preservation semantics against a partial server response.

Feedback from bcantoni on #1806.

Author: jacalata

tableauserverclient/models/webhook_item.py

@@ -109,6 +109,21 @@ def from_response(cls: type["WebhookItem"], resp: bytes, ns) -> list["WebhookIte
             all_webhooks_items.append(webhook_item)
         return all_webhooks_items
 
+    def _parse_common_tags(self, webhook_xml, ns) -> "WebhookItem":
+        """Merge fields from a server response into this item.
+
+        Used by the update endpoint (matching the convention in users_endpoint
+        and datasources_endpoint) so that locally-set fields are preserved
+        when the server's response omits them.
+        """
+        if not isinstance(webhook_xml, ET.Element):
+            parsed = fromstring(webhook_xml)
+            webhook_xml = parsed.find(".//t:webhook", namespaces=ns)
+        if webhook_xml is not None:
+            values = self._parse_element(webhook_xml, ns)
+            self._set_values(*values)
+        return self
+
     @staticmethod
     def _parse_element(webhook_xml: ET.Element, ns) -> tuple:
         id = webhook_xml.get("id", None)

tableauserverclient/server/endpoint/webhooks_endpoint.py

@@ -1,3 +1,4 @@
+import copy
 import logging
 
 from .endpoint import Endpoint, api
@@ -142,9 +143,9 @@ def update(self, webhook_item: WebhookItem) -> WebhookItem:
         url = f"{self.baseurl}/{webhook_item.id}"
         update_req = RequestFactory.Webhook.update_req(webhook_item)
         server_response = self.put_request(url, update_req)
-        updated_webhook = WebhookItem.from_response(server_response.content, self.parent_srv.namespace)[0]
         logger.info(f"Updated webhook (ID: {webhook_item.id})")
-        return updated_webhook
+        updated_webhook = copy.copy(webhook_item)
+        return updated_webhook._parse_common_tags(server_response.content, self.parent_srv.namespace)
 
     @api(version="3.6")
     def test(self, webhook_id: str):

test/test_webhook.py

@@ -207,6 +207,46 @@ def test_update_missing_id(server: TSC.Server) -> None:
         server.webhooks.update(webhook_item)
 
 
+def test_update_preserves_locally_set_fields_omitted_by_server(server: TSC.Server) -> None:
+    """update should preserve locally-set fields that the server response omits.
+
+    Matches the pattern used by users_endpoint.update and datasources_endpoint.update:
+    fields set on the input item should survive when the server returns a partial
+    response.
+    """
+    # Server response omits is_enabled, owner, and url; only id and name are returned.
+    partial_response = (
+        "<?xml version='1.0' encoding='UTF-8'?>"
+        '<tsResponse xmlns="http://tableau.com/api">'
+        '  <webhook id="webhook-id" name="webhook-name-updated">'
+        "    <webhook-source>"
+        "      <webhook-source-event-datasource-created />"
+        "    </webhook-source>"
+        "  </webhook>"
+        "</tsResponse>"
+    )
+    with requests_mock.mock() as m:
+        m.put(server.webhooks.baseurl + "/webhook-id", text=partial_response)
+        webhook_item = WebhookItem()
+        webhook_item._set_values(
+            "webhook-id",
+            "webhook-name-original",
+            "https://local-url.example.com/hook",
+            "datasource-created",
+            "local-owner-luid",
+        )
+        webhook_item.is_enabled = False
+
+        updated_webhook = server.webhooks.update(webhook_item)
+
+        # Fields returned by the server should be updated.
+        assert updated_webhook.name == "webhook-name-updated"
+        # Fields omitted by the server should retain their locally-set values.
+        assert updated_webhook.url == "https://local-url.example.com/hook"
+        assert updated_webhook.owner_id == "local-owner-luid"
+        assert updated_webhook.is_enabled is False
+
+
 def test_update_request_factory_is_enabled() -> None:
     webhook_item = WebhookItem()
     webhook_item._set_values(