← Back to branch summary

~corey.bryant/charm-helpers/drop-symlinks

« back to all changes in this revision

Viewing changes to tests/contrib/peerstorage/test_peerstorage.py

  • Committer: james.page at ubuntu
  • Date: 2015-06-05 10:51:42 UTC
  • mfrom: (381.3.6 ch-le-migration)
  • Revision ID: james.page@ubuntu.com-20150605105142-99i34wuegzf5t6y1
le enablement in cluster and peerstorage helpers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/contrib/peerstorage/test_peerstorage.py
 
1
import copy
 
2
import json
 
3
 
1
4
from tests.helpers import FakeRelation
2
5
from testtools import TestCase
3
6
from mock import patch, call
9
12
    'is_relation_made',
10
13
    'local_unit',
11
14
    'relation_get',
 
15
    '_relation_get',
12
16
    'relation_ids',
13
17
    'relation_set',
 
18
    '_relation_set',
 
19
    '_leader_get',
 
20
    'leader_set',
 
21
    'is_leader',
14
22
]
15
23
FAKE_RELATION_NAME = 'cluster'
16
24
FAKE_RELATION = {
67
75
                                             relation_settings={'key': 'value'})
68
76
 
69
77
    def test_peer_echo_no_includes(self):
 
78
        peerstorage.is_leader.side_effect = NotImplementedError
 
79
        settings = {'key1': 'value1', 'key2': 'value2'}
 
80
        self._relation_get.copy.return_value = settings
 
81
        self._relation_get.return_value = settings
70
82
        peerstorage.peer_echo()
71
 
        self.relation_set.assert_called_with(relation_settings={'key1': 'value1',
72
 
                                                                'key2': 'value2'})
 
83
        self._relation_set.assert_called_with(relation_settings=settings)
73
84
 
74
85
    def test_peer_echo_includes(self):
 
86
        peerstorage.is_leader.side_effect = NotImplementedError
 
87
        settings = {'key1': 'value1'}
 
88
        self._relation_get.copy.return_value = settings
 
89
        self._relation_get.return_value = settings
75
90
        peerstorage.peer_echo(['key1'])
76
 
        self.relation_set.assert_called_with(relation_settings={'key1': 'value1'})
 
91
        self._relation_set.assert_called_with(relation_settings=settings)
77
92
 
78
93
    @patch.object(peerstorage, 'peer_store')
79
94
    def test_peer_store_and_set_no_relation(self, peer_store):
181
196
        self.assertEquals(peerstorage.peer_retrieve_by_prefix(rel_id,
182
197
                                                              inc_list=['host']),
183
198
                          {'host': 'myhost'})
 
199
 
 
200
    def test_leader_get_migration_is_leader(self):
 
201
        self.is_leader.return_value = True
 
202
        l_settings = {'s3': 3}
 
203
        r_settings = {'s1': 1, 's2': 2}
 
204
 
 
205
        def mock_relation_get(attribute=None, unit=None):
 
206
            if attribute:
 
207
                if attribute in r_settings:
 
208
                    return r_settings.get(attribute)
 
209
                else:
 
210
                    return None
 
211
 
 
212
            return copy.deepcopy(r_settings)
 
213
 
 
214
        def mock_leader_get(attribute=None):
 
215
            if attribute:
 
216
                if attribute in l_settings:
 
217
                    return l_settings.get(attribute)
 
218
                else:
 
219
                    return None
 
220
 
 
221
            return copy.deepcopy(l_settings)
 
222
 
 
223
        def mock_leader_set(settings=None, **kwargs):
 
224
            if settings:
 
225
                l_settings.update(settings)
 
226
 
 
227
            l_settings.update(kwargs)
 
228
 
 
229
        def check_leader_db(dicta, dictb):
 
230
            _dicta = copy.deepcopy(dicta)
 
231
            _dictb = copy.deepcopy(dictb)
 
232
            miga = json.loads(_dicta[migration_key]).sort()
 
233
            migb = json.loads(_dictb[migration_key]).sort()
 
234
            self.assertEqual(miga, migb)
 
235
            del _dicta[migration_key]
 
236
            del _dictb[migration_key]
 
237
            self.assertEqual(_dicta, _dictb)
 
238
 
 
239
        migration_key = '__leader_get_migrated_settings__'
 
240
        self.relation_get.side_effect = mock_relation_get
 
241
        self._leader_get.side_effect = mock_leader_get
 
242
        self.leader_set.side_effect = mock_leader_set
 
243
 
 
244
        self.assertEqual({'s1': 1, 's2': 2}, peerstorage.relation_get())
 
245
        self.assertEqual({'s3': 3}, peerstorage._leader_get())
 
246
        self.assertEqual({'s1': 1, 's2': 2, 's3': 3}, peerstorage.leader_get())
 
