desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test to build an interface script for a network interface.'
| def test_build_interface(self):
| with patch.dict(rh_ip.__grains__, {'os': 'Fedora'}):
with patch.object(rh_ip, '_raise_error_iface', return_value=None):
self.assertRaises(AttributeError, rh_ip.build_interface, 'iface', 'slave', True)
with patch.dict(rh_ip.__salt__, {'network.interfaces': (lambda : {'eth': True})}):
self.assertRaises(AttributeError, rh_ip.build_interface, 'iface', 'eth', True, netmask='255.255.255.255', prefix=32, test=True)
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_interface('iface', 'vlan', True), '')
with patch.object(rh_ip, '_read_temp', return_value='A'):
with patch.object(jinja2.Environment, 'get_template', MagicMock()):
self.assertEqual(rh_ip.build_interface('iface', 'vlan', True, test='A'), 'A')
with patch.object(rh_ip, '_write_file_iface', return_value=None):
with patch.object(os.path, 'join', return_value='A'):
with patch.object(rh_ip, '_read_file', return_value='A'):
self.assertEqual(rh_ip.build_interface('iface', 'vlan', True), 'A')
|
'Test to build a route script for a network interface.'
| def test_build_routes(self):
| with patch.dict(rh_ip.__grains__, {'osrelease': '5.0'}):
with patch.object(rh_ip, '_parse_routes', MagicMock()):
mock = jinja2.exceptions.TemplateNotFound('foo')
with patch.object(jinja2.Environment, 'get_template', MagicMock(side_effect=mock)):
self.assertEqual(rh_ip.build_routes('iface'), '')
with patch.object(jinja2.Environment, 'get_template', MagicMock()):
with patch.object(rh_ip, '_read_temp', return_value=['A']):
self.assertEqual(rh_ip.build_routes('i', test='t'), ['A', 'A'])
with patch.object(rh_ip, '_read_file', return_value=['A']):
with patch.object(os.path, 'join', return_value='A'):
with patch.object(rh_ip, '_write_file_iface', return_value=None):
self.assertEqual(rh_ip.build_routes('i', test=None), ['A', 'A'])
|
'Test to shutdown a network interface'
| def test_down(self):
| with patch.dict(rh_ip.__salt__, {'cmd.run': MagicMock(return_value='A')}):
self.assertEqual(rh_ip.down('iface', 'iface_type'), 'A')
self.assertEqual(rh_ip.down('iface', 'slave'), None)
|
'Test to return the content of a bond script'
| def test_get_bond(self):
| with patch.object(os.path, 'join', return_value='A'):
with patch.object(rh_ip, '_read_file', return_value='A'):
self.assertEqual(rh_ip.get_bond('iface'), 'A')
|
'Test to return the contents of an interface script'
| def test_get_interface(self):
| with patch.object(os.path, 'join', return_value='A'):
with patch.object(rh_ip, '_read_file', return_value='A'):
self.assertEqual(rh_ip.get_interface('iface'), 'A')
|
'Test to start up a network interface'
| def test_up(self):
| with patch.dict(rh_ip.__salt__, {'cmd.run': MagicMock(return_value='A')}):
self.assertEqual(rh_ip.up('iface', 'iface_type'), 'A')
self.assertEqual(rh_ip.up('iface', 'slave'), None)
|
'Test to return the contents of the interface routes script.'
| def test_get_routes(self):
| with patch.object(os.path, 'join', return_value='A'):
with patch.object(rh_ip, '_read_file', return_value=['A']):
self.assertEqual(rh_ip.get_routes('iface'), ['A', 'A'])
|
'Test to return the contents of the global network script.'
| def test_get_network_settings(self):
| with patch.object(rh_ip, '_read_file', return_value='A'):
self.assertEqual(rh_ip.get_network_settings(), 'A')
|
'Test to apply global network configuration.'
| def test_apply_network_settings(self):
| with patch.dict(rh_ip.__salt__, {'service.restart': MagicMock(return_value=True)}):
self.assertTrue(rh_ip.apply_network_settings())
|
'Test to build the global network script.'
| def test_build_network_settings(self):
| with patch.object(rh_ip, '_parse_rh_config', MagicMock()):
with patch.object(rh_ip, '_parse_network_settings', MagicMock()):
mock = jinja2.exceptions.TemplateNotFound('foo')
with patch.object(jinja2.Environment, 'get_template', MagicMock(side_effect=mock)):
self.assertEqual(rh_ip.build_network_settings(), '')
with patch.object(jinja2.Environment, 'get_template', MagicMock()):
with patch.object(rh_ip, '_read_temp', return_value='A'):
self.assertEqual(rh_ip.build_network_settings(test='t'), 'A')
with patch.object(rh_ip, '_write_file_network', return_value=None):
with patch.object(rh_ip, '_read_file', return_value='A'):
self.assertEqual(rh_ip.build_network_settings(test=None), 'A')
|
'Test for Return server version from grub --version'
| def test_version(self):
| mock = MagicMock(return_value='out')
with patch.dict(grub_legacy.__salt__, {'cmd.run': mock}):
self.assertEqual(grub_legacy.version(), 'out')
|
'Test for Parse GRUB conf file'
| def test_conf(self):
| mock = MagicMock(side_effect=IOError('foo'))
with patch('salt.utils.files.fopen', mock):
with patch.object(grub_legacy, '_detect_conf', return_value='A'):
self.assertRaises(CommandExecutionError, grub_legacy.conf)
file_data = '\n'.join(['#', 'A B C D,E,F G H'])
with patch('salt.utils.files.fopen', mock_open(read_data=file_data), create=True) as f_mock:
f_mock.return_value.__iter__.return_value = file_data.splitlines()
with patch.object(grub_legacy, '_detect_conf', return_value='A'):
self.assertEqual(grub_legacy.conf(), {'A': 'B C D,E,F G H', 'stanzas': []})
|
'Test if it mount an image'
| def test_mount(self):
| with patch('os.path.join', MagicMock(return_value=True)):
with patch('os.path.isdir', MagicMock(return_value=True)):
with patch('os.listdir', MagicMock(return_value=False)):
with patch.dict(guestfs.__salt__, {'cmd.run': MagicMock(return_value='')}):
self.assertTrue(guestfs.mount('/srv/images/fedora.qcow'))
|
'Test to installs one or several pecl extensions.'
| def test_install(self):
| with patch.object(pecl, '_pecl', return_value='A'):
self.assertEqual(pecl.install('fuse', force=True), 'A')
self.assertFalse(pecl.install('fuse'))
with patch.object(pecl, 'list_', return_value={'A': ['A', 'B']}):
self.assertTrue(pecl.install(['A', 'B']))
|
'Test to uninstall one or several pecl extensions.'
| def test_uninstall(self):
| with patch.object(pecl, '_pecl', return_value='A'):
self.assertEqual(pecl.uninstall('fuse'), 'A')
|
'Test to update one or several pecl extensions.'
| def test_update(self):
| with patch.object(pecl, '_pecl', return_value='A'):
self.assertEqual(pecl.update('fuse'), 'A')
|
'Test to list installed pecl extensions.'
| def test_list_(self):
| with patch.object(pecl, '_pecl', return_value='A\nB'):
self.assertDictEqual(pecl.list_('channel'), {})
|
'Test if it execute Augeas commands'
| @skipIf(six.PY3, 'Disabled pending https://github.com/hercules-team/python-augeas/issues/30')
def test_execute(self):
| self.assertEqual(augeas_cfg.execute(), {'retval': True})
|
'Test if it execute Augeas commands'
| def test_execute_io_error(self):
| ret = {'error': 'Command is not supported (yet)', 'retval': False}
self.assertEqual(augeas_cfg.execute(None, None, [' ']), ret)
|
'Test if it execute Augeas commands'
| def test_execute_value_error(self):
| ret = {'retval': False, 'error': 'Invalid formatted command, see debug log for details: '}
self.assertEqual(augeas_cfg.execute(None, None, ['set ']), ret)
|
'Test if it get a value for a specific augeas path'
| def test_get(self):
| mock = MagicMock(side_effect=RuntimeError('error'))
with patch.object(_Augeas, 'match', mock):
self.assertEqual(augeas_cfg.get('/etc/hosts'), {'error': 'error'})
mock = MagicMock(return_value=True)
with patch.object(_Augeas, 'match', mock):
self.assertEqual(augeas_cfg.get('/etc/hosts'), {'/etc/hosts': None})
|
'Test if it set a value for a specific augeas path'
| def test_setvalue(self):
| self.assertEqual(augeas_cfg.setvalue('prefix=/etc/hosts'), {'retval': True})
|
'Test if it set a value for a specific augeas path'
| def test_setvalue_io_error(self):
| mock = MagicMock(side_effect=IOError(''))
with patch.object(_Augeas, 'save', mock):
self.assertEqual(augeas_cfg.setvalue('prefix=/files/etc/'), {'retval': False, 'error': ''})
|
'Test if it set a value for a specific augeas path'
| def test_setvalue_uneven_path(self):
| mock = MagicMock(side_effect=RuntimeError('error'))
with patch.object(_Augeas, 'match', mock):
self.assertRaises(SaltInvocationError, augeas_cfg.setvalue, ['/files/etc/hosts/1/canonical', 'localhost'])
|
'Test if it set a value for a specific augeas path'
| def test_setvalue_one_prefix(self):
| self.assertRaises(SaltInvocationError, augeas_cfg.setvalue, 'prefix=/files', '10.18.1.1', 'prefix=/etc', 'test')
|
'Test if it matches for path expression'
| def test_match(self):
| self.assertEqual(augeas_cfg.match('/etc/service', 'ssh'), {})
|
'Test if it matches for path expression'
| def test_match_runtime_error(self):
| mock = MagicMock(side_effect=RuntimeError('error'))
with patch.object(_Augeas, 'match', mock):
self.assertEqual(augeas_cfg.match('/etc/service-name', 'ssh'), {})
|
'Test if it removes for path expression'
| def test_remove(self):
| self.assertEqual(augeas_cfg.remove('/etc/service'), {'count': 0, 'retval': True})
|
'Test if it removes for path expression'
| def test_remove_io_runtime_error(self):
| mock = MagicMock(side_effect=RuntimeError('error'))
with patch.object(_Augeas, 'save', mock):
self.assertEqual(augeas_cfg.remove('/etc/service-name'), {'count': 0, 'error': 'error', 'retval': False})
|
'Test if it list the direct children of a node'
| def test_ls(self):
| self.assertEqual(augeas_cfg.ls('/etc/passwd'), {})
|
'Test if it returns recursively the complete tree of a node'
| def test_tree(self):
| self.assertEqual(augeas_cfg.tree('/etc/'), {'/etc': None})
|
'Tests build module using znc-buildmod'
| def test_buildmod(self):
| with patch('os.path.exists', MagicMock(return_value=False)):
self.assertEqual(znc.buildmod('modules.cpp'), 'Error: The file (modules.cpp) does not exist.')
|
'Tests build module using znc-buildmod'
| def test_buildmod_module(self):
| mock = MagicMock(return_value='SALT')
with patch.dict(znc.__salt__, {'cmd.run': mock}):
with patch('os.path.exists', MagicMock(return_value=True)):
self.assertEqual(znc.buildmod('modules.cpp'), 'SALT')
|
'Tests write the active configuration state to config file'
| def test_dumpconf(self):
| mock = MagicMock(return_value='SALT')
with patch.dict(znc.__salt__, {'ps.pkill': mock}):
self.assertEqual(znc.dumpconf(), 'SALT')
|
'Tests rehash the active configuration state from config file'
| def test_rehashconf(self):
| mock = MagicMock(return_value='SALT')
with patch.dict(znc.__salt__, {'ps.pkill': mock}):
self.assertEqual(znc.rehashconf(), 'SALT')
|
'Tests return server version from znc --version'
| def test_version(self):
| mock = MagicMock(return_value='ZNC 1.2 - http://znc.in')
with patch.dict(znc.__salt__, {'cmd.run': mock}):
self.assertEqual(znc.version(), 'ZNC 1.2')
|
'Test if it return information for the specified user'
| def test_info(self):
| mock_user_info = MagicMock(return_value={'name': 'SALT', 'password_changed': '', 'expiration_date': ''})
with patch.dict(win_shadow.__salt__, {'user.info': mock_user_info}):
self.assertDictEqual(win_shadow.info('SALT'), {'name': 'SALT', 'passwd': 'Unavailable', 'lstchg': '', 'min': '', 'max': '', 'warn': '', 'inact': '', 'expire': ''})
|
'Test if it set the password for a named user.'
| def test_set_password(self):
| mock_cmd = MagicMock(return_value={'retcode': False})
mock_user_info = MagicMock(return_value={'name': 'SALT', 'password_changed': '', 'expiration_date': ''})
with patch.dict(win_shadow.__salt__, {'cmd.run_all': mock_cmd, 'user.info': mock_user_info}):
self.assertTrue(win_shadow.set_password('root', 'mysecretpassword'))
|
'Test if it show current usages statistics.'
| def test_getusage(self):
| ret = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.getUsage(), ret)
self.assertDictEqual(random_org.getUsage(api_key='peW', api_version='1'), {'bitsLeft': None, 'requestsLeft': None, 'res': True, 'totalBits': None, 'totalRequests': None})
|
'Test if it generate random integers.'
| def test_generateintegers(self):
| ret1 = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.generateIntegers(), ret1)
ret2 = {'message': 'Rquired argument, number is missing.', 'res': False}
self.assertDictEqual(random_org.generateIntegers(api_key='peW', api_version='1'), ret2)
ret3 = {'message': 'Number of integers must be between 1 and 10000', 'res': False}
self.assertDictEqual(random_org.generateIntegers(api_key='peW', api_version='1', number='5', minimum='1', maximum='6'), ret3)
ret4 = {'message': 'Minimum argument must be between -1,000,000,000 and 1,000,000,000', 'res': False}
self.assertDictEqual(random_org.generateIntegers(api_key='peW', api_version='1', number=5, minimum='1', maximum='6'), ret4)
ret5 = {'message': 'Maximum argument must be between -1,000,000,000 and 1,000,000,000', 'res': False}
self.assertDictEqual(random_org.generateIntegers(api_key='peW', api_version='1', number=5, minimum=1, maximum='6'), ret5)
ret6 = {'message': 'Base must be either 2, 8, 10 or 16.', 'res': False}
self.assertDictEqual(random_org.generateIntegers(api_key='peW', api_version='1', number=5, minimum=1, maximum=6, base='2'), ret6)
ret7 = {'message': u"Parameter 'apiKey' is malformed", 'res': False}
self.assertDictEqual(random_org.generateIntegers(api_key='peW', api_version='1', number=5, minimum=1, maximum=6, base=2), ret7)
|
'Test if it generate random strings.'
| def test_generatestrings(self):
| ret1 = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.generateStrings(), ret1)
ret2 = {'message': 'Required argument, number is missing.', 'res': False}
self.assertDictEqual(random_org.generateStrings(api_key='peW', api_version='1'), ret2)
ret3 = {'message': 'Number of strings must be between 1 and 10000', 'res': False}
char = 'abcdefghijklmnopqrstuvwxyz'
self.assertDictEqual(random_org.generateStrings(api_key='peW', api_version='1', number='5', length='8', characters=char), ret3)
ret3 = {'message': 'Length of strings must be between 1 and 20', 'res': False}
self.assertDictEqual(random_org.generateStrings(api_key='peW', api_version='1', number=5, length='8', characters=char), ret3)
ret3 = {'message': 'Length of characters must be less than 80.', 'res': False}
self.assertDictEqual(random_org.generateStrings(api_key='peW', api_version='1', number=5, length=8, characters=(char * 4)), ret3)
ret3 = {'message': u"Parameter 'apiKey' is malformed", 'res': False}
self.assertDictEqual(random_org.generateStrings(api_key='peW', api_version='1', number=5, length=8, characters=char), ret3)
|
'Test if it generate a list of random UUIDs.'
| def test_generateuuids(self):
| ret1 = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.generateUUIDs(), ret1)
ret2 = {'message': 'Required argument, number is missing.', 'res': False}
self.assertDictEqual(random_org.generateUUIDs(api_key='peW', api_version='1'), ret2)
ret3 = {'message': 'Number of UUIDs must be between 1 and 1000', 'res': False}
self.assertDictEqual(random_org.generateUUIDs(api_key='peW', api_version='1', number='5'), ret3)
ret3 = {'message': u"Parameter 'apiKey' is malformed", 'res': False}
self.assertDictEqual(random_org.generateUUIDs(api_key='peW', api_version='1', number=5), ret3)
|
'Test if it generates true random decimal fractions.'
| def test_generatedecimalfractions(self):
| ret1 = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.generateDecimalFractions(), ret1)
ret2 = {'message': 'Required argument, number is missing.', 'res': False}
self.assertDictEqual(random_org.generateDecimalFractions(api_key='peW', api_version='1'), ret2)
ret3 = {'message': 'Number of decimal fractions must be between 1 and 10000', 'res': False}
self.assertDictEqual(random_org.generateDecimalFractions(api_key='peW', api_version='1', number='5', decimalPlaces='4', replacement=True), ret3)
ret4 = {'message': 'Number of decimal places must be between 1 and 20', 'res': False}
self.assertDictEqual(random_org.generateDecimalFractions(api_key='peW', api_version='1', number=5, decimalPlaces='4', replacement=True), ret4)
ret5 = {'message': u"Parameter 'apiKey' is malformed", 'res': False}
self.assertDictEqual(random_org.generateDecimalFractions(api_key='peW', api_version='1', number=5, decimalPlaces=4, replacement=True), ret5)
|
'Test if it generates true random numbers from a
Gaussian distribution (also known as a normal distribution).'
| def test_generategaussians(self):
| ret1 = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.generateGaussians(), ret1)
ret2 = {'message': 'Required argument, number is missing.', 'res': False}
self.assertDictEqual(random_org.generateGaussians(api_key='peW', api_version='1'), ret2)
ret3 = {'message': 'Number of decimal fractions must be between 1 and 10000', 'res': False}
self.assertDictEqual(random_org.generateGaussians(api_key='peW', api_version='1', number='5', mean='0.0', standardDeviation='1.0', significantDigits='8'), ret3)
ret4 = {'message': "The distribution's mean must be between -1000000 and 1000000", 'res': False}
self.assertDictEqual(random_org.generateGaussians(api_key='peW', api_version='1', number=5, mean='0.0', standardDeviation='1.0', significantDigits='8'), ret4)
ret5 = {'message': "The distribution's standard deviation must be between -1000000 and 1000000", 'res': False}
self.assertDictEqual(random_org.generateGaussians(api_key='peW', api_version='1', number=5, mean=0.0, standardDeviation='1.0', significantDigits='8'), ret5)
ret6 = {'message': 'The number of significant digits must be between 2 and 20', 'res': False}
self.assertDictEqual(random_org.generateGaussians(api_key='peW', api_version='1', number=5, mean=0.0, standardDeviation=1.0, significantDigits='8'), ret6)
ret7 = {'message': u"Parameter 'apiKey' is malformed", 'res': False}
self.assertDictEqual(random_org.generateGaussians(api_key='peW', api_version='1', number=5, mean=0.0, standardDeviation=1.0, significantDigits=8), ret7)
|
'Test if it list all Slack users.'
| def test_generateblobs(self):
| ret1 = {'message': 'No Random.org api key or api version found.', 'res': False}
self.assertDictEqual(random_org.generateBlobs(), ret1)
ret2 = {'message': 'Required argument, number is missing.', 'res': False}
self.assertDictEqual(random_org.generateBlobs(api_key='peW', api_version='1'), ret2)
ret3 = {'message': 'Number of blobs must be between 1 and 100', 'res': False}
self.assertDictEqual(random_org.generateBlobs(api_key='peW', api_version='1', number='5', size='1'), ret3)
ret4 = {'message': 'Number of blobs must be between 1 and 100', 'res': False}
self.assertDictEqual(random_org.generateBlobs(api_key='peW', api_version='1', number=5, size=1), ret4)
ret5 = {'message': 'Format must be either base64 or hex.', 'res': False}
self.assertDictEqual(random_org.generateBlobs(api_key='peW', api_version='1', number=5, size=8, format='oct'), ret5)
ret6 = {'message': u"Parameter 'apiKey' is malformed", 'res': False}
self.assertDictEqual(random_org.generateBlobs(api_key='peW', api_version='1', number=5, size=8, format='hex'), ret6)
|
'Tests if the group already exists or not'
| def test_add_group_exists(self):
| mock_group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
with patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)):
self.assertRaises(CommandExecutionError, mac_group.add, 'test')
|
'Tests if there is whitespace in the group name'
| def test_add_whitespace(self):
| with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
self.assertRaises(SaltInvocationError, mac_group.add, 'white space')
|
'Tests if the group name starts with an underscore or not'
| def test_add_underscore(self):
| with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
self.assertRaises(SaltInvocationError, mac_group.add, '_Test')
|
'Tests if the gid is an int or not'
| def test_add_gid_int(self):
| with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
self.assertRaises(SaltInvocationError, mac_group.add, 'foo', 'foo')
|
'Tests if the gid is already in use or not'
| def test_add_gid_exists(self):
| with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
with patch('salt.modules.mac_group._list_gids', MagicMock(return_value=['3456'])):
self.assertRaises(CommandExecutionError, mac_group.add, 'foo', 3456)
|
'Tests if specified group was added'
| def test_add(self):
| mock_ret = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}):
with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
with patch('salt.modules.mac_group._list_gids', MagicMock(return_value=[])):
self.assertTrue(mac_group.add('test', 500))
|
'Tests if there is whitespace in the group name'
| def test_delete_whitespace(self):
| self.assertRaises(SaltInvocationError, mac_group.delete, 'white space')
|
'Tests if the group name starts with an underscore or not'
| def test_delete_underscore(self):
| self.assertRaises(SaltInvocationError, mac_group.delete, '_Test')
|
'Tests if the group to be deleted exists or not'
| def test_delete_group_exists(self):
| with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
self.assertTrue(mac_group.delete('test'))
|
'Tests if the specified group was deleted'
| def test_delete(self):
| mock_ret = MagicMock(return_value=0)
mock_group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}):
with patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)):
self.assertTrue(mac_group.delete('test'))
|
'Tests if there is whitespace in the group name'
| def test_info_whitespace(self):
| self.assertRaises(SaltInvocationError, mac_group.info, 'white space')
|
'Tests the return of group information'
| def test_info(self):
| mock_getgrall = [grp.struct_group(('foo', '*', 20, ['test']))]
with patch('grp.getgrall', MagicMock(return_value=mock_getgrall)):
ret = {'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}
self.assertEqual(mac_group.info('foo'), ret)
|
'Tests the formatting of returned group information'
| def test_format_info(self):
| data = grp.struct_group(('wheel', '*', 0, ['root']))
ret = {'passwd': '*', 'gid': 0, 'name': 'wheel', 'members': ['root']}
self.assertEqual(mac_group._format_info(data), ret)
|
'Tests the return of information on all groups'
| def test_getent(self):
| mock_getgrall = [grp.struct_group(('foo', '*', 20, ['test']))]
with patch('grp.getgrall', MagicMock(return_value=mock_getgrall)):
ret = [{'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}]
self.assertEqual(mac_group.getent(), ret)
|
'Tests if gid is an integer or not'
| def test_chgid_gid_int(self):
| self.assertRaises(SaltInvocationError, mac_group.chgid, 'foo', 'foo')
|
'Tests if the group id exists or not'
| def test_chgid_group_exists(self):
| mock_pre_gid = MagicMock(return_value='')
with patch.dict(mac_group.__salt__, {'file.group_to_gid': mock_pre_gid}):
with patch('salt.modules.mac_group.info', MagicMock(return_value={})):
self.assertRaises(CommandExecutionError, mac_group.chgid, 'foo', 4376)
|
'Tests if the group id is the same as argument'
| def test_chgid_gid_same(self):
| mock_group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
mock_pre_gid = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__, {'file.group_to_gid': mock_pre_gid}):
with patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)):
self.assertTrue(mac_group.chgid('test', 0))
|
'Tests the gid for a named group was changed'
| def test_chgid(self):
| mock_group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
mock_pre_gid = MagicMock(return_value=0)
mock_ret = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__, {'file.group_to_gid': mock_pre_gid}):
with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}):
with patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)):
self.assertTrue(mac_group.chgid('test', 500))
|
'Test if it return version from nftables --version'
| def test_version(self):
| mock = MagicMock(return_value='nf_tables 0.3-1')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.version(), '0.3-1')
|
'Test if it build a well-formatted nftables rule based on kwargs.'
| def test_build_rule(self):
| self.assertEqual(nftables.build_rule(full='True'), 'Error: Table needs to be specified')
self.assertEqual(nftables.build_rule(table='filter', full='True'), 'Error: Chain needs to be specified')
self.assertEqual(nftables.build_rule(table='filter', chain='input', full='True'), 'Error: Command needs to be specified')
self.assertEqual(nftables.build_rule(table='filter', chain='input', command='insert', position='3', full='True'), 'nft insert rule ip filter input position 3 ')
self.assertEqual(nftables.build_rule(table='filter', chain='input', command='insert', full='True'), 'nft insert rule ip filter input ')
self.assertEqual(nftables.build_rule(table='filter', chain='input', command='halt', full='True'), 'nft halt rule ip filter input ')
self.assertEqual(nftables.build_rule(), '')
|
'Test if it return a data structure of the rules in the conf file'
| def test_get_saved_rules(self):
| with patch.dict(nftables.__grains__, {'os_family': 'Debian'}):
with patch.object(salt.utils.files, 'fopen', MagicMock(mock_open())):
self.assertListEqual(nftables.get_saved_rules(), [])
|
'Test if it return a data structure of the current, in-memory rules'
| def test_get_rules(self):
| mock = MagicMock(return_value='SALT STACK')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertListEqual(nftables.get_rules(), ['SALT STACK'])
mock = MagicMock(return_value=False)
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertListEqual(nftables.get_rules(), [])
|
'Test if it save the current in-memory rules to disk'
| def test_save(self):
| with patch.dict(nftables.__grains__, {'os_family': 'Debian'}):
mock = MagicMock(return_value=False)
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch.object(salt.utils.files, 'fopen', MagicMock(mock_open())):
self.assertEqual(nftables.save(), '#! nft -f\n\n')
with patch.object(salt.utils.files, 'fopen', MagicMock(side_effect=IOError)):
self.assertRaises(CommandExecutionError, nftables.save)
|
'Test if it get the handle for a particular rule'
| def test_get_rule_handle(self):
| self.assertEqual(nftables.get_rule_handle(), 'Error: Chain needs to be specified')
self.assertEqual(nftables.get_rule_handle(chain='input'), 'Error: Rule needs to be specified')
_ru = 'input tcp dport 22 log accept'
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.get_rule_handle(chain='input', rule=_ru), ret)
ret = 'Error: chain input in table filter in family ipv4 does not exist'
mock = MagicMock(return_value='table ip filter')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.get_rule_handle(chain='input', rule=_ru), ret)
ret = 'Error: rule input tcp dport 22 log accept chain input in table filter in family ipv4 does not exist'
ret1 = 'Error: could not find rule input tcp dport 22 log accept'
with patch.object(nftables, 'check_table', MagicMock(return_value=True)):
with patch.object(nftables, 'check_chain', MagicMock(return_value=True)):
with patch.object(nftables, 'check', MagicMock(side_effect=[False, True])):
self.assertEqual(nftables.get_rule_handle(chain='input', rule=_ru), ret)
_ru = 'input tcp dport 22 log accept'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.get_rule_handle(chain='input', rule=_ru), ret1)
|
'Test if it check for the existence of a rule in the table and chain'
| def test_check(self):
| self.assertEqual(nftables.check(), 'Error: Chain needs to be specified')
self.assertEqual(nftables.check(chain='input'), 'Error: Rule needs to be specified')
_ru = 'input tcp dport 22 log accept'
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.check(chain='input', rule=_ru), ret)
mock = MagicMock(return_value='table ip filter')
ret = 'Error: chain input in table filter in family ipv4 does not exist'
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.check(chain='input', rule=_ru), ret)
mock = MagicMock(return_value='table ip filter chain input {{')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertFalse(nftables.check(chain='input', rule=_ru))
r_val = 'table ip filter chain input {{ input tcp dport 22 log accept #'
mock = MagicMock(return_value=r_val)
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertTrue(nftables.check(chain='input', rule=_ru))
|
'Test if it check for the existence of a chain in the table'
| def test_check_chain(self):
| self.assertEqual(nftables.check_chain(), 'Error: Chain needs to be specified')
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertFalse(nftables.check_chain(chain='input'))
mock = MagicMock(return_value='chain input {{')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertTrue(nftables.check_chain(chain='input'))
|
'Test if it check for the existence of a table'
| def test_check_table(self):
| self.assertEqual(nftables.check_table(), 'Error: table needs to be specified')
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertFalse(nftables.check_table(table='nat'))
mock = MagicMock(return_value='table ip nat')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertTrue(nftables.check_table(table='nat'))
|
'Test if it create new custom table.'
| def test_new_table(self):
| self.assertEqual(nftables.new_table(table=None), 'Error: table needs to be specified')
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.new_table(table='nat'), True)
mock = MagicMock(return_value='table ip nat')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.new_table(table='nat'), 'Error: table nat in family ipv4 already exists')
|
'Test if it delete custom table.'
| def test_delete_table(self):
| self.assertEqual(nftables.delete_table(table=None), 'Error: table needs to be specified')
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.delete_table(table='nat'), 'Error: table nat in family ipv4 does not exist')
mock = MagicMock(return_value='table ip nat')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.delete_table(table='nat'), 'table ip nat')
|
'Test if it create new chain to the specified table.'
| def test_new_chain(self):
| self.assertEqual(nftables.new_chain(), 'Error: Chain needs to be specified')
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.new_chain(chain='input'), ret)
ret = 'Error: chain input in table filter in family ipv4 already exists'
mock = MagicMock(return_value='table ip filter chain input {{')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.new_chain(chain='input'), ret)
|
'Test if it create new chain to the specified table.'
| def test_new_chain_variable(self):
| mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch('salt.modules.nftables.check_chain', MagicMock(return_value=False)):
with patch('salt.modules.nftables.check_table', MagicMock(return_value=True)):
self.assertEqual(nftables.new_chain(chain='input', table_type='filter'), 'Error: table_type hook and priority required')
self.assertTrue(nftables.new_chain(chain='input', table_type='filter', hook='input', priority=0))
|
'Test if it delete the chain from the specified table.'
| def test_delete_chain(self):
| self.assertEqual(nftables.delete_chain(), 'Error: Chain needs to be specified')
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.delete_chain(chain='input'), ret)
ret = 'Error: chain input in table filter in family ipv4 does not exist'
mock = MagicMock(return_value='table ip filter')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.delete_chain(chain='input'), ret)
|
'Test if it delete the chain from the specified table.'
| def test_delete_chain_variables(self):
| mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch('salt.modules.nftables.check_chain', MagicMock(return_value=True)):
with patch('salt.modules.nftables.check_table', MagicMock(return_value=True)):
self.assertTrue(nftables.delete_chain(chain='input'))
|
'Test if it append a rule to the specified table & chain.'
| def test_append(self):
| self.assertEqual(nftables.append(), 'Error: Chain needs to be specified')
self.assertEqual(nftables.append(chain='input'), 'Error: Rule needs to be specified')
_ru = 'input tcp dport 22 log accept'
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.append(chain='input', rule=_ru), ret)
ret = 'Error: chain input in table filter in family ipv4 does not exist'
mock = MagicMock(return_value='table ip filter')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.append(chain='input', rule=_ru), ret)
r_val = 'table ip filter chain input {{ input tcp dport 22 log accept #'
mock = MagicMock(return_value=r_val)
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertTrue(nftables.append(chain='input', rule=_ru))
|
'Test if it append a rule to the specified table & chain.'
| def test_append_rule(self):
| _ru = 'input tcp dport 22 log accept'
mock = MagicMock(side_effect=['1', ''])
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch('salt.modules.nftables.check', MagicMock(return_value=False)):
with patch('salt.modules.nftables.check_chain', MagicMock(return_value=True)):
with patch('salt.modules.nftables.check_table', MagicMock(return_value=True)):
self.assertFalse(nftables.append(chain='input', rule=_ru))
self.assertTrue(nftables.append(chain='input', rule=_ru))
|
'Test if it insert a rule into the specified table & chain,
at the specified position.'
| def test_insert(self):
| self.assertEqual(nftables.insert(), 'Error: Chain needs to be specified')
self.assertEqual(nftables.insert(chain='input'), 'Error: Rule needs to be specified')
_ru = 'input tcp dport 22 log accept'
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.insert(chain='input', rule=_ru), ret)
ret = 'Error: chain input in table filter in family ipv4 does not exist'
mock = MagicMock(return_value='table ip filter')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.insert(chain='input', rule=_ru), ret)
r_val = 'table ip filter chain input {{ input tcp dport 22 log accept #'
mock = MagicMock(return_value=r_val)
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertTrue(nftables.insert(chain='input', rule=_ru))
|
'Test if it insert a rule into the specified table & chain,
at the specified position.'
| def test_insert_rule(self):
| _ru = 'input tcp dport 22 log accept'
mock = MagicMock(side_effect=['1', ''])
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch('salt.modules.nftables.check', MagicMock(return_value=False)):
with patch('salt.modules.nftables.check_chain', MagicMock(return_value=True)):
with patch('salt.modules.nftables.check_table', MagicMock(return_value=True)):
self.assertFalse(nftables.insert(chain='input', rule=_ru))
self.assertTrue(nftables.insert(chain='input', rule=_ru))
|
'Test if it delete a rule from the specified table & chain,
specifying either the rule in its entirety, or
the rule\'s position in the chain.'
| def test_delete(self):
| _ru = 'input tcp dport 22 log accept'
self.assertEqual(nftables.delete(table='filter', chain='input', position='3', rule=_ru), 'Error: Only specify a position or a rule, not both')
ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.delete(table='filter', chain='input', rule=_ru), ret)
ret = 'Error: chain input in table filter in family ipv4 does not exist'
mock = MagicMock(return_value='table ip filter')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.delete(table='filter', chain='input', rule=_ru), ret)
mock = MagicMock(return_value='table ip filter chain input {{')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertTrue(nftables.delete(table='filter', chain='input', rule=_ru))
|
'Test if it delete a rule from the specified table & chain,
specifying either the rule in its entirety, or
the rule\'s position in the chain.'
| def test_delete_rule(self):
| mock = MagicMock(side_effect=['1', ''])
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch('salt.modules.nftables.check', MagicMock(return_value=True)):
with patch('salt.modules.nftables.check_chain', MagicMock(return_value=True)):
with patch('salt.modules.nftables.check_table', MagicMock(return_value=True)):
self.assertFalse(nftables.delete(table='filter', chain='input', position='3'))
self.assertTrue(nftables.delete(table='filter', chain='input', position='3'))
|
'Test if it flush the chain in the specified table, flush all chains
in the specified table if chain is not specified.'
| def test_flush(self):
| ret = 'Error: table filter in family ipv4 does not exist'
mock = MagicMock(return_value='')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.flush(table='filter', chain='input'), ret)
ret = 'Error: chain input in table filter in family ip does not exist'
mock = MagicMock(return_value='table ip filter')
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
self.assertEqual(nftables.flush(table='filter', chain='input'), ret)
|
'Test if it flush the chain in the specified table, flush all chains
in the specified table if chain is not specified.'
| def test_flush_chain(self):
| mock = MagicMock(side_effect=['1', ''])
with patch.dict(nftables.__salt__, {'cmd.run': mock}):
with patch('salt.modules.nftables.check_chain', MagicMock(return_value=True)):
with patch('salt.modules.nftables.check_table', MagicMock(return_value=True)):
self.assertFalse(nftables.flush(table='filter', chain='input'))
self.assertTrue(nftables.flush(table='filter', chain='input'))
|
'Test for Return all installed services'
| def test_get_all(self):
| with patch.dict(launchctl.__salt__, {'cmd.run': MagicMock(return_value='A DCTB B DCTB C DCTB \n')}):
with patch.object(launchctl, '_available_services', return_value={'A': 'a', 'B': 'b'}):
self.assertEqual(launchctl.get_all(), ['A', 'B', 'C'])
|
'Test for Check that the given service is available.'
| def test_available(self):
| with patch.object(launchctl, '_service_by_name', return_value=True):
self.assertTrue(launchctl.available('job_label'))
|
'Test for The inverse of service.available'
| def test_missing(self):
| with patch.object(launchctl, '_service_by_name', return_value=True):
self.assertFalse(launchctl.missing('job_label'))
|
'Test for Return the status for a service'
| def test_status(self):
| launchctl_data = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n <key>Label</key>\n <string>salt-minion</string>\n <key>LastExitStatus</key>\n <integer>0</integer>\n <key>LimitLoadToSessionType</key>\n <string>System</string>\n <key>OnDemand</key>\n <false/>\n <key>PID</key>\n <integer>71</integer>\n <key>ProgramArguments</key>\n <array>\n <string>/usr/local/bin/salt-minion</string>\n </array>\n <key>TimeOut</key>\n <integer>30</integer>\n</dict>\n</plist>'
with patch.object(launchctl, '_service_by_name', return_value={'plist': {'Label': 'A'}}):
if six.PY3:
launchctl_data = salt.utils.stringutils.to_bytes(launchctl_data)
with patch.object(launchctl, '_get_launchctl_data', return_value=launchctl_data):
self.assertTrue(launchctl.status('job_label'))
|
'Test for Stop the specified service'
| def test_stop(self):
| with patch.object(launchctl, '_service_by_name', return_value={'file_path': 'A'}):
with patch.dict(launchctl.__salt__, {'cmd.retcode': MagicMock(return_value=False)}):
self.assertTrue(launchctl.stop('job_label'))
with patch.object(launchctl, '_service_by_name', return_value=None):
self.assertFalse(launchctl.stop('job_label'))
|
'Test for Start the specified service'
| def test_start(self):
| with patch.object(launchctl, '_service_by_name', return_value={'file_path': 'A'}):
with patch.dict(launchctl.__salt__, {'cmd.retcode': MagicMock(return_value=False)}):
self.assertTrue(launchctl.start('job_label'))
with patch.object(launchctl, '_service_by_name', return_value=None):
self.assertFalse(launchctl.start('job_label'))
|
'Test for Restart the named service'
| def test_restart(self):
| with patch.object(launchctl, 'stop', return_value=None):
with patch.object(launchctl, 'start', return_value=True):
self.assertTrue(launchctl.restart('job_label'))
|
'Test for Boot (create) a new instance'
| def test_boot(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'boot', MagicMock(return_value='A')):
self.assertTrue(nova.boot('name'))
|
'Test for List storage volumes'
| def test_volume_list(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'volume_list', MagicMock(return_value='A')):
self.assertTrue(nova.volume_list())
|
'Test for Create a block storage volume'
| def test_volume_show(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'volume_show', MagicMock(return_value='A')):
self.assertTrue(nova.volume_show('name'))
|
'Test for Create a block storage volume'
| def test_volume_create(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'volume_create', MagicMock(return_value='A')):
self.assertTrue(nova.volume_create('name'))
|
'Test for Destroy the volume'
| def test_volume_delete(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'volume_delete', MagicMock(return_value='A')):
self.assertTrue(nova.volume_delete('name'))
|
'Test for Attach a block storage volume'
| def test_volume_detach(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'volume_detach', MagicMock(return_value='A')):
self.assertTrue(nova.volume_detach('name'))
|
'Test for Attach a block storage volume'
| def test_volume_attach(self):
| self.mock_auth.side_effect = MagicMock()
with patch.object(self.mock_auth, 'volume_attach', MagicMock(return_value='A')):
self.assertTrue(nova.volume_attach('name', 'serv_name'))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.