Fix PropertyValues format and add edge case tests

Author: Abel Milash

src/PowerPlatform/Dataverse/models/filters.py

@@ -24,7 +24,7 @@
     # In operator (Dataverse function)
     expr = filter_in("statecode", [0, 1, 2])
     print(expr.to_odata())
-    # Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0, 1, 2])
+    # Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=["0","1","2"])
 
     # Negation
     expr = ~eq("statecode", 1)
@@ -225,7 +225,11 @@ def __init__(self, column: str, values: Sequence[Any]) -> None:
         self.values = list(values)
 
     def to_odata(self) -> str:
-        formatted = ", ".join(_format_value(v) for v in self.values)
+        # PropertyValues is Collection(Edm.String)
+        formatted = ",".join(
+            f'"{v.value if isinstance(v, enum.Enum) else v}"'
+            for v in self.values
+        )
         return (
             f"Microsoft.Dynamics.CRM.In"
             f"(PropertyName='{self.column}',PropertyValues=[{formatted}])"
@@ -392,7 +396,7 @@ def filter_in(column: str, values: Sequence[Any]) -> FilterExpression:
     Example::
 
         filter_in("statecode", [0, 1, 2]).to_odata()
-        # "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0, 1, 2])"
+        # "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=["0","1","2"])"
     """
     return _InFilter(column, values)
 

src/PowerPlatform/Dataverse/models/query_builder.py

@@ -228,7 +228,7 @@ def filter_in(self, column: str, values: Sequence[Any]) -> QueryBuilder:
 
             query = QueryBuilder("account").filter_in("statecode", [0, 1, 2])
             # Produces: Microsoft.Dynamics.CRM.In(
-            #     PropertyName='statecode',PropertyValues=[0, 1, 2])
+            #     PropertyName='statecode',PropertyValues=["0","1","2"])
         """
         self._filter_parts.append(filters.filter_in(column, values))
         return self

tests/unit/models/test_filters.py

@@ -171,6 +171,31 @@ def test_eq_uuid(self):
             "accountid eq 12345678-1234-1234-1234-123456789abc",
         )
 
+    def test_eq_datetime(self):
+        dt = datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+        self.assertEqual(
+            eq("createdon", dt).to_odata(),
+            "createdon eq 2024-01-15T10:30:00Z",
+        )
+
+    def test_eq_int_enum(self):
+        from enum import IntEnum
+
+        class Priority(IntEnum):
+            LOW = 1
+            HIGH = 2
+
+        self.assertEqual(eq("priority", Priority.HIGH).to_odata(), "priority eq 2")
+
+    def test_ne_string(self):
+        self.assertEqual(ne("name", "Contoso").to_odata(), "name ne 'Contoso'")
+
+    def test_gt_negative(self):
+        self.assertEqual(gt("temperature", -10).to_odata(), "temperature gt -10")
+
+    def test_gt_float(self):
+        self.assertEqual(gt("revenue", 99.5).to_odata(), "revenue gt 99.5")
+
 
 class TestFunctionFilters(unittest.TestCase):
     """Tests for string function filter factory functions."""
@@ -187,6 +212,12 @@ def test_endswith(self):
     def test_function_column_lowercased(self):
         self.assertEqual(contains("Name", "Corp").to_odata(), "contains(name, 'Corp')")
 
+    def test_contains_single_quotes(self):
+        self.assertEqual(
+            contains("name", "O'Brien").to_odata(),
+            "contains(name, 'O''Brien')",
+        )
+
 
 class TestBetween(unittest.TestCase):
     """Tests for the between factory function."""
@@ -201,6 +232,20 @@ def test_between_dates(self):
         result = between("createdon", date(2024, 1, 1), date(2024, 12, 31)).to_odata()
         self.assertEqual(result, "(createdon ge 2024-01-01 and createdon le 2024-12-31)")
 
