← Back to branch summary

~hopem/charms/trusty/keystone/stable-backport-lp1415579

« back to all changes in this revision

Viewing changes to unit_tests/test_keystone_utils.py

  • Committer: Edward Hope-Morley
  • Date: 2015-02-06 12:29:53 UTC
  • Revision ID: edward.hope-morley@canonical.com-20150206122953-zzriv9kfibnswoyb
[hopem,r=]

Backport fix from /next -r 116

* improves ssl master election logic
* adds more unit tests
* fixes config changes logic

Closes-Bug: 1415579

Show diffs side-by-side

added added

removed removed

Lines of Context:
unit_tests/test_keystone_utils.py
28
28
    'grant_role',
29
29
    'configure_installation_source',
30
30
    'is_elected_leader',
 
31
    'is_ssl_cert_master',
31
32
    'https',
32
33
    'peer_store_and_set',
33
34
    'service_stop',
380
381
        self.assertTrue(utils.is_db_ready())
381
382
 
382
383
    @patch.object(utils, 'peer_units')
383
 
    @patch.object(utils, 'is_elected_leader')
384
 
    @patch.object(utils, 'oldest_peer')
385
 
    @patch.object(utils, 'is_ssl_enabled')
386
 
    def test_ensure_ssl_cert_master(self, mock_is_str_true, mock_oldest_peer,
387
 
                                    mock_is_elected_leader, mock_peer_units):
388
 
        self.relation_ids.return_value = ['cluster:0']
389
 
        self.local_unit.return_value = 'unit/0'
390
 
 
391
 
        mock_is_str_true.return_value = False
392
 
        self.assertFalse(utils.ensure_ssl_cert_master())
393
 
        self.assertFalse(self.relation_set.called)
394
 
 
395
 
        mock_is_elected_leader.return_value = False
396
 
        self.assertFalse(utils.ensure_ssl_cert_master())
397
 
        self.assertFalse(self.relation_set.called)
398
 
 
399
 
        mock_is_str_true.return_value = True
400
 
        mock_is_elected_leader.return_value = False
401
 
        mock_peer_units.return_value = ['unit/0']
402
 
        self.assertFalse(utils.ensure_ssl_cert_master())
403
 
        self.assertFalse(self.relation_set.called)
404
 
 
405
 
        mock_peer_units.return_value = []
406
 
        self.assertTrue(utils.ensure_ssl_cert_master())
407
 
        settings = {'ssl-cert-master': 'unit/0'}
408
 
        self.relation_set.assert_called_with(relation_id='cluster:0',
409
 
                                             relation_settings=settings)
410
 
        self.relation_set.reset_mock()
411
 
 
412
 
        self.assertTrue(utils.ensure_ssl_cert_master(use_oldest_peer=True))
413
 
        settings = {'ssl-cert-master': 'unit/0'}
414
 
        self.relation_set.assert_called_with(relation_id='cluster:0',
415
 
                                             relation_settings=settings)
416
 
        self.relation_set.reset_mock()
417
 
 
418
 
        mock_peer_units.return_value = ['unit/0']
419
 
        self.assertFalse(utils.ensure_ssl_cert_master())
420
 
        self.assertFalse(utils.ensure_ssl_cert_master(use_oldest_peer=True))
421
 
        settings = {'ssl-cert-master': 'unit/0'}
422
 
        self.relation_set.assert_called_with(relation_id='cluster:0',
423
 
                                             relation_settings=settings)
424
 
        self.relation_set.reset_mock()
 
384
    @patch.object(utils, 'is_ssl_enabled')
 
385
    def test_ensure_ssl_cert_master_no_ssl(self, mock_is_ssl_enabled,
 
386
                                           mock_peer_units):
 
387
        mock_is_ssl_enabled.return_value = False
 
388
        self.assertFalse(utils.ensure_ssl_cert_master())
 
389
        self.assertFalse(self.relation_set.called)
 
390
 
 
391
    @patch.object(utils, 'peer_units')
 
392
    @patch.object(utils, 'is_ssl_enabled')
 
393
    def test_ensure_ssl_cert_master_ssl_no_peers(self, mock_is_ssl_enabled,
 
394
                                                 mock_peer_units):
 
395
        def mock_rel_get(unit=None, **kwargs):
 
396
            return None
 
397
 
 
398
        self.relation_get.side_effect = mock_rel_get
 
399
        mock_is_ssl_enabled.return_value = True
 
400
        self.relation_ids.return_value = ['cluster:0']
 
401
        self.local_unit.return_value = 'unit/0'
 
402
        self.related_units.return_value = []
 
403
        mock_peer_units.return_value = []
 
404
        # This should get ignored since we are overriding
 
405
        self.is_ssl_cert_master.return_value = False
 
406
        self.is_elected_leader.return_value = False
 
407
        self.assertTrue(utils.ensure_ssl_cert_master())
 
408
        settings = {'ssl-cert-master': 'unit/0'}
 
409
        self.relation_set.assert_called_with(relation_id='cluster:0',
 
410
                                             relation_settings=settings)
 
411
 
 
412
    @patch.object(utils, 'peer_units')
 
413
    @patch.object(utils, 'is_ssl_enabled')
 
414
    def test_ensure_ssl_cert_master_ssl_master_no_peers(self,
 
415
                                                        mock_is_ssl_enabled,
 
416
                                                        mock_peer_units):
 
417
        def mock_rel_get(unit=None, **kwargs):
 