247
        check_leader_db({'s1': 1, 's2': 2, 's3': 3,
 
248
                         migration_key: '["s2", "s1"]'}, l_settings)
 
249
        self.assertTrue(peerstorage.leader_set.called)
 
250
 
 
251
        peerstorage.leader_set.reset_mock()
 
252
        self.assertEqual({'s1': 1, 's2': 2, 's3': 3}, peerstorage.leader_get())
 
253
        check_leader_db({'s1': 1, 's2': 2, 's3': 3,
 
254
                         migration_key: '["s2", "s1"]'}, l_settings)
 
255
        self.assertFalse(peerstorage.leader_set.called)
 
256
 
 
257
        l_settings = {'s3': 3}
 
258
        peerstorage.leader_set.reset_mock()
 
259
        self.assertEqual(1, peerstorage.leader_get('s1'))
 
260
        check_leader_db({'s1': 1, 's3': 3,
 
261
                         migration_key: '["s1"]'}, l_settings)
 
262
        self.assertTrue(peerstorage.leader_set.called)
 
263
 
 
264
        # Test that leader vals take precedence over non-leader vals
 
265
        r_settings['s3'] = 2
 
266
        r_settings['s4'] = 3
 
267
        l_settings['s4'] = 4
 
268
 
 
269
        peerstorage.leader_set.reset_mock()
 
270
        self.assertEqual(4, peerstorage.leader_get('s4'))
 
271
        check_leader_db({'s1': 1, 's3': 3, 's4': 4,
 
272
                         migration_key: '["s1", "s4"]'}, l_settings)
 
273
        self.assertTrue(peerstorage.leader_set.called)
 
274
 
 
275
        peerstorage.leader_set.reset_mock()
 
276
        self.assertEqual({'s1': 1, 's2': 2, 's3': 2, 's4': 3},
 
277
                         peerstorage.relation_get())
 
278
        check_leader_db({'s1': 1, 's3': 3, 's4': 4,
 
279
                         migration_key: '["s1", "s4"]'},
 
280
                        peerstorage._leader_get())
 
281
        self.assertEqual({'s1': 1, 's2': 2, 's3': 3, 's4': 4},
 
282
                         peerstorage.leader_get())
 
283
        check_leader_db({'s1': 1, 's2': 2, 's3': 3, 's4': 4,
 
284
                         migration_key: '["s3", "s2", "s1", "s4"]'},
 
285
                        l_settings)
 
286
        self.assertTrue(peerstorage.leader_set.called)
 
287
 
 
288
    def test_leader_get_migration_is_not_leader(self):
 
289
        self.is_leader.return_value = False
 
290
        l_settings = {'s3': 3}
 
291
        r_settings = {'s1': 1, 's2': 2}
 
292
 
 
293
        def mock_relation_get(attribute=None, unit=None):
 
294
            if attribute:
 
295
                if attribute in r_settings:
 
296
                    return r_settings.get(attribute)
 
297
                else:
 
298
                    return None
 
299
 
 
300
            return copy.deepcopy(r_settings)
 
301
 
 
302
        def mock_leader_get(attribute=None):
 
303
            if attribute:
 
304
                if attribute in l_settings:
 
305
                    return l_settings.get(attribute)
 
306
                else:
 
307
                    return None
 
308
 
 
309
            return copy.deepcopy(l_settings)
 
310
 
 
311
        def mock_leader_set(settings=None, **kwargs):
 
312
            if settings:
 
313
                l_settings.update(settings)
 
314
 
 
315
            l_settings.update(kwargs)
 
316
 
 
317
        self.relation_get.side_effect = mock_relation_get
 
318
        self._leader_get.side_effect = mock_leader_get
 
319
        self.leader_set.side_effect = mock_leader_set
 
320
        self.assertEqual({'s1': 1, 's2': 2}, peerstorage.relation_get())
 
321
        self.assertEqual({'s3': 3}, peerstorage._leader_get())
 
322
        self.assertEqual({'s3': 3}, peerstorage.leader_get())
 
323
        self.assertEqual({'s3': 3}, l_settings)
 
324
        self.assertFalse(peerstorage.leader_set.called)
 
325
 
 
326
        self.assertEqual({'s3': 3}, peerstorage.leader_get())
 
327
        self.assertEqual({'s3': 3}, l_settings)
 
328
        self.assertFalse(peerstorage.leader_set.called)
 
329
 
 
330
        # Test that leader vals take precedence over non-leader vals
 
331
        r_settings['s3'] = 2
 
332
        r_settings['s4'] = 3
 
333
        l_settings['s4'] = 4
 
334
 
 
335
        self.assertEqual(4, peerstorage.leader_get('s4'))
 
336
        self.assertEqual({'s3': 3, 's4': 4}, l_settings)
 
337
        self.assertFalse(peerstorage.leader_set.called)