+    def test_between_floats(self):
+        self.assertEqual(
+            between("revenue", 100.5, 999.9).to_odata(),
+            "(revenue ge 100.5 and revenue le 999.9)",
+        )
+
+    def test_between_datetimes(self):
+        start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
+        end = datetime(2024, 12, 31, 23, 59, 59, tzinfo=timezone.utc)
+        self.assertEqual(
+            between("createdon", start, end).to_odata(),
+            "(createdon ge 2024-01-01T00:00:00Z and createdon le 2024-12-31T23:59:59Z)",
+        )
+
 
 class TestNullChecks(unittest.TestCase):
     """Tests for is_null and is_not_null."""
@@ -234,31 +279,58 @@ class TestInFilter(unittest.TestCase):
     def test_filter_in_ints(self):
         self.assertEqual(
             filter_in("statecode", [0, 1, 2]).to_odata(),
-            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0, 1, 2])",
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1","2"])',
         )
 
     def test_filter_in_strings(self):
         self.assertEqual(
             filter_in("name", ["Contoso", "Fabrikam"]).to_odata(),
-            "Microsoft.Dynamics.CRM.In(PropertyName='name',PropertyValues=['Contoso', 'Fabrikam'])",
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'name\',PropertyValues=["Contoso","Fabrikam"])',
         )
 
     def test_filter_in_single_value(self):
         self.assertEqual(
             filter_in("statecode", [0]).to_odata(),
-            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0])",
+            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[\"0\"])",
         )
 
     def test_filter_in_column_lowercased(self):
         self.assertEqual(
             filter_in("StateCode", [0, 1]).to_odata(),
-            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0, 1])",
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1"])',
         )
 
     def test_filter_in_empty_raises(self):
         with self.assertRaises(ValueError):
             filter_in("statecode", [])
 
+    def test_filter_in_int_enum(self):
+        from enum import IntEnum
+
+        class Priority(IntEnum):
+            LOW = 1
+            MEDIUM = 2
+            HIGH = 3
+
+        self.assertEqual(
+            filter_in("priority", [Priority.LOW, Priority.HIGH]).to_odata(),
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'priority\',PropertyValues=["1","3"])',
+        )
+
+    def test_filter_in_strings_with_quotes(self):
+        self.assertEqual(
+            filter_in("name", ["O'Brien", "McDonald's"]).to_odata(),
+            "Microsoft.Dynamics.CRM.In(PropertyName='name',PropertyValues=[\"O'Brien\",\"McDonald's\"])",
+        )
+
+    def test_filter_in_uuids(self):
+        uid1 = uuid.UUID("12345678-1234-1234-1234-123456789abc")
+        uid2 = uuid.UUID("87654321-4321-4321-4321-cba987654321")
+        self.assertEqual(
+            filter_in("accountid", [uid1, uid2]).to_odata(),
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'accountid\',PropertyValues=["12345678-1234-1234-1234-123456789abc","87654321-4321-4321-4321-cba987654321"])',
+        )
+
 
 class TestLogicalOperators(unittest.TestCase):
     """Tests for &, |, ~ operator overloads."""
@@ -311,6 +383,13 @@ def test_or_with_non_expression_returns_not_implemented(self):
         result = eq("a", 1).__or__("not an expression")
         self.assertIs(result, NotImplemented)
 
+    def test_and_with_filter_in(self):
+        expr = filter_in("statecode", [0, 1]) & gt("revenue", 100000)
+        self.assertEqual(
+            expr.to_odata(),
+            '(Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1"]) and revenue gt 100000)',
+        )
+
 
 class TestStrAndRepr(unittest.TestCase):
     """Tests for __str__ and __repr__."""

tests/unit/models/test_query_builder.py

@@ -78,6 +78,13 @@ def test_filter_eq_float(self):
         qb = QueryBuilder("account").filter_eq("revenue", 1000000.5)
         self.assertEqual(qb.build()["filter"], "revenue eq 1000000.5")
 