418
            if unit == 'unit/0':
 
419
                return 'unit/0'
 
420
 
 
421
            return None
 
422
 
 
423
        self.relation_get.side_effect = mock_rel_get
 
424
        mock_is_ssl_enabled.return_value = True
 
425
        self.relation_ids.return_value = ['cluster:0']
 
426
        self.local_unit.return_value = 'unit/0'
 
427
        self.related_units.return_value = []
 
428
        mock_peer_units.return_value = []
 
429
        # This should get ignored since we are overriding
 
430
        self.is_ssl_cert_master.return_value = False
 
431
        self.is_elected_leader.return_value = False
 
432
        self.assertTrue(utils.ensure_ssl_cert_master())
 
433
        settings = {'ssl-cert-master': 'unit/0'}
 
434
        self.relation_set.assert_called_with(relation_id='cluster:0',
 
435
                                             relation_settings=settings)
 
436
 
 
437
    @patch.object(utils, 'peer_units')
 
438
    @patch.object(utils, 'is_ssl_enabled')
 
439
    def test_ensure_ssl_cert_master_ssl_not_leader(self, mock_is_ssl_enabled,
 
440
                                                   mock_peer_units):
 
441
        mock_is_ssl_enabled.return_value = True
 
442
        self.relation_ids.return_value = ['cluster:0']
 
443
        self.local_unit.return_value = 'unit/0'
 
444
        mock_peer_units.return_value = ['unit/1']
 
445
        self.is_ssl_cert_master.return_value = False
 
446
        self.is_elected_leader.return_value = False
 
447
        self.assertFalse(utils.ensure_ssl_cert_master())
 
448
        self.assertFalse(self.relation_set.called)
 
449
 
 
450
    @patch.object(utils, 'peer_units')
 
451
    @patch.object(utils, 'is_ssl_enabled')
 
452
    def test_ensure_ssl_cert_master_is_leader_new_peer(self,
 
453
                                                       mock_is_ssl_enabled,
 
454
                                                       mock_peer_units):
 
455
        def mock_rel_get(unit=None, **kwargs):
 
456
            if unit == 'unit/0':
 
457
                return 'unit/0'
 
458
 
 
459
            return 'unknown'
 
460
 
 
461
        self.relation_get.side_effect = mock_rel_get
 
462
        mock_is_ssl_enabled.return_value = True
 
463
        self.relation_ids.return_value = ['cluster:0']
 
464
        self.local_unit.return_value = 'unit/0'
 
465
        mock_peer_units.return_value = ['unit/1']
 
466
        self.related_units.return_value = ['unit/1']
 
467
        self.is_ssl_cert_master.return_value = False
 
468
        self.is_elected_leader.return_value = True
 
469
        self.assertFalse(utils.ensure_ssl_cert_master())
 
470
        settings = {'ssl-cert-master': 'unit/0'}
 
471
        self.relation_set.assert_called_with(relation_id='cluster:0',
 
472
                                             relation_settings=settings)
 
473
 
 
474
    @patch.object(utils, 'peer_units')
 
475
    @patch.object(utils, 'is_ssl_enabled')
 
476
    def test_ensure_ssl_cert_master_is_leader_no_new_peer(self,
 
477
                                                          mock_is_ssl_enabled,
 
478
                                                          mock_peer_units):
 
479
        def mock_rel_get(unit=None, **kwargs):
 
480
            if unit == 'unit/0':
 
481
                return 'unit/0'
 
482
 
 
483
            return 'unit/0'
 
484
 
 
485
        self.relation_get.side_effect = mock_rel_get
 
486
        mock_is_ssl_enabled.return_value = True
 
487
        self.relation_ids.return_value = ['cluster:0']
 
488
        self.local_unit.return_value = 'unit/0'
 
489
        mock_peer_units.return_value = ['unit/1']
 
490
        self.related_units.return_value = ['unit/1']
 
491
        self.is_ssl_cert_master.return_value = False
 
492
        self.is_elected_leader.return_value = True
 
493
        self.assertFalse(utils.ensure_ssl_cert_master())
 
494
        self.assertFalse(self.relation_set.called)
 
495
 
 
496
    @patch.object(utils, 'peer_units')
 
497
    @patch.object(utils, 'is_ssl_enabled')
 
498
    def test_ensure_ssl_cert_master_is_leader_bad_votes(self,
 
499
                                                        mock_is_ssl_enabled,
 
500
                                                        mock_peer_units):
 
501
        counter = {0: 0}
 
502
 
 
503
        def mock_rel_get(unit=None, **kwargs):
 
504
            """Returns a mix of votes."""
 
505
            if unit == 'unit/0':
 
506
                return 'unit/0'
 
507
 
 
508
            ret = 'unit/%d' % (counter[0])
 
509
            counter[0] += 1
 
510
            return ret
 
511
 
 
512
        self.relation_get.side_effect = mock_rel_get
 
513
        mock_is_ssl_enabled.return_value = True
 
514
        self.relation_ids.return_value = ['cluster:0']
 
515
        self.local_unit.return_value = 'unit/0'
 
516
        mock_peer_units.return_value = ['unit/1']
 
517
        self.related_units.return_value = ['unit/1']
 
518
        self.is_ssl_cert_master.return_value = False
 
519
        self.is_elected_leader.return_value = True
 
520
        self.assertFalse(utils.ensure_ssl_cert_master())
 
521
        self.assertFalse(self.relation_set.called)