desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test for Display a summary from monit'
| def test_summary(self):
| mock = MagicMock(side_effect=['daemon is not running', 'A\nB\nC\nD\nE'])
with patch.dict(monit.__salt__, {'cmd.run': mock}):
self.assertEqual(monit.summary(), {'monit': 'daemon is not running', 'result': False})
self.assertEqual(monit.summary(), {})
|
'Test for Display a process status from monit'
| def test_status(self):
| with patch.dict(monit.__salt__, {'cmd.run': MagicMock(return_value='Process')}):
self.assertEqual(monit.status('service'), 'No such service')
|
'Test for Reload configuration'
| def test_reload(self):
| mock = MagicMock(return_value=0)
with patch.dict(monit.__salt__, {'cmd.retcode': mock}):
self.assertTrue(monit.reload_())
|
'Test for Display version from monit -V'
| def test_version(self):
| mock = MagicMock(return_value='This is Monit version 5.14\nA\nB')
with patch.dict(monit.__salt__, {'cmd.run': mock}):
self.assertEqual(monit.version(), '5.14')
|
'Test for Display unique id'
| def test_id(self):
| mock = MagicMock(return_value='Monit ID: d3b1aba48527dd599db0e86f5ad97120')
with patch.dict(monit.__salt__, {'cmd.run': mock}):
self.assertEqual(monit.id_(), 'd3b1aba48527dd599db0e86f5ad97120')
|
'Test for Regenerate a unique id'
| def test_reset_id(self):
| expected = {'stdout': 'Monit id d3b1aba48527dd599db0e86f5ad97120 and ...'}
mock = MagicMock(return_value=expected)
with patch.dict(monit.__salt__, {'cmd.run_all': mock}):
self.assertEqual(monit.id_(reset=True), 'd3b1aba48527dd599db0e86f5ad97120')
|
'Test for Check configuration syntax'
| def test_configtest(self):
| excepted = {'stdout': 'Control file syntax OK', 'retcode': 0, 'stderr': ''}
mock = MagicMock(return_value=excepted)
with patch.dict(monit.__salt__, {'cmd.run_all': mock}):
self.assertTrue(monit.configtest()['result'])
self.assertEqual(monit.configtest()['comment'], 'Syntax OK')
|
'Test for Check all services are monitored'
| def test_validate(self):
| mock = MagicMock(return_value=0)
with patch.dict(monit.__salt__, {'cmd.retcode': mock}):
self.assertTrue(monit.validate())
|
'Return value for cmd.run_all.'
| @staticmethod
def _m_all(stdout=True):
| return MagicMock(return_value={'retcode': 0, 'stdout': stdout})
|
'Return value for cmd.which_bin.'
| @staticmethod
def _m_bin():
| return MagicMock(return_value='/tmp/bin_env')
|
'Tests if it start the named service.'
| def test_start(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.start())
|
'Tests if it restart the named service.'
| def test_restart(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.restart())
|
'Tests if it stop the named service.'
| def test_stop(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.stop())
|
'Tests if it activates any updates in config for process/group.'
| def test_add(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.add('salt'))
|
'Tests if it removes process/group from active config'
| def test_remove(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.remove('salt'))
|
'Tests if it reload the daemon\'s configuration files'
| def test_reread(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.reread())
|
'Tests if it reload config and add/remove as necessary'
| def test_update(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.update())
|
'Tests if it list programs and its state'
| def test_status(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all('salt running'), 'cmd.which_bin': self._m_bin()}):
self.assertDictEqual(supervisord.status(), {'salt': {'state': 'running', 'reason': ''}})
|
'Tests if it display the raw output of status'
| def test_status_raw(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.status_raw())
|
'Tests if it run any custom supervisord command'
| def test_custom(self):
| with patch.dict(supervisord.__salt__, {'cmd.run_all': self._m_all(), 'cmd.which_bin': self._m_bin()}):
self.assertTrue(supervisord.custom("mstop '*gunicorn*'"))
|
'Tests if it read the config file and return the config options
for a given process'
| def test_options(self):
| class MockConfig(object, ):
'\n Mock Config class\n '
flag = None
def __init__(self):
self.name = None
def sections(self):
'\n Mock sections methos\n '
if (self.flag == 1):
return []
return ['program:salt']
def items(self, name):
'\n Mock sections methos\n '
self.name = name
return [('salt', 'True')]
with patch.object(supervisord, '_read_config', MagicMock(return_value=MockConfig())):
MockConfig.flag = 1
self.assertRaises(CommandExecutionError, supervisord.options, 'salt')
MockConfig.flag = 0
self.assertDictEqual(supervisord.options('salt'), {'salt': True})
|
'Test if it set a value in an OpenStack configuration file.'
| def test_set(self):
| mock = MagicMock(return_value={'retcode': 0, 'stderr': 'error', 'stdout': 'salt'})
with patch.dict(openstack_config.__salt__, {'cmd.run_all': mock}):
self.assertEqual(openstack_config.set_('/etc/keystone/keys.conf', 'sql', 'connection', 'foo'), 'salt')
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'error', 'stdout': 'salt'})
with patch.dict(openstack_config.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, openstack_config.set_, '/etc/keystone/keystone.conf', 'sql', 'connection', 'foo')
|
'Test if it get a value from an OpenStack configuration file.'
| def test_get(self):
| mock = MagicMock(return_value={'retcode': 0, 'stderr': 'error', 'stdout': 'salt'})
with patch.dict(openstack_config.__salt__, {'cmd.run_all': mock}):
self.assertEqual(openstack_config.get('/etc/keystone/keys.conf', 'sql', 'connection'), 'salt')
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'error', 'stdout': 'salt'})
with patch.dict(openstack_config.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, openstack_config.get, '/etc/key/keystone.conf', 'sql', 'connection')
|
'Test if it delete a value from an OpenStack configuration file.'
| def test_delete(self):
| mock = MagicMock(return_value={'retcode': 0, 'stderr': 'error', 'stdout': 'salt'})
with patch.dict(openstack_config.__salt__, {'cmd.run_all': mock}):
self.assertEqual(openstack_config.delete('/etc/keystone/keys.conf', 'sql', 'connection'), 'salt')
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'error', 'stdout': 'salt'})
with patch.dict(openstack_config.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, openstack_config.delete, '/etc/key/keystone.conf', 'sql', 'connection')
|
'Test installing a bundle ID as being allowed to run with assistive access'
| def test_install_assistive_bundle(self):
| mock_ret = MagicMock(return_value={'retcode': 0})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
with patch.dict(assistive.__grains__, {'osrelease': '10.11.3'}):
self.assertTrue(assistive.install('foo'))
|
'Test installing a bundle ID as being allowed to run with assistive access'
| def test_install_assistive_error(self):
| mock_ret = MagicMock(return_value={'retcode': 1})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
with patch.dict(assistive.__grains__, {'osrelease': '10.11.3'}):
self.assertRaises(CommandExecutionError, assistive.install, 'foo')
|
'Test checking to see if a bundle id is installed as being able to use assistive access'
| def test_installed_bundle(self):
| with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[('foo', 0)])):
self.assertTrue(assistive.installed('foo'))
|
'Test checking to see if a bundle id is installed as being able to use assistive access'
| def test_installed_bundle_not(self):
| with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[])):
self.assertFalse(assistive.installed('foo'))
|
'Test enabling a bundle ID as being allowed to run with assistive access'
| def test_enable_assistive(self):
| mock_ret = MagicMock(return_value={'retcode': 0})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[('foo', 0)])):
self.assertTrue(assistive.enable('foo', True))
|
'Test enabled a bundle ID that throws a command error'
| def test_enable_error(self):
| mock_ret = MagicMock(return_value={'retcode': 1})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[('foo', 0)])):
self.assertRaises(CommandExecutionError, assistive.enable, 'foo')
|
'Test return of enable function when app isn\'t found.'
| def test_enable_false(self):
| with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[])):
self.assertFalse(assistive.enable('foo'))
|
'Test enabling a bundle ID as being allowed to run with assistive access'
| def test_enabled_assistive(self):
| with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[('foo', '1')])):
self.assertTrue(assistive.enabled('foo'))
|
'Test if a bundle ID is disabled for assistive access'
| def test_enabled_assistive_false(self):
| with patch('salt.modules.mac_assistive._get_assistive_access', MagicMock(return_value=[])):
self.assertFalse(assistive.enabled('foo'))
|
'Test removing an assitive bundle.'
| def test_remove_assistive(self):
| mock_ret = MagicMock(return_value={'retcode': 0})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
self.assertTrue(assistive.remove('foo'))
|
'Test removing an assitive bundle.'
| def test_remove_assistive_error(self):
| mock_ret = MagicMock(return_value={'retcode': 1})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
self.assertRaises(CommandExecutionError, assistive.remove, 'foo')
|
'Test if a bundle ID is enabled for assistive access'
| def test_get_assistive_access(self):
| mock_out = 'kTCCServiceAccessibility|/bin/bash|1|1|1|\nkTCCServiceAccessibility|/usr/bin/osascript|1|1|1|'
mock_ret = MagicMock(return_value={'retcode': 0, 'stdout': mock_out})
expected = [('/bin/bash', '1'), ('/usr/bin/osascript', '1')]
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
self.assertEqual(assistive._get_assistive_access(), expected)
|
'Test a CommandExecutionError is raised when something goes wrong.'
| def test_get_assistive_access_error(self):
| mock_ret = MagicMock(return_value={'retcode': 1})
with patch.dict(assistive.__salt__, {'cmd.run_all': mock_ret}):
self.assertRaises(CommandExecutionError, assistive._get_assistive_access)
|
'Test to return the running services'
| def test_get_running(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(return_value='A online\n')}):
self.assertEqual(smf.get_running(), ['A'])
|
'Test to return the stopped services'
| def test_get_stopped(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(return_value='A\n')}):
self.assertListEqual(smf.get_stopped(), ['A'])
|
'Test to returns ``True`` if the specified service is available,
otherwise returns ``False``.'
| def test_available(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(return_value='A')}):
with patch.object(smf, 'get_all', return_value='A'):
self.assertTrue(smf.available('A'))
|
'The inverse of service.available.
Returns ``True`` if the specified service is not available, otherwise
returns ``False``.'
| def test_missing(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(return_value='A')}):
with patch.object(smf, 'get_all', return_value='A'):
self.assertFalse(smf.missing('A'))
|
'Test to return all installed services'
| def test_get_all(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(return_value='A\n')}):
self.assertListEqual(smf.get_all(), ['A'])
|
'Test to start the specified service'
| def test_start(self):
| with patch.dict(smf.__salt__, {'cmd.retcode': MagicMock(side_effect=[False, 3, None, False, 4])}):
self.assertTrue(smf.start('name'))
self.assertTrue(smf.start('name'))
self.assertFalse(smf.start('name'))
|
'Test to stop the specified service'
| def test_stop(self):
| with patch.dict(smf.__salt__, {'cmd.retcode': MagicMock(return_value=False)}):
self.assertTrue(smf.stop('name'))
|
'Test to restart the named service'
| def test_restart(self):
| with patch.dict(smf.__salt__, {'cmd.retcode': MagicMock(side_effect=[False, True])}):
with patch.object(smf, 'start', return_value='A'):
self.assertEqual(smf.restart('name'), 'A')
self.assertFalse(smf.restart('name'))
|
'Test to reload the named service'
| def test_reload_(self):
| with patch.dict(smf.__salt__, {'cmd.retcode': MagicMock(side_effect=[False, True])}):
with patch.object(smf, 'start', return_value='A'):
self.assertEqual(smf.reload_('name'), 'A')
self.assertFalse(smf.reload_('name'))
|
'Test to return the status for a service, returns a bool whether the
service is running.'
| def test_status(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(side_effect=['online', 'online1'])}):
self.assertTrue(smf.status('name'))
self.assertFalse(smf.status('name'))
|
'Test to enable the named service to start at boot'
| def test_enable(self):
| with patch.dict(smf.__salt__, {'cmd.retcode': MagicMock(return_value=False)}):
self.assertTrue(smf.enable('name'))
|
'Test to disable the named service to start at boot'
| def test_disable(self):
| with patch.dict(smf.__salt__, {'cmd.retcode': MagicMock(return_value=False)}):
self.assertTrue(smf.disable('name'))
|
'Test to check to see if the named service is enabled to start on boot'
| def test_enabled(self):
| with patch.dict(smf.__salt__, {'cmd.run': MagicMock(side_effect=['fmri', 'A B true', 'fmri', 'A B false'])}):
self.assertTrue(smf.enabled('name'))
self.assertFalse(smf.enabled('name'))
|
'Test to check to see if the named service is disabled to start on boot'
| def test_disabled(self):
| with patch.object(smf, 'enabled', return_value=False):
self.assertTrue(smf.disabled('name'))
|
'Test to return the enabled services'
| def test_get_enabled(self):
| with patch.object(smf, '_get_enabled_disabled', return_value=True):
self.assertTrue(smf.get_enabled())
|
'Test to return the disabled services'
| def test_get_disabled(self):
| with patch.object(smf, '_get_enabled_disabled', return_value=True):
self.assertTrue(smf.get_disabled())
|
'Test if it writes the contents of a file to a user\'s crontab'
| def test_write_incron_file(self):
| mock = MagicMock(return_value=0)
with patch.dict(incron.__salt__, {'cmd.retcode': mock}):
with patch('salt.modules.incron._get_incron_cmdstr', MagicMock(return_value='incrontab')):
self.assertTrue(incron.write_incron_file('cybage', '/home/cybage/new_cron'))
|
'Test if it writes the contents of a file to a user\'s crontab and
return error message on error'
| def test_write_cron_file_verbose(self):
| mock = MagicMock(return_value=True)
with patch.dict(incron.__salt__, {'cmd.run_all': mock}):
with patch('salt.modules.incron._get_incron_cmdstr', MagicMock(return_value='incrontab')):
self.assertTrue(incron.write_incron_file_verbose('cybage', '/home/cybage/new_cron'))
|
'Test if it return the contents of the system wide incrontab'
| def test_raw_system_incron(self):
| with patch('salt.modules.incron._read_file', MagicMock(return_value='salt')):
self.assertEqual(incron.raw_system_incron(), 'salt')
|
'Test if it return the contents of the user\'s incrontab'
| def test_raw_incron(self):
| mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
mock = MagicMock(return_value='salt')
with patch.dict(incron.__salt__, {'cmd.run_stdout': mock}):
self.assertEqual(incron.raw_incron('cybage'), 'salt')
|
'Test if it return the contents of the specified user\'s incrontab'
| def test_list_tab(self):
| mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
mock = MagicMock(return_value='salt')
with patch.dict(incron.__salt__, {'cmd.run_stdout': mock}):
self.assertDictEqual(incron.list_tab('cybage'), {'pre': ['salt'], 'crons': []})
|
'Test if it sets a cron job up for a specified user.'
| def test_set_job(self):
| self.assertEqual(incron.set_job('cybage', '/home/cybage', 'TO_MODIFY', 'echo "$$ $@ $# $% $&"'), 'Invalid mask type: TO_MODIFY')
val = {'pre': [], 'crons': [{'path': '/home/cybage', 'mask': 'IN_MODIFY', 'cmd': 'echo "SALT"', 'comment': ''}]}
with patch.object(incron, 'list_tab', MagicMock(return_value=val)):
self.assertEqual(incron.set_job('cybage', '/home/cybage', 'IN_MODIFY', 'echo "SALT"'), 'present')
with patch.object(incron, 'list_tab', MagicMock(return_value={'pre': ['salt'], 'crons': []})):
mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
with patch.object(incron, '_write_incron_lines', MagicMock(return_value={'retcode': True, 'stderr': 'error'})):
self.assertEqual(incron.set_job('cybage', '/home/cybage', 'IN_MODIFY', 'echo "SALT"'), 'error')
with patch.object(incron, 'list_tab', MagicMock(return_value={'pre': ['salt'], 'crons': []})):
mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
with patch.object(incron, '_write_incron_lines', MagicMock(return_value={'retcode': False, 'stderr': 'error'})):
self.assertEqual(incron.set_job('cybage', '/home/cybage', 'IN_MODIFY', 'echo "SALT"'), 'new')
val = {'pre': [], 'crons': [{'path': '/home/cybage', 'mask': 'IN_MODIFY,IN_DELETE', 'cmd': 'echo "SALT"', 'comment': ''}]}
with patch.object(incron, 'list_tab', MagicMock(return_value=val)):
mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
with patch.object(incron, '_write_incron_lines', MagicMock(return_value={'retcode': False, 'stderr': 'error'})):
self.assertEqual(incron.set_job('cybage', '/home/cybage', 'IN_DELETE', 'echo "SALT"'), 'updated')
|
'Test if it remove a cron job for a specified user. If any of the
day/time params are specified, the job will only be removed if
the specified params match.'
| def test_rm_job(self):
| self.assertEqual(incron.rm_job('cybage', '/home/cybage', 'TO_MODIFY', 'echo "$$ $@ $# $% $&"'), 'Invalid mask type: TO_MODIFY')
with patch.object(incron, 'list_tab', MagicMock(return_value={'pre': ['salt'], 'crons': []})):
mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
with patch.object(incron, '_write_incron_lines', MagicMock(return_value={'retcode': True, 'stderr': 'error'})):
self.assertEqual(incron.rm_job('cybage', '/home/cybage', 'IN_MODIFY', 'echo "SALT"'), 'error')
with patch.object(incron, 'list_tab', MagicMock(return_value={'pre': ['salt'], 'crons': []})):
mock = MagicMock(return_value='incrontab')
with patch.dict(incron.__grains__, {'os_family': mock}):
with patch.object(incron, '_write_incron_lines', MagicMock(return_value={'retcode': False, 'stderr': 'error'})):
self.assertEqual(incron.rm_job('cybage', '/home/cybage', 'IN_MODIFY', 'echo "SALT"'), 'absent')
|
'Tests successful return of exists function'
| def test_exists_success(self):
| ret = {}
ret['stdout'] = 'NAME USED AVAIL REFER MOUNTPOINT\nmyzpool/mydataset 30K 157G 30K /myzpool/mydataset'
ret['stderr'] = ''
ret['retcode'] = 0
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertTrue(zfs.exists('myzpool/mydataset'))
|
'Tests unsuccessful return of exists function if dataset does not exist'
| def test_exists_failure_not_exists(self):
| ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot open 'myzpool/mydataset': dataset does not exist"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertFalse(zfs.exists('myzpool/mydataset'))
|
'Tests unsuccessful return of exists function if dataset name is invalid'
| def test_exists_failure_invalid_name(self):
| ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot open 'myzpool/': invalid dataset name"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertFalse(zfs.exists('myzpool/'))
|
'Tests successful return of create function on ZFS file system creation'
| def test_create_success(self):
| res = {'myzpool/mydataset': 'created'}
ret = {}
ret['stdout'] = ''
ret['stderr'] = ''
ret['retcode'] = 0
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool/mydataset'), res)
|
'Tests successful return of create function when ``create_parent=True``'
| def test_create_success_with_create_parent(self):
| res = {'myzpool/mydataset/mysubdataset': 'created'}
ret = {}
ret['stdout'] = ''
ret['stderr'] = ''
ret['retcode'] = 0
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool/mydataset/mysubdataset', create_parent=True), res)
|
'Tests successful return of create function on ZFS file system creation (with properties)'
| def test_create_success_with_properties(self):
| res = {'myzpool/mydataset': 'created'}
ret = {}
ret['stdout'] = ''
ret['stderr'] = ''
ret['retcode'] = 0
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool/mydataset', properties={'mountpoint': '/export/zfs', 'sharenfs': 'on'}), res)
|
'Tests unsuccessful return of create function if dataset name is missing'
| def test_create_error_missing_dataset(self):
| res = {'myzpool': "cannot create 'myzpool': missing dataset name"}
ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot create 'myzpool': missing dataset name"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool'), res)
|
'Tests unsuccessful return of create function if trailing slash in name is present'
| def test_create_error_trailing_slash(self):
| res = {'myzpool/': "cannot create 'myzpool/': trailing slash in name"}
ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot create 'myzpool/': trailing slash in name"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool/'), res)
|
'Tests unsuccessful return of create function if the pool is not present'
| def test_create_error_no_such_pool(self):
| res = {'myzpool/mydataset': "cannot create 'myzpool/mydataset': no such pool 'myzpool'"}
ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot create 'myzpool/mydataset': no such pool 'myzpool'"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool/mydataset'), res)
|
'Tests unsuccessful return of create function if the parent datasets do not exist'
| def test_create_error_missing_parent(self):
| res = {'myzpool/mydataset/mysubdataset': "cannot create 'myzpool/mydataset/mysubdataset': parent does not exist"}
ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot create 'myzpool/mydataset/mysubdataset': parent does not exist"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.create('myzpool/mydataset/mysubdataset'), res)
|
'Tests zfs list'
| def test_list_success(self):
| res = OrderedDict([('myzpool', {'avail': '79.9M', 'mountpoint': '/myzpool', 'used': '113K', 'refer': '19K'})])
ret = {'pid': 31817, 'retcode': 0, 'stderr': '', 'stdout': 'myzpool DCTB 113K DCTB 79.9M DCTB 19K DCTB /myzpool'}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.list_('myzpool'), res)
|
'Tests zfs mount of filesystem'
| def test_mount_success(self):
| res = {'myzpool/mydataset': 'mounted'}
ret = {}
ret['stdout'] = ''
ret['stderr'] = ''
ret['retcode'] = 0
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.mount('myzpool/mydataset'), res)
|
'Tests zfs mount of already mounted filesystem'
| def test_mount_failure(self):
| res = {'myzpool/mydataset': "cannot mount 'myzpool/mydataset': filesystem already mounted"}
ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot mount 'myzpool/mydataset': filesystem already mounted"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.mount('myzpool/mydataset'), res)
|
'Tests zfs unmount of filesystem'
| def test_unmount_success(self):
| res = {'myzpool/mydataset': 'unmounted'}
ret = {}
ret['stdout'] = ''
ret['stderr'] = ''
ret['retcode'] = 0
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.unmount('myzpool/mydataset'), res)
|
'Tests zfs unmount of already mounted filesystem'
| def test_unmount_failure(self):
| res = {'myzpool/mydataset': "cannot mount 'myzpool/mydataset': not currently mounted"}
ret = {}
ret['stdout'] = ''
ret['stderr'] = "cannot mount 'myzpool/mydataset': not currently mounted"
ret['retcode'] = 1
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.unmount('myzpool/mydataset'), res)
|
'Tests zfs inherit of compression property'
| def test_inherit_success(self):
| res = {'myzpool/mydataset': {'compression': 'cleared'}}
ret = {'pid': 45193, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.inherit('compression', 'myzpool/mydataset'), res)
|
'Tests zfs inherit of canmount'
| def test_inherit_failure(self):
| res = {'myzpool/mydataset': {'canmount': "'canmount' property cannot be inherited, use revert=True to try and reset it to it's default value."}}
ret = {'pid': 43898, 'retcode': 1, 'stderr': "'canmount' property cannot be inherited", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.inherit('canmount', 'myzpool/mydataset'), res)
|
'Tests zfs diff'
| def test_diff(self):
| res = ['M DCTB / DCTB /myzpool/mydataset/', '+ DCTB F DCTB /myzpool/mydataset/hello']
ret = {'pid': 51495, 'retcode': 0, 'stderr': '', 'stdout': 'M DCTB / DCTB /myzpool/mydataset/\n+ DCTB F DCTB /myzpool/mydataset/hello'}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.diff('myzpool/mydataset@yesterday', 'myzpool/mydataset'), res)
|
'Tests zfs rollback success'
| def test_rollback_success(self):
| res = {'myzpool/mydataset': 'rolledback to snapshot: yesterday'}
ret = {'pid': 56502, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.rollback('myzpool/mydataset@yesterday'), res)
|
'Tests zfs rollback failure'
| def test_rollback_failure(self):
| res = {'myzpool/mydataset': "cannot rollback to 'myzpool/mydataset@yesterday': more recent snapshots or bookmarks exist\nuse '-r' to force deletion of the following snapshots and bookmarks:\nmyzpool/mydataset@today"}
ret = {'pid': 57471, 'retcode': 1, 'stderr': "cannot rollback to 'myzpool/mydataset@yesterday': more recent snapshots or bookmarks exist\nuse '-r' to force deletion of the following snapshots and bookmarks:\nmyzpool/mydataset@today", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.rollback('myzpool/mydataset@yesterday'), res)
|
'Tests zfs clone success'
| def test_clone_success(self):
| res = {'myzpool/yesterday': 'cloned from myzpool/mydataset@yesterday'}
ret = {'pid': 64532, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.clone('myzpool/mydataset@yesterday', 'myzpool/yesterday'), res)
|
'Tests zfs clone failure'
| def test_clone_failure(self):
| res = {'myzpool/archive/yesterday': "cannot create 'myzpool/archive/yesterday': parent does not exist"}
ret = {'pid': 64864, 'retcode': 1, 'stderr': "cannot create 'myzpool/archive/yesterday': parent does not exist", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.clone('myzpool/mydataset@yesterday', 'myzpool/archive/yesterday'), res)
|
'Tests zfs promote success'
| def test_promote_success(self):
| res = {'myzpool/yesterday': 'promoted'}
ret = {'pid': 69075, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.promote('myzpool/yesterday'), res)
|
'Tests zfs promote failure'
| def test_promote_failure(self):
| res = {'myzpool/yesterday': "cannot promote 'myzpool/yesterday': not a cloned filesystem"}
ret = {'pid': 69209, 'retcode': 1, 'stderr': "cannot promote 'myzpool/yesterday': not a cloned filesystem", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.promote('myzpool/yesterday'), res)
|
'Tests zfs bookmark success'
| def test_bookmark_success(self):
| with patch('salt.utils.path.which', MagicMock(return_value='/usr/bin/man')):
res = {'myzpool/mydataset@yesterday': 'bookmarked as myzpool/mydataset#important'}
ret = {'pid': 20990, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.bookmark('myzpool/mydataset@yesterday', 'myzpool/mydataset#important'), res)
|
'Tests zfs holds success'
| def test_holds_success(self):
| res = {'myzpool/mydataset@baseline': {'important ': 'Wed Dec 23 21:06 2015', 'release-1.0': 'Wed Dec 23 21:08 2015'}}
ret = {'pid': 40216, 'retcode': 0, 'stderr': '', 'stdout': 'myzpool/mydataset@baseline DCTB important DCTB Wed Dec 23 21:06 2015\nmyzpool/mydataset@baseline DCTB release-1.0 DCTB Wed Dec 23 21:08 2015'}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.holds('myzpool/mydataset@baseline'), res)
|
'Tests zfs holds failure'
| def test_holds_failure(self):
| res = {'myzpool/mydataset@baseline': "cannot open 'myzpool/mydataset@baseline': dataset does not exist"}
ret = {'pid': 40993, 'retcode': 1, 'stderr': "cannot open 'myzpool/mydataset@baseline': dataset does not exist", 'stdout': 'no datasets available'}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.holds('myzpool/mydataset@baseline'), res)
|
'Tests zfs hold success'
| def test_hold_success(self):
| res = {'myzpool/mydataset@baseline': {'important': 'held'}, 'myzpool/[email protected]': {'important': 'held'}}
ret = {'pid': 50876, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.hold('important', 'myzpool/mydataset@baseline', 'myzpool/[email protected]'), res)
|
'Tests zfs hold failure'
| def test_hold_failure(self):
| res = {'myzpool/mydataset@baseline': {'important': 'tag already exists on this dataset'}}
ret = {'pid': 51006, 'retcode': 1, 'stderr': "cannot hold snapshot 'myzpool/mydataset@baseline': tag already exists on this dataset", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.hold('important', 'myzpool/mydataset@baseline'), res)
|
'Tests zfs release success'
| def test_release_success(self):
| res = {'myzpool/mydataset@baseline': {'important': 'released'}, 'myzpool/[email protected]': {'important': 'released'}}
ret = {'pid': 50876, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.release('important', 'myzpool/mydataset@baseline', 'myzpool/[email protected]'), res)
|
'Tests zfs release failure'
| def test_release_failure(self):
| res = {'myzpool/mydataset@baseline': {'important': 'no such tag on this dataset'}}
ret = {'pid': 51006, 'retcode': 1, 'stderr': "cannot release hold from snapshot 'myzpool/mydataset@baseline': no such tag on this dataset", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.release('important', 'myzpool/mydataset@baseline'), res)
|
'Tests zfs snapshot success'
| def test_snapshot_success(self):
| res = {'myzpool/mydataset@baseline': 'snapshotted'}
ret = {'pid': 69125, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.snapshot('myzpool/mydataset@baseline'), res)
|
'Tests zfs snapshot failure'
| def test_snapshot_failure(self):
| res = {'myzpool/mydataset@baseline': 'dataset already exists'}
ret = {'pid': 68526, 'retcode': 1, 'stderr': "cannot create snapshot 'myzpool/mydataset@baseline': dataset already exists", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.snapshot('myzpool/mydataset@baseline'), res)
|
'Tests zfs snapshot failure'
| def test_snapshot_failure2(self):
| res = {'myzpool/mydataset@baseline': 'dataset does not exist'}
ret = {'pid': 69256, 'retcode': 2, 'stderr': "cannot open 'myzpool/mydataset': dataset does not exist\nusage:\n DCTB snapshot [-r] [-o property=value] ... <filesystem|volume>@<snap> ...\n\nFor the property list, run: zfs set|get\n\nFor the delegated permission list, run: zfs allow|unallow", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.snapshot('myzpool/mydataset@baseline'), res)
|
'Tests zfs set success'
| def test_set_success(self):
| res = {'myzpool/mydataset': {'compression': 'set'}}
ret = {'pid': 79736, 'retcode': 0, 'stderr': '', 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.set('myzpool/mydataset', compression='lz4'), res)
|
'Tests zfs set failure'
| def test_set_failure(self):
| res = {'myzpool/mydataset': {'canmount': "'canmount' must be one of 'on | off | noauto'"}}
ret = {'pid': 79887, 'retcode': 1, 'stderr': "cannot set property for 'myzpool/mydataset': 'canmount' must be one of 'on | off | noauto'", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.set('myzpool/mydataset', canmount='lz4'), res)
|
'Tests zfs get success'
| def test_get_success(self):
| res = OrderedDict([('myzpool', {'compression': {'value': 'off'}})])
ret = {'pid': 562, 'retcode': 0, 'stderr': '', 'stdout': 'myzpool DCTB compression DCTB off'}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.get('myzpool', properties='compression', fields='value'), res)
|
'Test for powerpath'
| def test_has_powerpath(self):
| with patch('os.path.exists') as mock_exists:
mock_exists.return_value = True
self.assertTrue(powerpath.has_powerpath())
mock_exists.return_value = False
self.assertFalse(powerpath.has_powerpath())
|
'Test to returns a list of applied powerpath license keys'
| def test_list_licenses(self):
| with patch.dict(powerpath.__salt__, {'cmd.run': MagicMock(return_value='A\nB')}):
self.assertListEqual(powerpath.list_licenses(), [])
|
'Test to add a license'
| def test_add_license(self):
| with patch.object(powerpath, 'has_powerpath', return_value=False):
self.assertDictEqual(powerpath.add_license('key'), {'output': 'PowerPath is not installed', 'result': False, 'retcode': (-1)})
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'stderr'})
with patch.object(powerpath, 'has_powerpath', return_value=True):
with patch.dict(powerpath.__salt__, {'cmd.run_all': mock}):
self.assertDictEqual(powerpath.add_license('key'), {'output': 'stderr', 'result': False, 'retcode': 1})
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.