cmframework/test/cmprocessor_node_activation_test.py

   1 # Copyright 2019 Nokia
   2
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import unittest
  16 import mock
  17 from mock import call
  18 import json
  19
  20 from cmframework.server.cmprocessor import CMProcessor
  21 from cmframework.apis.cmerror import CMError
  22 from cmframework.server.cmcsn import CMCSN
  23
  24 # TODO:Add the checking for calling the changemonitorhandle
  25
  26
  27 class CMProcessorNodeActivationTest(unittest.TestCase):
  28     @staticmethod
  29     def backend_get_property(key):
  30         if key == 'cloud.cmframework':
  31             return '{"csn": {"global": 101, "nodes": {"node-a": 99, "node-b": 100, "node-c": 101}}}'
  32         elif key == 'foo':
  33             return '{"foo": "bar"}'
  34
  35     @mock.patch('cmframework.server.cmprocessor.logging')
  36     @mock.patch('cmframework.server.cmprocessor.cmactivationwork.CMActivationWork')
  37     def test_get_property(self, mock_work, mock_logging):
  38         mock_backend = mock.MagicMock()
  39         mock_backend.get_property = CMProcessorNodeActivationTest.backend_get_property
  40
  41         mock_validator = mock.MagicMock()
  42         mock_activator = mock.MagicMock()
  43         mock_changemonitor = mock.MagicMock()
  44         mock_activationstate_handler = mock.MagicMock()
  45         mock_snapshot_handler = mock.MagicMock()
  46
  47         mock_work.OPER_SET = mock.MagicMock()
  48
  49         processor = CMProcessor(mock_backend, mock_validator, mock_activator,
  50                                 mock_changemonitor, mock_activationstate_handler,
  51                                 mock_snapshot_handler)
  52
  53         self.assertEqual(json.loads(processor.get_property('foo'))['foo'], 'bar')
  54
  55     @mock.patch('cmframework.server.cmprocessor.logging')
  56     @mock.patch('cmframework.server.cmprocessor.cmactivationwork.CMActivationWork')
  57     def test_set_property(self, mock_work, mock_logging):
  58         mock_backend = mock.MagicMock()
  59         mock_backend.get_property = CMProcessorNodeActivationTest.backend_get_property
  60
  61         mock_validator = mock.MagicMock()
  62         mock_activator = mock.MagicMock()
  63         mock_changemonitor = mock.MagicMock()
  64         mock_activationstate_handler = mock.MagicMock()
  65         mock_snapshot_handler = mock.MagicMock()
  66
  67         mock_work.OPER_SET = mock.MagicMock()
  68
  69         processor = CMProcessor(mock_backend, mock_validator, mock_activator,
  70                                 mock_changemonitor, mock_activationstate_handler,
  71                                 mock_snapshot_handler)
  72
  73         processor.set_property('foo', 'barbar')
  74
  75         mock_validator.validate_set.assert_called_once_with({'foo': 'barbar'})
  76         mock_backend.set_properties.called_once_with({'foo': 'barbar'})
  77         mock_work.assert_called_once_with(mock_work.OPER_SET, 102, {'foo': 'barbar'})
  78         mock_activator.add_work.assert_called_once_with(mock_work.return_value)
  79
  80     @mock.patch('cmframework.server.cmprocessor.logging')
  81     @mock.patch('cmframework.server.cmprocessor.cmactivationwork.CMActivationWork')
  82     @mock.patch('cmframework.server.cmprocessor.cmalarm.CMActivationFailedAlarm')
  83     def test_activate_node_no_change(self, mock_alarm, mock_work, mock_logging):
  84         mock_backend = mock.MagicMock()
  85         mock_backend.get_property = CMProcessorNodeActivationTest.backend_get_property
  86
  87         mock_validator = mock.MagicMock()
  88         mock_activator = mock.MagicMock()
  89         mock_changemonitor = mock.MagicMock()
  90         mock_activationstate_handler = mock.MagicMock()
  91         mock_snapshot_handler = mock.MagicMock()
  92
  93         mock_work.return_value.get_result = mock.MagicMock()
  94         mock_work.return_value.get_result.return_value = None
  95
  96         mock_work.OPER_NODE = mock.MagicMock()
  97
  98         processor = CMProcessor(mock_backend, mock_validator, mock_activator,
  99                                 mock_changemonitor, mock_activationstate_handler,
 100                                 mock_snapshot_handler)
 101
 102         self.assertEqual(processor.activate_node('node-c'), False)
 103
 104         mock_alarm.assert_not_called()
 105         mock_activator.add_work.assert_not_called()
 106
 107     @mock.patch('cmframework.server.cmprocessor.logging')
 108     @mock.patch('cmframework.server.cmprocessor.cmactivationwork.CMActivationWork')
 109     @mock.patch('cmframework.server.cmprocessor.cmalarm.CMActivationFailedAlarm')
 110     @mock.patch.object(CMProcessor, '_clear_reboot_requests')
 111     @mock.patch.object(CMCSN, 'sync_node_csn')
 112     def test_activate_node_changed_no_reboot(self, mock_sync_node_csn, mock_clear_reboot_requests,
 113                                              mock_alarm, mock_work, mock_logging):
 114         mock_backend = mock.MagicMock()
 115         mock_backend.get_property = CMProcessorNodeActivationTest.backend_get_property
 116
 117         mock_validator = mock.MagicMock()
 118         mock_activator = mock.MagicMock()
 119         mock_changemonitor = mock.MagicMock()
 120         mock_activationstate_handler = mock.MagicMock()
 121         mock_snapshot_handler = mock.MagicMock()
 122
 123         mock_work.return_value.get_result = mock.MagicMock()
 124         mock_work.return_value.get_result.return_value = None
 125
 126         mock_work.OPER_NODE = mock.MagicMock()
 127
 128         processor = CMProcessor(mock_backend, mock_validator, mock_activator,
 129                                 mock_changemonitor, mock_activationstate_handler,
 130                                 mock_snapshot_handler)
 131
 132         self.assertEqual(processor.activate_node('node-b'), False)
 133
 134         mock_clear_reboot_requests.assert_called_once()
 135         mock_work.assert_called_once_with(mock_work.OPER_NODE, 101, {}, 'node-b')
 136         mock_activator.add_work.assert_called_once_with(mock_work.return_value)
 137         mock_alarm.return_value.cancel_alarm_for_node.assert_called_once_with('node-b')
 138         mock_work.return_value.get_result.assert_called_once()
 139         mock_sync_node_csn.assert_called_once()
 140         mock_alarm.return_value.raise_alarm_for_node.assert_not_called()
 141
 142     @mock.patch('cmframework.server.cmprocessor.logging')
 143     @mock.patch('cmframework.server.cmprocessor.cmactivationwork.CMActivationWork')
 144     @mock.patch('cmframework.server.cmprocessor.cmalarm.CMActivationFailedAlarm')
 145     @mock.patch.object(CMProcessor, '_clear_reboot_requests')
 146     @mock.patch.object(CMCSN, 'sync_node_csn')
 147     def test_activate_node_changed_and_reboot(self, mock_sync_node_csn, mock_clear_reboot_requests,
 148                                               mock_alarm, mock_work, mock_logging):
 149         mock_backend = mock.MagicMock()
 150         mock_backend.get_property = CMProcessorNodeActivationTest.backend_get_property
 151
 152         mock_validator = mock.MagicMock()
 153         mock_activator = mock.MagicMock()
 154         mock_changemonitor = mock.MagicMock()
 155         mock_activationstate_handler = mock.MagicMock()
 156         mock_snapshot_handler = mock.MagicMock()
 157
 158         mock_work.return_value.get_result = mock.MagicMock()
 159         mock_work.return_value.get_result.return_value = None
 160
 161         mock_work.OPER_NODE = mock.MagicMock()
 162
 163         processor = CMProcessor(mock_backend, mock_validator, mock_activator,
 164                                 mock_changemonitor, mock_activationstate_handler,
 165                                 mock_snapshot_handler)
 166
 167         processor.reboot_request('node-b')
 168
 169         self.assertEqual(processor.activate_node('node-b'), True)
 170
 171         mock_clear_reboot_requests.assert_called_once()
 172         mock_work.assert_called_once_with(mock_work.OPER_NODE, 101, {}, 'node-b')
 173         mock_activator.add_work.assert_called_once_with(mock_work.return_value)
 174         mock_alarm.return_value.cancel_alarm_for_node.assert_called_once_with('node-b')
 175         mock_work.return_value.get_result.assert_called_once()
 176         mock_sync_node_csn.assert_called_once()
 177         mock_alarm.return_value.raise_alarm_for_node.assert_not_called()
 178
 179     @mock.patch('cmframework.server.cmprocessor.logging')
 180     @mock.patch('cmframework.server.cmprocessor.cmactivationwork.CMActivationWork')
 181     @mock.patch('cmframework.server.cmprocessor.cmalarm.CMActivationFailedAlarm')
 182     @mock.patch.object(CMCSN, 'sync_node_csn')
 183     def test_activate_node_changed_activation_fails(self, mock_sync_node_csn,
 184                                                     mock_alarm, mock_work, mock_logging):
 185         mock_backend = mock.MagicMock()
 186         mock_backend.get_property = CMProcessorNodeActivationTest.backend_get_property
 187
 188         mock_validator = mock.MagicMock()
 189         mock_activator = mock.MagicMock()
 190         mock_changemonitor = mock.MagicMock()
 191         mock_activationstate_handler = mock.MagicMock()
 192         mock_snapshot_handler = mock.MagicMock()
 193
 194         mock_work.return_value.get_result = mock.MagicMock()
 195         mock_work.return_value.get_result.return_value = {'test handler': ['test error']}
 196
 197         mock_work.OPER_NODE = mock.MagicMock()
 198
 199         processor = CMProcessor(mock_backend, mock_validator, mock_activator,
 200                                 mock_changemonitor, mock_activationstate_handler,
 201                                 mock_snapshot_handler)
 202
 203         processor.activate_node('node-b')
 204
 205         mock_work.assert_called_once_with(mock_work.OPER_NODE, 101, {}, 'node-b')
 206         mock_activator.add_work.assert_called_once_with(mock_work.return_value)
 207         mock_work.return_value.get_result.assert_called_once()
 208         mock_sync_node_csn.assert_not_called()
 209         mock_alarm.return_value.assert_has_calls(
 210             [call.cancel_alarm_for_node('node-b'),
 211              call.raise_alarm_for_node('node-b', {'failed activators': ['test error']})])
 212
 213 if __name__ == '__main__':
 214     unittest.main()