desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test if it update a key with a value in the minion datastore'
| def test_update(self):
| with patch('salt.modules.data.load', MagicMock(return_value={})):
with patch('salt.modules.data.dump', MagicMock(return_value=True)):
self.assertTrue(data.update('foo', 'salt'))
|
'Test if it gets a value from the minion datastore'
| def test_get(self):
| with patch('salt.modules.data.load', MagicMock(return_value={'salt': 'SALT'})):
self.assertEqual(data.get('salt'), 'SALT')
|
'Test if it gets values from the minion datastore'
| def test_get_vals(self):
| with patch('salt.modules.data.load', MagicMock(return_value={'salt': 'SALT', 'salt1': 'SALT1'})):
self.assertEqual(data.get(['salt', 'salt1']), ['SALT', 'SALT1'])
|
'Test if it check and set a value in the minion datastore'
| def test_cas_not_load(self):
| with patch('salt.modules.data.load', MagicMock(return_value={'salt': 'SALT', 'salt1': 'SALT1'})):
self.assertFalse(data.cas('salt3', 'SALT', 'SALTSTACK'))
|
'Test if it check and set a value in the minion datastore'
| def test_cas_not_equal(self):
| with patch('salt.modules.data.load', MagicMock(return_value={'salt': 'SALT', 'salt1': 'SALT1'})):
self.assertFalse(data.cas('salt', 'SALT', 'SALTSTACK'))
|
'Test if it check and set a value in the minion datastore'
| def test_cas(self):
| with patch('salt.modules.data.load', MagicMock(return_value={'salt': 'SALT', 'salt1': 'SALT1'})):
with patch('salt.modules.data.dump', MagicMock(return_value=True)):
self.assertTrue(data.cas('salt', 'SALTSTACK', 'SALT'))
|
'Tests the return of the list of taps'
| def test_list_taps(self):
| mock_taps = MagicMock(return_value={'stdout': TAPS_STRING, 'retcode': 0})
mock_user = MagicMock(return_value='foo')
mock_cmd = MagicMock(return_value='')
with patch.dict(mac_brew.__salt__, {'file.get_user': mock_user, 'cmd.run_all': mock_taps, 'cmd.run': mock_cmd}):
self.assertEqual(mac_brew._list_taps(), TAPS_LIST)
|
'Tests if tap argument is already installed or not'
| def test_tap_installed(self):
| with patch('salt.modules.mac_brew._list_taps', MagicMock(return_value=TAPS_LIST)):
self.assertTrue(mac_brew._tap('homebrew/science'))
|
'Tests if the tap installation failed'
| def test_tap_failure(self):
| mock_failure = MagicMock(return_value={'stdout': '', 'stderr': '', 'retcode': 1})
mock_user = MagicMock(return_value='foo')
mock_cmd = MagicMock(return_value='')
with patch.dict(mac_brew.__salt__, {'cmd.run_all': mock_failure, 'file.get_user': mock_user, 'cmd.run': mock_cmd}):
with patch('salt.modules.mac_brew._list_taps', MagicMock(return_value={})):
self.assertFalse(mac_brew._tap('homebrew/test'))
|
'Tests adding unofficial GitHub repos to the list of brew taps'
| def test_tap(self):
| mock_failure = MagicMock(return_value={'retcode': 0})
mock_user = MagicMock(return_value='foo')
mock_cmd = MagicMock(return_value='')
with patch.dict(mac_brew.__salt__, {'cmd.run_all': mock_failure, 'file.get_user': mock_user, 'cmd.run': mock_cmd}):
with patch('salt.modules.mac_brew._list_taps', MagicMock(return_value=TAPS_LIST)):
self.assertTrue(mac_brew._tap('homebrew/test'))
|
'Tests the path to the homebrew binary'
| def test_homebrew_bin(self):
| mock_path = MagicMock(return_value='/usr/local')
with patch.dict(mac_brew.__salt__, {'cmd.run': mock_path}):
self.assertEqual(mac_brew._homebrew_bin(), '/usr/local/bin/brew')
|
'Tests removed implementation'
| def test_list_pkgs_removed(self):
| self.assertEqual(mac_brew.list_pkgs(removed=True), {})
|
'Tests if pkg.list_pkgs is already in context and is a list'
| def test_list_pkgs_versions_true(self):
| mock_context = {'foo': ['bar']}
with patch.dict(mac_brew.__context__, {'pkg.list_pkgs': mock_context}):
self.assertEqual(mac_brew.list_pkgs(versions_as_list=True), mock_context)
|
'Tests version name returned'
| def test_version(self):
| mock_version = MagicMock(return_value='0.1.5')
with patch.dict(mac_brew.__salt__, {'pkg_resource.version': mock_version}):
self.assertEqual(mac_brew.version('foo'), '0.1.5')
|
'Tests if package to be removed exists'
| def test_remove(self):
| mock_params = MagicMock(return_value=({'foo': None}, 'repository'))
with patch('salt.modules.mac_brew.list_pkgs', return_value={'test': '0.1.5'}):
with patch.dict(mac_brew.__salt__, {'pkg_resource.parse_targets': mock_params}):
self.assertEqual(mac_brew.remove('foo'), {})
|
'Tests an update of homebrew package repository failure'
| def test_refresh_db_failure(self):
| mock_user = MagicMock(return_value='foo')
mock_failure = MagicMock(return_value={'stdout': '', 'stderr': '', 'retcode': 1})
with patch.dict(mac_brew.__salt__, {'file.get_user': mock_user, 'cmd.run_all': mock_failure}):
with patch('salt.modules.mac_brew._homebrew_bin', MagicMock(return_value=HOMEBREW_BIN)):
with patch.object(salt.utils.pkg, 'clear_rtag', Mock()):
self.assertRaises(CommandExecutionError, mac_brew.refresh_db)
|
'Tests a successful update of homebrew package repository'
| def test_refresh_db(self):
| mock_user = MagicMock(return_value='foo')
mock_success = MagicMock(return_value={'retcode': 0})
with patch.dict(mac_brew.__salt__, {'file.get_user': mock_user, 'cmd.run_all': mock_success}):
with patch('salt.modules.mac_brew._homebrew_bin', MagicMock(return_value=HOMEBREW_BIN)):
with patch.object(salt.utils.pkg, 'clear_rtag', Mock()):
self.assertTrue(mac_brew.refresh_db())
|
'Tests if package to be installed exists'
| def test_install(self):
| mock_params = MagicMock(return_value=[None, None])
with patch.dict(mac_brew.__salt__, {'pkg_resource.parse_targets': mock_params}):
self.assertEqual(mac_brew.install('name=foo'), {})
|
'Test if it returns the version of locate'
| def test_version(self):
| mock = MagicMock(return_value='mlocate 0.26')
with patch.dict(locate.__salt__, {'cmd.run': mock}):
self.assertListEqual(locate.version(), ['mlocate 0.26'])
|
'Test if it returns statistics about the locate database'
| def test_stats(self):
| ret = {'files': '75,253', 'directories': '49,252', 'bytes in file names': '93,214', 'bytes used to store database': '29,165', 'database': '/var/lib/mlocate/mlocate.db'}
mock_ret = 'Database /var/lib/mlocate/mlocate.db:\n 49,252 directories \n 75,253 files \n 93,214 bytes in file names \n 29,165 bytes used to store database'
with patch.dict(locate.__salt__, {'cmd.run': MagicMock(return_value=mock_ret)}):
self.assertDictEqual(locate.stats(), ret)
|
'Test if it updates the locate database'
| def test_updatedb(self):
| mock = MagicMock(return_value='')
with patch.dict(locate.__salt__, {'cmd.run': mock}):
self.assertListEqual(locate.updatedb(), [])
|
'Test if it performs a file lookup.'
| def test_locate(self):
| mock = MagicMock(return_value='')
with patch.dict(locate.__salt__, {'cmd.run': mock}):
self.assertListEqual(locate.locate('wholename', database='myfile'), [])
|
'Test if the %u, %h, and %% tokens are correctly expanded'
| def test_expand_user_token(self):
| output = ssh._expand_authorized_keys_path('/home/%u', 'user', '/home/user')
self.assertEqual(output, '/home/user')
output = ssh._expand_authorized_keys_path('/home/%h', 'user', '/home/user')
self.assertEqual(output, '/home//home/user')
output = ssh._expand_authorized_keys_path('%h/foo', 'user', '/home/user')
self.assertEqual(output, '/home/user/foo')
output = ssh._expand_authorized_keys_path('/srv/%h/aaa/%u%%', 'user', '/home/user')
self.assertEqual(output, '/srv//home/user/aaa/user%')
user = 'dude'
home = '/home/dude'
path = '/home/dude%'
self.assertRaises(CommandExecutionError, ssh._expand_authorized_keys_path, path, user, home)
path = '/home/%dude'
self.assertRaises(CommandExecutionError, ssh._expand_authorized_keys_path, path, user, home)
|
'Test the _replace_auth_key with some different authorized_keys examples'
| def test_replace_auth_key(self):
| enc = 'ssh-rsa'
key = 'AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ=='
options = 'command="/usr/local/lib/ssh-helper"'
email = 'github.com'
empty_line = '\n'
comment_line = '# this is a comment \n'
if salt.utils.platform.is_windows():
temp_file = tempfile.NamedTemporaryFile(delete=False)
else:
temp_file = tempfile.NamedTemporaryFile(delete=False, mode='w+')
temp_file.write(comment_line)
temp_file.write(empty_line)
temp_file.write('{0} {1} {2} {3}'.format(options, enc, key, email))
temp_file.close()
with patch.dict(ssh.__salt__, {'user.info': MagicMock(return_value={})}):
with patch('salt.modules.ssh._get_config_file', MagicMock(return_value=temp_file.name)):
ssh._replace_auth_key('foo', key, config=temp_file.name)
with salt.utils.files.fopen(temp_file.name) as _fh:
file_txt = _fh.read()
self.assertIn(enc, file_txt)
self.assertIn(key, file_txt)
self.assertNotIn(options, file_txt)
self.assertNotIn(email, file_txt)
enc = 'ecdsa-sha2-nistp256'
key = 'abcxyz'
with salt.utils.files.fopen(temp_file.name, 'a') as _fh:
_fh.write('{0} {1}'.format(enc, key))
options = ['no-port-forwarding', 'no-agent-forwarding', 'no-X11-forwarding', 'command="echo \'Please login as the user "ubuntu" rather than the user "root".\'']
email = '[email protected]'
with patch.dict(ssh.__salt__, {'user.info': MagicMock(return_value={})}):
with patch('salt.modules.ssh._get_config_file', MagicMock(return_value=temp_file.name)):
ssh._replace_auth_key('foo', key, enc=enc, comment=email, options=options, config=temp_file.name)
with salt.utils.files.fopen(temp_file.name) as _fh:
file_txt = _fh.read()
self.assertIn(enc, file_txt)
self.assertIn(key, file_txt)
self.assertIn('{0} '.format(','.join(options)), file_txt)
self.assertIn(email, file_txt)
self.assertIn(empty_line, file_txt)
self.assertIn(comment_line, file_txt)
|
'Return value for [].'
| @staticmethod
def _m_lst():
| return MagicMock(return_value=[])
|
'Return value for RET.'
| @staticmethod
def _m_ret():
| return MagicMock(return_value=RET)
|
'Return Bool value.'
| @staticmethod
def _m_bool(bol=True):
| return MagicMock(return_value=bol)
|
'test _chkconfig_is_enabled function'
| def test__chkconfig_is_enabled(self):
| name = 'atd'
chkconfig_out = textwrap.dedent('\n {0} 0:off 1:off 2:off 3:on 4:on 5:on 6:off\n '.format(name))
xinetd_out = textwrap.dedent(' xinetd based services:\n {0} on\n '.format(name))
with patch.object(rh_service, '_runlevel', MagicMock(return_value=3)):
mock_run = MagicMock(return_value={'retcode': 0, 'stdout': chkconfig_out})
with patch.dict(rh_service.__salt__, {'cmd.run_all': mock_run}):
self.assertTrue(rh_service._chkconfig_is_enabled(name))
self.assertFalse(rh_service._chkconfig_is_enabled(name, 2))
self.assertTrue(rh_service._chkconfig_is_enabled(name, 3))
mock_run = MagicMock(return_value={'retcode': 0, 'stdout': xinetd_out})
with patch.dict(rh_service.__salt__, {'cmd.run_all': mock_run}):
self.assertTrue(rh_service._chkconfig_is_enabled(name))
self.assertTrue(rh_service._chkconfig_is_enabled(name, 2))
self.assertTrue(rh_service._chkconfig_is_enabled(name, 3))
|
'Test if it return the enabled services. Use the ``limit``
param to restrict results to services of that type.'
| def test_get_enabled(self):
| with patch.object(rh_service, '_upstart_services', self._m_ret()):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=False)):
self.assertListEqual(rh_service.get_enabled('upstart'), [])
mock_run = MagicMock(return_value='salt stack')
with patch.dict(rh_service.__salt__, {'cmd.run': mock_run}):
with patch.object(rh_service, '_sysv_services', self._m_ret()):
with patch.object(rh_service, '_sysv_is_enabled', self._m_bool()):
self.assertListEqual(rh_service.get_enabled('sysvinit'), RET)
with patch.object(rh_service, '_upstart_services', self._m_lst()):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=True)):
self.assertListEqual(rh_service.get_enabled(), RET)
|
'Test if it return the disabled services. Use the ``limit``
param to restrict results to services of that type.'
| def test_get_disabled(self):
| with patch.object(rh_service, '_upstart_services', self._m_ret()):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=False)):
self.assertListEqual(rh_service.get_disabled('upstart'), RET)
mock_run = MagicMock(return_value='salt stack')
with patch.dict(rh_service.__salt__, {'cmd.run': mock_run}):
with patch.object(rh_service, '_sysv_services', self._m_ret()):
with patch.object(rh_service, '_sysv_is_enabled', self._m_bool(False)):
self.assertListEqual(rh_service.get_disabled('sysvinit'), RET)
with patch.object(rh_service, '_upstart_services', self._m_lst()):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=False)):
self.assertListEqual(rh_service.get_disabled(), RET)
|
'Test if it return all installed services. Use the ``limit``
param to restrict results to services of that type.'
| def test_get_all(self):
| with patch.object(rh_service, '_upstart_services', self._m_ret()):
self.assertListEqual(rh_service.get_all('upstart'), RET)
with patch.object(rh_service, '_sysv_services', self._m_ret()):
self.assertListEqual(rh_service.get_all('sysvinit'), RET)
with patch.object(rh_service, '_upstart_services', self._m_lst()):
self.assertListEqual(rh_service.get_all(), RET)
|
'Test if it return True if the named service is available.'
| def test_available(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
self.assertTrue(rh_service.available('salt-api', 'upstart'))
with patch.object(rh_service, '_service_is_sysv', self._m_bool()):
self.assertTrue(rh_service.available('salt-api', 'sysvinit'))
with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
self.assertTrue(rh_service.available('salt-api'))
|
'Test if it return True if the named service is not available.'
| def test_missing(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool(False)):
self.assertTrue(rh_service.missing('sshd', 'upstart'))
with patch.object(rh_service, '_service_is_sysv', self._m_bool(False)):
self.assertTrue(rh_service.missing('sshd'))
with patch.object(rh_service, '_service_is_sysv', self._m_bool()):
self.assertFalse(rh_service.missing('sshd', 'sysvinit'))
with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
self.assertFalse(rh_service.missing('sshd'))
|
'Test if it start the specified service.'
| def test_start(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
with patch.dict(rh_service.__salt__, {'cmd.retcode': self._m_bool(False)}):
self.assertTrue(rh_service.start('salt-api'))
|
'Test if it stop the specified service.'
| def test_stop(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
with patch.dict(rh_service.__salt__, {'cmd.retcode': self._m_bool(False)}):
self.assertTrue(rh_service.stop('salt-api'))
|
'Test if it restart the specified service.'
| def test_restart(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
with patch.dict(rh_service.__salt__, {'cmd.retcode': self._m_bool(False)}):
self.assertTrue(rh_service.restart('salt-api'))
|
'Test if it reload the specified service.'
| def test_reload(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
with patch.dict(rh_service.__salt__, {'cmd.retcode': self._m_bool(False)}):
self.assertTrue(rh_service.reload_('salt-api'))
|
'Test if it return the status for a service,
returns a bool whether the service is running.'
| def test_status(self):
| with patch.object(rh_service, '_service_is_upstart', self._m_bool()):
mock_run = MagicMock(return_value='start/running')
with patch.dict(rh_service.__salt__, {'cmd.run': mock_run}):
self.assertTrue(rh_service.status('salt-api'))
with patch.object(rh_service, '_service_is_upstart', self._m_bool(False)):
with patch.dict(rh_service.__salt__, {'status.pid': self._m_bool()}):
self.assertTrue(rh_service.status('salt-api', sig=True))
mock_ret = MagicMock(return_value=0)
with patch.dict(rh_service.__salt__, {'cmd.retcode': mock_ret}):
self.assertTrue(rh_service.status('salt-api'))
|
'Test if it enable the named service to start at boot.'
| def test_enable(self):
| mock_bool = MagicMock(side_effect=[True, True, False])
with patch.object(rh_service, '_service_is_upstart', mock_bool):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=True)):
with patch.object(rh_service, '_upstart_enable', MagicMock(return_value=False)):
self.assertFalse(rh_service.enable('salt-api'))
with patch.object(rh_service, '_upstart_enable', MagicMock(return_value=True)):
self.assertTrue(rh_service.enable('salt-api'))
with patch.object(rh_service, '_sysv_enable', self._m_bool()):
self.assertTrue(rh_service.enable('salt-api'))
|
'Test if it disable the named service to start at boot.'
| def test_disable(self):
| mock_bool = MagicMock(side_effect=[True, True, False])
with patch.object(rh_service, '_service_is_upstart', mock_bool):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=True)):
with patch.object(rh_service, '_upstart_disable', MagicMock(return_value=False)):
self.assertFalse(rh_service.disable('salt-api'))
with patch.object(rh_service, '_upstart_disable', MagicMock(return_value=True)):
self.assertTrue(rh_service.disable('salt-api'))
with patch.object(rh_service, '_sysv_disable', self._m_bool()):
self.assertTrue(rh_service.disable('salt-api'))
|
'Test if it check to see if the named service is enabled
to start on boot.'
| def test_enabled(self):
| mock_bool = MagicMock(side_effect=[True, False])
with patch.object(rh_service, '_service_is_upstart', mock_bool):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=False)):
self.assertFalse(rh_service.enabled('salt-api'))
with patch.object(rh_service, '_sysv_is_enabled', self._m_bool()):
self.assertTrue(rh_service.enabled('salt-api'))
|
'Test if it check to see if the named service is disabled
to start on boot.'
| def test_disabled(self):
| mock_bool = MagicMock(side_effect=[True, False])
with patch.object(rh_service, '_service_is_upstart', mock_bool):
with patch.object(rh_service, '_upstart_is_enabled', MagicMock(return_value=False)):
self.assertTrue(rh_service.disabled('salt-api'))
with patch.object(rh_service, '_sysv_is_enabled', self._m_bool(False)):
self.assertTrue(rh_service.disabled('salt-api'))
|
'Test if it return a list of users based off of rabbitmqctl user_list.'
| def test_list_users_rabbitmq2(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing users ...\nguest DCTB [administrator, user]\njustAnAdmin DCTB [administrator]\n', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_users(), {'guest': ['administrator', 'user'], 'justAnAdmin': ['administrator']})
|
'Test if it return a list of users based off of rabbitmqctl user_list.'
| def test_list_users_rabbitmq3(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'guest DCTB [administrator user]\r\nother DCTB [a b]\r\n', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_users(), {'guest': ['administrator', 'user'], 'other': ['a', 'b']})
|
'Test if having a leading WARNING returns the user_list anyway.'
| def test_list_users_with_warning_rabbitmq2(self):
| rtn_stdout = '\n'.join(['WARNING: ignoring /etc/rabbitmq/rabbitmq.conf -- location has moved to /etc/rabbitmq/rabbitmq-env.conf', 'Listing users ...', 'guest DCTB [administrator, user]\n'])
mock_run = MagicMock(return_value={'retcode': 0, 'stdout': rtn_stdout, 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_users(), {'guest': ['administrator', 'user']})
|
'Test if having a leading WARNING returns the user_list anyway.'
| def test_list_users_with_warning_rabbitmq3(self):
| rtn_stdout = '\n'.join(['WARNING: ignoring /etc/rabbitmq/rabbitmq.conf -- location has moved to /etc/rabbitmq/rabbitmq-env.conf', 'Listing users ...', 'guest DCTB [administrator user]\n'])
mock_run = MagicMock(return_value={'retcode': 0, 'stdout': rtn_stdout, 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_users(), {'guest': ['administrator', 'user']})
|
'Test if it return a list of vhost based on rabbitmqctl list_vhosts.'
| def test_list_vhosts(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': '/\nsaltstack\n...', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertListEqual(rabbitmq.list_vhosts(), ['/', 'saltstack', '...'])
|
'Test if it return a list of vhost based on rabbitmqctl list_vhosts even with a leading WARNING.'
| def test_list_vhosts_with_warning(self):
| rtn_stdout = '\n'.join(['WARNING: ignoring /etc/rabbitmq/rabbitmq.conf -- location has moved to /etc/rabbitmq/rabbitmq-env.conf', 'Listing users ...', '/', 'saltstack', '...\n'])
mock_run = MagicMock(return_value={'retcode': 0, 'stdout': rtn_stdout, 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertListEqual(rabbitmq.list_vhosts(), ['/', 'saltstack', '...'])
|
'Test whether a given rabbitmq-internal user exists based
on rabbitmqctl list_users.'
| def test_user_exists(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing users ...\nsaltstack DCTB [administrator]\n...done', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertTrue(rabbitmq.user_exists('saltstack'))
|
'Negative test of whether rabbitmq-internal user exists based
on rabbitmqctl list_users.'
| def test_user_exists_negative(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing users ...\nsaltstack DCTB [administrator]\n...done', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertFalse(rabbitmq.user_exists('salt'))
|
'Test if it return whether the vhost exists based
on rabbitmqctl list_vhosts.'
| def test_vhost_exists(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing vhosts ...\nsaltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertTrue(rabbitmq.vhost_exists('saltstack'))
|
'Test if it return whether the vhost exists based
on rabbitmqctl list_vhosts.'
| def test_vhost_exists_negative(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing vhosts ...\nsaltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertFalse(rabbitmq.vhost_exists('salt'))
|
'Test if it add a rabbitMQ user via rabbitmqctl
user_add <user> <password>'
| def test_add_user(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.add_user('saltstack'), {'Added': 'saltstack'})
mock_run = MagicMock(return_value='Error')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
with patch.object(rabbitmq, 'clear_password', return_value={'Error': 'Error', 'retcode': 1}):
self.assertRaises(CommandExecutionError, rabbitmq.add_user, 'saltstack')
|
'Test if it deletes a user via rabbitmqctl delete_user.'
| def test_delete_user(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.delete_user('saltstack'), {'Deleted': 'saltstack'})
|
'Test if it changes a user\'s password.'
| def test_change_password(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.change_password('saltstack', 'salt@123'), {'Password Changed': 'saltstack'})
|
'Test if it removes a user\'s password.'
| def test_clear_password(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.clear_password('saltstack'), {'Password Cleared': 'saltstack'})
|
'Test if it adds a vhost via rabbitmqctl add_vhost.'
| def test_add_vhost(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.add_vhost('saltstack'), {'Added': 'saltstack'})
|
'Test if it deletes a vhost rabbitmqctl delete_vhost.'
| def test_delete_vhost(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.delete_vhost('saltstack'), {'Deleted': 'saltstack'})
|
'Test if it sets permissions for vhost via rabbitmqctl set_permissions.'
| def test_set_permissions(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.set_permissions('myvhost', 'myuser'), {'Permissions Set': 'saltstack'})
|
'Test if it lists permissions for a vhost
via rabbitmqctl list_permissions.'
| def test_list_permissions(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing stuff ...\nsaltstack DCTB saltstack DCTB .* DCTB 1\nguest DCTB 0 DCTB one\n...done', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_user_permissions('myuser'), {'saltstack': ['saltstack', '.*', '1'], 'guest': ['0', 'one']})
|
'Test if it list permissions for a user
via rabbitmqctl list_user_permissions.'
| def test_list_user_permissions(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'Listing stuff ...\nsaltstack DCTB saltstack DCTB 0 DCTB 1\nguest DCTB 0 DCTB one\n...done', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_user_permissions('myuser'), {'saltstack': ['saltstack', '0', '1'], 'guest': ['0', 'one']})
|
'Test if it add user tags via rabbitmqctl set_user_tags.'
| def test_set_user_tags(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.set_user_tags('myadmin', 'admin'), {'Tag(s) set': 'saltstack'})
|
'Test if it return rabbitmq status.'
| def test_status(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertEqual(rabbitmq.status(), 'saltstack')
|
'Test if it return rabbitmq cluster_status.'
| def test_cluster_status(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertEqual(rabbitmq.cluster_status(), 'saltstack')
|
'Test if it join a rabbit cluster.'
| def test_join_cluster(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.join_cluster('rabbit.example.com'), {'Join': 'saltstack'})
|
'Test if it stops the RabbitMQ application,
leaving the Erlang node running.'
| def test_stop_app(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertEqual(rabbitmq.stop_app(), 'saltstack')
|
'Test if it start the RabbitMQ application.'
| def test_start_app(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertEqual(rabbitmq.start_app(), 'saltstack')
|
'Test if it return a RabbitMQ node to its virgin state'
| def test_reset(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertEqual(rabbitmq.reset(), 'saltstack')
|
'Test if it forcefully Return a RabbitMQ node to its virgin state'
| def test_force_reset(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertEqual(rabbitmq.force_reset(), 'saltstack')
|
'Test if it returns queue details of the / virtual host'
| def test_list_queues(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack DCTB 0\nceleryev.234-234 DCTB 10', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_queues(), {'saltstack': ['0'], 'celeryev.234-234': ['10']})
|
'Test if it returns queue details of specified virtual host.'
| def test_list_queues_vhost(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack DCTB 0\nceleryev.234-234 DCTB 10', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_queues_vhost('consumers'), {'saltstack': ['0'], 'celeryev.234-234': ['10']})
|
'Test if it return a dictionary of policies nested by vhost
and name based on the data returned from rabbitmqctl list_policies.'
| def test_list_policies(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.list_policies(), {})
|
'Test if it set a policy based on rabbitmqctl set_policy.'
| def test_set_policy(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.set_policy('/', 'HA', '.*', '{"ha-mode": "all"}'), {'Set': 'saltstack'})
|
'Test if it delete a policy based on rabbitmqctl clear_policy.'
| def test_delete_policy(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertDictEqual(rabbitmq.delete_policy('/', 'HA'), {'Deleted': 'saltstack'})
|
'Test if it return whether the policy exists
based on rabbitmqctl list_policies.'
| def test_policy_exists(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run}):
self.assertFalse(rabbitmq.policy_exists('/', 'HA'))
|
'Test if it returns a list of plugins.'
| def test_list_available_plugins(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack\nsalt\nother', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertListEqual(rabbitmq.list_available_plugins(), ['saltstack', 'salt', 'other'])
|
'Test if it returns a list of plugins.'
| def test_list_available_plugins_space_delimited(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack salt other', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertListEqual(rabbitmq.list_available_plugins(), ['saltstack', 'salt', 'other'])
|
'Test if it returns a list of plugins.'
| def test_list_enabled_plugins(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack\nsalt\nother', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertListEqual(rabbitmq.list_enabled_plugins(), ['saltstack', 'salt', 'other'])
|
'Test if it returns a list of plugins.'
| def test_list_enabled_plugins_space_delimited(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack salt other', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertListEqual(rabbitmq.list_enabled_plugins(), ['saltstack', 'salt', 'other'])
|
'Test if it returns true for an enabled plugin.'
| def test_plugin_is_enabled(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack\nsalt\nother', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertTrue(rabbitmq.plugin_is_enabled('saltstack'))
self.assertTrue(rabbitmq.plugin_is_enabled('salt'))
self.assertTrue(rabbitmq.plugin_is_enabled('other'))
|
'Test if it returns false for a disabled plugin.'
| def test_plugin_is_enabled_negative(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack\nother', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertFalse(rabbitmq.plugin_is_enabled('salt'))
self.assertFalse(rabbitmq.plugin_is_enabled('stack'))
self.assertFalse(rabbitmq.plugin_is_enabled('random'))
|
'Test if it enable a RabbitMQ plugin via the rabbitmq-plugins command.'
| def test_enable_plugin(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertDictEqual(rabbitmq.enable_plugin('salt'), {'Enabled': 'saltstack'})
|
'Test if it disable a RabbitMQ plugin via the rabbitmq-plugins command.'
| def test_disable_plugin(self):
| mock_run = MagicMock(return_value={'retcode': 0, 'stdout': 'saltstack', 'stderr': ''})
mock_pkg = MagicMock(return_value='')
with patch.dict(rabbitmq.__salt__, {'cmd.run_all': mock_run, 'pkg.version': mock_pkg}):
self.assertDictEqual(rabbitmq.disable_plugin('salt'), {'Disabled': 'saltstack'})
|
'Test for Returns the long hash of a given identifier'
| def test_revision(self):
| mock = MagicMock(side_effect=[{'retcode': 0, 'stdout': 'A'}, {'retcode': 1, 'stdout': 'A'}])
with patch.dict(hg.__salt__, {'cmd.run_all': mock}):
self.assertEqual(hg.revision('cwd'), 'A')
self.assertEqual(hg.revision('cwd'), '')
|
'Test for Mimic git describe.'
| def test_describe(self):
| with patch.dict(hg.__salt__, {'cmd.run_stdout': MagicMock(return_value='A')}):
with patch.object(hg, 'revision', return_value=False):
self.assertEqual(hg.describe('cwd'), 'A')
|
'Test for Export a tarball from the repository'
| def test_archive(self):
| with patch.dict(hg.__salt__, {'cmd.run': MagicMock(return_value='A')}):
self.assertEqual(hg.archive('cwd', 'output'), 'A')
|
'Test for Perform a pull on the given repository'
| def test_pull(self):
| with patch.dict(hg.__salt__, {'cmd.run_all': MagicMock(return_value={'retcode': 0, 'stdout': 'A'})}):
self.assertEqual(hg.pull('cwd'), 'A')
|
'Test for Update to a given revision'
| def test_update(self):
| with patch.dict(hg.__salt__, {'cmd.run_all': MagicMock(return_value={'retcode': 0, 'stdout': 'A'})}):
self.assertEqual(hg.update('cwd', 'rev'), 'A')
|
'Test for Clone a new repository'
| def test_clone(self):
| with patch.dict(hg.__salt__, {'cmd.run_all': MagicMock(return_value={'retcode': 0, 'stdout': 'A'})}):
self.assertEqual(hg.clone('cwd', 'repository'), 'A')
|
'Test for Status to a given repository'
| def test_status_single(self):
| with patch.dict(hg.__salt__, {'cmd.run_stdout': MagicMock(return_value='A added 0\nA added 1\nM modified')}):
self.assertEqual(hg.status('cwd'), {'added': ['added 0', 'added 1'], 'modified': ['modified']})
|
'Test for Status to a given repository (cwd is list)'
| def test_status_multiple(self):
| with patch.dict(hg.__salt__, {'cmd.run_stdout': MagicMock(side_effect=(lambda *args, **kwargs: {'dir 0': 'A file 0\n', 'dir 1': 'M file 1'}[kwargs['cwd']]))}):
self.assertEqual(hg.status(['dir 0', 'dir 1']), {'dir 0': {'added': ['file 0']}, 'dir 1': {'modified': ['file 1']}})
|
'Test for create a blank virtual machine image file
of the specified size in megabytes'
| def test_make_image(self):
| with patch.object(os.path, 'isabs', MagicMock(side_effect=[False, True, True, True])):
self.assertEqual(qemu_img.make_image('location', 'size', 'fmt'), '')
with patch.object(os.path, 'isdir', MagicMock(side_effect=[False, True, True])):
self.assertEqual(qemu_img.make_image('location', 'size', 'fmt'), '')
with patch.dict(qemu_img.__salt__, {'cmd.retcode': MagicMock(side_effect=[False, True])}):
self.assertEqual(qemu_img.make_image('location', 'size', 'fmt'), 'location')
self.assertEqual(qemu_img.make_image('location', 'size', 'fmt'), '')
|
'Mock create method'
| def create(self, body, to, from_):
| msg = MockMessages()
if (self.flag == 1):
raise MockTwilioRestException()
msg.body = body
msg.to = to
msg.from_ = from_
return msg
|
'Test if it send an sms.'
| def test_send_sms(self):
| mock = MagicMock(return_value=MockTwilioRestClient())
with patch.object(twilio_notify, '_get_twilio', mock):
self.assertDictEqual(twilio_notify.send_sms('twilio-account', 'SALTSTACK', '+18019999999', '+18011111111'), {'message': {'status': 'Sent', 'num_segments': '2', 'price': '200', 'body': 'SALTSTACK', 'sid': '011', 'date_sent': '01-01-2015', 'date_created': '01-01-2015', 'price_unit': '1'}})
MockMessages.flag = 1
self.assertDictEqual(twilio_notify.send_sms('twilio-account', 'SALTSTACK', '+18019999999', '+18011111111'), {'message': {'sid': None}, '_error': {'msg': 'Exception error', 'status': 'Not send', 'code': 'error code'}})
|
'Test to accepts list of dicts (or a string representing a
list of dicts) and packs the key/value pairs into a single dict.'
| def test_pack_sources(self):
| with patch.object(yaml, 'safe_load', MagicMock(side_effect=yaml.parser.ParserError('f'))):
with patch.dict(pkg_resource.__salt__, {'pkg.normalize_name': MagicMock()}):
self.assertDictEqual(pkg_resource.pack_sources('sources'), {})
self.assertDictEqual(pkg_resource.pack_sources(['A', 'a']), {})
self.assertTrue(pkg_resource.pack_sources([{'A': 'a'}]))
|
'Test to parses the input to pkg.install and
returns back the package(s) to be installed. Returns a
list of packages, as well as a string noting whether the
packages are to come from a repository or a binary package.'
| def test_parse_targets(self):
| with patch.dict(pkg_resource.__grains__, {'os': 'A'}):
self.assertEqual(pkg_resource.parse_targets(pkgs='a', sources='a'), (None, None))
with patch.object(pkg_resource, '_repack_pkgs', return_value=False):
self.assertEqual(pkg_resource.parse_targets(pkgs='a'), (None, None))
with patch.object(pkg_resource, '_repack_pkgs', return_value='A'):
self.assertEqual(pkg_resource.parse_targets(pkgs='a'), ('A', 'repository'))
with patch.dict(pkg_resource.__grains__, {'os': 'MacOS1'}):
with patch.object(pkg_resource, 'pack_sources', return_value=False):
self.assertEqual(pkg_resource.parse_targets(sources='s'), (None, None))
with patch.object(pkg_resource, 'pack_sources', return_value={'A': '/a'}):
with patch.dict(pkg_resource.__salt__, {'config.valid_fileproto': MagicMock(return_value=False)}):
self.assertEqual(pkg_resource.parse_targets(sources='s'), (['/a'], 'file'))
with patch.object(pkg_resource, 'pack_sources', return_value={'A': 'a'}):
with patch.dict(pkg_resource.__salt__, {'config.valid_fileproto': MagicMock(return_value=False)}):
self.assertEqual(pkg_resource.parse_targets(name='n'), ({'n': None}, 'repository'))
self.assertEqual(pkg_resource.parse_targets(), (None, None))
|
'Test to Common interface for obtaining the version
of installed packages.'
| def test_version(self):
| with patch.object(salt.utils, 'is_true', return_value=True):
mock = MagicMock(return_value={'A': 'B'})
with patch.dict(pkg_resource.__salt__, {'pkg.list_pkgs': mock}):
self.assertEqual(pkg_resource.version('A'), 'B')
self.assertDictEqual(pkg_resource.version(), {})
mock = MagicMock(return_value={})
with patch.dict(pkg_resource.__salt__, {'pkg.list_pkgs': mock}):
with patch(('builtins.next' if six.PY3 else '__builtin__.next')) as mock_next:
mock_next.side_effect = StopIteration()
self.assertEqual(pkg_resource.version('A'), '')
|
'Test to add a package to a dict of installed packages.'
| def test_add_pkg(self):
| self.assertIsNone(pkg_resource.add_pkg({'pkgs': []}, 'name', 'version'))
|
'Test to accepts a dict obtained from pkg.list_pkgs() and sorts
in place the list of versions for any packages that have multiple
versions installed, so that two package lists can be compared
to one another.'
| def test_sort_pkglist(self):
| self.assertIsNone(pkg_resource.sort_pkglist({}))
|
'Test to takes a dict of package name/version information
and joins each list of
installed versions into a string.'
| def test_stringify(self):
| self.assertIsNone(pkg_resource.stringify({}))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.