Kubernetes memory parameter
[ta/config-manager.git] / cmframework / test / cmsnapshot_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.cmsnapshot import CMSnapshot
21 from cmframework.apis.cmerror import CMError
22
23
24 class CMSnapshotTest(unittest.TestCase):
25     @staticmethod
26     def snapshot_list_data(name):
27         return {'snapshot_properties': {'some': 'value'},
28                 'snapshot_metadata': 'meta-{}'.format(name)}
29
30     @mock.patch('cmframework.server.cmsnapshot.logging')
31     def test_new_snapshot_object(self, mock_logging):
32         mock_handler = mock.MagicMock()
33
34         snapshot = CMSnapshot(mock_handler)
35
36         with self.assertRaises(CMError) as context:
37             snapshot.get_property('foo')
38
39     @mock.patch('cmframework.server.cmsnapshot.logging')
40     def test_restore_without_load(self, mock_logging):
41         mock_handler = mock.MagicMock()
42
43         mock_target_backend = mock.MagicMock()
44         mock_target_backend.get_properties.return_value = {"foo": "bar",
45                                                            "some": {"other": "value"}}
46
47         snapshot = CMSnapshot(mock_handler)
48
49         with self.assertRaises(CMError) as context:
50             snapshot.restore(mock_target_backend)
51
52     @mock.patch('cmframework.server.cmsnapshot.datetime.datetime')
53     @mock.patch('cmframework.server.cmsnapshot.logging')
54     def test_create(self, mock_logging, mock_datetime):
55         mock_handler = mock.MagicMock()
56         mock_handler.snapshot_exists.return_value = False
57
58         mock_source_backend = mock.MagicMock()
59         mock_source_backend.get_properties.return_value = {"foo": "bar", "some": {"other": "value"}}
60         mock_source_backend.get_property.return_value = 'some'
61
62         mock_datetime.now = mock.MagicMock()
63         from datetime import datetime
64         mock_datetime.now.return_value = datetime.now()
65         expected_creation_date = mock_datetime.now.return_value.isoformat()
66
67         snapshot = CMSnapshot(mock_handler)
68         snapshot.create('snap1', mock_source_backend)
69
70         mock_handler.set_data.assert_called_once_with(
71             'snap1',
72             {'snapshot_properties': mock_source_backend.get_properties.return_value,
73              'snapshot_metadata': {'name': 'snap1',
74                                    'creation_date': expected_creation_date,
75                                    'custom': None}})
76
77     @mock.patch('cmframework.server.cmsnapshot.logging')
78     def test_create_already_exists(self, mock_logging):
79         mock_handler = mock.MagicMock()
80         mock_handler.snapshot_exists.return_value = True
81
82         mock_backend_handler = mock.MagicMock()
83
84         snapshot = CMSnapshot(mock_handler)
85
86         with self.assertRaises(CMError) as context:
87             snapshot.create('already_exists', mock_backend_handler)
88
89     @mock.patch('cmframework.server.cmsnapshot.logging')
90     def test_load_non_existing(self, mock_logging):
91         mock_handler = mock.MagicMock()
92         mock_handler.snapshot_exists.return_value = False
93
94         snapshot = CMSnapshot(mock_handler)
95
96         with self.assertRaises(CMError) as context:
97             snapshot.load('snap1')
98
99     @mock.patch('cmframework.server.cmsnapshot.logging')
100     def test_load(self, mock_logging):
101         expected_data = {'some': 'value'}
102         expected_metadata = {'name': 'snap1',
103                              'creation_date': 'somedate',
104                              'custom': None}
105
106         mock_handler = mock.MagicMock()
107         mock_handler.snapshot_exists.return_value = True
108         mock_handler.get_data.return_value = {
109             'snapshot_properties': expected_data,
110             'snapshot_metadata': expected_metadata}
111
112         snapshot = CMSnapshot(mock_handler)
113
114         snapshot.load('already_exists')
115
116         assert snapshot._data == expected_data
117         assert snapshot._metadata == expected_metadata
118
119     @mock.patch('cmframework.server.cmsnapshot.logging')
120     def test_restore(self, mock_logging):
121         expected_data = {'foo': 'bar', 'some': {'other': 'value'}}
122         expected_metadata = {'name': 'already_exists',
123                              'creation_date': 'somedate',
124                              'custom': None}
125
126         mock_handler = mock.MagicMock()
127         mock_handler.snapshot_exists.return_value = True
128         mock_handler.get_data.return_value = {
129             'snapshot_properties': expected_data,
130             'snapshot_metadata': expected_metadata}
131
132         target_backend = mock.MagicMock()
133         target_backend.get_properties.return_value = {"a": "1", "b": "2"}
134
135         snapshot = CMSnapshot(mock_handler)
136         snapshot.load('already_exists')
137
138         snapshot.restore(target_backend)
139
140         assert {'a', 'b'} == set(target_backend.delete_properties.call_args[0][0])
141         target_backend.set_properties.assert_called_once_with(expected_data)
142
143     @mock.patch('cmframework.server.cmsnapshot.logging')
144     def test_restore_only_one_in_target(self, mock_logging):
145         expected_data = {'foo': 'bar', 'some': {'other': 'value'}}
146         expected_metadata = {'name': 'already_exists',
147                              'creation_date': 'somedate',
148                              'custom': None}
149
150         mock_handler = mock.MagicMock()
151         mock_handler.snapshot_exists.return_value = True
152         mock_handler.get_data.return_value = {
153             'snapshot_properties': expected_data,
154             'snapshot_metadata': expected_metadata}
155
156         target_backend = mock.MagicMock()
157         target_backend.get_properties.return_value = {"a": "1"}
158
159         snapshot = CMSnapshot(mock_handler)
160         snapshot.load('already_exists')
161
162         snapshot.restore(target_backend)
163
164         target_backend.delete_property.assert_called_once_with('a')
165         target_backend.set_properties.assert_called_once_with(expected_data)
166
167     @mock.patch('cmframework.server.cmsnapshot.logging')
168     def test_list(self, mock_logging):
169         mock_handler = mock.MagicMock()
170         mock_handler.get_data.side_effect = CMSnapshotTest.snapshot_list_data
171         mock_handler.list_snapshots.return_value = {'snap1', 'snap2'}
172
173         expected_snapshot_list = {'meta-snap1', 'meta-snap2'}
174
175         snapshot = CMSnapshot(mock_handler)
176         snapshot_list = snapshot.list()
177
178         assert set(snapshot_list) == expected_snapshot_list
179
180     @mock.patch('cmframework.server.cmsnapshot.logging')
181     def test_delete(self, mock_logging):
182         mock_handler = mock.MagicMock()
183         mock_handler.snapshot_exists.return_value = True
184
185         snapshot = CMSnapshot(mock_handler)
186         snapshot.delete('already_exists')
187
188         mock_handler.delete_snapshot.assert_called_once_with('already_exists')
189
190     @mock.patch('cmframework.server.cmsnapshot.logging')
191     def test_delete_non_existing(self, mock_logging):
192         mock_handler = mock.MagicMock()
193         mock_handler.snapshot_exists.return_value = False
194
195         snapshot = CMSnapshot(mock_handler)
196
197         with self.assertRaises(CMError) as context:
198             snapshot.delete('snap1')
199
200 if __name__ == '__main__':
201     unittest.main()