RDBC-780 RavenDB_8355Test::canUseCustomSorter

Author: poissoncorp

ravendb/documents/operations/sorters.py

@@ -0,0 +1,51 @@
+from typing import List, TYPE_CHECKING
+
+import requests
+
+from ravendb import SorterDefinition, RaftCommand, ServerNode
+from ravendb.documents.operations.definitions import VoidMaintenanceOperation
+from ravendb.http.raven_command import VoidRavenCommand
+from ravendb.util.util import RaftIdGenerator
+
+if TYPE_CHECKING:
+    from ravendb.documents.conventions import DocumentConventions
+
+
+class PutSortersOperation(VoidMaintenanceOperation):
+    def __init__(self, *sorters_to_add: SorterDefinition):
+        if not sorters_to_add:
+            raise ValueError("Sorters must not be empty or None")
+
+        self._sorters_to_add = sorters_to_add
+
+    def get_command(self, conventions: "DocumentConventions") -> "PutSortersOperation.PutSortersCommand":
+        return self.PutSortersCommand(conventions, list(self._sorters_to_add))
+
+    class PutSortersCommand(VoidRavenCommand, RaftCommand):
+        def __init__(self, conventions: "DocumentConventions", sorters_to_add: List[SorterDefinition]):
+            if conventions is None:
+                raise ValueError("Conventions cannot be None")
+
+            if sorters_to_add is None:
+                raise ValueError("Sorters cannot be None")
+
+            if any([sorter is None for sorter in sorters_to_add]):
+                raise ValueError("Sorter cannot be None")
+
+            super().__init__()
+
+            self._sorters_to_add = sorters_to_add
+
+        def create_request(self, node: ServerNode) -> requests.Request:
+            url = f"{node.url}/databases/{node.database}/admin/sorters"
+
+            request = requests.Request("PUT", url)
+            request.data = {"Sorters": [sorter.to_json() for sorter in self._sorters_to_add]}
+
+            return request
+
+        def is_read_request(self) -> bool:
+            return False
+
+        def get_raft_unique_request_id(self) -> str:
+            return RaftIdGenerator.new_id()

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

@@ -274,7 +274,10 @@ def score_descending(cls) -> OrderByToken:
     def __init__(self, field_name: str, descending: bool, ordering_or_sorter_name: Union[OrderingType, str]):
         self.__field_name = field_name
         self.__descending = descending
+
+        # duck typing the arg
         is_ordering = isinstance(ordering_or_sorter_name, OrderingType)
+
         self.__ordering = ordering_or_sorter_name if is_ordering else None
         self.__sorter_name = None if is_ordering else ordering_or_sorter_name
 

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_8355.py

@@ -0,0 +1,107 @@
+from typing import Type
+
+from ravendb import SorterDefinition, DocumentStore, RawDocumentQuery, DocumentQuery
+from ravendb.documents.operations.sorters import PutSortersOperation
+from ravendb.exceptions.raven_exceptions import RavenException
+from ravendb.infrastructure.orders import Company
+from ravendb.tests.test_base import TestBase
+
+sorter_code = (
+    "using System;\n"
+    "using System.Collections.Generic;\n"
+    "using Lucene.Net.Index;\n"
+    "using Lucene.Net.Search;\n"
+    "using Lucene.Net.Store;\n"
+    "\n"
+    "namespace SlowTests.Data.RavenDB_8355\n"
+    "{\n"
+    "    public class MySorter : FieldComparator\n"
+    "    {\n"
+    "        private readonly string _args;\n"
+    "\n"
+    "        public MySorter(string fieldName, int numHits, int sortPos, bool reversed, List<string> diagnostics)\n"
+    "        {\n"
+    '            _args = $"{fieldName}:{numHits}:{sortPos}:{reversed}";\n'
+    "        }\n"
+    "\n"
+    "        public override int Compare(int slot1, int slot2)\n"
+    "        {\n"
+    '            throw new InvalidOperationException($"Catch me: {_args}");\n'
+    "        }\n"
+    "\n"
+    "        public override void SetBottom(int slot)\n"
+    "        {\n"
+    '            throw new InvalidOperationException($"Catch me: {_args}");\n'
+    "        }\n"
+    "\n"
+    "        public override int CompareBottom(int doc, IState state)\n"
+    "        {\n"
+    '            throw new InvalidOperationException($"Catch me: {_args}");\n'
+    "        }\n"
+    "\n"
+    "        public override void Copy(int slot, int doc, IState state)\n"
+    "        {\n"
+    '            throw new InvalidOperationException($"Catch me: {_args}");\n'
+    "        }\n"
+    "\n"
+    "        public override void SetNextReader(IndexReader reader, int docBase, IState state)\n"
+    "        {\n"
+    '            throw new InvalidOperationException($"Catch me: {_args}");\n'
+    "        }\n"
+    "\n"
+    '        public override IComparable this[int slot] => throw new InvalidOperationException($"Catch me: {_args}");\n'
+    "    }\n"
+    "}\n"
+)
+
+
+class TestRavenDB8355(TestBase):
+    def setUp(self):
+        super().setUp()
+
+    def test_can_use_custom_sorter(self):
+        sorter_definition = SorterDefinition("MySorter", sorter_code)
+        operation = PutSortersOperation(sorter_definition)
+
+        self.store.maintenance.send(operation)
+
+        with self.store.open_session() as session:
+            company1 = Company(name="C1")
+            session.store(company1)
+
+            company2 = Company(name="C2")
+            session.store(company2)
+
+            session.save_changes()
+
+        self._can_use_sorter_internal(RuntimeError, self.store, "Catch me: name:2:0:False", "Catch me: name:2:0:True")
+
+    def _can_use_sorter_internal(self, expected_class: Type[Exception], store: DocumentStore, asc: str, desc: str) -> None:
+        with store.open_session() as session:
+            self.assertRaisesWithMessageContaining(
+                RawDocumentQuery.__iter__,
+                expected_class,
+                asc,
+                session.advanced.raw_query("from Companies order by custom(name, 'MySorter')"),
+            )
+            self.assertRaisesWithMessageContaining(
+                DocumentQuery.__iter__,
+                expected_class,
+                asc,
+                session.query(object_type=Company).order_by(field="name", sorter_name_or_ordering_type="MySorter"),
+            )
+
+            self.assertRaisesWithMessageContaining(
+                RawDocumentQuery.__iter__,
+                expected_class,
+                desc,
+                session.advanced.raw_query("from Companies order by custom(name, 'MySorter') desc"),
+            )
+            self.assertRaisesWithMessageContaining(
+                DocumentQuery.__iter__,
+                expected_class,
+                desc,
+                session.query(object_type=Company).order_by_descending(
+                    field="name", sorter_name_or_ordering_type="MySorter"
+                ),
+            )