RDBC-1068 Fix C#-contradiction bugs found in post-sync audit

- ChunkingOptions.from_json: default MaxTokensPerChunk/OverlapTokens to
  512/0 (matching C#'s non-nullable int initializers) instead of None,
  which crashed validate() with a TypeError on missing keys.
- EmbeddingsGenerationConfiguration.validate: drop the spurious
  'cannot specify both paths and transformation' rejection (C# allows
  both), and add the per-path ChunkingOptions validation loop C# performs.
- OrderByToken.create_distance_ascending_wkt: emit
  spatial.distance(field, spatial.wkt(...)) instead of the malformed
  spatial.distance(field), spatial.wkt(...) (stray paren).

Each fix has a regression test that fails on the pre-fix code.

Author: poissoncorp

ravendb/documents/operations/ai/chunking_options.py

@@ -44,8 +44,8 @@ def __init__(
     def from_json(cls, json_dict: Dict[str, Any]) -> "ChunkingOptions":
         return cls(
             chunking_method=ChunkingMethod(json_dict["ChunkingMethod"]),
-            max_tokens_per_chunk=json_dict.get("MaxTokensPerChunk", None),
-            overlap_tokens=json_dict.get("OverlapTokens", None),
+            max_tokens_per_chunk=json_dict.get("MaxTokensPerChunk", 512),
+            overlap_tokens=json_dict.get("OverlapTokens", 0),
             context_prefix=json_dict.get("ContextPrefix", None),
         )
 

ravendb/documents/operations/ai/embeddings_generation_configuration.py

@@ -135,8 +135,14 @@ def validate(
 
         if not has_paths and not has_transformation:
             errors.append("Either EmbeddingsPathConfigurations or EmbeddingsTransformation must be provided")
-        elif has_paths and has_transformation:
-            errors.append("Cannot specify both EmbeddingsPathConfigurations and EmbeddingsTransformation")
+
+        # Validate each path's chunking options (mirrors the server / C# client; both may be set).
+        if self.embeddings_path_configurations:
+            for path_configuration in self.embeddings_path_configurations:
+                if path_configuration.chunking_options is not None:
+                    path_configuration.chunking_options.validate(path_configuration.path, errors)
+                else:
+                    errors.append(f"Path '{path_configuration.path}': ChunkingOptions must be provided.")
 
         # Validate transformation if provided
         if has_transformation:

ravendb/documents/session/tokens/query_tokens/definitions.py

@@ -299,7 +299,7 @@ def create_distance_ascending_wkt(
         nulls: NullsOrdering = NullsOrdering.DEFAULT,
     ) -> OrderByToken:
         return cls(
-            f"spatial.distance({field_name}), "
+            f"spatial.distance({field_name}, "
             f"spatial.wkt(${wkt_parameter_name})"
             f"{'' if round_factor_parameter_name is None else ', $' + round_factor_parameter_name})",
             False,

ravendb/tests/embeddings_generation_tests/test_chunking_options.py

@@ -64,6 +64,17 @@ def test_overlap_rejected_on_non_paragraph_methods(self):
             self.assertEqual(1, len(errors), method)
             self.assertIn("OverlapTokens", errors[0])
 
+    def test_from_json_missing_int_keys_use_csharp_defaults(self):
+        # Missing MaxTokensPerChunk/OverlapTokens must default to 512/0 (matching C#'s non-nullable
+        # int initializers), not None. None would crash validate() with a TypeError.
+        options = ChunkingOptions.from_json({"ChunkingMethod": "HtmlStrip"})
+        self.assertEqual(512, options.max_tokens_per_chunk)
+        self.assertEqual(0, options.overlap_tokens)
+
+        errors = []
+        options.validate("source", errors)  # must not raise TypeError on the defaults
+        self.assertEqual([], errors)
+
 
 if __name__ == "__main__":
     unittest.main()

ravendb/tests/embeddings_generation_tests/test_embeddings_generation_configuration_validate.py

@@ -0,0 +1,68 @@
+import unittest
+
+from ravendb.documents.operations.ai.chunking_options import ChunkingOptions, ChunkingMethod
+from ravendb.documents.operations.ai.embedding_path_configuration import EmbeddingPathConfiguration
+from ravendb.documents.operations.ai.embeddings_generation_configuration import EmbeddingsGenerationConfiguration
+from ravendb.documents.operations.ai.embeddings_transformation import EmbeddingsTransformation
+
+
+def _config(**overrides) -> EmbeddingsGenerationConfiguration:
+    # A base config that passes every check except the paths/transformation logic under test.
+    base = dict(
+        name="emb",
+        identifier="emb",
+        collection="Docs",
+        connection_string_name="cs",
+        chunking_options_for_querying=ChunkingOptions(ChunkingMethod.HTML_STRIP, 100, 0),
+    )
+    base.update(overrides)
+    return EmbeddingsGenerationConfiguration(**base)
+
+
+def _validate(config) -> list:
+    return config.validate(validate_name=False, validate_identifier=False)
+
+
+class TestEmbeddingsGenerationConfigurationValidate(unittest.TestCase):
+    def test_paths_and_transformation_together_are_allowed(self):
+        # C# has no mutual-exclusivity rule; setting both must NOT be rejected client-side.
+        config = _config(
+            embeddings_path_configurations=[
+                EmbeddingPathConfiguration("Name", ChunkingOptions(ChunkingMethod.HTML_STRIP, 100, 0))
+            ],
+            embeddings_transformation=EmbeddingsTransformation(script="embeddings.generate(this.Name)"),
+        )
+        errors = _validate(config)
+        self.assertNotIn("Cannot specify both EmbeddingsPathConfigurations and EmbeddingsTransformation", errors)
+        self.assertEqual([], errors)
+
+    def test_path_missing_chunking_options_is_rejected(self):
+        # Mirrors C#: each path must carry ChunkingOptions.
+        config = _config(embeddings_path_configurations=[EmbeddingPathConfiguration("Name", None)])
+        errors = _validate(config)
+        self.assertIn("Path 'Name': ChunkingOptions must be provided.", errors)
+
+    def test_path_invalid_chunking_options_is_rejected(self):
+        # Each path's ChunkingOptions is validated with the path as the error source.
+        config = _config(
+            embeddings_path_configurations=[
+                EmbeddingPathConfiguration("Name", ChunkingOptions(ChunkingMethod.HTML_STRIP, 0, 0))
+            ]
+        )
+        errors = _validate(config)
+        self.assertTrue(
+            any("Name" in e and "MaxTokensPerChunk" in e for e in errors),
+            f"expected a per-path MaxTokensPerChunk error, got: {errors}",
+        )
+
+    def test_path_with_valid_chunking_options_passes(self):
+        config = _config(
+            embeddings_path_configurations=[
+                EmbeddingPathConfiguration("Name", ChunkingOptions(ChunkingMethod.HTML_STRIP, 100, 0))
+            ]
+        )
+        self.assertEqual([], _validate(config))
+
+
+if __name__ == "__main__":
+    unittest.main()

ravendb/tests/jvm_migrated_tests/client_tests/queries_tests/test_order_by_distance_wkt.py

@@ -0,0 +1,34 @@
+import unittest
+
+from ravendb.documents.session.tokens.query_tokens.definitions import OrderByToken
+
+
+def _rql(token: OrderByToken) -> str:
+    writer = []
+    token.write_to(writer)
+    return "".join(writer)
+
+
+class TestOrderByDistanceWktRql(unittest.TestCase):
+    """The WKT ascending distance factory must nest spatial.wkt(...) inside spatial.distance(field, ...),
+    matching C# (OrderByToken.cs) and its three sibling factories. The bug emitted a stray ')' right
+    after the field name: 'spatial.distance(loc), spatial.wkt(...)'."""
+
+    def test_distance_ascending_wkt_nests_wkt_inside_distance(self):
+        rql = _rql(OrderByToken.create_distance_ascending_wkt("loc", "p0", None))
+        self.assertIn("spatial.distance(loc, spatial.wkt($p0))", rql)
+        self.assertNotIn("spatial.distance(loc),", rql)
+
+    def test_distance_ascending_wkt_matches_descending_structure(self):
+        asc = _rql(OrderByToken.create_distance_ascending_wkt("loc", "p0", None))
+        desc = _rql(OrderByToken.create_distance_descending_wkt("loc", "p0", None))
+        # Identical apart from the trailing descending marker.
+        self.assertEqual(asc, desc.replace(" desc", ""))
+
+    def test_distance_ascending_wkt_with_round_factor(self):
+        rql = _rql(OrderByToken.create_distance_ascending_wkt("loc", "p0", "p1"))
+        self.assertIn("spatial.distance(loc, spatial.wkt($p0), $p1)", rql)
+
+
+if __name__ == "__main__":
+    unittest.main()