Add tests for cassandra/metric_batch.py

Change-Id: I048b77a7bef7e8477081ba2a404e919897752b7b

monasca_persister/tests/test_cassandra_metric_batch.py

@@ -0,0 +1,180 @@
+# (C) Copyright 2019 Fujitsu Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mock import Mock
+from mock import patch
+
+from cassandra.query import BatchStatement
+from cassandra.query import SimpleStatement
+from oslotest import base
+
+from monasca_persister.repositories.cassandra import metric_batch
+
+
+class FakeException(Exception):
+    pass
+
+
+class TestMetricBatch(base.BaseTestCase):
+    def setUp(self):
+        super(TestMetricBatch, self).setUp()
+        self.bound_stmt = SimpleStatement("whatever")
+        self.metric_batch = metric_batch.MetricBatch(Mock(), Mock(), 1)
+        self._set_patchers()
+        self._set_mocks()
+
+    def _set_patchers(self):
+        self.patch_from_key = patch.object(self.metric_batch.metadata.token_map.token_class,
+                                           'from_key')
+        self.patch_lb_make_query_plan = patch.object(self.metric_batch.lb_policy,
+                                                     'make_query_plan')
+
+    def _set_mocks(self):
+        self.mock_key = self.patch_from_key.start()
+        self.mock_lb_make_query = self.patch_lb_make_query_plan.start()
+        self.mock_key.return_value = 'token'
+        self.mock_lb_make_query.return_value = 'token'
+
+    def tearDown(self):
+        super(TestMetricBatch, self).tearDown()
+        self.mock_key.reset_mock()
+        self.patch_from_key.stop()
+        self.mock_lb_make_query.reset_mock()
+        self.patch_lb_make_query_plan.stop()
+
+    def test_batch_query_by_token_creates_a_query_map_tuple(self):
+        query_map = {}
+
+        self.metric_batch.batch_query_by_token(self.bound_stmt, query_map)
+        batch_statement, counter = query_map.get('token')[0]
+
+        self.assertIsInstance(batch_statement, BatchStatement)
+        self.assertIsInstance(counter, metric_batch.Counter)
+
+    def test_batch_query_increments_counter_if_counter_value_lt_batch_limit(self):
+        self.metric_batch.batch_limit = 2
+        query_map = {}
+
+        self.metric_batch.batch_query_by_token(self.bound_stmt, query_map)
+        prev_counter = query_map.get('token')[0][1].value()
+
+        self.metric_batch.batch_query_by_token(self.bound_stmt, query_map)
+        current_counter = query_map.get('token')[0][1].value()
+
+        self.assertEqual(prev_counter + 1, current_counter)
+
+    def test_new_batch_added_if_counter_value_gt_or_eq_batch_limit(self):
+        self.metric_batch.batch_limit = 1
+        query_map = {}
+
+        self.metric_batch.batch_query_by_token(self.bound_stmt, query_map)
+        prev_len = len(query_map.get('token'))
+
+        self.metric_batch.batch_query_by_token(self.bound_stmt, query_map)
+        curr_len = len(query_map.get('token'))
+
+        self.assertEqual(prev_len + 1, curr_len)
+
+    def test_batch_query_by_replicas_creates_a_query_map_tuple(self):
+        query_map = {}
+
+        self.metric_batch.batch_query_by_replicas(self.bound_stmt, query_map)
+        batch_statement, counter = query_map.get(tuple('token'))[0]
+
+        self.assertIsInstance(batch_statement, BatchStatement)
+        self.assertIsInstance(counter, metric_batch.Counter)
+
+    def test_batch_query_by_replicas_increments_counter_if_counter_value_lt_30(self):
+        query_map = {}
+        self.metric_batch.batch_query_by_replicas(self.bound_stmt, query_map)
+        prev_counter = query_map.get(tuple('token'))[0][1]._count = 29
+
+        self.metric_batch.batch_query_by_replicas(self.bound_stmt, query_map)
+        current_counter = query_map.get(tuple('token'))[0][1].value()
+
+        self.assertEqual(prev_counter + 1, current_counter)
+
+    def test_batch_query_by_replicas_adds_new_batch_if_counter_value_gt_30(self):
+        query_map = {}
+        self.metric_batch.batch_query_by_replicas(self.bound_stmt, query_map)
+        prev_len = len(query_map.get(tuple('token')))
+
+        query_map.get(tuple('token'))[0][1]._count = 30
+        self.metric_batch.batch_query_by_replicas(self.bound_stmt, query_map)
+        curr_len = len(query_map.get(tuple('token')))
+
+        self.assertEqual(prev_len + 1, curr_len)
+
+    def test_add_metric_query(self):
+        self.metric_batch.add_metric_query(self.bound_stmt)
+
+    def test_add_dimension_query(self):
+        self.metric_batch.add_dimension_query(self.bound_stmt)
+
+    def test_add_dimension_metric_query(self):
+        self.metric_batch.add_dimension_metric_query(self.bound_stmt)
+
+    def test_add_metric_dimension_query(self):
+        self.metric_batch.add_metric_dimension_query(self.bound_stmt)
+
+    def test_add_measurement_query(self):
+        self.metric_batch.add_measurement_query(self.bound_stmt)
+
+    def test_clear(self):
+        self.metric_batch.clear()
+
+        self.assertEqual(self.metric_batch.metric_queries, {})
+        self.assertEqual(self.metric_batch.dimension_queries, {})
+        self.assertEqual(self.metric_batch.dimension_metric_queries, {})
+        self.assertEqual(self.metric_batch.metric_dimension_queries, {})
+        self.assertEqual(self.metric_batch.measurement_queries, {})
+
+    def test_log_token_batch_map(self):
+        query_map = {}
+        self.metric_batch.batch_query_by_token(self.bound_stmt, query_map)
+        with patch.object(metric_batch.LOG, 'info') as mock_log_info:
+            self.metric_batch.log_token_batch_map('name', query_map)
+            mock_log_info.assert_called_with('name : Size: 1;  Tokens: |token: 1|')
+
+    def test_log_replica_batch_map(self):
+        query_map = {}
+        with patch.object(self.metric_batch.lb_policy, 'make_query_plan'):
+            with patch.object(metric_batch.LOG, 'info') as mock_log_info:
+                self.metric_batch.batch_query_by_replicas(self.bound_stmt, query_map)
+                self.metric_batch.log_replica_batch_map('name', query_map)
+                mock_log_info.assert_called_with('name : Size: 1;  Replicas: |: 1|')
+
+    def test_get_all_batches(self):
+        with patch.object(self.metric_batch, 'log_token_batch_map'):
+            with(patch.object(self.metric_batch, 'log_replica_batch_map')):
+                sample_elements = ['measurement_query', 'metric_query', 'dimension_query',
+                                   'dimension_metric_query', 'metric_dimension_query']
+                self.metric_batch.measurement_queries.update({'some': sample_elements[0]})
+                self.metric_batch.metric_queries.update({'some': sample_elements[1]})
+                self.metric_batch.dimension_queries.update({'some': sample_elements[2]})
+                self.metric_batch.dimension_metric_queries.update({'some': sample_elements[3]})
+                self.metric_batch.metric_dimension_queries.update({'some': sample_elements[4]})
+
+                result_list = self.metric_batch.get_all_batches()
+
+                for elem in sample_elements:
+                    self.assertIn(elem[0], result_list)
+
+    def test_counter_increment_by(self):
+        counter = metric_batch.Counter()
+        temp_counter_value = counter.value()
+        counter.increment_by(5)
+
+        self.assertEqual(temp_counter_value + 5, counter.value())