Validate/strip record_id in get(), fix clear_nulls docstring, remove duplicate helper tests

Author: Saurabh Badenkal

src/PowerPlatform/Dataverse/operations/dataframe.py

@@ -110,6 +110,9 @@ def get(
                 df = client.dataframe.get("account", select=["name"], top=100)
         """
         if record_id is not None:
+            if not isinstance(record_id, str) or not record_id.strip():
+                raise ValueError("record_id must be a non-empty string")
+            record_id = record_id.strip()
             if any(p is not None for p in (filter, orderby, top, expand, page_size)):
                 raise ValueError(
                     "Cannot specify query parameters (filter, orderby, top, "
@@ -219,9 +222,11 @@ def update(
         :raises ValueError: If ``changes`` is empty, ``id_column`` is not found in the
             DataFrame, ``id_column`` contains invalid (non-string, empty, or whitespace-only)
             values, or no updatable columns exist besides ``id_column``.
-            Rows where all change values are NaN/None (after applying ``clear_nulls``)
-            are silently skipped. If all rows are skipped, the method returns without
-            making an API call.
+            When ``clear_nulls`` is ``False`` (default), rows where all change values
+            are NaN/None produce empty patches and are silently skipped. If all rows
+            are skipped, the method returns without making an API call. When
+            ``clear_nulls`` is ``True``, NaN/None values become explicit nulls, so
+            rows are never skipped.
 
         .. tip::
             All rows are sent in a single ``UpdateMultiple`` request (or a

tests/unit/test_dataframe_operations.py

@@ -12,100 +12,6 @@
 
 from PowerPlatform.Dataverse.client import DataverseClient
 from PowerPlatform.Dataverse.operations.dataframe import DataFrameOperations
-from PowerPlatform.Dataverse.utils._pandas import dataframe_to_records
-
-
-class TestDataframeToRecordsHelper(unittest.TestCase):
-    """Unit tests for the dataframe_to_records() helper in isolation."""
-
-    def test_dataframe_to_records_basic(self):
-        """Basic DataFrame with string values is converted correctly."""
-        df = pd.DataFrame([{"name": "Contoso", "city": "Seattle"}])
-        result = dataframe_to_records(df)
-        self.assertEqual(result, [{"name": "Contoso", "city": "Seattle"}])
-
-    def test_dataframe_to_records_nan_dropped(self):
-        """NaN values are omitted from records when na_as_null=False (default)."""
-        df = pd.DataFrame([{"name": "Contoso", "telephone1": None}])
-        result = dataframe_to_records(df)
-        self.assertNotIn("telephone1", result[0])
-
-    def test_dataframe_to_records_nan_as_null(self):
-        """NaN values become None when na_as_null=True."""
-        df = pd.DataFrame([{"name": "Contoso", "telephone1": None}])
-        result = dataframe_to_records(df, na_as_null=True)
-        self.assertIn("telephone1", result[0])
-        self.assertIsNone(result[0]["telephone1"])
-
-    def test_dataframe_to_records_timestamp_conversion(self):
-        """pd.Timestamp values are converted to ISO 8601 strings."""
-        ts = pd.Timestamp("2024-01-15 10:30:00")
-        df = pd.DataFrame([{"createdon": ts}])
-        result = dataframe_to_records(df)
-        self.assertEqual(result[0]["createdon"], "2024-01-15T10:30:00")
-
-    def test_dataframe_to_records_numpy_int(self):
-        """np.int64 values are converted to Python int."""
-        df = pd.DataFrame([{"priority": np.int64(42)}])
-        result = dataframe_to_records(df)
-        self.assertIsInstance(result[0]["priority"], int)
-        self.assertEqual(result[0]["priority"], 42)
-
-    def test_dataframe_to_records_numpy_float(self):
-        """np.float64 values are converted to Python float."""
-        df = pd.DataFrame([{"score": np.float64(3.14)}])
-        result = dataframe_to_records(df)
-        self.assertIsInstance(result[0]["score"], float)
-        self.assertAlmostEqual(result[0]["score"], 3.14)
-
-    def test_dataframe_to_records_numpy_bool(self):
-        """np.bool_ values are converted to Python bool."""
-        df = pd.DataFrame([{"active": np.bool_(True)}])
-        result = dataframe_to_records(df)
-        self.assertIsInstance(result[0]["active"], bool)
-        self.assertTrue(result[0]["active"])
-
-    def test_dataframe_to_records_list_value(self):
-        """Cells containing lists pass through without crashing."""
-        df = pd.DataFrame([{"tags": ["a", "b", "c"]}])
-        result = dataframe_to_records(df)
-        self.assertEqual(result[0]["tags"], ["a", "b", "c"])
-
-    def test_dataframe_to_records_dict_value(self):
-        """Cells containing dicts pass through without crashing."""
-        df = pd.DataFrame([{"metadata": {"key": "value"}}])
-        result = dataframe_to_records(df)
-        self.assertEqual(result[0]["metadata"], {"key": "value"})
-
-    def test_dataframe_to_records_empty_dataframe(self):
-        """Empty DataFrame returns an empty list."""
-        df = pd.DataFrame(columns=["name", "telephone1"])
-        result = dataframe_to_records(df)
-        self.assertEqual(result, [])
-
-    def test_dataframe_to_records_mixed_types(self):
-        """DataFrame with mixed types converts all values correctly."""
-        ts = pd.Timestamp("2024-06-01")
-        df = pd.DataFrame(
-            [
-                {
-                    "name": "Contoso",
-                    "count": np.int64(5),
-                    "score": np.float64(9.8),
-                    "active": np.bool_(True),
-                    "createdon": ts,
-                    "notes": None,
-                }
-            ]
-        )
-        result = dataframe_to_records(df)
-        rec = result[0]
-        self.assertEqual(rec["name"], "Contoso")
-        self.assertIsInstance(rec["count"], int)
-        self.assertIsInstance(rec["score"], float)
-        self.assertIsInstance(rec["active"], bool)
-        self.assertEqual(rec["createdon"], "2024-06-01T00:00:00")
-        self.assertNotIn("notes", rec)
 
 
 class TestDataFrameOperationsNamespace(unittest.TestCase):
@@ -187,6 +93,18 @@ def test_get_record_id_with_top_raises(self):
             self.client.dataframe.get("account", record_id="guid-1", top=10)
         self.assertIn("Cannot specify query parameters", str(ctx.exception))
 
+    def test_get_empty_record_id_raises(self):
+        """ValueError raised when record_id is empty or whitespace."""
+        with self.assertRaises(ValueError) as ctx:
+            self.client.dataframe.get("account", record_id="  ")
+        self.assertIn("non-empty string", str(ctx.exception))
+
+    def test_get_record_id_stripped(self):
+        """Leading/trailing whitespace in record_id is stripped."""
+        self.client._odata._get.return_value = {"accountid": "guid-1", "name": "Contoso"}
+        self.client.dataframe.get("account", record_id="  guid-1  ")
+        self.client._odata._get.assert_called_once_with("account", "guid-1", select=None)
+
 
 class TestDataFrameCreate(unittest.TestCase):
     """Tests for client.dataframe.create()."""