Various tests #2

Author: yh-0

ravendb/documents/commands/revisions.py

@@ -92,7 +92,7 @@ def get_request_query_string(self, path_builder: List[str]) -> None:
                 path_builder.append(Utils.escape(change_vector))
 
         if self._before is not None:
-            path_builder.append("&before")
+            path_builder.append("&before=")
             path_builder.append(Utils.datetime_to_string(self._before))
 
         if self._start is not None:

ravendb/documents/indexes/abstract_index_creation_tasks.py

@@ -22,6 +22,7 @@
 from ravendb.documents.indexes.vector.options import VectorOptions
 from ravendb.documents.operations.indexes import PutIndexesOperation
 from ravendb.documents.store.definition import DocumentStoreBase
+from ravendb.exceptions.raven_exceptions import IndexCompilationException
 from ravendb.primitives import constants
 
 _T_IndexDefinition = TypeVar("_T_IndexDefinition", bound=IndexDefinition)
@@ -268,7 +269,7 @@ def __set_suggestions(options: IndexFieldOptions, value: bool):
             return index_definition
 
         except Exception as e:
-            raise RuntimeError(f"Failed to create index {self._index_name}", e)  # todo: IndexCompilationException
+            raise IndexCompilationException(f"Failed to create index {self._index_name}", e)
 
 
 class IndexDefinitionBuilder(AbstractIndexDefinitionBuilder[IndexDefinition]):

ravendb/documents/session/document_session_operations/in_memory_document_session_operations.py

@@ -1887,7 +1887,7 @@ def with_timeout(self, timeout: datetime.timedelta) -> InMemoryDocumentSessionOp
             return self
 
         def throw_on_timeout(self, should_throw: bool) -> InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder:
-            self.get_options().index_options.throw_on_timeout_in_wait_for_replicas = should_throw
+            self.get_options().index_options.throw_on_timeout_in_wait_for_indexes = should_throw
             return self
 
         def wait_for_indexes(self, *indexes: str) -> InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder:

ravendb/documents/session/misc.py

@@ -10,7 +10,7 @@
 
 if TYPE_CHECKING:
     from ravendb.http.request_executor import RequestExecutor
