sfq 0.0.27__tar.gz → 0.0.29__tar.gz

{sfq-0.0.27 → sfq-0.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sfq
-Version: 0.0.27
+Version: 0.0.29
 Summary: Python wrapper for the Salesforce's Query API.
 Author-email: David Moruzzi <sfq.pypi@dmoruzi.com>
 Keywords: salesforce,salesforce query

{sfq-0.0.27 → sfq-0.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sfq"
-version = "0.0.27"
+version = "0.0.29"
 description = "Python wrapper for the Salesforce's Query API."
 readme = "README.md"
 authors = [{ name = "David Moruzzi", email = "sfq.pypi@dmoruzi.com" }]

{sfq-0.0.27 → sfq-0.0.29}/src/sfq/__init__.py

@@ -7,11 +7,13 @@ import http.client
 import json
 import logging
 import os
+import re
 import time
 import warnings
+import xml.etree.ElementTree as ET
 from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Any, Dict, Iterable, Literal, Optional, List, Tuple
+from typing import Any, Dict, Iterable, List, Literal, Optional, Tuple
 from urllib.parse import quote, urlparse
 
 __all__ = ["SFAuth"]  # https://pdoc.dev/docs/pdoc.html#control-what-is-documented
@@ -24,7 +26,7 @@ def trace(self: logging.Logger, message: str, *args: Any, **kwargs: Any) -> None
     """Custom TRACE level logging function with redaction."""
 
     def _redact_sensitive(data: Any) -> Any:
-        """Redacts sensitive keys from a dictionary or query string."""
+        """Redacts sensitive keys from a dictionary, query string, or sessionId."""
         REDACT_VALUE = "*" * 8
         REDACT_KEYS = [
             "access_token",
@@ -33,6 +35,7 @@ def trace(self: logging.Logger, message: str, *args: Any, **kwargs: Any) -> None
             "cookie",
             "refresh_token",
             "client_secret",
+            "sessionid",
         ]
         if isinstance(data, dict):
             return {
@@ -49,6 +52,12 @@ def trace(self: logging.Logger, message: str, *args: Any, **kwargs: Any) -> None
                 )
             )
         elif isinstance(data, str):
+            if "<sessionId>" in data and "</sessionId>" in data:
+                data = re.sub(
+                    r"(<sessionId>)(.*?)(</sessionId>)",
+                    r"\1{}\3".format(REDACT_VALUE),
+                    data,
+                )
             parts = data.split("&")
             for i, part in enumerate(parts):
                 if "=" in part:
@@ -90,7 +99,7 @@ class SFAuth:
         access_token: Optional[str] = None,
         token_expiration_time: Optional[float] = None,
         token_lifetime: int = 15 * 60,
-        user_agent: str = "sfq/0.0.27",
+        user_agent: str = "sfq/0.0.29",
         sforce_client: str = "_auto",
         proxy: str = "_auto",
     ) -> None:
@@ -828,7 +837,9 @@ class SFAuth:
                 for i, result in enumerate(results):
                     key = batch_keys[i]
                     if result.get("statusCode") == 200 and "result" in result:
-                        paginated = self._paginate_query_result(result["result"], headers)
+                        paginated = self._paginate_query_result(
+                            result["result"], headers
+                        )
                         batch_results[key] = paginated
                     else:
                         logger.error("Query failed for key %s: %s", key, result)
@@ -854,7 +865,9 @@ class SFAuth:
             for i in range(0, len(keys), BATCH_SIZE):
                 batch_keys = keys[i : i + BATCH_SIZE]
                 batch_queries = [query_dict[key] for key in batch_keys]
-                futures.append(executor.submit(_execute_batch, batch_keys, batch_queries))
+                futures.append(
+                    executor.submit(_execute_batch, batch_keys, batch_queries)
+                )
 
             for future in as_completed(futures):
                 results_dict.update(future.result())
@@ -910,12 +923,14 @@ class SFAuth:
         ]
         return combined_response or None
 