+    def test_filter_eq_datetime(self):
+        from datetime import datetime, timezone
+
+        dt = datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+        qb = QueryBuilder("account").filter_eq("createdon", dt)
+        self.assertEqual(qb.build()["filter"], "createdon eq 2024-01-15T10:30:00Z")
+
 
 class TestFilterIn(unittest.TestCase):
     """Tests for the filter_in() method."""
@@ -86,28 +93,28 @@ def test_filter_in_integers(self):
         qb = QueryBuilder("account").filter_in("statecode", [0, 1, 2])
         self.assertEqual(
             qb.build()["filter"],
-            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0, 1, 2])",
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1","2"])',
         )
 
     def test_filter_in_strings(self):
         qb = QueryBuilder("account").filter_in("name", ["Contoso", "Fabrikam"])
         self.assertEqual(
             qb.build()["filter"],
-            "Microsoft.Dynamics.CRM.In(PropertyName='name',PropertyValues=['Contoso', 'Fabrikam'])",
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'name\',PropertyValues=["Contoso","Fabrikam"])',
         )
 
     def test_filter_in_single_value(self):
         qb = QueryBuilder("account").filter_in("statecode", [0])
         self.assertEqual(
             qb.build()["filter"],
-            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0])",
+            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[\"0\"])",
         )
 
     def test_filter_in_column_lowercased(self):
         qb = QueryBuilder("account").filter_in("StateCode", [0, 1])
         self.assertEqual(
             qb.build()["filter"],
-            "Microsoft.Dynamics.CRM.In(PropertyName='statecode',PropertyValues=[0, 1])",
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1"])',
         )
 
     def test_filter_in_empty_raises(self):
@@ -118,6 +125,26 @@ def test_filter_in_returns_self(self):
         qb = QueryBuilder("account")
         self.assertIs(qb.filter_in("statecode", [0, 1]), qb)
 
+    def test_filter_in_int_enum(self):
+        from enum import IntEnum
+
+        class Priority(IntEnum):
+            LOW = 1
+            HIGH = 3
+
+        qb = QueryBuilder("account").filter_in("priority", [Priority.LOW, Priority.HIGH])
+        self.assertEqual(
+            qb.build()["filter"],
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'priority\',PropertyValues=["1","3"])',
+        )
+
+    def test_filter_in_combined_with_other_filters(self):
+        qb = QueryBuilder("account").filter_eq("statecode", 0).filter_in("priority", [1, 2, 3])
+        self.assertEqual(
+            qb.build()["filter"],
+            'statecode eq 0 and Microsoft.Dynamics.CRM.In(PropertyName=\'priority\',PropertyValues=["1","2","3"])',
+        )
+
     def test_filter_ne(self):
         qb = QueryBuilder("account").filter_ne("statecode", 1)
         self.assertEqual(qb.build()["filter"], "statecode ne 1")
@@ -168,6 +195,10 @@ def test_filter_endswith(self):
         qb = QueryBuilder("account").filter_endswith("name", "Ltd")
         self.assertEqual(qb.build()["filter"], "endswith(name, 'Ltd')")
 
+    def test_filter_contains_single_quotes(self):
+        qb = QueryBuilder("account").filter_contains("name", "O'Brien")
+        self.assertEqual(qb.build()["filter"], "contains(name, 'O''Brien')")
+
 
 class TestNullFilters(unittest.TestCase):
     """Tests for null/not-null filter methods."""
@@ -209,6 +240,17 @@ def test_filter_between_combined_with_other_filters(self):
             "statecode eq 0 and (revenue ge 100000 and revenue le 500000)",
         )
 
+    def test_filter_between_datetimes(self):
+        from datetime import datetime, timezone
+
+        start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
+        end = datetime(2024, 12, 31, 23, 59, 59, tzinfo=timezone.utc)
+        qb = QueryBuilder("account").filter_between("createdon", start, end)
+        self.assertEqual(
+            qb.build()["filter"],
+            "(createdon ge 2024-01-01T00:00:00Z and createdon le 2024-12-31T23:59:59Z)",
+        )
+
 
 class TestFilterRaw(unittest.TestCase):
     """Tests for the filter_raw() method."""