-    from ravendb.documents.queries.misc import Query
+    from ravendb.documents.session.query import DocumentQuery
     from ravendb.documents.session.operations.query import QueryOperation
     from ravendb.documents.session.document_session_operations.in_memory_document_session_operations import (
         InMemoryDocumentSessionOperations,
@@ -153,7 +153,7 @@ def __init__(
 
 
 class DocumentQueryCustomization:
-    def __init__(self, query: Query):
+    def __init__(self, query: DocumentQuery):
         self.query = query
         self.query_operation: QueryOperation = None
 

ravendb/documents/smuggler/backup_utils.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+from ravendb.documents.smuggler.periodic_backup_file_extension_comparator import PeriodicBackupFileExtensionComparator
+
+
+class BackupUtils:
+
+    @staticmethod
+    def file_comparator(file1: Path, file2: Path) -> int:
+        base_name1 = file1.stem
+        base_name2 = file2.stem
+
+        if base_name1 != base_name2:
+            return (base_name1 > base_name2) - (base_name1 < base_name2)
+
+        ext1 = file1.suffix[1:] if file1.suffix.startswith('.') else file1.suffix
+        ext2 = file2.suffix[1:] if file2.suffix.startswith('.') else file2.suffix
+
+        if ext1 != ext2:
+            return PeriodicBackupFileExtensionComparator.compare(file1, file2)
+
+        last_modified1 = file1.stat().st_mtime
+        last_modified2 = file2.stat().st_mtime
+
+        return (last_modified1 > last_modified2) - (last_modified1 < last_modified2)

ravendb/documents/smuggler/periodic_backup_file_extension_comparator.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+from ravendb.primitives.constants import PeriodicBackup
+
+class PeriodicBackupFileExtensionComparator:
+
+    @staticmethod
+    def compare(file1: Path, file2: Path) -> int:
+        if file1.resolve() == file2.resolve():
+            return 0
+
+        ext1 = file1.suffix[1:].lower() if file1.suffix.startswith('.') else file1.suffix.lower()
+
+        if ext1 == PeriodicBackup.SNAPSHOT_EXTENSION:
+            return -1
+
+        if ext1 == PeriodicBackup.FULL_BACKUP_EXTENSION:
+            return -1
+
+        return 1

ravendb/documents/subscriptions/document_subscriptions.py

@@ -73,6 +73,15 @@ def create_for_class(
         options = options or SubscriptionCreationOptions()
         return self.create_for_options(self.ensure_criteria(options, object_type, False), database)
 
+    def create_for_revisions(
+        self,
+        object_type: Type[_T],
+        options: Optional[SubscriptionCreationOptions] = None,
+        database: Optional[str] = None,
+    ) -> str:
+        options = options or SubscriptionCreationOptions()
+        return self.create_for_options(self.ensure_criteria(options, object_type, True), database)
+
     def ensure_criteria(self, criteria: SubscriptionCreationOptions, object_type: Type[_T], revisions: bool):
         if criteria is None:
             criteria = SubscriptionCreationOptions()

ravendb/primitives/constants.py

@@ -114,3 +114,16 @@ def configuration_to_method_name(source: VectorEmbeddingType, dest: VectorEmbedd
 
     DEFAULT_EMBEDDING_TYPE = VectorEmbeddingType.SINGLE
     DEFAULT_IS_EXACT = False
+
+class PeriodicBackup:
+    FULL_BACKUP_EXTENSION = "ravendb-full-backup"
+    SNAPSHOT_EXTENSION = "ravendb-snapshot"
+    ENCRYPTED_FULL_BACKUP_EXTENSION = ".ravendb-encrypted-full-backup"
+    ENCRYPTED_SNAPSHOT_EXTENSION = ".ravendb-encrypted-snapshot"
+    INCREMENTAL_BACKUP_EXTENSION = "ravendb-incremental-backup"
+    ENCRYPTED_INCREMENTAL_BACKUP_EXTENSION = ".ravendb-encrypted-incremental-backup"
+
+    class Folders:
+        INDEXES = "Indexes"
+        DOCUMENTS = "Documents"
+        CONFIGURATION = "Configuration"

ravendb/tests/jvm_migrated_tests/bugs_tests/caching_tests/test_caching_of_document_include.py

@@ -28,6 +28,24 @@ class CachingOfDocumentsIncludeTest(TestBase):
     def setUp(self):
         super().setUp()
 
+    def test_can_cache_document_with_includes(self):
+        with self.store.open_session() as session:
+            user = User(name="Ayende")
+            session.store(user)
+
+            partner = User(partner_id="users/1-A")
+            session.store(partner)
+
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            session.include("partnerId").load("users/2-A", User)
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            session.include("partnerId").load("users/2-A", User)
+            self.assertEqual(len(session.advanced.request_executor.cache), 1)
+
     def test_can_avoid_using_server_for_load_with_include_if_everything_is_in_session_cacheLazy(self):
         with self.store.open_session() as session:
             user = User(name="Ayende")

ravendb/tests/jvm_migrated_tests/client_tests/subscriptions_tests/test_revisions_subscriptions.py

@@ -0,0 +1,68 @@
+from ravendb.documents.subscriptions.revision import Revision
+
+from ravendb.documents.subscriptions.worker import SubscriptionBatch
+
+from ravendb.documents.subscriptions.options import SubscriptionWorkerOptions
+
+from ravendb.documents.operations.revisions import RevisionsCollectionConfiguration, RevisionsConfiguration, \
+    ConfigureRevisionsOperation
+
+from ravendb.tests.test_base import TestBase, User, Company
+
+import threading
+
+
+class TestRevisionsSubscriptions(TestBase):
+    def setUp(self):
+        super(TestRevisionsSubscriptions, self).setUp()
+
+    def test_plain_revisions_subscriptions_compare_docs(self):
+        subscription_id = self.store.subscriptions.create_for_revisions(object_type=User)
+
+        default_collection = RevisionsCollectionConfiguration(minimum_revisions_to_keep=5)
+        users_config = RevisionsCollectionConfiguration()
+        dons_config = RevisionsCollectionConfiguration()
+
+        per_collection_config = { "Users": users_config, "Dons": dons_config }
+        configuration = RevisionsConfiguration(default_collection, per_collection_config)
+
+        operation = ConfigureRevisionsOperation(configuration)
+        self.store.maintenance.send(operation)
+
+        for i in range(10):
+            with self.store.open_session() as session:
+                user = User(f"users1 ver {i}", i)
+                session.store(user)
+
+                company = Company(name=f"dons1 ver {i}")
+                session.store(company)
+
+                session.save_changes()
+
+        sub = self.store.subscriptions.get_subscription_worker_for_revisions(SubscriptionWorkerOptions(subscription_id), object_type=User)
+
+        mre = threading.Semaphore(0)
+        names = []
+        max_age = -1
+
+        def process_batch(batch: SubscriptionBatch):
+            nonlocal mre, names, max_age
+
+            for item in batch.items:
+                item: SubscriptionBatch.Item[Revision[User]]
+                x = item.result
+
+                if x.current.age > max_age and x.current.age > (x.previous.age if x.previous is not None else -1):
+                    current_name = x.current.name if x.current is not None else None
+                    previous_name = x.previous.name if x.previous is not None else None
+                    names.append(f"{current_name} + {previous_name}")
+                    max_age = x.current.age
+
+                if len(names) == 10:
+                    mre.release()
+
+        # todo kuba: RuntimeError: dictionary changed size during iteration
+        # todo kuba: TypeError: 'NoneType' object does not support the context manager protocol
+        sub.run(process_batch)
+
+        self.assertTrue(mre.acquire(timeout=15))