# Copyright (c) 2015 Red Hat, Inc.
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

"""Test cases for GlusterFS common routines."""

from unittest import mock

import ddt
from oslo_config import cfg

from manila import exception
from manila.share.drivers.glusterfs import common
from manila import test
from manila.tests import fake_utils


CONF = cfg.CONF


fake_gluster_manager_attrs = {
    'export': '127.0.0.1:/testvol',
    'host': '127.0.0.1',
    'qualified': 'testuser@127.0.0.1:/testvol',
    'user': 'testuser',
    'volume': 'testvol',
    'path_to_private_key': '/fakepath/to/privatekey',
    'remote_server_password': 'fakepassword',
}
fake_args = ('foo', 'bar')
fake_kwargs = {'key1': 'value1', 'key2': 'value2'}
fake_path_to_private_key = '/fakepath/to/privatekey'
fake_remote_server_password = 'fakepassword'
NFS_EXPORT_DIR = 'nfs.export-dir'

fakehost = 'example.com'
fakevol = 'testvol'
fakeexport = ':/'.join((fakehost, fakevol))
fakemnt = '/mnt/glusterfs'


@ddt.ddt
class GlusterManagerTestCase(test.TestCase):
    """Tests GlusterManager."""

    def setUp(self):
        super(GlusterManagerTestCase, self).setUp()
        self.fake_execf = mock.Mock()
        self.fake_executor = mock.Mock(return_value=('', ''))
        with mock.patch.object(common.GlusterManager, 'make_gluster_call',
                               return_value=self.fake_executor):
            self._gluster_manager = common.GlusterManager(
                'testuser@127.0.0.1:/testvol', self.fake_execf,
                fake_path_to_private_key, fake_remote_server_password)
            fake_gluster_manager_dict = {
                'host': '127.0.0.1',
                'user': 'testuser',
                'volume': 'testvol'
            }
            self._gluster_manager_dict = common.GlusterManager(
                fake_gluster_manager_dict, self.fake_execf,
                fake_path_to_private_key, fake_remote_server_password)
            self._gluster_manager_array = [self._gluster_manager,
                                           self._gluster_manager_dict]

    def test_check_volume_presence(self):
        common._check_volume_presence(mock.Mock())(self._gluster_manager)

    def test_check_volume_presence_error(self):
        gmgr = common.GlusterManager('testuser@127.0.0.1')

        self.assertRaises(
            exception.GlusterfsException,
            common._check_volume_presence(mock.Mock()), gmgr)

    def test_volxml_get(self):
        xmlout = mock.Mock()
        value = mock.Mock()
        value.text = 'foobar'
        xmlout.find = mock.Mock(return_value=value)

        ret = common.volxml_get(xmlout, 'some/path')

        self.assertEqual('foobar', ret)

    @ddt.data(None, 'some-value')
    def test_volxml_get_notfound_fallback(self, default):
        xmlout = mock.Mock()
        xmlout.find = mock.Mock(return_value=None)

        ret = common.volxml_get(xmlout, 'some/path', default=default)

        self.assertEqual(default, ret)

    def test_volxml_get_multiple(self):
        xmlout = mock.Mock()
        value = mock.Mock()
        value.text = 'foobar'
        xmlout.find = mock.Mock(side_effect=(None, value))

        ret = common.volxml_get(xmlout, 'some/path', 'better/path')

        self.assertEqual('foobar', ret)

    def test_volxml_get_notfound(self):
        xmlout = mock.Mock()
        xmlout.find = mock.Mock(return_value=None)

        self.assertRaises(exception.InvalidShare, common.volxml_get,
                          xmlout, 'some/path')

    def test_gluster_manager_common_init(self):
        for gmgr in self._gluster_manager_array:
            self.assertEqual(
                fake_gluster_manager_attrs['user'],
                gmgr.user)
            self.assertEqual(
                fake_gluster_manager_attrs['host'],
                gmgr.host)
            self.assertEqual(
                fake_gluster_manager_attrs['volume'],
                gmgr.volume)
            self.assertEqual(
                fake_gluster_manager_attrs['qualified'],
                gmgr.qualified)
            self.assertEqual(
                fake_gluster_manager_attrs['export'],
                gmgr.export)
            self.assertEqual(
                fake_gluster_manager_attrs['path_to_private_key'],
                gmgr.path_to_private_key)
            self.assertEqual(
                fake_gluster_manager_attrs['remote_server_password'],
                gmgr.remote_server_password)
            self.assertEqual(
                self.fake_executor,
                gmgr.gluster_call)

    @ddt.data({'user': 'testuser', 'host': '127.0.0.1',
               'volume': 'testvol', 'path': None},
              {'user': None, 'host': '127.0.0.1',
               'volume': 'testvol', 'path': '/testpath'},
              {'user': None, 'host': '127.0.0.1',
               'volume': 'testvol', 'path': None},
              {'user': None, 'host': '127.0.0.1',
               'volume': None, 'path': None},
              {'user': 'testuser', 'host': '127.0.0.1',
               'volume': None, 'path': None},
              {'user': 'testuser', 'host': '127.0.0.1',
               'volume': 'testvol', 'path': '/testpath'})
    def test_gluster_manager_init_check(self, test_addr_dict):
        test_gluster_manager = common.GlusterManager(
            test_addr_dict, self.fake_execf)
        self.assertEqual(test_addr_dict, test_gluster_manager.components)

    @ddt.data(None, True)
    def test_gluster_manager_init_has_vol(self, has_volume):
        test_gluster_manager = common.GlusterManager(
            'testuser@127.0.0.1:/testvol', self.fake_execf,
            requires={'volume': has_volume})
        self.assertEqual('testvol', test_gluster_manager.volume)

    @ddt.data(None, True)
    def test_gluster_manager_dict_init_has_vol(self, has_volume):
        test_addr_dict = {'user': 'testuser',
                          'host': '127.0.0.1',
                          'volume': 'testvol',
                          'path': '/testdir'}
        test_gluster_manager = common.GlusterManager(
            test_addr_dict, self.fake_execf,
            requires={'volume': has_volume})
        self.assertEqual('testvol', test_gluster_manager.volume)

    @ddt.data(None, False)
    def test_gluster_manager_init_no_vol(self, has_volume):
        test_gluster_manager = common.GlusterManager(
            'testuser@127.0.0.1', self.fake_execf,
            requires={'volume': has_volume})
        self.assertIsNone(test_gluster_manager.volume)

    @ddt.data(None, False)
    def test_gluster_manager_dict_init_no_vol(self, has_volume):
        test_addr_dict = {'user': 'testuser',
                          'host': '127.0.0.1'}
        test_gluster_manager = common.GlusterManager(
            test_addr_dict, self.fake_execf,
            requires={'volume': has_volume})
        self.assertIsNone(test_gluster_manager.volume)

    def test_gluster_manager_init_has_shouldnt_have_vol(self):
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager,
                          'testuser@127.0.0.1:/testvol',
                          self.fake_execf, requires={'volume': False})

    def test_gluster_manager_dict_init_has_shouldnt_have_vol(self):
        test_addr_dict = {'user': 'testuser',
                          'host': '127.0.0.1',
                          'volume': 'testvol'}
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager,
                          test_addr_dict,
                          self.fake_execf, requires={'volume': False})

    def test_gluster_manager_hasnt_should_have_vol(self):
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager, 'testuser@127.0.0.1',
                          self.fake_execf, requires={'volume': True})

    def test_gluster_manager_dict_hasnt_should_have_vol(self):
        test_addr_dict = {'user': 'testuser',
                          'host': '127.0.0.1'}
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager, test_addr_dict,
                          self.fake_execf, requires={'volume': True})

    def test_gluster_manager_invalid(self):
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager, '127.0.0.1:vol',
                          'self.fake_execf')

    def test_gluster_manager_dict_invalid_req_host(self):
        test_addr_dict = {'user': 'testuser',
                          'volume': 'testvol'}
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager, test_addr_dict,
                          'self.fake_execf')

    @ddt.data({'user': 'testuser'},
              {'host': 'johndoe@example.com'},
              {'host': 'example.com/so', 'volume': 'me/path'},
              {'user': 'user@error', 'host': "example.com", 'volume': 'vol'},
              {'host': 'example.com', 'volume': 'vol', 'pith': '/path'},
              {'host': 'example.com', 'path': '/path'},
              {'user': 'user@error', 'host': "example.com", 'path': '/path'})
    def test_gluster_manager_dict_invalid_input(self, test_addr_dict):
        self.assertRaises(exception.GlusterfsException,
                          common.GlusterManager, test_addr_dict,
                          'self.fake_execf')

    def test_gluster_manager_getattr(self):
        self.assertEqual('testvol', self._gluster_manager.volume)

    def test_gluster_manager_getattr_called(self):
        class FakeGlusterManager(common.GlusterManager):
            pass

        _gluster_manager = FakeGlusterManager('127.0.0.1:/testvol',
                                              self.fake_execf)
        FakeGlusterManager.__getattr__ = mock.Mock()
        _gluster_manager.volume
        _gluster_manager.__getattr__.assert_called_once_with('volume')

    def test_gluster_manager_getattr_noattr(self):
        self.assertRaises(AttributeError, getattr, self._gluster_manager,
                          'fakeprop')

    @ddt.data({'mockargs': {}, 'kwargs': {}},
              {'mockargs': {'side_effect': exception.ProcessExecutionError},
               'kwargs': {'error_policy': 'suppress'}},
              {'mockargs': {
                  'side_effect': exception.ProcessExecutionError(exit_code=2)},
               'kwargs': {'error_policy': (2,)}})
    @ddt.unpack
    def test_gluster_manager_make_gluster_call_local(self, mockargs, kwargs):
        fake_obj = mock.Mock(**mockargs)
        fake_execute = mock.Mock()
        kwargs.update(fake_kwargs)
        with mock.patch.object(common.ganesha_utils, 'RootExecutor',
                               mock.Mock(return_value=fake_obj)):
            gluster_manager = common.GlusterManager(
                '127.0.0.1:/testvol', self.fake_execf)
            gluster_manager.make_gluster_call(fake_execute)(*fake_args,
                                                            **kwargs)
            common.ganesha_utils.RootExecutor.assert_called_with(
                fake_execute)
        fake_obj.assert_called_once_with(
            *(('gluster',) + fake_args), **fake_kwargs)

    def test_gluster_manager_make_gluster_call_remote(self):
        fake_obj = mock.Mock()
        fake_execute = mock.Mock()
        with mock.patch.object(common.ganesha_utils, 'SSHExecutor',
                               mock.Mock(return_value=fake_obj)):
            gluster_manager = common.GlusterManager(
                'testuser@127.0.0.1:/testvol', self.fake_execf,
                fake_path_to_private_key, fake_remote_server_password)
            gluster_manager.make_gluster_call(fake_execute)(*fake_args,
                                                            **fake_kwargs)
            common.ganesha_utils.SSHExecutor.assert_called_with(
                gluster_manager.host, 22, None, gluster_manager.user,
                password=gluster_manager.remote_server_password,
                privatekey=gluster_manager.path_to_private_key)
        fake_obj.assert_called_once_with(
            *(('gluster',) + fake_args), **fake_kwargs)

    @ddt.data({'trouble': exception.ProcessExecutionError,
               '_exception': exception.GlusterfsException, 'xkw': {}},
              {'trouble': exception.ProcessExecutionError(exit_code=2),
               '_exception': exception.GlusterfsException,
               'xkw': {'error_policy': (1,)}},
              {'trouble': exception.ProcessExecutionError,
               '_exception': exception.GlusterfsException,
               'xkw': {'error_policy': 'coerce'}},
              {'trouble': exception.ProcessExecutionError,
               '_exception': exception.ProcessExecutionError,
               'xkw': {'error_policy': 'raw'}},
              {'trouble': RuntimeError, '_exception': RuntimeError, 'xkw': {}})
    @ddt.unpack
    def test_gluster_manager_make_gluster_call_error(self, trouble,
                                                     _exception, xkw):
        fake_obj = mock.Mock(side_effect=trouble)
        fake_execute = mock.Mock()
        kwargs = fake_kwargs.copy()
        kwargs.update(xkw)
        with mock.patch.object(common.ganesha_utils, 'RootExecutor',
                               mock.Mock(return_value=fake_obj)):
            gluster_manager = common.GlusterManager(
                '127.0.0.1:/testvol', self.fake_execf)

            self.assertRaises(_exception,
                              gluster_manager.make_gluster_call(fake_execute),
                              *fake_args, **kwargs)

            common.ganesha_utils.RootExecutor.assert_called_with(
                fake_execute)
        fake_obj.assert_called_once_with(
            *(('gluster',) + fake_args), **fake_kwargs)

    def test_gluster_manager_make_gluster_call_bad_policy(self):
        fake_obj = mock.Mock()
        fake_execute = mock.Mock()
        with mock.patch.object(common.ganesha_utils, 'RootExecutor',
                               mock.Mock(return_value=fake_obj)):
            gluster_manager = common.GlusterManager(
                '127.0.0.1:/testvol', self.fake_execf)

            self.assertRaises(TypeError,
                              gluster_manager.make_gluster_call(fake_execute),
                              *fake_args, error_policy='foobar')

    @ddt.data({}, {'opErrstr': None}, {'opErrstr': 'error'})
    def test_xml_response_check(self, xdict):
        fdict = {'opRet': '0', 'opErrno': '0', 'some/count': '1'}
        fdict.update(xdict)

        def vxget(x, e, *a):
            if a:
                return fdict.get(e, a[0])
            else:
                return fdict[e]

        xtree = mock.Mock()
        command = ['volume', 'command', 'fake']

        with mock.patch.object(common, 'volxml_get', side_effect=vxget):
            self._gluster_manager.xml_response_check(xtree, command,
                                                     'some/count')

            self.assertTrue(common.volxml_get.called)

    @ddt.data('1', '2')
    def test_xml_response_check_failure(self, count):
        fdict = {'opRet': '-1', 'opErrno': '0', 'some/count': count}

        def vxget(x, e, *a):
            if a:
                return fdict.get(e, a[0])
            else:
                return fdict[e]

        xtree = mock.Mock()
        command = ['volume', 'command', 'fake']

        with mock.patch.object(common, 'volxml_get', side_effect=vxget):
            self.assertRaises(exception.GlusterfsException,
                              self._gluster_manager.xml_response_check,
                              xtree, command, 'some/count')

            self.assertTrue(common.volxml_get.called)

    @ddt.data({'opRet': '-2', 'opErrno': '0', 'some/count': '1'},
              {'opRet': '0', 'opErrno': '1', 'some/count': '1'},
              {'opRet': '0', 'opErrno': '0', 'some/count': '0'},
              {'opRet': '0', 'opErrno': '0', 'some/count': '2'})
    def test_xml_response_check_invalid(self, fdict):

        def vxget(x, *e, **kw):
            if kw:
                return fdict.get(e[0], kw['default'])
            else:
                return fdict[e[0]]

        xtree = mock.Mock()
        command = ['volume', 'command', 'fake']

        with mock.patch.object(common, 'volxml_get', side_effect=vxget):
            self.assertRaises(exception.InvalidShare,
                              self._gluster_manager.xml_response_check,
                              xtree, command, 'some/count')

            self.assertTrue(common.volxml_get.called)

    @ddt.data({'opRet': '0', 'opErrno': '0'},
              {'opRet': '0', 'opErrno': '0', 'some/count': '2'})
    def test_xml_response_check_count_ignored(self, fdict):

        def vxget(x, e, *a):
            if a:
                return fdict.get(e, a[0])
            else:
                return fdict[e]

        xtree = mock.Mock()
        command = ['volume', 'command', 'fake']

        with mock.patch.object(common, 'volxml_get', side_effect=vxget):
            self._gluster_manager.xml_response_check(xtree, command)

            self.assertTrue(common.volxml_get.called)

    def test_get_vol_option_via_info_empty_volinfo(self):
        args = ('--xml', 'volume', 'info', self._gluster_manager.volume)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(return_value=('', {})))
        self.assertRaises(exception.GlusterfsException,
                          self._gluster_manager._get_vol_option_via_info,
                          'foobar')
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, log=mock.ANY)

    def test_get_vol_option_via_info_ambiguous_volinfo(self):

        def xml_output(*ignore_args, **ignore_kwargs):
            return """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cliOutput>
  <opRet>0</opRet>
  <opErrno>0</opErrno>
  <opErrstr/>
  <volInfo>
    <volumes>
      <count>0</count>
    </volumes>
  </volInfo>
</cliOutput>""", ''

        args = ('--xml', 'volume', 'info', self._gluster_manager.volume)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(side_effect=xml_output))
        self.assertRaises(exception.InvalidShare,
                          self._gluster_manager._get_vol_option_via_info,
                          'foobar')
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, log=mock.ANY)

    def test_get_vol_option_via_info_trivial_volinfo(self):

        def xml_output(*ignore_args, **ignore_kwargs):
            return """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cliOutput>
  <opRet>0</opRet>
  <opErrno>0</opErrno>
  <opErrstr/>
  <volInfo>
    <volumes>
      <volume>
      </volume>
      <count>1</count>
    </volumes>
  </volInfo>
</cliOutput>""", ''

        args = ('--xml', 'volume', 'info', self._gluster_manager.volume)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(side_effect=xml_output))
        ret = self._gluster_manager._get_vol_option_via_info('foobar')
        self.assertIsNone(ret)
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, log=mock.ANY)

    def test_get_vol_option_via_info(self):

        def xml_output(*ignore_args, **ignore_kwargs):
            return """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cliOutput>
  <opRet>0</opRet>
  <opErrno>0</opErrno>
  <opErrstr/>
  <volInfo>
    <volumes>
      <volume>
        <options>
           <option>
              <name>foobar</name>
              <value>FIRE MONKEY!</value>
           </option>
        </options>
      </volume>
      <count>1</count>
    </volumes>
  </volInfo>
</cliOutput>""", ''

        args = ('--xml', 'volume', 'info', self._gluster_manager.volume)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(side_effect=xml_output))
        ret = self._gluster_manager._get_vol_option_via_info('foobar')
        self.assertEqual('FIRE MONKEY!', ret)
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, log=mock.ANY)

    def test_get_vol_user_option(self):
        self.mock_object(self._gluster_manager, '_get_vol_option_via_info',
                         mock.Mock(return_value='VALUE'))

        ret = self._gluster_manager._get_vol_user_option('OPT')

        self.assertEqual(ret, 'VALUE')
        (self._gluster_manager._get_vol_option_via_info.
         assert_called_once_with('user.OPT'))

    def test_get_vol_regular_option_empty_reponse(self):
        args = ('--xml', 'volume', 'get', self._gluster_manager.volume,
                NFS_EXPORT_DIR)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(return_value=('', {})))

        ret = self._gluster_manager._get_vol_regular_option(NFS_EXPORT_DIR)

        self.assertIsNone(ret)
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, check_exit_code=False)

    @ddt.data(0, 2)
    def test_get_vol_regular_option_ambiguous_volinfo(self, count):

        def xml_output(*ignore_args, **ignore_kwargs):
            return """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cliOutput>
  <opRet>0</opRet>
  <opErrno>0</opErrno>
  <opErrstr/>
  <volGetopts>
    <count>%d</count>
  </volGetopts>
</cliOutput>""" % count, ''

        args = ('--xml', 'volume', 'get', self._gluster_manager.volume,
                NFS_EXPORT_DIR)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(side_effect=xml_output))

        self.assertRaises(exception.InvalidShare,
                          self._gluster_manager._get_vol_regular_option,
                          NFS_EXPORT_DIR)

        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, check_exit_code=False)

    @ddt.data({'start': "", 'end': ""}, {'start': "<Opt>", 'end': "</Opt>"})
    def test_get_vol_regular_option(self, extratag):

        def xml_output(*ignore_args, **ignore_kwargs):
            return """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cliOutput>
  <opRet>0</opRet>
  <opErrno>0</opErrno>
  <opErrstr/>
  <volGetopts>
    <count>1</count>
    %(start)s
    <Option>nfs.export-dir</Option>
    <Value>/foo(10.0.0.1|10.0.0.2),/bar(10.0.0.1)</Value>
    %(end)s
  </volGetopts>
</cliOutput>""" % extratag, ''

        args = ('--xml', 'volume', 'get', self._gluster_manager.volume,
                NFS_EXPORT_DIR)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(side_effect=xml_output))

        ret = self._gluster_manager._get_vol_regular_option(NFS_EXPORT_DIR)

        self.assertEqual('/foo(10.0.0.1|10.0.0.2),/bar(10.0.0.1)', ret)
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, check_exit_code=False)

    def test_get_vol_regular_option_not_suppored(self):
        args = ('--xml', 'volume', 'get', self._gluster_manager.volume,
                NFS_EXPORT_DIR)
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(return_value=(
                                   """Ceci n'est pas un XML.""", '')))
        self.mock_object(self._gluster_manager, '_get_vol_option_via_info',
                         mock.Mock(return_value="VALUE"))

        ret = self._gluster_manager._get_vol_regular_option(NFS_EXPORT_DIR)

        self.assertEqual("VALUE", ret)
        self._gluster_manager.gluster_call.assert_called_once_with(
            *args, check_exit_code=False)
        (self._gluster_manager._get_vol_option_via_info.
         assert_called_once_with(NFS_EXPORT_DIR))

    @ddt.data({'opt': 'some.option', 'opttype': 'regular',
               'lowopt': 'some.option'},
              {'opt': 'user.param', 'opttype': 'user', 'lowopt': 'param'})
    @ddt.unpack
    def test_get_vol_option(self, opt, opttype, lowopt):
        for t in ('user', 'regular'):
            self.mock_object(self._gluster_manager, '_get_vol_%s_option' % t,
                             mock.Mock(return_value='value-%s' % t))

        ret = self._gluster_manager.get_vol_option(opt)

        self.assertEqual('value-%s' % opttype, ret)
        for t in ('user', 'regular'):
            func = getattr(self._gluster_manager, '_get_vol_%s_option' % t)
            if opttype == t:
                func.assert_called_once_with(lowopt)
            else:
                self.assertFalse(func.called)

    def test_get_vol_option_unset(self):
        self.mock_object(self._gluster_manager, '_get_vol_regular_option',
                         mock.Mock(return_value=None))

        ret = self._gluster_manager.get_vol_option('some.option')

        self.assertIsNone(ret)

    @ddt.data({'value': '0', 'boolval': False},
              {'value': 'Off', 'boolval': False},
              {'value': 'no', 'boolval': False},
              {'value': '1', 'boolval': True},
              {'value': 'true', 'boolval': True},
              {'value': 'enAble', 'boolval': True},
              {'value': None, 'boolval': None})
    @ddt.unpack
    def test_get_vol_option_boolean(self, value, boolval):
        self.mock_object(self._gluster_manager, '_get_vol_regular_option',
                         mock.Mock(return_value=value))

        ret = self._gluster_manager.get_vol_option('some.option',
                                                   boolean=True)

        self.assertEqual(boolval, ret)

    def test_get_vol_option_boolean_bad(self):
        self.mock_object(self._gluster_manager, '_get_vol_regular_option',
                         mock.Mock(return_value='jabberwocky'))

        self.assertRaises(exception.GlusterfsException,
                          self._gluster_manager.get_vol_option,
                          'some.option', boolean=True)

    @ddt.data({'setting': 'some_value', 'args': ('set', 'some_value')},
              {'setting': None, 'args': ('reset',)},
              {'setting': True, 'args': ('set', 'ON')},
              {'setting': False, 'args': ('set', 'OFF')})
    @ddt.unpack
    def test_set_vol_option(self, setting, args):
        self.mock_object(self._gluster_manager, 'gluster_call', mock.Mock())

        self._gluster_manager.set_vol_option('an_option', setting)

        self._gluster_manager.gluster_call.assert_called_once_with(
            'volume', args[0], 'testvol', 'an_option', *args[1:],
            error_policy=mock.ANY)

    @ddt.data({}, {'ignore_failure': False})
    def test_set_vol_option_error(self, kwargs):
        fake_obj = mock.Mock(
            side_effect=exception.ProcessExecutionError(exit_code=1))
        with mock.patch.object(common.ganesha_utils, 'RootExecutor',
                               mock.Mock(return_value=fake_obj)):
            gluster_manager = common.GlusterManager(
                '127.0.0.1:/testvol', self.fake_execf)

            self.assertRaises(exception.GlusterfsException,
                              gluster_manager.set_vol_option,
                              'an_option', "some_value", **kwargs)

            self.assertTrue(fake_obj.called)

    def test_set_vol_option_error_relaxed(self):
        fake_obj = mock.Mock(
            side_effect=exception.ProcessExecutionError(exit_code=1))
        with mock.patch.object(common.ganesha_utils, 'RootExecutor',
                               mock.Mock(return_value=fake_obj)):
            gluster_manager = common.GlusterManager(
                '127.0.0.1:/testvol', self.fake_execf)

            gluster_manager.set_vol_option('an_option', "some_value",
                                           ignore_failure=True)

            self.assertTrue(fake_obj.called)

    def test_get_gluster_version(self):
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(return_value=('glusterfs 3.6.2beta3', '')))
        ret = self._gluster_manager.get_gluster_version()
        self.assertEqual(['3', '6', '2beta3'], ret)
        self._gluster_manager.gluster_call.assert_called_once_with(
            '--version', log=mock.ANY)

    @ddt.data("foo 1.1.1", "glusterfs 3-6", "glusterfs 3.6beta3")
    def test_get_gluster_version_exception(self, versinfo):
        self.mock_object(self._gluster_manager, 'gluster_call',
                         mock.Mock(return_value=(versinfo, '')))
        self.assertRaises(exception.GlusterfsException,
                          self._gluster_manager.get_gluster_version)
        self._gluster_manager.gluster_call.assert_called_once_with(
            '--version', log=mock.ANY)

    def test_check_gluster_version(self):
        self.mock_object(self._gluster_manager, 'get_gluster_version',
                         mock.Mock(return_value=('3', '6')))

        ret = self._gluster_manager.check_gluster_version((3, 5, 2))
        self.assertIsNone(ret)
        self._gluster_manager.get_gluster_version.assert_called_once_with()

    def test_check_gluster_version_unmet(self):
        self.mock_object(self._gluster_manager, 'get_gluster_version',
                         mock.Mock(return_value=('3', '5', '2')))

        self.assertRaises(exception.GlusterfsException,
                          self._gluster_manager.check_gluster_version, (3, 6))
        self._gluster_manager.get_gluster_version.assert_called_once_with()

    @ddt.data(('3', '6'),
              ('3', '6', '2beta'),
              ('3', '6', '2beta', '4'))
    def test_numreduct(self, vers):
        ret = common.numreduct(vers)
        self.assertEqual((3, 6), ret)