@@ -277,6 +319,16 @@ def test_where_with_not(self):
         qb = QueryBuilder("account").where(~eq("statecode", 1))
         self.assertEqual(qb.build()["filter"], "not (statecode eq 1)")
 
+    def test_where_with_filter_in(self):
+        from PowerPlatform.Dataverse.models.filters import filter_in, gt
+
+        expr = filter_in("statecode", [0, 1]) & gt("revenue", 100000)
+        qb = QueryBuilder("account").where(expr)
+        self.assertEqual(
+            qb.build()["filter"],
+            '(Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1"]) and revenue gt 100000)',
+        )
+
 
 class TestOrderBy(unittest.TestCase):
     """Tests for the order_by() method."""
@@ -519,6 +571,22 @@ def test_execute_with_where_expressions(self):
             "((statecode eq 0 or statecode eq 1) and revenue gt 100000)",
         )
 
+    def test_execute_with_filter_in(self):
+        mock_query_ops = MagicMock()
+        mock_client = mock_query_ops._client
+        mock_client.records.get.return_value = iter([])
+
+        qb = QueryBuilder("account")
+        qb._query_ops = mock_query_ops
+        qb.filter_in("statecode", [0, 1, 2])
+        list(qb.execute())
+
+        call_args = mock_client.records.get.call_args
+        self.assertEqual(
+            call_args.kwargs["filter"],
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1","2"])',
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

tests/unit/test_query_operations.py

@@ -150,6 +150,50 @@ def test_builder_execute_with_where(self):
             "((statecode eq 0 or statecode eq 1) and revenue gt 100000)",
         )
 
+    def test_builder_execute_with_filter_in(self):
+        """builder().filter_in().execute() should forward CRM.In filter to _get_multiple."""
+        self.client._odata._get_multiple.return_value = iter([[{"accountid": "1"}]])
+
+        list(self.client.query.builder("account").select("name").filter_in("statecode", [0, 1, 2]).execute())
+
+        call_kwargs = self.client._odata._get_multiple.call_args
+        self.assertEqual(
+            call_kwargs.kwargs["filter"],
+            'Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1","2"])',
+        )
+
+    def test_builder_execute_with_where_filter_in(self):
+        """builder().where(filter_in(...) & ...).execute() should compile composed expression."""
+        from PowerPlatform.Dataverse.models.filters import filter_in, gt
+
+        self.client._odata._get_multiple.return_value = iter([[{"accountid": "1"}]])
+
+        list(
+            self.client.query.builder("account").where(filter_in("statecode", [0, 1]) & gt("revenue", 100000)).execute()
+        )
+
+        call_kwargs = self.client._odata._get_multiple.call_args
+        self.assertEqual(
+            call_kwargs.kwargs["filter"],
+            '(Microsoft.Dynamics.CRM.In(PropertyName=\'statecode\',PropertyValues=["0","1"]) and revenue gt 100000)',
+        )
+
+    def test_builder_execute_with_filter_between_datetimes(self):
+        """builder().filter_between() with datetimes should forward correct OData."""
+        from datetime import datetime, timezone
+
+        self.client._odata._get_multiple.return_value = iter([[{"accountid": "1"}]])
+
+        start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
+        end = datetime(2024, 12, 31, 23, 59, 59, tzinfo=timezone.utc)
+        list(self.client.query.builder("account").filter_between("createdon", start, end).execute())
+
+        call_kwargs = self.client._odata._get_multiple.call_args
+        self.assertEqual(
+            call_kwargs.kwargs["filter"],
+            "(createdon ge 2024-01-01T00:00:00Z and createdon le 2024-12-31T23:59:59Z)",
+        )
+
     def test_builder_full_fluent_workflow(self):
         """End-to-end test of the fluent query workflow."""
         expected_records = [