desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test if it recurses through etcd and return all values'
| def test_tree(self):
| with patch.dict(etcd_mod.__utils__, {'etcd_util.get_conn': self.EtcdClientMock}):
self.instance.tree.return_value = {}
self.assertDictEqual(etcd_mod.tree('/some-dir'), {})
self.instance.tree.assert_called_with('/some-dir')
self.assertDictEqual(etcd_mod.tree(), {})
self.instance.tree.assert_called_with('/')
self.instance.tree.side_effect = Exception
self.assertRaises(Exception, etcd_mod.tree, 'err')
|
'Test if watch returns the right tuples'
| def test_watch(self):
| with patch.dict(etcd_mod.__utils__, {'etcd_util.get_conn': self.EtcdClientMock}):
self.instance.watch.return_value = {'value': 'stack', 'changed': True, 'dir': False, 'mIndex': 1, 'key': '/salt'}
self.assertEqual(etcd_mod.watch('/salt'), self.instance.watch.return_value)
self.instance.watch.assert_called_with('/salt', recurse=False, timeout=0, index=None)
self.instance.watch.return_value['dir'] = True
self.assertEqual(etcd_mod.watch('/some-dir', recurse=True, timeout=5, index=10), self.instance.watch.return_value)
self.instance.watch.assert_called_with('/some-dir', recurse=True, timeout=5, index=10)
self.assertEqual(etcd_mod.watch('/some-dir', True, None, 5, 10), self.instance.watch.return_value)
self.instance.watch.assert_called_with('/some-dir', recurse=True, timeout=5, index=10)
|
'Tests return when template=None'
| def test_render_cmd_no_template(self):
| self.assertEqual(cmdmod._render_cmd('foo', 'bar', None), ('foo', 'bar'))
|
'Tests CommandExecutionError raised when template isn\'t in the
template registry'
| def test_render_cmd_unavailable_engine(self):
| self.assertRaises(CommandExecutionError, cmdmod._render_cmd, 'boo', 'bar', 'baz')
|
'Tests return of providing an invalid loglevel option'
| def test_check_loglevel_bad_level(self):
| with patch.dict(LOG_LEVELS, self.mock_loglevels):
self.assertEqual(cmdmod._check_loglevel(level='bad_loglevel'), 'foo')
|
'Tests the return of providing an invalid loglevel option that is not a string'
| def test_check_loglevel_bad_level_not_str(self):
| with patch.dict(LOG_LEVELS, self.mock_loglevels):
self.assertEqual(cmdmod._check_loglevel(level=1000), 'foo')
|
'Tests the return of providing a loglevel of \'quiet\''
| def test_check_loglevel_quiet(self):
| with patch.dict(LOG_LEVELS, self.mock_loglevels):
self.assertEqual(cmdmod._check_loglevel(level='quiet'), None)
|
'Tests the return of quiet=True'
| def test_check_loglevel_utils_quite(self):
| with patch.dict(LOG_LEVELS, self.mock_loglevels):
self.assertEqual(cmdmod._check_loglevel(quiet=True), None)
|
'Tests the return of an env that is not an env'
| def test_parse_env_not_env(self):
| self.assertEqual(cmdmod._parse_env(None), {})
|
'Tests the return of an env that is a list'
| def test_parse_env_list(self):
| ret = {'foo': None, 'bar': None}
self.assertEqual(ret, cmdmod._parse_env(['foo', 'bar']))
|
'Test the return of an env that is not a dict'
| def test_parse_env_dict(self):
| self.assertEqual(cmdmod._parse_env('test'), {})
|
'Tests error raised when shell is not available after _is_valid_shell error msg
and os.path.isfile returns False'
| def test_run_shell_is_not_file(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=False)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar')
|
'Tests error raised when shell is not available after _is_valid_shell error msg,
os.path.isfile returns True, but os.access returns False'
| def test_run_shell_file_no_access(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=False)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar')
|
'Tests error raised when runas is passed on windows'
| def test_run_runas_with_windows(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=True)):
with patch.dict(cmdmod.__grains__, {'os': 'fake_os'}):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar', runas='baz')
|
'Tests return when runas user is not available'
| def test_run_user_not_available(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar', runas='baz')
|
'Tests error raised when umask is set to zero'
| def test_run_zero_umask(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar', umask=0)
|
'Tests error raised when an invalid umask is given'
| def test_run_invalid_umask(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar', umask='baz')
|
'Tests error raised when cwd is not an absolute path'
| def test_run_invalid_cwd_not_abs_path(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar')
|
'Tests error raised when cwd is not a dir'
| def test_run_invalid_cwd_not_dir(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
with patch('os.path.isabs', MagicMock(return_value=True)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo', 'bar')
|
'Tests error raised when not useing vt and OSError is provided'
| def test_run_no_vt_os_error(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
with patch('salt.utils.timed_subprocess.TimedProc', MagicMock(side_effect=OSError)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo')
|
'Tests error raised when not useing vt and IOError is provided'
| def test_run_no_vt_io_error(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
with patch('salt.utils.timed_subprocess.TimedProc', MagicMock(side_effect=IOError)):
self.assertRaises(CommandExecutionError, cmdmod._run, 'foo')
|
'Tests end result when a command is not found'
| @skipIf(salt.utils.platform.is_windows(), 'Do not run on Windows')
def test_run(self):
| with patch('salt.modules.cmdmod._is_valid_shell', MagicMock(return_value=True)):
with patch('salt.utils.platform.is_windows', MagicMock(return_value=False)):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.access', MagicMock(return_value=True)):
ret = cmdmod._run('foo', use_vt=True).get('stderr')
self.assertIn('foo', ret)
|
'Tests return if running on windows'
| def test_is_valid_shell_windows(self):
| with patch('salt.utils.platform.is_windows', MagicMock(return_value=True)):
self.assertTrue(cmdmod._is_valid_shell('foo'))
|
'Tests return of when os.path.exists(/etc/shells) isn\'t available'
| @skipIf(salt.utils.platform.is_windows(), 'Do not run on Windows')
def test_is_valid_shell_none(self):
| with patch('os.path.exists', MagicMock(return_value=False)):
self.assertIsNone(cmdmod._is_valid_shell('foo'))
|
'Tests return when provided shell is available'
| def test_is_valid_shell_available(self):
| with patch('os.path.exists', MagicMock(return_value=True)):
with patch('salt.utils.files.fopen', mock_open(read_data=MOCK_SHELL_FILE)):
self.assertTrue(cmdmod._is_valid_shell('/bin/bash'))
|
'Tests return when provided shell is not available'
| @skipIf(salt.utils.platform.is_windows(), 'Do not run on Windows')
def test_is_valid_shell_unavailable(self):
| with patch('os.path.exists', MagicMock(return_value=True)):
with patch('salt.utils.files.fopen', mock_open(read_data=MOCK_SHELL_FILE)):
self.assertFalse(cmdmod._is_valid_shell('foo'))
|
'Make sure the OS environment is not tainted after running a command
that specifies runas.'
| def test_os_environment_remains_intact(self):
| with patch('pwd.getpwnam') as getpwnam_mock:
with patch('subprocess.Popen') as popen_mock:
environment = os.environ.copy()
popen_mock.return_value = Mock(communicate=(lambda *args, **kwags: ['{}', None]), pid=(lambda : 1), retcode=0)
with patch.dict(cmdmod.__grains__, {'os': 'Darwin', 'os_family': 'Solaris'}):
if sys.platform.startswith(('freebsd', 'openbsd')):
shell = '/bin/sh'
else:
shell = '/bin/bash'
cmdmod._run('ls', cwd=tempfile.gettempdir(), runas='foobar', shell=shell)
environment2 = os.environ.copy()
self.assertEqual(environment, environment2)
getpwnam_mock.assert_called_with('foobar')
|
'cmd.run should fail and raise
salt.exceptions.CommandExecutionError if the cwd dir does not
exist'
| def test_run_cwd_doesnt_exist_issue_7154(self):
| cmd = 'echo OHAI'
cwd = '/path/to/nowhere'
try:
cmdmod.run_all(cmd, cwd=cwd)
except CommandExecutionError:
pass
else:
raise RuntimeError
|
'Test if it raises an exception when install package fails'
| def test_install_with_error(self):
| mock = MagicMock(return_value={'retcode': 1, 'stderr': 'error'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, bower.install, '/path/to/project', 'underscore')
|
'Test if it returns True when install package succeeds'
| def test_install_new_package(self):
| mock = MagicMock(return_value={'retcode': 0, 'stdout': '{"underscore":{}}'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertTrue(bower.install('/path/to/project', 'underscore'))
|
'Test if it returns False when package already installed'
| def test_install_existing_package(self):
| mock = MagicMock(return_value={'retcode': 0, 'stdout': '{}'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertFalse(bower.install('/path/to/project', 'underscore'))
|
'Test if it raises an exception when uninstall package fails'
| def test_uninstall_with_error(self):
| mock = MagicMock(return_value={'retcode': 1, 'stderr': 'error'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, bower.uninstall, '/path/to/project', 'underscore')
|
'Test if it returns True when uninstall package succeeds'
| def test_uninstall_existing_package(self):
| mock = MagicMock(return_value={'retcode': 0, 'stdout': '{"underscore": {}}'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertTrue(bower.uninstall('/path/to/project', 'underscore'))
|
'Test if it returns False when package is not installed'
| def test_uninstall_missing_package(self):
| mock = MagicMock(return_value={'retcode': 0, 'stdout': '{}'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertFalse(bower.uninstall('/path/to/project', 'underscore'))
|
'Test if it raises an exception when list installed packages fails'
| def test_list_packages_with_error(self):
| mock = MagicMock(return_value={'retcode': 1, 'stderr': 'error'})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, bower.list_, '/path/to/project')
|
'Test if it lists installed Bower packages'
| def test_list_packages_success(self):
| output = '{"dependencies": {"underscore": {}, "jquery":{}}}'
mock = MagicMock(return_value={'retcode': 0, 'stdout': output})
with patch.dict(bower.__salt__, {'cmd.run_all': mock}):
self.assertEqual(bower.list_('/path/to/project'), {'underscore': {}, 'jquery': {}})
|
'Test to return the enabled services'
| def test_get_enabled(self):
| mock = MagicMock(return_value=[{'ServiceName': 'spongebob'}, {'ServiceName': 'squarepants'}, {'ServiceName': 'patrick'}])
with patch.object(win_service, '_get_services', mock):
mock_info = MagicMock(side_effect=[{'StartType': 'Auto'}, {'StartType': 'Manual'}, {'StartType': 'Disabled'}])
with patch.object(win_service, 'info', mock_info):
self.assertListEqual(win_service.get_enabled(), ['spongebob'])
|
'Test to return the disabled services'
| def test_get_disabled(self):
| mock = MagicMock(return_value=[{'ServiceName': 'spongebob'}, {'ServiceName': 'squarepants'}, {'ServiceName': 'patrick'}])
with patch.object(win_service, '_get_services', mock):
mock_info = MagicMock(side_effect=[{'StartType': 'Auto'}, {'StartType': 'Manual'}, {'StartType': 'Disabled'}])
with patch.object(win_service, 'info', mock_info):
self.assertListEqual(win_service.get_disabled(), ['patrick', 'squarepants'])
|
'Test to Returns ``True`` if the specified service
is available, otherwise returns ``False``'
| def test_available(self):
| mock = MagicMock(return_value=['c', 'a', 'b'])
with patch.object(win_service, 'get_all', mock):
self.assertTrue(win_service.available('a'))
|
'Test to the inverse of service.available'
| def test_missing(self):
| mock = MagicMock(return_value=['c', 'a', 'b'])
with patch.object(win_service, 'get_all', mock):
self.assertTrue(win_service.missing('d'))
|
'Test to return all installed services'
| def test_get_all(self):
| mock = MagicMock(return_value=[{'ServiceName': 'spongebob'}, {'ServiceName': 'squarepants'}, {'ServiceName': 'patrick'}])
with patch.object(win_service, '_get_services', mock):
self.assertListEqual(win_service.get_all(), ['patrick', 'spongebob', 'squarepants'])
|
'Test to the Display Name is what is displayed
in Windows when services.msc is executed.'
| def test_get_service_name(self):
| mock = MagicMock(return_value=[{'ServiceName': 'spongebob', 'DisplayName': 'Sponge Bob'}, {'ServiceName': 'squarepants', 'DisplayName': 'Square Pants'}, {'ServiceName': 'patrick', 'DisplayName': 'Patrick the Starfish'}])
with patch.object(win_service, '_get_services', mock):
self.assertDictEqual(win_service.get_service_name(), {'Patrick the Starfish': 'patrick', 'Sponge Bob': 'spongebob', 'Square Pants': 'squarepants'})
self.assertDictEqual(win_service.get_service_name('patrick'), {'Patrick the Starfish': 'patrick'})
|
'Test to start the specified service'
| @skipIf((not WINAPI), 'win32serviceutil not available')
def test_start(self):
| mock_true = MagicMock(return_value=True)
mock_false = MagicMock(return_value=False)
mock_info = MagicMock(side_effect=[{'Status': 'Stopped'}, {'Status': 'Start Pending'}, {'Status': 'Running'}])
with patch.object(win_service, 'status', mock_true):
self.assertTrue(win_service.start('spongebob'))
with patch.object(win_service, 'status', mock_false):
with patch.object(win32serviceutil, 'StartService', mock_true):
with patch.object(win_service, 'info', mock_info):
with patch.object(win_service, 'status', mock_true):
self.assertTrue(win_service.start('spongebob'))
|
'Test to stop the specified service'
| @skipIf((not WINAPI), 'win32serviceutil not available')
def test_stop(self):
| mock_true = MagicMock(return_value=True)
mock_false = MagicMock(return_value=False)
mock_info = MagicMock(side_effect=[{'Status': 'Running'}, {'Status': 'Stop Pending'}, {'Status': 'Stopped'}])
with patch.object(win_service, 'status', mock_false):
self.assertTrue(win_service.stop('spongebob'))
with patch.object(win_service, 'status', mock_true):
with patch.object(win32serviceutil, 'StopService', mock_true):
with patch.object(win_service, 'info', mock_info):
with patch.object(win_service, 'status', mock_false):
self.assertTrue(win_service.stop('spongebob'))
|
'Test to restart the named service'
| def test_restart(self):
| mock_true = MagicMock(return_value=True)
with patch.object(win_service, 'create_win_salt_restart_task', mock_true):
with patch.object(win_service, 'execute_salt_restart_task', mock_true):
self.assertTrue(win_service.restart('salt-minion'))
with patch.object(win_service, 'stop', mock_true):
with patch.object(win_service, 'start', mock_true):
self.assertTrue(win_service.restart('salt'))
|
'Test to create a task in Windows task
scheduler to enable restarting the salt-minion'
| def test_createwin_saltrestart_task(self):
| mock_true = MagicMock(return_value=True)
with patch.dict(win_service.__salt__, {'task.create_task': mock_true}):
self.assertTrue(win_service.create_win_salt_restart_task())
|
'Test to run the Windows Salt restart task'
| def test_execute_salt_restart_task(self):
| mock_true = MagicMock(return_value=True)
with patch.dict(win_service.__salt__, {'task.run': mock_true}):
self.assertTrue(win_service.execute_salt_restart_task())
|
'Test to return the status for a service'
| @skipIf((not WINAPI), 'win32serviceutil not available')
def test_status(self):
| mock_info = MagicMock(side_effect=[{'Status': 'Running'}, {'Status': 'Stop Pending'}, {'Status': 'Stopped'}])
with patch.object(win_service, 'info', mock_info):
self.assertTrue(win_service.status('spongebob'))
self.assertTrue(win_service.status('patrick'))
self.assertFalse(win_service.status('squidward'))
|
'Test to return the sid for this windows service'
| def test_getsid(self):
| mock_info = MagicMock(side_effect=[{'sid': 'S-1-5-80-1956725871...'}, {'sid': None}])
with patch.object(win_service, 'info', mock_info):
self.assertEqual(win_service.getsid('spongebob'), 'S-1-5-80-1956725871...')
self.assertEqual(win_service.getsid('plankton'), None)
|
'Test to enable the named service to start at boot'
| def test_enable(self):
| mock_modify = MagicMock(return_value=True)
mock_info = MagicMock(return_value={'StartType': 'Auto', 'StartTypeDelayed': False})
with patch.object(win_service, 'modify', mock_modify):
with patch.object(win_service, 'info', mock_info):
self.assertTrue(win_service.enable('spongebob'))
|
'Test to disable the named service to start at boot'
| def test_disable(self):
| mock_modify = MagicMock(return_value=True)
mock_info = MagicMock(return_value={'StartType': 'Disabled'})
with patch.object(win_service, 'modify', mock_modify):
with patch.object(win_service, 'info', mock_info):
self.assertTrue(win_service.disable('spongebob'))
|
'Test to check to see if the named
service is enabled to start on boot'
| def test_enabled(self):
| mock = MagicMock(side_effect=[{'StartType': 'Auto'}, {'StartType': 'Disabled'}])
with patch.object(win_service, 'info', mock):
self.assertTrue(win_service.enabled('spongebob'))
self.assertFalse(win_service.enabled('squarepants'))
|
'Test to check to see if the named
service is disabled to start on boot'
| def test_disabled(self):
| mock = MagicMock(side_effect=[False, True])
with patch.object(win_service, 'enabled', mock):
self.assertTrue(win_service.disabled('spongebob'))
self.assertFalse(win_service.disabled('squarepants'))
|
'Test for Install composer dependencies for a directory.'
| def test_install(self):
| mock = MagicMock(return_value=False)
with patch.object(composer, '_valid_composer', mock):
self.assertRaises(CommandNotFoundError, composer.install, 'd')
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
self.assertRaises(SaltInvocationError, composer.install, None)
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, composer.install, 'd')
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value={'retcode': 0, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertTrue(composer.install('dir', None, None, None, None, None, None, None, None, None, True))
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
rval = {'retcode': 0, 'stderr': 'A', 'stdout': 'B'}
mock = MagicMock(return_value=rval)
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertEqual(composer.install('dir'), rval)
|
'Test for Update composer dependencies for a directory.'
| def test_update(self):
| mock = MagicMock(return_value=False)
with patch.object(composer, '_valid_composer', mock):
self.assertRaises(CommandNotFoundError, composer.update, 'd')
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value=True)
with patch.object(composer, 'did_composer_install', mock):
self.assertRaises(SaltInvocationError, composer.update, None)
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value=True)
with patch.object(composer, 'did_composer_install', mock):
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, composer.update, 'd')
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value=True)
with patch.object(composer, 'did_composer_install', mock):
mock = MagicMock(return_value={'retcode': 0, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertTrue(composer.update('dir', None, None, None, None, None, None, None, None, None, True))
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value=False)
with patch.object(composer, 'did_composer_install', mock):
mock = MagicMock(return_value={'retcode': 0, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertTrue(composer.update('dir', None, None, None, None, None, None, None, None, None, True))
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value=True)
with patch.object(composer, 'did_composer_install', mock):
rval = {'retcode': 0, 'stderr': 'A', 'stdout': 'B'}
mock = MagicMock(return_value=rval)
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertEqual(composer.update('dir'), rval)
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value=False)
with patch.object(composer, 'did_composer_install', mock):
rval = {'retcode': 0, 'stderr': 'A', 'stdout': 'B'}
mock = MagicMock(return_value=rval)
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertEqual(composer.update('dir'), rval)
|
'Test for Composer selfupdate'
| def test_selfupdate(self):
| mock = MagicMock(return_value=False)
with patch.object(composer, '_valid_composer', mock):
self.assertRaises(CommandNotFoundError, composer.selfupdate)
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value={'retcode': 1, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, composer.selfupdate)
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
mock = MagicMock(return_value={'retcode': 0, 'stderr': 'A'})
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertTrue(composer.selfupdate(quiet=True))
mock = MagicMock(return_value=True)
with patch.object(composer, '_valid_composer', mock):
rval = {'retcode': 0, 'stderr': 'A', 'stdout': 'B'}
mock = MagicMock(return_value=rval)
with patch.dict(composer.__salt__, {'cmd.run_all': mock}):
self.assertEqual(composer.selfupdate(), rval)
|
'Test for Fire an event off up to the master server'
| def test_fire_master(self):
| with patch('salt.crypt.SAuth') as salt_crypt_sauth:
with patch('salt.transport.Channel.factory') as salt_transport_channel_factory:
preload = {'id': 'id', 'tag': 'tag', 'data': 'data', 'tok': 'salt', 'cmd': '_minion_event'}
with patch.dict(event.__opts__, {'transport': 'raet', 'local': False}):
with patch.object(salt_transport_channel_factory, 'send', return_value=None):
self.assertTrue(event.fire_master('data', 'tag'))
with patch.dict(event.__opts__, {'transport': 'A', 'master_uri': 'localhost', 'local': False}):
with patch.object(salt_crypt_sauth, 'gen_token', return_value='tok'):
with patch.object(salt_transport_channel_factory, 'send', return_value=None):
self.assertTrue(event.fire_master('data', 'tag', preload))
with patch.dict(event.__opts__, {'transport': 'A', 'local': False}):
with patch.object(salt.utils.event.MinionEvent, 'fire_event', side_effect=Exception('foo')):
self.assertFalse(event.fire_master('data', 'tag'))
|
'Test to fire an event on the local minion event bus.
Data must be formed as a dict.'
| def test_fire(self):
| with patch('salt.utils.event') as salt_utils_event:
with patch.object(salt_utils_event, 'get_event') as mock:
mock.fire_event = MagicMock(return_value=True)
self.assertTrue(event.fire('data', 'tag'))
|
'Test for Send an event to the Salt Master'
| def test_send(self):
| with patch.object(event, 'fire_master', return_value='B'):
self.assertEqual(event.send('tag'), 'B')
|
'Test for Return version from hadoop version'
| def test_version(self):
| mock = MagicMock(return_value='A \nB \n')
with patch.dict(hadoop.__salt__, {'cmd.run': mock}):
self.assertEqual(hadoop.version(), 'B')
|
'Test for Execute a command on DFS'
| def test_dfs(self):
| with patch.object(hadoop, '_hadoop_cmd', return_value='A'):
self.assertEqual(hadoop.dfs('command'), 'A')
self.assertEqual(hadoop.dfs(), 'Error: command must be provided')
|
'Test for Check if a file or directory is present on the distributed FS.'
| def test_dfs_present(self):
| with patch.object(hadoop, '_hadoop_cmd', side_effect=['No such file or directory', 'A']):
self.assertFalse(hadoop.dfs_present('path'))
self.assertTrue(hadoop.dfs_present('path'))
|
'Test for Check if a file or directory is absent on the distributed FS.'
| def test_dfs_absent(self):
| with patch.object(hadoop, '_hadoop_cmd', side_effect=['No such file or directory', 'A']):
self.assertTrue(hadoop.dfs_absent('path'))
self.assertFalse(hadoop.dfs_absent('path'))
|
'Test for Format a name node'
| def test_namenode_format(self):
| with patch.object(hadoop, '_hadoop_cmd', return_value='A'):
self.assertEqual(hadoop.namenode_format('force'), 'A')
|
'Test if it create a bond script in /etc/modprobe.d with the passed
settings and load the bonding kernel module.'
| def test_build_bond(self):
| with patch('salt.modules.debian_ip._parse_settings_bond', MagicMock(return_value={})):
with patch('salt.modules.debian_ip._write_file', MagicMock(return_value=True)):
mock = MagicMock(return_value=1)
with patch.dict(debian_ip.__grains__, {'osrelease': mock}):
mock = MagicMock(return_value=True)
with patch.dict(debian_ip.__salt__, {'kmod.load': mock, 'pkg.install': mock}):
self.assertEqual(debian_ip.build_bond('bond0'), '')
|
'Test if it create a bond script in /etc/modprobe.d with the passed
settings and load the bonding kernel module.'
| def test_build_bond_exception(self):
| with patch('salt.modules.debian_ip._parse_settings_bond', MagicMock(return_value={})):
mock = MagicMock(return_value=1)
with patch.dict(debian_ip.__grains__, {'osrelease': mock}):
mock = MagicMock(side_effect=jinja2.exceptions.TemplateNotFound('error'))
with patch.object(jinja2.Environment, 'get_template', mock):
self.assertEqual(debian_ip.build_bond('bond0'), '')
|
'Test if it create a bond script in /etc/modprobe.d with the passed
settings and load the bonding kernel module.'
| def test_build_bond_data(self):
| with patch('salt.modules.debian_ip._parse_settings_bond', MagicMock(return_value={})):
with patch('salt.modules.debian_ip._read_temp', MagicMock(return_value=True)):
mock = MagicMock(return_value=1)
with patch.dict(debian_ip.__grains__, {'osrelease': mock}):
self.assertTrue(debian_ip.build_bond('bond0', test='True'))
|
'Test if it builds an interface script for a network interface.'
| def test_build_interface(self):
| with patch('salt.modules.debian_ip._write_file_ifaces', MagicMock(return_value='salt')):
self.assertEqual(debian_ip.build_interface('eth0', 'eth', 'enabled'), ['s\n', 'a\n', 'l\n', 't\n'])
self.assertTrue(debian_ip.build_interface('eth0', 'eth', 'enabled', test='True'))
with patch.object(debian_ip, '_parse_settings_eth', MagicMock(return_value={'routes': []})):
self.assertRaises(AttributeError, debian_ip.build_interface, 'eth0', 'bridge', 'enabled')
self.assertRaises(AttributeError, debian_ip.build_interface, 'eth0', 'slave', 'enabled')
self.assertRaises(AttributeError, debian_ip.build_interface, 'eth0', 'bond', 'enabled')
self.assertTrue(debian_ip.build_interface('eth0', 'eth', 'enabled', test='True'))
|
'Test if it add route scripts for a network interface using up commands.'
| def test_build_routes(self):
| with patch('salt.modules.debian_ip._parse_routes', MagicMock(return_value={'routes': []})):
with patch('salt.modules.debian_ip._write_file_routes', MagicMock(return_value=True)):
with patch('salt.modules.debian_ip._read_file', MagicMock(return_value='salt')):
self.assertEqual(debian_ip.build_routes('eth0'), 'saltsalt')
|
'Test if it add route scripts for a network interface using up commands.'
| def test_build_routes_exception(self):
| with patch('salt.modules.debian_ip._parse_routes', MagicMock(return_value={'routes': []})):
self.assertTrue(debian_ip.build_routes('eth0', test='True'))
mock = MagicMock(side_effect=jinja2.exceptions.TemplateNotFound('err'))
with patch.object(jinja2.Environment, 'get_template', mock):
self.assertEqual(debian_ip.build_routes('eth0'), '')
|
'Test if it shutdown a network interface'
| def test_down(self):
| self.assertEqual(debian_ip.down('eth0', 'slave'), None)
mock = MagicMock(return_value='Salt')
with patch.dict(debian_ip.__salt__, {'cmd.run': mock}):
self.assertEqual(debian_ip.down('eth0', 'eth'), 'Salt')
|
'Test if it return the content of a bond script'
| def test_get_bond(self):
| self.assertEqual(debian_ip.get_bond('bond0'), '')
|
'Test if it return the contents of an interface script'
| def test_get_interface(self):
| with patch.object(debian_ip, '_parse_interfaces', MagicMock(return_value={})):
self.assertListEqual(debian_ip.get_interface('eth0'), [])
mock_ret = {'lo': {'enabled': True, 'data': {'inet': {'addrfam': 'inet', 'proto': 'loopback'}}}}
with patch.object(debian_ip, '_parse_interfaces', MagicMock(return_value=mock_ret)):
self.assertListEqual(debian_ip.get_interface('lo'), [u'auto lo\n', u'iface lo inet loopback\n', u'\n'])
mock = MagicMock(side_effect=jinja2.exceptions.TemplateNotFound('error'))
with patch.object(jinja2.Environment, 'get_template', mock):
self.assertEqual(debian_ip.get_interface('lo'), '')
|
'Test if it start up a network interface'
| def test_up(self):
| self.assertEqual(debian_ip.down('eth0', 'slave'), None)
mock = MagicMock(return_value='Salt')
with patch.dict(debian_ip.__salt__, {'cmd.run': mock}):
self.assertEqual(debian_ip.up('eth0', 'eth'), 'Salt')
|
'Test if it return the contents of the global network script.'
| def test_get_network_settings(self):
| with patch.dict(debian_ip.__grains__, {'osfullname': 'Ubuntu', 'osrelease': '14'}):
with patch('salt.modules.debian_ip._parse_hostname', MagicMock(return_value='SaltStack')):
with patch('salt.modules.debian_ip._parse_domainname', MagicMock(return_value='saltstack.com')):
mock_avai = MagicMock(return_value=True)
with patch.dict(debian_ip.__salt__, {'service.available': mock_avai, 'service.status': mock_avai}):
self.assertEqual(debian_ip.get_network_settings(), [u'NETWORKING=yes\n', u'HOSTNAME=SaltStack\n', u'DOMAIN=saltstack.com\n'])
mock = MagicMock(side_effect=jinja2.exceptions.TemplateNotFound('error'))
with patch.object(jinja2.Environment, 'get_template', mock):
self.assertEqual(debian_ip.get_network_settings(), '')
|
'Test if it return the routes for the interface'
| def test_get_routes(self):
| with patch('salt.modules.debian_ip._read_file', MagicMock(return_value='salt')):
self.assertEqual(debian_ip.get_routes('eth0'), 'saltsalt')
|
'Test if it apply global network configuration.'
| def test_apply_network_settings(self):
| mock = MagicMock(return_value=True)
with patch.dict(debian_ip.__salt__, {'network.mod_hostname': mock, 'service.stop': mock, 'service.start': mock}):
self.assertEqual(debian_ip.apply_network_settings(), True)
|
'Test if it build the global network script.'
| def test_build_network_settings(self):
| with patch('salt.modules.debian_ip._parse_network_settings', MagicMock(return_value={'networking': 'yes', 'hostname': 'Salt.saltstack.com', 'domainname': 'saltstack.com', 'search': 'test.saltstack.com'})):
with patch('salt.modules.debian_ip._write_file_network', MagicMock(return_value=True)):
with patch.dict(debian_ip.__grains__, {'osfullname': 'Ubuntu', 'osrelease': '14'}):
mock = MagicMock(return_value=True)
with patch.dict(debian_ip.__salt__, {'service.available': mock, 'service.disable': mock, 'service.enable': mock}):
self.assertEqual(debian_ip.build_network_settings(), [u'NETWORKING=yes\n', u'HOSTNAME=Salt\n', u'DOMAIN=saltstack.com\n', u'SEARCH=test.saltstack.com\n'])
mock = MagicMock(side_effect=jinja2.exceptions.TemplateNotFound('error'))
with patch.object(jinja2.Environment, 'get_template', mock):
self.assertEqual(debian_ip.build_network_settings(), '')
with patch.dict(debian_ip.__grains__, {'osfullname': 'Ubuntu', 'osrelease': '10'}):
mock = MagicMock(return_value=True)
with patch.dict(debian_ip.__salt__, {'service.available': mock, 'service.disable': mock, 'service.enable': mock}):
mock = MagicMock(side_effect=jinja2.exceptions.TemplateNotFound('error'))
with patch.object(jinja2.Environment, 'get_template', mock):
self.assertEqual(debian_ip.build_network_settings(), '')
with patch.object(debian_ip, '_read_temp', MagicMock(return_value=True)):
self.assertTrue(debian_ip.build_network_settings(test='True'))
|
'Test if it enables win_autoruns the service on the server'
| def test_list(self):
| with patch('os.listdir', MagicMock(return_value=[])):
ret = {KEY[0]: ['SALT'], KEY[1]: ['SALT'], KEY[2]: ['SALT']}
mock = MagicMock(return_value='Windows 7')
with patch.dict(win_autoruns.__grains__, {'osfullname': mock}):
mock = MagicMock(return_value='SALT')
with patch.dict(win_autoruns.__salt__, {'cmd.run': mock}):
self.assertDictEqual(win_autoruns.list_(), ret)
|
'Test if it runs arbitrary django management command'
| def test_command(self):
| mock = MagicMock(return_value=True)
with patch.dict(djangomod.__salt__, {'cmd.run': mock}):
self.assertTrue(djangomod.command('DJANGO_SETTINGS_MODULE', 'validate'))
|
'Test if it runs the Django-Admin syncdb command'
| def test_syncdb(self):
| mock = MagicMock(return_value=True)
with patch.dict(djangomod.__salt__, {'cmd.run': mock}):
self.assertTrue(djangomod.syncdb('DJANGO_SETTINGS_MODULE'))
|
'Test if it create a super user for the database.'
| def test_createsuperuser(self):
| mock = MagicMock(return_value=True)
with patch.dict(djangomod.__salt__, {'cmd.run': mock}):
self.assertTrue(djangomod.createsuperuser('DJANGO_SETTINGS_MODULE', 'SALT', '[email protected]'))
|
'Test if it loads fixture data'
| def test_loaddata(self):
| mock = MagicMock(return_value=True)
with patch.dict(djangomod.__salt__, {'cmd.run': mock}):
self.assertTrue(djangomod.loaddata('DJANGO_SETTINGS_MODULE', 'mydata'))
|
'Test if it collect static files from each of your applications
into a single location'
| def test_collectstatic(self):
| mock = MagicMock(return_value=True)
with patch.dict(djangomod.__salt__, {'cmd.run': mock}):
self.assertTrue(djangomod.collectstatic('DJANGO_SETTINGS_MODULE'))
|
'Test for Return a list of service that are enabled on boot'
| def test_get_enabled(self):
| mock_runlevel = MagicMock(return_value=1)
mock_prefix = '/etc/rc1.d/S'
mock_glob = MagicMock(return_value=[(mock_prefix + '01name')])
with patch.object(debian_service, '_get_runlevel', mock_runlevel):
with patch.object(debian_service.glob, 'glob', mock_glob):
self.assertEqual(debian_service.get_enabled()[0], 'name')
|
'Test for Return a set of services that are installed but disabled'
| def test_get_disabled(self):
| mock = MagicMock(return_value=['A'])
with patch.object(debian_service, 'get_all', mock):
mock = MagicMock(return_value=['B'])
with patch.object(debian_service, 'get_enabled', mock):
self.assertEqual(debian_service.get_disabled(), ['A'])
|
'Test for Returns ``True`` if the specified service is
available, otherwise returns
``False``.'
| def test_available(self):
| mock = MagicMock(return_value=['A'])
with patch.object(debian_service, 'get_all', mock):
self.assertFalse(debian_service.available('name'))
|
'Test for The inverse of service.available.'
| def test_missing(self):
| mock = MagicMock(return_value=['A'])
with patch.object(debian_service, 'get_all', mock):
self.assertTrue(debian_service.missing('name'))
|
'Test for Return all available boot services'
| def test_getall(self):
| mock = MagicMock(return_value='A')
with patch.object(debian_service, 'get_enabled', mock):
self.assertEqual(debian_service.get_all()[0], 'A')
|
'Test for Start the specified service'
| def test_start(self):
| mock = MagicMock(return_value=True)
with patch.object(debian_service, '_service_cmd', mock):
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.start('name'))
|
'Test for Stop the specified service'
| def test_stop(self):
| mock = MagicMock(return_value=True)
with patch.object(debian_service, '_service_cmd', mock):
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.stop('name'))
|
'Test for Restart the named service'
| def test_restart(self):
| mock = MagicMock(return_value=True)
with patch.object(debian_service, '_service_cmd', mock):
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.restart('name'))
|
'Test for Reload the named service'
| def test_reload_(self):
| mock = MagicMock(return_value=True)
with patch.object(debian_service, '_service_cmd', mock):
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.reload_('name'))
|
'Test for Force-reload the named service'
| def test_force_reload(self):
| mock = MagicMock(return_value=True)
with patch.object(debian_service, '_service_cmd', mock):
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.force_reload('name'))
|
'Test for Return the status for a service'
| def test_status(self):
| mock = MagicMock(return_value=True)
with patch.dict(debian_service.__salt__, {'status.pid': mock}):
self.assertTrue(debian_service.status('name', 1))
mock = MagicMock(return_value='A')
with patch.object(debian_service, '_service_cmd', mock):
mock = MagicMock(return_value=True)
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.status('name'))
|
'Test for Enable the named service to start at boot'
| def test_enable(self):
| mock = MagicMock(return_value='5')
with patch.object(debian_service, '_osrel', mock):
mock = MagicMock(return_value='')
with patch.object(debian_service, '_cmd_quote', mock):
mock = MagicMock(return_value=True)
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.enable('name'))
|
'Test for Disable the named service to start at boot'
| def test_disable(self):
| mock = MagicMock(return_value='5')
with patch.object(debian_service, '_osrel', mock):
mock = MagicMock(return_value=True)
with patch.dict(debian_service.__salt__, {'cmd.retcode': mock}):
self.assertFalse(debian_service.disable('name'))
|
'Test for Return True if the named service is enabled, false otherwise'
| def test_enabled(self):
| mock = MagicMock(return_value=['A'])
with patch.object(debian_service, 'get_enabled', mock):
self.assertFalse(debian_service.enabled('name'))
|
'Test for Return True if the named service is enabled, false otherwise'
| def test_disabled(self):
| mock = MagicMock(return_value=['A'])
with patch.object(debian_service, 'get_enabled', mock):
self.assertFalse(debian_service.disabled('name'))
|
'Test to create a bond script in /etc/modprobe.d with the passed
settings and load the bonding kernel module.'
| def test_build_bond(self):
| with patch.dict(rh_ip.__grains__, {'osrelease': 'osrelease'}):
with patch.object(rh_ip, '_parse_settings_bond', MagicMock()):
mock = jinja2.exceptions.TemplateNotFound('foo')
with patch.object(jinja2.Environment, 'get_template', MagicMock(side_effect=mock)):
self.assertEqual(rh_ip.build_bond('iface'), '')
with patch.dict(rh_ip.__salt__, {'kmod.load': MagicMock(return_value=None)}):
with patch.object(rh_ip, '_write_file_iface', return_value=None):
with patch.object(rh_ip, '_read_temp', return_value='A'):
self.assertEqual(rh_ip.build_bond('iface', test='A'), 'A')
with patch.object(rh_ip, '_read_file', return_value='A'):
self.assertEqual(rh_ip.build_bond('iface', test=None), 'A')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.