RDBC-692 BasicCountersIndexes_JavaScript::basicMultiMapIndex

Author: poissoncorp

ravendb/documents/indexes/counters.py

@@ -8,6 +8,8 @@
     FieldTermVector,
     IndexDefinition,
     IndexSourceType,
+    IndexFieldOptions,
+    IndexType,
 )
 from ravendb.documents.indexes.index_creation import AbstractIndexCreationTaskBase, AbstractIndexDefinitionBuilder
 from ravendb.documents.indexes.spatial.configuration import SpatialOptions, SpatialOptionsFactory
@@ -119,3 +121,73 @@ def create_index_definition(self) -> CountersIndexDefinition:
         index_definition_builder.deployment_mode = self.deployment_mode
 
         return index_definition_builder.to_index_definition(self.conventions)
+
+
+class AbstractJavaScriptCountersIndexCreationTask(AbstractIndexCreationTaskBase[CountersIndexDefinition]):
+    def __init__(self):
+        super(AbstractJavaScriptCountersIndexCreationTask, self).__init__()
+        self._definition = CountersIndexDefinition()
+
+    @property
+    def maps(self) -> Set[str]:
+        return self._definition.maps
+
+    @maps.setter
+    def maps(self, value: Set[str]):
+        self._definition.maps = value
+
+    @property
+    def fields(self) -> Dict[str, IndexFieldOptions]:
+        return self._definition.fields
+
+    @fields.setter
+    def fields(self, value: Dict[str, IndexFieldOptions]):
+        self._definition.fields = value
+
+    @property
+    def reduce(self) -> str:
+        return self._definition.reduce
+
+    @reduce.setter
+    def reduce(self, value: Dict[str, IndexFieldOptions]):
+        self._definition.reduce = value
+
+    @property
+    def is_map_reduce(self) -> bool:
+        return self.reduce is not None
+
+    @property
+    def output_reduce_to_collection(self) -> str:
+        return self._definition.output_reduce_to_collection
+
+    @output_reduce_to_collection.setter
+    def output_reduce_to_collection(self, value: Dict[str, IndexFieldOptions]):
+        self._definition.output_reduce_to_collection = value
+
+    @property
+    def pattern_references_collection_name(self) -> str:
+        return self._definition.pattern_references_collection_name
+
+    @pattern_references_collection_name.setter
+    def pattern_references_collection_name(self, value: Dict[str, IndexFieldOptions]):
+        self._definition.pattern_references_collection_name = value
+
+    @property
+    def pattern_for_output_reduce_to_collection_references(self) -> str:
+        return self._definition.pattern_for_output_reduce_to_collection_references
+
+    @pattern_for_output_reduce_to_collection_references.setter
+    def pattern_for_output_reduce_to_collection_references(self, value: Dict[str, IndexFieldOptions]):
+        self._definition.pattern_for_output_reduce_to_collection_references = value
+
+    def create_index_definition(self) -> CountersIndexDefinition:
+        self._definition.name = self.index_name
+        self._definition.type = IndexType.JAVA_SCRIPT_MAP_REDUCE if self.is_map_reduce else IndexType.JAVA_SCRIPT_MAP
+        self._definition.additional_sources = self.additional_sources or {}
+        self._definition.additional_assemblies = self.additional_assemblies or set()
+        self._definition.configuration = self.configuration
+        self._definition.lock_mode = self.lock_mode
+        self._definition.priority = self.priority
+        self._definition.state = self.state
+        self._definition.deployment_mode = self.deployment_mode
+        return self._definition

ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/counters_tests/test_basic_counters_indexes_javascript.py

@@ -0,0 +1,82 @@
+from ravendb.documents.indexes.counters import AbstractJavaScriptCountersIndexCreationTask
+from ravendb.infrastructure.entities import User
+from ravendb.infrastructure.orders import Company
+from ravendb.tests.test_base import TestBase
+
+
+class MyCounterIndex(AbstractJavaScriptCountersIndexCreationTask):
+    def __init__(self):
+        super(MyCounterIndex, self).__init__()
+        self._maps = [
+            "counters.map('Companies', 'HeartRate', function (counter) {\n return {\n heartBeat: counter.Value,\nname: counter.Name,\nuser: counter.DocumentId\n};\n})"
+        ]
+
+
+class MyMultiMapCounterIndex(AbstractJavaScriptCountersIndexCreationTask):
+    class Result:
+        def __init__(self, heart_beat: float = None, name: str = None, user: str = None):
+            self.heart_beat = heart_beat
+            self.name = name
+            self.user = user
+
+    def __init__(self):
+        super(MyMultiMapCounterIndex, self).__init__()
+        maps = set()
+        maps.add(
+            "counters.map('Companies', 'heartRate', function (counter) {\n"
+            + "return {\n"
+            + "    heartBeat: counter.Value,\n"
+            + "    name: counter.Name,\n"
+            + "    user: counter.DocumentId\n"
+            + "};\n"
+            + "})"
+        )
+
+        maps.add(
+            "counters.map('Companies', 'heartRate2', function (counter) {\n"
+            + "return {\n"
+            + "    heartBeat: counter.Value,\n"
+            + "    name: counter.Name,\n"
+            + "    user: counter.DocumentId\n"
+            + "};\n"
+            + "})"
+        )
+
+        maps.add(
+            "counters.map('Users', 'heartRate', function (counter) {\n"
+            + "return {\n"
+            + "    heartBeat: counter.Value,\n"
+            + "    name: counter.Name,\n"
+            + "    user: counter.DocumentId\n"
+            + "};\n"
+            + "})"
+        )
+
+        self.maps = maps
+
+
+class TestBasicCountersIndexes_JavaScript(TestBase):
+    def setUp(self):
+        super(TestBasicCountersIndexes_JavaScript, self).setUp()
+
+    def test_basic_multi_map_index(self):
+        time_series_index = MyMultiMapCounterIndex()
+        time_series_index.execute(self.store)
+
+        with self.store.open_session() as session:
+            company = Company()
+            session.store(company)
+
+            session.counters_for_entity(company).increment("heartRate", 3)
+            session.counters_for_entity(company).increment("heartRate2", 5)
+
+            user = User()
+            session.store(user)
+            session.counters_for_entity(user).increment("heartRate", 2)
+            session.save_changes()
+
+        self.wait_for_indexing(self.store)
+
+        with self.store.open_session() as session:
+            results = list(session.query_index_type(MyMultiMapCounterIndex, MyMultiMapCounterIndex.Result))
+            self.assertEqual(3, len(results))