From 54df2c58b4f5a18407bec3b5ac1e615dab2b6970 Mon Sep 17 00:00:00 2001 From: Arseni Lipinski Date: Tue, 23 Apr 2019 14:42:29 +0200 Subject: [PATCH] Add tests for cassandra/metric_batch.py Change-Id: I048b77a7bef7e8477081ba2a404e919897752b7b --- .../tests/test_cassandra_metric_batch.py | 180 ++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 monasca_persister/tests/test_cassandra_metric_batch.py diff --git a/monasca_persister/tests/test_cassandra_metric_batch.py b/monasca_persister/tests/test_cassandra_metric_batch.py new file mode 100644 index 00000000..5055b9c1 --- /dev/null +++ b/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())