-    def _cupdate(self, update_dict: Dict[str, Any], batch_size: int = 25, max_workers: int = None) -> Optional[Dict[str, Any]]:
+    def _cupdate(
+        self, update_dict: Dict[str, Any], batch_size: int = 25, max_workers: int = None
+    ) -> Optional[Dict[str, Any]]:
         """
         Execute the Composite Update API to update multiple records.
 
         :param update_dict: A dictionary of keys of records to be updated, and a dictionary of field-value pairs to be updated, with a special key '_' overriding the sObject type which is otherwise inferred from the key. Example:
-            {'001aj00000C8kJhAAJ': {'Subject': 'Easily updated via SFQ'}, '00aaj000006wtdcAAA': {'_': 'CaseComment', 'IsPublished': False}, '001aj0000002yJRCAY': {'_': 'IdeaComment', 'CommentBody': 'Hello World!'}} 
+            {'001aj00000C8kJhAAJ': {'Subject': 'Easily updated via SFQ'}, '00aaj000006wtdcAAA': {'_': 'CaseComment', 'IsPublished': False}, '001aj0000002yJRCAY': {'_': 'IdeaComment', 'CommentBody': 'Hello World!'}}
         :param batch_size: The number of records to update in each batch (default is 25).
         :return: JSON response from the update request or None on failure.
         """
@@ -929,26 +944,26 @@ class SFAuth:
             sobject = record.copy().pop("_", None)
             if not sobject and not sobject_prefixes:
                 sobject_prefixes = self.get_sobject_prefixes()
-            
+
             if not sobject:
                 sobject = str(sobject_prefixes.get(str(key[:3]), None))
-            
+
             compositeRequest_payload.append(
                 {
-                    'method': 'PATCH',
-                    'url': f"/services/data/{self.api_version}/sobjects/{sobject}/{key}",
-                    'referenceId': key,
-                    'body': record,
+                    "method": "PATCH",
+                    "url": f"/services/data/{self.api_version}/sobjects/{sobject}/{key}",
+                    "referenceId": key,
+                    "body": record,
                 }
             )
 
