Merge branch 'v5.0' of https://github.com/ravendb/ravendb-python-client into v5.0

Author: ayende

pyravendb/commands/raven_commands.py

@@ -57,34 +57,55 @@ def is_failed_with_node(self, node):
 
 
 class GetDocumentCommand(RavenCommand):
-    def __init__(self, key_or_keys, includes=None, metadata_only=False):
+    def __init__(self, key_or_keys, includes=None, metadata_only=False, start=None, page_size=None,
+                 counter_includes=None):
         """
         @param key_or_keys: the key of the documents you want to retrieve (key can be a list of ids)
         :type str or list
         @param includes: array of paths in documents in which server should look for a 'referenced' document
         :type list
         @param metadata_only: specifies if only document metadata should be returned
         :type bool
+        @param start: number of results to skip.
+        type: int
+        @param page_size: maximum number of results to retrieve
+        type: int
+        @param counter_includes: the names of the counters to be included or True to include all counters
+        type: list[str] or bool
         @return: A list of the id or ids we looked for (if they exists)
         :rtype: dict
         """
         super(GetDocumentCommand, self).__init__(method="GET", is_read_request=True)
         self.key_or_keys = key_or_keys
         self.includes = includes
         self.metadata_only = metadata_only
+        self.start = start
+        self.page_size = page_size
+        self.counter_includes = counter_includes
 
-    def create_request(self, server_node):
         if self.key_or_keys is None:
             raise ValueError("None Key is not valid")
+
+    def create_request(self, server_node):
         path = "docs?"
+
+        if self.start:
+            path += f"&start={self.start}"
+        if self.page_size:
+            path += f"&pageSize={self.page_size}"
+        if self.metadata_only:
+            path += "&metadataOnly=true"
         if self.includes:
             path += "".join("&include=" + Utils.quote_key(item) for item in self.includes)
+        if self.counter_includes:
+            if self.counter_includes is True:
+                path += f"&counter={Utils.quote_key('@all_counters')}"
+            else:
+                path += "".join("&counter=" + Utils.quote_key(item) for item in self.counter_includes)
+
         # make get method handle a multi document requests in a single request
         if isinstance(self.key_or_keys, list):
             key_or_keys = collections.OrderedDict.fromkeys(self.key_or_keys)
-            if self.metadata_only:
-                path += "&metadataOnly=true"
-
             # If it is too big, we drop to POST (note that means that we can't use the HTTP cache any longer)
             if (sum(len(x) for x in key_or_keys)) > 1024:
                 self.method = "POST"
@@ -111,6 +132,82 @@ def set_response(self, response):
         return response
 
 
+class GetDocumentsByPrefixCommand(RavenCommand):
+    def __init__(self, start_with, start_after=None, matches=None, exclude=None, start=None, page_size=None,
+                 metadata_only=None):
+
+        """
+        @param start_with: Retrieve all documents whose IDs begin with this string.
+        If the value of this parameter is left empty, all documents in the database are retrieved.
+        :type str
+
+        @param start_after: Retrieve only the results after the first document ID that begins with this prefix.
+        :type str
+
+        @param matches: Retrieve documents whose IDs are exactly <startsWith>+<matches>.
+        Accepts multiple values separated by a pipe character: ' | ' .
+        Use ? to represent any single character, and * to represent any string.
+        :type str
+
+        @param exclude: Exclude documents whose IDs are exactly <startsWith>+<exclude>.
+        Accepts multiple values separated by a pipe character: ' | ' .
+        Use ? to represent any single character, and * to represent any string.
+        type: str
+
+        @param start: number of results to skip.
+        type: int
+
+        @param page_size: maximum number of results to retrieve
+        type: int
+
+        @param metadata_only: specifies if only document metadata should be returned
+        :type bool
+
+        @return: A list of the id or ids we looked for (if they exists)
+        :rtype: dict
+        """
+
+        super(GetDocumentsByPrefixCommand, self).__init__(method="GET", is_read_request=True)
+
+        self.start_with = start_with
+        self.start_after = start_after
+        self.matches = matches
+        self.exclude = exclude
+        self.start = start
+        self.page_size = page_size
+        self.metadata_only = metadata_only
+
+        if self.start_with is None:
+            raise ValueError("None start_with is not valid")
+
+    def create_request(self, server_node):
+        path = f"docs?startsWith={Utils.quote_key(self.start_with)}"
+
+        if self.matches:
+            path += f"&matches={Utils.quote_key(self.matches)}"
+        if self.exclude:
+            path += f"&exclude={Utils.quote_key(self.exclude)}"
+        if self.start_after:
+            path += f"&startAfter={Utils.quote_key(self.start_after)}"
+        if self.start:
+            path += f"&start={self.start}"
+        if self.page_size:
+            path += f"&pageSize={self.page_size}"
+        if self.metadata_only:
+            path += "&metadataOnly=true"
+
+        self.url = "{0}/databases/{1}/{2}".format(server_node.url, server_node.database, path)
+
+    def set_response(self, response):
+        if response is None:
+            return
+
+        response = response.json()
+        if "Error" in response:
+            raise exceptions.ErrorResponseException(response["Error"])
+        return response
+
+
 class DeleteDocumentCommand(RavenCommand):
     def __init__(self, key, change_vector=None):
         super(DeleteDocumentCommand, self).__init__(method="DELETE")