@ddt.ddt
class GlusterFSCommonTestCase(test.TestCase):
    """Tests common GlusterFS utility functions."""

    def setUp(self):
        super(GlusterFSCommonTestCase, self).setUp()
        fake_utils.stub_out_utils_execute(self)
        self._execute = fake_utils.fake_execute
        self.addCleanup(fake_utils.fake_execute_set_repliers, [])
        self.addCleanup(fake_utils.fake_execute_clear_log)
        self.mock_object(common.GlusterManager, 'make_gluster_call')

    @staticmethod
    def _mount_exec(vol, mnt):
        return ['mkdir -p %s' % mnt,
                'mount -t glusterfs %(exp)s %(mnt)s' % {'exp': vol,
                                                        'mnt': mnt}]

    def test_mount_gluster_vol(self):
        expected_exec = self._mount_exec(fakeexport, fakemnt)
        ret = common._mount_gluster_vol(self._execute, fakeexport, fakemnt,
                                        False)
        self.assertEqual(fake_utils.fake_execute_get_log(), expected_exec)
        self.assertIsNone(ret)

    def test_mount_gluster_vol_mounted_noensure(self):
        def exec_runner(*ignore_args, **ignore_kwargs):
            raise exception.ProcessExecutionError(stderr='already mounted')
        expected_exec = self._mount_exec(fakeexport, fakemnt)
        fake_utils.fake_execute_set_repliers([('mount', exec_runner)])
        self.assertRaises(exception.GlusterfsException,
                          common._mount_gluster_vol,
                          self._execute, fakeexport, fakemnt, False)
        self.assertEqual(fake_utils.fake_execute_get_log(), expected_exec)

    def test_mount_gluster_vol_mounted_ensure(self):
        def exec_runner(*ignore_args, **ignore_kwargs):
            raise exception.ProcessExecutionError(stderr='already mounted')
        expected_exec = self._mount_exec(fakeexport, fakemnt)
        common.LOG.warning = mock.Mock()
        fake_utils.fake_execute_set_repliers([('mount', exec_runner)])
        ret = common._mount_gluster_vol(self._execute, fakeexport, fakemnt,
                                        True)
        self.assertEqual(fake_utils.fake_execute_get_log(), expected_exec)
        self.assertIsNone(ret)
        common.LOG.warning.assert_called_with(
            "%s is already mounted.", fakeexport)

    @ddt.data(True, False)
    def test_mount_gluster_vol_fail(self, ensure):
        def exec_runner(*ignore_args, **ignore_kwargs):
            raise RuntimeError('fake error')
        expected_exec = self._mount_exec(fakeexport, fakemnt)
        fake_utils.fake_execute_set_repliers([('mount', exec_runner)])
        self.assertRaises(RuntimeError, common._mount_gluster_vol,
                          self._execute, fakeexport, fakemnt, ensure)
        self.assertEqual(fake_utils.fake_execute_get_log(), expected_exec)

    def test_umount_gluster_vol(self):
        expected_exec = ['umount %s' % fakemnt]
        ret = common._umount_gluster_vol(self._execute, fakemnt)
        self.assertEqual(fake_utils.fake_execute_get_log(), expected_exec)
        self.assertIsNone(ret)

    @ddt.data({'in_exc': exception.ProcessExecutionError,
               'out_exc': exception.GlusterfsException},
              {'in_exc': RuntimeError, 'out_exc': RuntimeError})
    @ddt.unpack
    def test_umount_gluster_vol_fail(self, in_exc, out_exc):
        def exec_runner(*ignore_args, **ignore_kwargs):
            raise in_exc('fake error')
        expected_exec = ['umount %s' % fakemnt]
        fake_utils.fake_execute_set_repliers([('umount', exec_runner)])
        self.assertRaises(out_exc, common._umount_gluster_vol,
                          self._execute, fakemnt)
        self.assertEqual(fake_utils.fake_execute_get_log(), expected_exec)

    def test_restart_gluster_vol(self):
        gmgr = common.GlusterManager(fakeexport, self._execute, None, None)
        test_args = [(('volume', 'stop', fakevol, '--mode=script'),
                      {'log': mock.ANY}),
                     (('volume', 'start', fakevol), {'log': mock.ANY})]

        common._restart_gluster_vol(gmgr)
        self.assertEqual(
            [mock.call(*arg[0], **arg[1]) for arg in test_args],
            gmgr.gluster_call.call_args_list)