-        chunks = [compositeRequest_payload[i:i+batch_size] for i in range(0, len(compositeRequest_payload), batch_size)]
+        chunks = [
+            compositeRequest_payload[i : i + batch_size]
+            for i in range(0, len(compositeRequest_payload), batch_size)
+        ]
 
         def update_chunk(chunk: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
-            payload = {
-                "allOrNone": bool(allOrNone),
-                "compositeRequest": chunk
-            }
+            payload = {"allOrNone": bool(allOrNone), "compositeRequest": chunk}
 
             status_code, resp_data = self._send_request(
                 method="POST",
@@ -979,5 +994,174 @@ class SFAuth:
             for item in (result if isinstance(result, list) else [result])
             if isinstance(result, (dict, list))
         ]
-        
+
+        return combined_response or None
+
+    def _gen_soap_envelope(self, header: str, body: str) -> str:
+        """Generates a full SOAP envelope with all required namespaces for Salesforce Enterprise API."""
+        return (
+            '<?xml version="1.0" encoding="UTF-8"?>'
+            "<soapenv:Envelope "
+            'xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" '
+            'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
+            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
+            'xmlns="urn:enterprise.soap.sforce.com" '
+            'xmlns:sf="urn:sobject.enterprise.soap.sforce.com">'
+            f"{header}{body}"
+            "</soapenv:Envelope>"
+        )
+
+    def _gen_soap_header(self):
+        """This function generates the header for the SOAP request."""
+        headers = self._get_common_headers()
+        session_id = headers["Authorization"].split(" ")[1]
+        return f"<soapenv:Header><SessionHeader><sessionId>{session_id}</sessionId></SessionHeader></soapenv:Header>"
+
+    def _extract_soap_result_fields(self, xml_string: str) -> Optional[Dict[str, Any]]:
+        """
+        Parse SOAP XML and extract all child fields from <result> as a dict.
+        """
+
+        def strip_ns(tag):
+            return tag.split("}", 1)[-1] if "}" in tag else tag
+
+        try:
+            root = ET.fromstring(xml_string)
+            results = []
+            for result in root.iter():
+                if result.tag.endswith("result"):
+                    out = {}
+                    for child in result:
+                        out[strip_ns(child.tag)] = child.text
+                    results.append(out)
+            if not results:
+                return None
+            if len(results) == 1:
+                return results[0]
+            return results
+        except ET.ParseError as e:
+            logger.error("Failed to parse SOAP XML: %s", e)
+            return None
+
+    def _gen_soap_body(self, sobject: str, method: str, data: Dict[str, Any]) -> str:
+        """Generates a compact SOAP request body for one or more records."""
+        # Accept both a single dict and a list of dicts
+        if isinstance(data, dict):
+            records = [data]
+        else:
+            records = data
+        sobjects = "".join(
+            f'<sObjects xsi:type="{sobject}">'
+            + "".join(f"<{k}>{v}</{k}>" for k, v in record.items())
+            + "</sObjects>"
+            for record in records
+        )
+        return f"<soapenv:Body><{method}>{sobjects}</{method}></soapenv:Body>"
+
+    def _xml_to_json(self, xml_string: str) -> Optional[Dict[str, Any]]:
+        """
+        Convert an XML string to a JSON-like dictionary.
+
+        :param xml_string: The XML string to convert.
+        :return: A dictionary representation of the XML or None on failure.
+        """
+        try:
+            root = ET.fromstring(xml_string)
+            return self._xml_to_dict(root)
+        except ET.ParseError as e:
+            logger.error("Failed to parse XML: %s", e)
+            return None
+
+    def _xml_to_dict(self, element: ET.Element) -> Dict[str, Any]:
+        """
+        Recursively convert an XML Element to a dictionary.
+
+        :param element: The XML Element to convert.
+        :return: A dictionary representation of the XML Element.
+        """
+        if len(element) == 0:
+            return element.text or ""
+
+        result = {}
+        for child in element:
+            child_dict = self._xml_to_dict(child)
+            if child.tag not in result:
+                result[child.tag] = child_dict
+            else:
+                if not isinstance(result[child.tag], list):
+                    result[child.tag] = [result[child.tag]]
+                result[child.tag].append(child_dict)
+        return result
+
+    def _create(  # I don't like this name, will think of a better one later...as such, not public.
+        self,
+        sobject: str,
+        insert_list: List[Dict[str, Any]],
+        batch_size: int = 200,
+        max_workers: int = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Execute the Insert API to insert multiple records via SOAP calls.
+
+        :param sobject: The name of the sObject to insert into.
+        :param insert_list: A list of dictionaries, each representing a record to insert. Example: [{'Subject': 'Easily inserted via SFQ'}]
+        :param batch_size: The number of records to insert in each batch (default is 200).
+        :param max_workers: The maximum number of threads to spawn for concurrent execution (default is None).
+        :return: JSON response from the insert request or None on failure.
+        """
+
+        endpoint = f"/services/Soap/c/{self.api_version}"
+
+        if isinstance(insert_list, dict):
+            insert_list = [insert_list]
+
+        chunks = [
+            insert_list[i : i + batch_size]
+            for i in range(0, len(insert_list), batch_size)
+        ]
+
+        def insert_chunk(chunk: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+            header = self._gen_soap_header()
+            body = self._gen_soap_body(sobject=sobject, method="create", data=chunk)
+            envelope = self._gen_soap_envelope(header, body)
+            soap_headers = self._get_common_headers().copy()
+            soap_headers["Content-Type"] = "text/xml; charset=UTF-8"
+            soap_headers["SOAPAction"] = '""'
+
+            logger.trace("SOAP request envelope: %s", envelope)
+            logger.trace("SOAP request headers: %s", soap_headers)
+            status_code, resp_data = self._send_request(
+                method="POST",
+                endpoint=endpoint,
+                headers=soap_headers,
+                body=envelope,
+            )
+
+            if status_code == 200:
+                logger.debug("Insert API request successful.")
+                logger.trace("Insert API response: %s", resp_data)
+                result = self._extract_soap_result_fields(resp_data)
+                if result:
+                    return result
+                logger.error("Failed to extract fields from SOAP response.")
+            else:
+                logger.error("Insert API request failed: %s", status_code)
+                logger.debug("Response body: %s", resp_data)
+                return None
+
+        results = []
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(insert_chunk, chunk) for chunk in chunks]
+            for future in as_completed(futures):
+                result = future.result()
+                if result:
+                    results.append(result)
+
+        combined_response = [
+            item
+            for result in results
+            for item in (result if isinstance(result, list) else [result])
+            if isinstance(result, (dict, list))
+        ]
+
         return combined_response or None

sfq-0.0.29/tests/test_cdelete.py

@@ -0,0 +1,73 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+# --- Setup local import path ---
+project_root = Path(__file__).resolve().parents[1]
+src_path = project_root / "src"
+sys.path.insert(0, str(src_path))
+from sfq import SFAuth  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def sf_instance():
+    required_env_vars = [
+        "SF_INSTANCE_URL",
+        "SF_CLIENT_ID",
+        "SF_CLIENT_SECRET",
+        "SF_REFRESH_TOKEN",
+    ]
+
+    missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+    if missing_vars:
+        pytest.fail(f"Missing required env vars: {', '.join(missing_vars)}")
+
+    sf = SFAuth(
+        instance_url=os.getenv("SF_INSTANCE_URL"),
+        client_id=os.getenv("SF_CLIENT_ID"),
+        client_secret=os.getenv("SF_CLIENT_SECRET"),
+        refresh_token=os.getenv("SF_REFRESH_TOKEN"),
+    )
+    return sf
+
+
+def test_cdelete(sf_instance):
+    """Ensure that a simple delete returns the expected results."""
+    query = "SELECT Id FROM FeedComment LIMIT 1"
+    response = sf_instance.query(query)
+    assert response and response["records"], "No FeedComment found for test."
+    feed_comment_id = response["records"][0]["Id"]
+
+    result = sf_instance.cdelete([feed_comment_id])
+    assert result and isinstance(result, list), (
+        f"Delete did not return a list: {result}"
+    )
+
+    assert result[0].get("success"), f"Delete failed: {result}"
+    assert "id" in result[0], f"No ID returned: {result}"
+
+
+def test_cdelete_batch(sf_instance):
+    """Test batching/pagination: Delete multiple FeedComment records and ensure batching works."""
+    query = "SELECT Id FROM FeedComment LIMIT 250"
+    response = sf_instance.query(query)
+    assert response and response["records"], "No FeedComment found for test."
+
+    response_size = len(response["records"])
+    if response_size < 201:
+        pytest.skip("Not enough FeedComment records for batch delete test.")
+
+    feed_comment_ids = [record["Id"] for record in response["records"]]
+
+    result = sf_instance.cdelete(feed_comment_ids)
+    assert result and isinstance(result, list), (
+        f"Delete did not return a list: {result}"
+    )
+
+    assert all(item.get("success") for item in result), f"Delete failed: {result}"
+
+    assert len(result) == response_size, (
+        f"Expected {response_size} results, got {len(result)}: {result}"
+    )

sfq-0.0.29/tests/test_cquery.py

@@ -0,0 +1,66 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+# --- Setup local import path ---
+project_root = Path(__file__).resolve().parents[1]
+src_path = project_root / "src"
+sys.path.insert(0, str(src_path))
+from sfq import SFAuth  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def sf_instance():
+    required_env_vars = [
+        "SF_INSTANCE_URL",
+        "SF_CLIENT_ID",
+        "SF_CLIENT_SECRET",
+        "SF_REFRESH_TOKEN",
+    ]
+
+    missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+    if missing_vars:
+        pytest.fail(f"Missing required env vars: {', '.join(missing_vars)}")
+
+    sf = SFAuth(
+        instance_url=os.getenv("SF_INSTANCE_URL"),
+        client_id=os.getenv("SF_CLIENT_ID"),
+        client_secret=os.getenv("SF_CLIENT_SECRET"),
+        refresh_token=os.getenv("SF_REFRESH_TOKEN"),
+    )
+    return sf
+
+
+def test_simple_query(sf_instance):
+    """Ensure that a simple query returns the expected results."""
+    result = sf_instance.cquery({'refId': 'SELECT Id FROM Organization LIMIT 1'})
+
+    sf_api_version = sf_instance.api_version
+    expected = {
+        "totalSize": 1,
+        "done": True,
+        "records": [
+            {
+                "attributes": {
+                    "type": "Organization",
+                    "url": f"/services/data/{sf_api_version}/sobjects/Organization/00Daj000004ej9WEAQ",
+                },
+                "Id": "00Daj000004ej9WEAQ",
+            }
+        ],
+    }
+
+    assert result["refId"]["done"]
+    assert result["refId"]["totalSize"] == 1
+    assert len(result["refId"]["records"]) == 1
+    assert result["refId"] == expected
+
+def test_cquery_with_pagination(sf_instance):
+    """Ensure that query pagination is functioning"""
+    result = sf_instance.cquery({"refId": "SELECT Id FROM FeedComment LIMIT 2200"})
+
+    assert len(result["refId"]["records"]) == 2200
+    assert result["refId"]["totalSize"] == 2200
+    assert result["refId"]["done"]

sfq-0.0.29/tests/test_create.py

@@ -0,0 +1,80 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+# --- Setup local import path ---
+project_root = Path(__file__).resolve().parents[1]
+src_path = project_root / "src"
+sys.path.insert(0, str(src_path))
+from sfq import SFAuth  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def sf_instance():
+    required_env_vars = [
+        "SF_INSTANCE_URL",
+        "SF_CLIENT_ID",
+        "SF_CLIENT_SECRET",
+        "SF_REFRESH_TOKEN",
+    ]
+
+    missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+    if missing_vars:
+        pytest.fail(f"Missing required env vars: {', '.join(missing_vars)}")
+
+    sf = SFAuth(
+        instance_url=os.getenv("SF_INSTANCE_URL"),
+        client_id=os.getenv("SF_CLIENT_ID"),
+        client_secret=os.getenv("SF_CLIENT_SECRET"),
+        refresh_token=os.getenv("SF_REFRESH_TOKEN"),
+    )
+    return sf
+
+
+def get_feed_item_id(sf_instance):
+    """Helper to fetch a valid FeedItemId for tests."""
+    response = sf_instance.query("SELECT Id FROM FeedItem LIMIT 1")
+    assert response and response["records"], "No FeedItem found for test."
+    return response["records"][0]["Id"]
+
+
+def test_feed_comment_insertion(sf_instance):
+    """Ensure that a simple insert returns the expected results."""
+    feed_item_id = get_feed_item_id(sf_instance)
+    comment = {
+        "FeedItemId": feed_item_id,
+        "CommentBody": f"Test comment via {sf_instance.user_agent}",
+    }
+    result = sf_instance._create("FeedComment", [comment])
+    assert result and isinstance(result, list), (
+        f"Create did not return a list: {result}"
+    )
+    assert result[0].get("success"), f"Insert failed: {result}"
+    assert "id" in result[0], f"No ID returned: {result}"
+
+
+def test_feed_comment_batch_insertion(sf_instance):
+    """Test batching/pagination: Insert multiple FeedComment records and ensure batching works."""
+    feed_item_id = get_feed_item_id(sf_instance)
+    comments = [
+        {
+            "FeedItemId": feed_item_id,
+            "CommentBody": f"Batch comment {i} via {sf_instance.user_agent}",
+        }
+        for i in range(250)
+    ]
+    results = sf_instance._create("FeedComment", comments)
+    assert results and isinstance(results, list), (
+        f"Batch create did not return a list: {results}"
+    )
+    assert len(results) == 250, f"Expected 250 results, got {len(results)}"
+    successes = [
+        r
+        for r in results
+        if str(r.get("success")).lower() == "true" or r.get("success") is True
+    ]
+    assert len(successes) == 250, f"Not all inserts succeeded: {len(successes)}"
+    for r in results:
+        assert "id" in r, f"Result missing 'id': {r}"

sfq-0.0.29/tests/test_cupdate.py

@@ -0,0 +1,112 @@
+import random
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+# --- Setup local import path ---
+project_root = Path(__file__).resolve().parents[1]
+src_path = project_root / "src"
+sys.path.insert(0, str(src_path))
+from sfq import SFAuth  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def sf_instance():
+    required_env_vars = [
+        "SF_INSTANCE_URL",
+        "SF_CLIENT_ID",
+        "SF_CLIENT_SECRET",
+        "SF_REFRESH_TOKEN",
+    ]
+
+    missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+    if missing_vars:
+        pytest.fail(f"Missing required env vars: {', '.join(missing_vars)}")
+
+    sf = SFAuth(
+        instance_url=os.getenv("SF_INSTANCE_URL"),
+        client_id=os.getenv("SF_CLIENT_ID"),
+        client_secret=os.getenv("SF_CLIENT_SECRET"),
+        refresh_token=os.getenv("SF_REFRESH_TOKEN"),
+    )
+    return sf
+
+
+def test_simple_cupdate(sf_instance):
+    """Ensure that a simple update returns the expected results."""
+    query = "SELECT Id, CommentBody FROM FeedComment LIMIT 1"
+    response = sf_instance.query(query)
+    assert response and response["records"], "No FeedComment found for test."
+
+    update_dict = dict()
+    feed_comment_id = response["records"][0]["Id"]
+    update_dict[feed_comment_id] = {"CommentBody": f"Evaluated at {datetime.now()}"}
+
+    result = sf_instance._cupdate(update_dict)
+
+    # Validate the result
+    assert result, "CUpdate did not return a result."
+    assert isinstance(result, list), "CUpdate result is not a list."
+    assert len(result) == 1, "CUpdate result should contain one response."
+    assert "compositeResponse" in result[0], "CUpdate response does not contain 'compositeResponse'."
+    assert len(result[0]["compositeResponse"]) == 1, "CUpdate response should contain one composite response."
+    assert result[0]["compositeResponse"][0]["httpStatusCode"] == 204, "CUpdate did not return HTTP status 204."
+    assert result[0]["compositeResponse"][0]["body"] is None, "CUpdate response body should be None."
+
+    # Verify that the update was successful by querying the updated record
+    new_query = f"SELECT Id, CommentBody FROM FeedComment WHERE Id = '{feed_comment_id}'"
+    updated_response = sf_instance.query(new_query)
+    assert updated_response and updated_response["records"], "No updated FeedComment found."
+    assert len(updated_response["records"]) == 1, "Expected one updated FeedComment."
+    assert updated_response["records"][0]["CommentBody"] == update_dict[feed_comment_id]["CommentBody"], "Updated CommentBody does not match."
+
+def test_cupdate_with_invalid_data(sf_instance):
+    """Test cupdate with invalid data to ensure it raises an error."""
+    update_dict = {"invalid_id": {"CommentBody": "This should fail"}}
+
+    res = sf_instance._cupdate(update_dict)  
+    assert res, "CUpdate did not return a result."
+    assert isinstance(res, list), "CUpdate result is not a list."
+    assert len(res) == 1, "CUpdate result should contain one response."
+    assert "compositeResponse" in res[0], "CUpdate response does not contain 'compositeResponse'."
+    assert len(res[0]["compositeResponse"]) == 1, "CUpdate response should contain one composite response."
+    assert res[0]["compositeResponse"][0]["httpStatusCode"] == 404, "CUpdate did not return HTTP status 404."
+    assert res[0]["compositeResponse"][0]["body"][0]["errorCode"] == "NOT_FOUND", "Expected NOT_FOUND error code."
+    assert res[0]["compositeResponse"][0]["body"][0]["message"] == "The requested resource does not exist", "Expected NOT_FOUND error message."
+
+def test_cupdate_pagination(sf_instance):
+    """Test cupdate with pagination to ensure it handles multiple records."""
+    size = 35  # using `/services/data/{self.api_version}/sobjects/{sobject}/{key}` which is 25 per pagination; I want to migrate to Soap for larger 200 batches.
+    query = f"SELECT Id, CommentBody FROM FeedComment LIMIT {size}"
+    initial_query_response = sf_instance.query(query)
+
+    response_count = len(initial_query_response["records"])
+    assert response_count == size, f"Expected {size} records, got {response_count}."
+    ids_updated = {record["Id"] for record in initial_query_response["records"]}
+
+    update_dict = dict()
+    for record in initial_query_response["records"]:
+        feed_comment_id = record["Id"]
+        update_dict[feed_comment_id] = {"CommentBody": f"sfq/{datetime.now().timestamp()} #{random.randint(1000, 9999)}"}
+
+    update_response = sf_instance._cupdate(update_dict)
+    assert update_response, "CUpdate did not return a result."
+    assert isinstance(update_response, list), "CUpdate result is not a list."
+
+    subset_ids = random.sample(list(ids_updated), min(50, len(ids_updated)))
+    subset_id_str = ", ".join([f"'{id_}'" for id_ in subset_ids])
+    subset_query = f"SELECT Id, CommentBody FROM FeedComment WHERE Id IN ({subset_id_str})"
+    updated_response = sf_instance.query(subset_query)
+    
+    # Validate the updated records
+    assert updated_response, "Query for updated records did not return a result."
+    assert updated_response and updated_response["records"], "No updated FeedComment found."
+    assert len(updated_response["records"]) == len(subset_ids), "Expected updated records count does not match subset size."
+
+    # validate that all updated records have the expected CommentBody
+    for record in updated_response["records"]:
+        expected_comment_body = update_dict[record["Id"]]["CommentBody"]
+        assert record["CommentBody"] == expected_comment_body, f"Updated CommentBody for {record['Id']} does not match expected value."

{sfq-0.0.27 → sfq-0.0.29}/tests/test_log_trace_redact.py

@@ -77,3 +77,56 @@ def test_access_token_redacted_in_logs(sf_instance, capture_logs):
     assert "'access_token': '********'," in log_contents in log_contents, (
         "Access token was not properly redacted in logs"
     )
+
+
+def test_soap_sessionid_redacted_in_logs(sf_instance, capture_logs):
+    """
+    Ensure SOAP sessionId is redacted in log output to prevent leakage.
+    """
+    logger, log_stream = capture_logs
+
+    soap_header = sf_instance._gen_soap_header()
+    logger.trace("SOAP header payload: %s", soap_header)
+
+    logger.handlers[0].flush()
+    log_contents = log_stream.getvalue()
+
+    assert "<sessionId>" in log_contents, "Expected <sessionId> tag in logs"
+    assert f"<sessionId>{'*' * 8}</sessionId>" in log_contents, (
+        "SOAP sessionId was not properly redacted in logs"
+    )
+
+
+def test_soap_create_redaction(sf_instance, capture_logs):
+    """
+    Ensure SOAP create operation does not leak sensitive information in logs.
+    """
+    logger, log_stream = capture_logs
+
+    create_response = sf_instance._create("Account", [{"Name": "Test Account"}])
+    logger.trace("Creating Account: %s", create_response)
+
+    created_ids = [
+        item["id"]
+        for item in create_response
+        if item.get("success") is True and "id" in item
+    ]
+
+    if created_ids:
+        del_response = sf_instance.cdelete(created_ids)
+        logger.trace("Deleting created Account: %s", del_response)
+
+    logger.handlers[0].flush()
+    log_contents = log_stream.getvalue()
+
+    for acc_id in created_ids:
+        assert acc_id in log_contents, f"Expected account ID {acc_id} in logs"
+
+    assert "<sessionId>" in log_contents, (
+        "SOAP sessionId should be logged, but redacted"
+    )
+    assert f"<sessionId>{'*' * 8}</sessionId>" in log_contents, (
+        "SOAP sessionId should be logged in redacted form, but was not"
+    )
+
+    assert "access_token" not in log_contents, "Access token should not be logged"

sfq-0.0.29/tests/test_query.py

@@ -0,0 +1,126 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+# --- Setup local import path ---
+project_root = Path(__file__).resolve().parents[1]
+src_path = project_root / "src"
+sys.path.insert(0, str(src_path))
+from sfq import SFAuth  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def sf_instance():
+    required_env_vars = [
+        "SF_INSTANCE_URL",
+        "SF_CLIENT_ID",
+        "SF_CLIENT_SECRET",
+        "SF_REFRESH_TOKEN",
+    ]
+
+    missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+    if missing_vars:
+        pytest.fail(f"Missing required env vars: {', '.join(missing_vars)}")
+
+    sf = SFAuth(
+        instance_url=os.getenv("SF_INSTANCE_URL"),
+        client_id=os.getenv("SF_CLIENT_ID"),
+        client_secret=os.getenv("SF_CLIENT_SECRET"),
+        refresh_token=os.getenv("SF_REFRESH_TOKEN"),
+    )
+    return sf
+
+
+def test_simple_query(sf_instance):
+    """Ensure that a simple query returns the expected results."""
+    result = sf_instance.query("SELECT Id FROM Organization LIMIT 1")
+
+    sf_api_version = sf_instance.api_version
+    expected = {
+        "totalSize": 1,
+        "done": True,
+        "records": [
+            {
+                "attributes": {
+                    "type": "Organization",
+                    "url": f"/services/data/{sf_api_version}/sobjects/Organization/00Daj000004ej9WEAQ",
+                },
+                "Id": "00Daj000004ej9WEAQ",
+            }
+        ],
+    }
+
+    assert result["done"]
+    assert result["totalSize"] == 1
+    assert len(result["records"]) == 1
+    assert result == expected
+
+
+def test_simple_query_with_tooling(sf_instance):
+    """Ensure that a simple query returns the expected results."""
+    result = sf_instance.query(
+        "SELECT ProdSuffixType FROM OrgDomainLog LIMIT 1", tooling=True
+    )
+
+    sf_api_version = sf_instance.api_version
+    expected = {
+        "size": 1,
+        "totalSize": 1,
+        "done": True,
+        "queryLocator": None,
+        "entityTypeName": "OrgDomainLog",
+        "records": [
+            {
+                "attributes": {
+                    "type": "OrgDomainLog",
+                    "url": f"/services/data/{sf_api_version}/tooling/sobjects/OrgDomainLog/9UXaj000000p9inGAA",
+                },
+                "ProdSuffixType": "MySalesforce",
+            }
+        ],
+    }
+
+    assert result["done"]
+    assert result["totalSize"] == 1
+    assert len(result["records"]) == 1
+    assert result == expected
+
+
+def test_query_with_pagination(sf_instance):
+    """Ensure that query pagination is functioning"""
+    current_count = sf_instance.query("SELECT Count() FROM FeedComment LIMIT 2200")[
+        "totalSize"
+    ]
+    if current_count < 2200:
+        feedItemId = sf_instance.query("SELECT Id FROM FeedItem LIMIT 1")["records"][0][
+            "Id"
+        ]
+        required_count = 2200 - current_count + 250
+        comments = [
+            {
+                "FeedItemId": feedItemId,
+                "CommentBody": f"Test comment {i} via {sf_instance.user_agent}",
+            }
+            for i in range(required_count)
+        ]
+
+        results = sf_instance.create("FeedComment", comments)
+        assert results and isinstance(results, list), (
+            f"Batch create did not return a list: {results}"
+        )
+
+        current_count = sf_instance.query("SELECT Count() FROM FeedComment LIMIT 2200")[
+            "totalSize"
+        ]
+
+    assert current_count >= 2200, (
+        "Not enough FeedComment records for pagination test exist, despite recent creation..."
+    )
+
+    result = sf_instance.query("SELECT Id FROM FeedComment LIMIT 2200")
+
+    assert len(result["records"]) == 2200
+    assert result["totalSize"] == 2200
+    assert result["done"]

{sfq-0.0.27 → sfq-0.0.29}/uv.lock

@@ -3,5 +3,5 @@ requires-python = ">=3.9"
 
 [[package]]
 name = "sfq"
-version = "0.0.27"
+version = "0.0.29"
 source = { editable = "." }