pyravendb/tests/raven_commands_tests/test_get.py

@@ -8,11 +8,14 @@ def setUp(self):
         super(TestGet, self).setUp()
         put_command = PutDocumentCommand("products/101", {"Name": "test", "@metadata": {}})
         put_command2 = PutDocumentCommand("products/10", {"Name": "test", "@metadata": {}})
+        put_command3 = PutDocumentCommand("products/102", {"Name": "test", "@metadata": {}})
         self.requests_executor = self.store.get_request_executor()
         self.requests_executor.execute(put_command)
         self.requests_executor.execute(put_command2)
+        self.requests_executor.execute(put_command3)
         self.response = self.requests_executor.execute(GetDocumentCommand("products/101"))
         self.other_response = self.requests_executor.execute(GetDocumentCommand("products/10"))
+        self.paged_response = self.requests_executor.execute(GetDocumentCommand("products/102", start=2, page_size=1))
 
     def tearDown(self):
         super(TestGet, self).tearDown()
@@ -25,6 +28,10 @@ def test_not_equal(self):
         self.assertNotEqual(self.response["Results"][0]["@metadata"]["@id"],
                             self.other_response["Results"][0]["@metadata"]["@id"])
 
+    def test_paging(self):
+        self.assertEqual(len(self.paged_response["Results"]), 1)
+        self.assertEqual(self.paged_response["Results"][0]["@metadata"]["@id"], "products/102")
+
     def test_null(self):
         self.assertIsNone(self.requests_executor.execute(GetDocumentCommand("product")))
 

pyravendb/tests/raven_commands_tests/test_get_by_prefix.py

@@ -0,0 +1,74 @@
+import unittest
+
+from pyravendb.commands.raven_commands import (
+    PutDocumentCommand,
+    GetDocumentsByPrefixCommand,
+)
+from pyravendb.tests.test_base import TestBase
+
+
+class TestGetDocumentsByPrefixCommand(TestBase):
+    def setUp(self):
+        super(TestGetDocumentsByPrefixCommand, self).setUp()
+        self.requests_executor = self.store.get_request_executor()
+        self.requests_executor.execute(
+            PutDocumentCommand("products/MB-200", {"Name": "test", "@metadata": {}})
+        )
+        self.requests_executor.execute(
+            PutDocumentCommand("products/MB-201", {"Name": "test", "@metadata": {}})
+        )
+        self.requests_executor.execute(
+            PutDocumentCommand("products/MB-100", {"Name": "test", "@metadata": {}})
+        )
+        self.requests_executor.execute(
+            PutDocumentCommand("products/MB-101", {"Name": "test", "@metadata": {}})
+        )
+        self.requests_executor.execute(
+            PutDocumentCommand("products/BM-100", {"Name": "test", "@metadata": {}})
+        )
+        self.requests_executor.execute(
+            PutDocumentCommand("products/BM-200", {"Name": "test", "@metadata": {}})
+        )
+
+    def tearDown(self):
+        super(TestGetDocumentsByPrefixCommand, self).tearDown()
+        self.delete_all_topology_files()
+
+    def test_init_WHEN_start_with_is_empty_THEN_raise(self):
+        self.assertRaises(ValueError, GetDocumentsByPrefixCommand, None)
+
+    def test_start_with(self):
+        response = self.requests_executor.execute(
+            GetDocumentsByPrefixCommand("products/MB")
+        )
+        self.assertEqual(len(response["Results"]), 4)
+
+    def test_matches(self):
+        response = self.requests_executor.execute(
+            GetDocumentsByPrefixCommand("products/MB-", matches="2*")
+        )
+        self.assertEqual(len(response["Results"]), 2)
+
+    def test_excludes(self):
+        response = self.requests_executor.execute(
+            GetDocumentsByPrefixCommand("products/BM-", exclude="2*")
+        )
+        self.assertEqual(len(response["Results"]), 1)
+
+    def test_start_after(self):
+        response = self.requests_executor.execute(
+            GetDocumentsByPrefixCommand(
+                "products/MB-", matches="2*", start_after="products/MB-200"
+            )
+        )
+        self.assertEqual(len(response["Results"]), 1)
+
+    def test_page(self):
+        response = self.requests_executor.execute(
+            GetDocumentsByPrefixCommand("products/MB", start=1, page_size=2)
+        )
+        self.assertEqual(len(response["Results"]), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()