示例#1
0
class TestConsul(unittest.TestCase):
    @patch.object(consul.Consul.Session, 'create',
                  Mock(return_value='fd4f44fe-2cac-bba5-a60b-304b51ff39b7'))
    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.KV, 'get', kv_get)
    @patch.object(consul.Consul.KV, 'delete', Mock())
    def setUp(self):
        Consul({
            'ttl': 30,
            'scope': 't',
            'name': 'p',
            'url': 'https://*****:*****@patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(consul.Consul.Session, 'create',
                  Mock(side_effect=ConsulException))
    def test_create_session(self):
        self.c._session = None
        self.assertRaises(SleepException, self.c.create_session)

    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.Session, 'create',
                  Mock(side_effect=[InvalidSessionTTL, ConsulException]))
    @patch.object(consul.Consul.Agent, 'self',
                  Mock(return_value={'Config': {
                      'SessionTTLMin': 0
                  }}))
    @patch.object(HTTPClient, 'set_ttl', Mock(side_effect=ValueError))
    def test_referesh_session(self):
        self.c._session = '1'
        self.assertFalse(self.c.refresh_session())
        self.c._last_session_refresh = 0
        self.assertRaises(ConsulError, self.c.refresh_session)

    @patch.object(consul.Consul.KV, 'delete', Mock())
    def test_get_cluster(self):
        self.c._base_path = '/service/test'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/fail'
        self.assertRaises(ConsulError, self.c.get_cluster)
        self.c._base_path = '/service/broken'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/legacy'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/good'
        self.c._session = 'fd4f44fe-2cac-bba5-a60b-304b51ff39b8'
        self.assertIsInstance(self.c.get_cluster(), Cluster)

    @patch.object(consul.Consul.KV, 'delete',
                  Mock(side_effect=[ConsulException, True, True, True]))
    @patch.object(consul.Consul.KV, 'put',
                  Mock(side_effect=[True, ConsulException, InvalidSession]))
    def test_touch_member(self):
        self.c.refresh_session = Mock(return_value=False)
        with patch.object(Consul, 'update_service',
                          Mock(side_effect=Exception)):
            self.c.touch_member({
                'conn_url':
                'postgres://*****:*****@127.0.0.1:5433/postgres',
                'api_url': 'http://127.0.0.1:8009/patroni'
            })
        self.c._register_service = True
        self.c.refresh_session = Mock(return_value=True)
        for _ in range(0, 4):
            self.c.touch_member({'balbla': 'blabla'})
        self.c.refresh_session = Mock(side_effect=ConsulError('foo'))
        self.assertFalse(self.c.touch_member({'balbla': 'blabla'}))

    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=InvalidSession))
    def test_take_leader(self):
        self.c.set_ttl(20)
        self.c.refresh_session = Mock()
        self.c.take_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_failover_value(self):
        self.c.set_failover_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_config_value(self):
        self.c.set_config_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=ConsulException))
    def test_write_leader_optime(self):
        self.c.write_leader_optime('1')

    @patch.object(consul.Consul.Session, 'renew', Mock())
    def test_update_leader(self):
        self.c.update_leader(12345)

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_leader(self):
        self.c.delete_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_initialize(self):
        self.c.initialize()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_cancel_initialization(self):
        self.c.cancel_initialization()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_cluster(self):
        self.c.delete_cluster()

    @patch.object(AbstractDCS, 'watch', Mock())
    def test_watch(self):
        self.c.watch(None, 1)
        self.c._name = ''
        self.c.watch(6429, 1)
        with patch.object(consul.Consul.KV, 'get',
                          Mock(side_effect=ConsulException)):
            self.c.watch(6429, 1)

    def test_set_retry_timeout(self):
        self.c.set_retry_timeout(10)

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_sync_state(self):
        self.assertTrue(self.c.set_sync_state_value('{}'))
        self.assertTrue(self.c.delete_sync_state())

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_history_value(self):
        self.assertTrue(self.c.set_history_value('{}'))

    @patch.object(consul.Consul.Agent.Service, 'register',
                  Mock(side_effect=(False, True)))
    @patch.object(consul.Consul.Agent.Service, 'deregister',
                  Mock(return_value=True))
    def test_update_service(self):
        d = {
            'role': 'replica',
            'api_url': 'http://a/t',
            'conn_url': 'pg://c:1',
            'state': 'running'
        }
        self.assertIsNone(self.c.update_service({}, {}))
        self.assertFalse(self.c.update_service({}, d))
        self.assertTrue(self.c.update_service(d, d))
        self.assertIsNone(self.c.update_service(d, d))
        d['state'] = 'stopped'
        self.assertTrue(self.c.update_service(d, d, force=True))
        d['state'] = 'unknown'
        self.assertIsNone(self.c.update_service({}, d))
        d['state'] = 'running'
        d['role'] = 'bla'
        self.assertIsNone(self.c.update_service({}, d))

    def test_reload_config(self):
        self.assertEqual([], self.c._service_tags)
        self.c.reload_config({
            'consul': {
                'token': 'foo',
                'register_service': True,
                'service_tags': ['foo']
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        self.assertEqual(["foo"], self.c._service_tags)

        self.c.refresh_session = Mock(return_value=False)

        d = {
            'role': 'replica',
            'api_url': 'http://a/t',
            'conn_url': 'pg://c:1',
            'state': 'running'
        }

        # Changing register_service from True to False calls deregister()
        self.c.reload_config({
            'consul': {
                'register_service': False
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        with patch(
                'consul.Consul.Agent.Service.deregister') as mock_deregister:
            self.c.touch_member(d)
            mock_deregister.assert_called_once()

        self.assertEqual([], self.c._service_tags)

        # register_service staying False between reloads does not call deregister()
        self.c.reload_config({
            'consul': {
                'register_service': False
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        with patch(
                'consul.Consul.Agent.Service.deregister') as mock_deregister:
            self.c.touch_member(d)
            self.assertFalse(mock_deregister.called)

        # Changing register_service from False to True calls register()
        self.c.reload_config({
            'consul': {
                'register_service': True
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        with patch('consul.Consul.Agent.Service.register') as mock_register:
            self.c.touch_member(d)
            mock_register.assert_called_once()

        # register_service staying True between reloads does not call register()
        self.c.reload_config({
            'consul': {
                'register_service': True
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        with patch('consul.Consul.Agent.Service.register') as mock_register:
            self.c.touch_member(d)
            self.assertFalse(mock_deregister.called)

        # register_service staying True between reloads does calls register() if other service data has changed
        self.c.reload_config({
            'consul': {
                'register_service': True
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        with patch('consul.Consul.Agent.Service.register') as mock_register:
            self.c.touch_member(d)
            mock_register.assert_called_once()

        # register_service staying True between reloads does calls register() if service_tags have changed
        self.c.reload_config({
            'consul': {
                'register_service': True,
                'service_tags': ['foo']
            },
            'loop_wait': 10,
            'ttl': 30,
            'retry_timeout': 10
        })
        with patch('consul.Consul.Agent.Service.register') as mock_register:
            self.c.touch_member(d)
            mock_register.assert_called_once()
示例#2
0
class TestConsul(unittest.TestCase):
    @patch.object(consul.Consul.Session, 'create',
                  Mock(return_value='fd4f44fe-2cac-bba5-a60b-304b51ff39b7'))
    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.KV, 'get', kv_get)
    @patch.object(consul.Consul.KV, 'delete', Mock())
    def setUp(self):
        Consul({
            'ttl': 30,
            'scope': 't',
            'name': 'p',
            'url': 'https://*****:*****@patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(consul.Consul.Session, 'create',
                  Mock(side_effect=ConsulException))
    def test_create_session(self):
        self.c._session = None
        self.assertRaises(SleepException, self.c.create_session)

    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.Session, 'create',
                  Mock(side_effect=[InvalidSessionTTL, ConsulException]))
    @patch.object(consul.Consul.Agent, 'self',
                  Mock(return_value={'Config': {
                      'SessionTTLMin': 0
                  }}))
    @patch.object(HTTPClient, 'set_ttl', Mock(side_effect=ValueError))
    def test_referesh_session(self):
        self.c._session = '1'
        self.assertFalse(self.c.refresh_session())
        self.c._last_session_refresh = 0
        self.assertRaises(ConsulError, self.c.refresh_session)

    @patch.object(consul.Consul.KV, 'delete', Mock())
    def test_get_cluster(self):
        self.c._base_path = '/service/test'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/fail'
        self.assertRaises(ConsulError, self.c.get_cluster)
        self.c._base_path = '/service/good'
        self.c._session = 'fd4f44fe-2cac-bba5-a60b-304b51ff39b8'
        self.assertIsInstance(self.c.get_cluster(), Cluster)

    @patch.object(consul.Consul.KV, 'delete',
                  Mock(side_effect=[ConsulException, True, True]))
    @patch.object(consul.Consul.KV, 'put',
                  Mock(side_effect=[True, ConsulException]))
    def test_touch_member(self):
        self.c.refresh_session = Mock(return_value=True)
        self.c.touch_member({'balbla': 'blabla'})
        self.c.touch_member({'balbla': 'blabla'})
        self.c.touch_member({'balbla': 'blabla'})
        self.c.refresh_session = Mock(return_value=False)
        self.c.touch_member({'balbla': 'blabla'})

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=False))
    def test_take_leader(self):
        self.c.set_ttl(20)
        self.c.refresh_session = Mock()
        self.c.take_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_failover_value(self):
        self.c.set_failover_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_config_value(self):
        self.c.set_config_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=ConsulException))
    def test_write_leader_optime(self):
        self.c.write_leader_optime('1')

    @patch.object(consul.Consul.Session, 'renew', Mock())
    def test_update_leader(self):
        self.c.update_leader(None)

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_leader(self):
        self.c.delete_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_initialize(self):
        self.c.initialize()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_cancel_initialization(self):
        self.c.cancel_initialization()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_cluster(self):
        self.c.delete_cluster()

    @patch.object(AbstractDCS, 'watch', Mock())
    def test_watch(self):
        self.c.watch(None, 1)
        self.c._name = ''
        self.c.watch(6429, 1)
        with patch.object(consul.Consul.KV, 'get',
                          Mock(side_effect=ConsulException)):
            self.c.watch(6429, 1)

    def test_set_retry_timeout(self):
        self.c.set_retry_timeout(10)

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_sync_state(self):
        self.assertTrue(self.c.set_sync_state_value('{}'))
        self.assertTrue(self.c.delete_sync_state())

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_history_value(self):
        self.assertTrue(self.c.set_history_value('{}'))
示例#3
0
class TestConsul(unittest.TestCase):

    @patch.object(consul.Consul.Session, 'create', Mock(return_value='fd4f44fe-2cac-bba5-a60b-304b51ff39b7'))
    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.KV, 'get', kv_get)
    @patch.object(consul.Consul.KV, 'delete', Mock())
    def setUp(self):
        Consul({'ttl': 30, 'scope': 't', 'name': 'p', 'url': 'https://*****:*****@patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(consul.Consul.Session, 'create', Mock(side_effect=ConsulException))
    def test_create_session(self):
        self.c._session = None
        self.assertRaises(SleepException, self.c.create_session)

    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.Session, 'create', Mock(side_effect=[InvalidSessionTTL, ConsulException]))
    @patch.object(consul.Consul.Agent, 'self', Mock(return_value={'Config': {'SessionTTLMin': 0}}))
    @patch.object(HTTPClient, 'set_ttl', Mock(side_effect=ValueError))
    def test_referesh_session(self):
        self.c._session = '1'
        self.assertFalse(self.c.refresh_session())
        self.c._last_session_refresh = 0
        self.assertRaises(ConsulError, self.c.refresh_session)

    @patch.object(consul.Consul.KV, 'delete', Mock())
    def test_get_cluster(self):
        self.c._base_path = '/service/test'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/fail'
        self.assertRaises(ConsulError, self.c.get_cluster)
        self.c._base_path = '/service/good'
        self.c._session = 'fd4f44fe-2cac-bba5-a60b-304b51ff39b8'
        self.assertIsInstance(self.c.get_cluster(), Cluster)

    @patch.object(consul.Consul.KV, 'delete', Mock(side_effect=[ConsulException, True, True]))
    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=[True, ConsulException]))
    def test_touch_member(self):
        self.c.refresh_session = Mock(return_value=True)
        self.c.touch_member({'balbla': 'blabla'})
        self.c.touch_member({'balbla': 'blabla'})
        self.c.touch_member({'balbla': 'blabla'})
        self.c.refresh_session = Mock(return_value=False)
        self.c.touch_member({'balbla': 'blabla'})

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=False))
    def test_take_leader(self):
        self.c.set_ttl(20)
        self.c.refresh_session = Mock()
        self.c.take_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_failover_value(self):
        self.c.set_failover_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_config_value(self):
        self.c.set_config_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=ConsulException))
    def test_write_leader_optime(self):
        self.c.write_leader_optime('1')

    @patch.object(consul.Consul.Session, 'renew', Mock())
    def test_update_leader(self):
        self.c.update_leader(None)

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_leader(self):
        self.c.delete_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_initialize(self):
        self.c.initialize()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_cancel_initialization(self):
        self.c.cancel_initialization()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_cluster(self):
        self.c.delete_cluster()

    @patch.object(AbstractDCS, 'watch', Mock())
    def test_watch(self):
        self.c.watch(None, 1)
        self.c._name = ''
        self.c.watch(6429, 1)
        with patch.object(consul.Consul.KV, 'get', Mock(side_effect=ConsulException)):
            self.c.watch(6429, 1)

    def test_set_retry_timeout(self):
        self.c.set_retry_timeout(10)

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_sync_state(self):
        self.assertTrue(self.c.set_sync_state_value('{}'))
        self.assertTrue(self.c.delete_sync_state())

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_history_value(self):
        self.assertTrue(self.c.set_history_value('{}'))
class TestConsul(unittest.TestCase):
    @patch.object(consul.Consul.Session, 'create',
                  Mock(return_value='fd4f44fe-2cac-bba5-a60b-304b51ff39b7'))
    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.KV, 'get', kv_get)
    @patch.object(consul.Consul.KV, 'delete', Mock())
    def setUp(self):
        self.c = Consul({
            'ttl': 30,
            'scope': 'test',
            'name': 'postgresql1',
            'host': 'localhost:1',
            'retry_timeout': 10
        })
        self.c._base_path = '/service/good'
        self.c._load_cluster()

    @patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(consul.Consul.Session, 'create',
                  Mock(side_effect=ConsulException))
    def test_create_session(self):
        self.c._session = None
        self.assertRaises(SleepException, self.c.create_session)

    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.Session, 'create',
                  Mock(side_effect=ConsulException))
    def test_referesh_session(self):
        self.c._session = '1'
        self.assertFalse(self.c.refresh_session())
        self.c._last_session_refresh = 0
        self.assertRaises(ConsulError, self.c.refresh_session)

    @patch.object(consul.Consul.KV, 'delete', Mock())
    def test_get_cluster(self):
        self.c._base_path = '/service/test'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/fail'
        self.assertRaises(ConsulError, self.c.get_cluster)
        self.c._base_path = '/service/good'
        self.c._session = 'fd4f44fe-2cac-bba5-a60b-304b51ff39b8'
        self.assertIsInstance(self.c.get_cluster(), Cluster)

    @patch.object(consul.Consul.KV, 'delete',
                  Mock(side_effect=[ConsulException, True, True]))
    @patch.object(consul.Consul.KV, 'put',
                  Mock(side_effect=[True, ConsulException]))
    def test_touch_member(self):
        self.c.refresh_session = Mock(return_value=True)
        self.c.touch_member('balbla')
        self.c.touch_member('balbla')
        self.c.touch_member('balbla')
        self.c.refresh_session = Mock(return_value=False)
        self.c.touch_member('balbla')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=False))
    def test_take_leader(self):
        self.c.set_ttl(20)
        self.c.refresh_session = Mock()
        self.c.take_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_failover_value(self):
        self.c.set_failover_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_config_value(self):
        self.c.set_config_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=ConsulException))
    def test_write_leader_optime(self):
        self.c.write_leader_optime('1')

    @patch.object(consul.Consul.Session, 'renew', Mock())
    def test_update_leader(self):
        self.c.update_leader()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_leader(self):
        self.c.delete_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_initialize(self):
        self.c.initialize()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_cancel_initialization(self):
        self.c.cancel_initialization()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_cluster(self):
        self.c.delete_cluster()

    @patch.object(AbstractDCS, 'watch', Mock())
    def test_watch(self):
        self.c.watch(1)
        self.c._name = ''
        self.c.watch(1)
        with patch.object(consul.Consul.KV, 'get',
                          Mock(side_effect=ConsulException)):
            self.c.watch(1)

    def test_set_retry_timeout(self):
        self.c.set_retry_timeout(10)

    def test_sync_state(self):
        self.assertFalse(self.c.set_sync_state_value('{}'))
        self.assertFalse(self.c.delete_sync_state())
示例#5
0
class TestConsul(unittest.TestCase):

    @patch.object(consul.Consul.Session, 'create', Mock(return_value='fd4f44fe-2cac-bba5-a60b-304b51ff39b7'))
    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.KV, 'get', kv_get)
    @patch.object(consul.Consul.KV, 'delete', Mock())
    def setUp(self):
        self.c = Consul({'ttl': 30, 'scope': 'test', 'name': 'postgresql1', 'host': 'localhost:1', 'retry_timeout': 10})
        self.c._base_path = '/service/good'
        self.c._load_cluster()

    @patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(consul.Consul.Session, 'create', Mock(side_effect=ConsulException))
    def test_create_session(self):
        self.c._session = None
        self.assertRaises(SleepException, self.c.create_session)

    @patch.object(consul.Consul.Session, 'renew', Mock(side_effect=NotFound))
    @patch.object(consul.Consul.Session, 'create', Mock(side_effect=ConsulException))
    def test_referesh_session(self):
        self.c._session = '1'
        self.c._name = ''
        self.assertRaises(ConsulError, self.c.refresh_session)

    @patch.object(consul.Consul.KV, 'delete', Mock())
    def test_get_cluster(self):
        self.c._base_path = '/service/test'
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.assertIsInstance(self.c.get_cluster(), Cluster)
        self.c._base_path = '/service/fail'
        self.assertRaises(ConsulError, self.c.get_cluster)
        self.c._base_path = '/service/good'
        self.c._session = 'fd4f44fe-2cac-bba5-a60b-304b51ff39b8'
        self.assertIsInstance(self.c.get_cluster(), Cluster)

    @patch.object(consul.Consul.KV, 'delete', Mock(side_effect=[ConsulException, True, True]))
    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=[True, ConsulException]))
    def test_touch_member(self):
        self.c.refresh_session = Mock(return_value=True)
        self.c.touch_member('balbla')
        self.c.touch_member('balbla')
        self.c.touch_member('balbla')
        self.c.refresh_session = Mock(return_value=False)
        self.c.touch_member('balbla')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=False))
    def test_take_leader(self):
        self.c.take_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_failover_value(self):
        self.c.set_failover_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_set_config_value(self):
        self.c.set_config_value('')

    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=ConsulException))
    def test_write_leader_optime(self):
        self.c.write_leader_optime('')

    def test_update_leader(self):
        self.c.update_leader()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_leader(self):
        self.c.delete_leader()

    @patch.object(consul.Consul.KV, 'put', Mock(return_value=True))
    def test_initialize(self):
        self.c.initialize()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_cancel_initialization(self):
        self.c.cancel_initialization()

    @patch.object(consul.Consul.KV, 'delete', Mock(return_value=True))
    def test_delete_cluster(self):
        self.c.delete_cluster()

    @patch.object(AbstractDCS, 'watch', Mock())
    def test_watch(self):
        self.c._name = ''
        self.c.watch(1)
        with patch.object(consul.Consul.KV, 'get', Mock(side_effect=ConsulException)):
            self.c.watch(1)

    @patch.object(consul.Consul.Session, 'destroy', Mock(side_effect=ConsulException))
    def test_set_ttl(self):
        self.c.set_ttl(20)
        self.assertTrue(self.c.watch(1))

    def test_set_retry_timeout(self):
        self.c.set_retry_timeout(10)