desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test to return a list off MAC addresses from the named vm'
| def test_get_macs(self):
| mock = MagicMock(side_effect=[None, ['a', 'b', 'c']])
with patch.object(xapi, 'get_nics', mock):
self.assertIsNone(xapi.get_macs('salt'))
self.assertListEqual(xapi.get_macs('salt'), ['a', 'b', 'c'])
|
'Test to return the disks of a named vm'
| def test_get_disks(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.get_disks('salt'))
self.assertDictEqual(xapi.get_disks('salt'), {})
|
'Test to changes the amount of memory allocated to VM.'
| def test_setmem(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.setmem('salt', '1'))
self.assertTrue(xapi.setmem('salt', '1'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.setmem('salt', '1'))
|
'Test to changes the amount of vcpus allocated to VM.'
| def test_setvcpus(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.setvcpus('salt', '1'))
self.assertTrue(xapi.setvcpus('salt', '1'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.setvcpus('salt', '1'))
|
'Test to Set which CPUs a VCPU can use.'
| def test_vcpu_pin(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.vcpu_pin('salt', '1', '2'))
self.assertTrue(xapi.vcpu_pin('salt', '1', '2'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
with patch.dict(xapi.__salt__, {'cmd.run': mock}):
self.assertTrue(xapi.vcpu_pin('salt', '1', '2'))
|
'Test to return an int representing the amount of memory
that has not been given to virtual machines on this node'
| def test_freemem(self):
| mock = MagicMock(return_value={'free_memory': 1024})
with patch.object(xapi, 'node_info', mock):
self.assertEqual(xapi.freemem(), 1024)
|
'Test to return an int representing the number
of unallocated cpus on this hypervisor'
| def test_freecpu(self):
| mock = MagicMock(return_value={'free_cpus': 1024})
with patch.object(xapi, 'node_info', mock):
self.assertEqual(xapi.freecpu(), 1024)
|
'Test to return the node_info, vm_info and freemem'
| def test_full_info(self):
| mock = MagicMock(return_value='salt')
with patch.object(xapi, 'node_info', mock):
mock = MagicMock(return_value='stack')
with patch.object(xapi, 'vm_info', mock):
self.assertDictEqual(xapi.full_info(), {'node_info': 'salt', 'vm_info': 'stack'})
|
'Test to send a soft shutdown signal to the named vm'
| def test_shutdown(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.shutdown('salt'))
self.assertTrue(xapi.shutdown('salt'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.shutdown('salt'))
|
'Test to pause the named vm'
| def test_pause(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.pause('salt'))
self.assertTrue(xapi.pause('salt'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.pause('salt'))
|
'Test to resume the named vm'
| def test_resume(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.resume('salt'))
self.assertTrue(xapi.resume('salt'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.resume('salt'))
|
'Test to reboot a domain via ACPI request'
| def test_start(self):
| mock = MagicMock(return_value=True)
with patch.object(xapi, 'start', mock):
self.assertTrue(xapi.start('salt'))
|
'Test to reboot a domain via ACPI request'
| def test_reboot(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.reboot('salt'))
self.assertTrue(xapi.reboot('salt'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.reboot('salt'))
|
'Test to reset a VM by emulating the
reset button on a physical machine'
| def test_reset(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.reset('salt'))
self.assertTrue(xapi.reset('salt'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.reset('salt'))
|
'Test to migrates the virtual machine to another hypervisor'
| def test_migrate(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.migrate('salt', 'stack'))
self.assertTrue(xapi.migrate('salt', 'stack'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.migrate('salt', 'stack'))
|
'Test to Hard power down the virtual machine,
this is equivalent to pulling the power'
| def test_stop(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(side_effect=[False, ['a', 'b', 'c']])
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.stop('salt'))
self.assertTrue(xapi.stop('salt'))
with patch.object(xapi, '_check_xenapi', MagicMock(return_value=Mockxapi)):
mock = MagicMock(return_value=True)
with patch.dict(xapi.__salt__, {'config.option': mock}):
with patch.object(xapi, '_get_label_uuid', mock):
self.assertFalse(xapi.stop('salt'))
|
'Test to returns a bool whether or not
this node is a hypervisor of any kind'
| def test_is_hyper(self):
| with patch.dict(xapi.__grains__, {'virtual_subtype': 'Dom0'}):
self.assertFalse(xapi.is_hyper())
with patch.dict(xapi.__grains__, {'virtual': 'Xen Dom0'}):
self.assertFalse(xapi.is_hyper())
with patch.dict(xapi.__grains__, {'virtual_subtype': 'Xen Dom0'}):
with patch('salt.utils.files.fopen', mock_open(read_data='salt')):
self.assertFalse(xapi.is_hyper())
with patch('salt.utils.files.fopen', mock_open()) as mock_read:
mock_read.side_effect = IOError
self.assertFalse(xapi.is_hyper())
with patch('salt.utils.files.fopen', mock_open(read_data='xen_')):
with patch.dict(xapi.__grains__, {'ps': 'salt'}):
mock = MagicMock(return_value={'xenstore': 'salt'})
with patch.dict(xapi.__salt__, {'cmd.run': mock}):
self.assertTrue(xapi.is_hyper())
|
'Test to Return cputime used by the vms'
| def test_vm_cputime(self):
| ret = {'1': {'cputime_percent': 0, 'cputime': 1}}
with patch.object(xapi, '_get_xapi_session', MagicMock()):
mock = MagicMock(return_value={'host_CPUs': '1'})
with patch.object(xapi, '_get_record_by_label', mock):
mock = MagicMock(return_value={'VCPUs_number': '1', 'VCPUs_utilisation': {'0': '1'}})
with patch.object(xapi, '_get_metrics_record', mock):
self.assertDictEqual(xapi.vm_cputime('1'), ret)
mock = MagicMock(return_value={})
with patch.object(xapi, 'list_domains', mock):
self.assertDictEqual(xapi.vm_cputime(''), {})
|
'Test to return combined network counters used by the vms'
| def test_vm_netstats(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
self.assertDictEqual(xapi.vm_netstats(''), {})
|
'Test to return disk usage counters used by the vms'
| def test_vm_diskstats(self):
| with patch.object(xapi, '_get_xapi_session', MagicMock()):
self.assertDictEqual(xapi.vm_diskstats(''), {})
|
'Test for Return compactionstats info'
| def test_compactionstats(self):
| mock = MagicMock(return_value='A')
with patch.object(cassandra, '_nodetool', mock):
self.assertEqual(cassandra.compactionstats(), 'A')
|
'Test for Return the cassandra version'
| def test_version(self):
| mock = MagicMock(return_value='A')
with patch.object(cassandra, '_nodetool', mock):
self.assertEqual(cassandra.version(), 'A')
|
'Test for Return netstats info'
| def test_netstats(self):
| mock = MagicMock(return_value='A')
with patch.object(cassandra, '_nodetool', mock):
self.assertEqual(cassandra.netstats(), 'A')
|
'Test for Return tpstats info'
| def test_tpstats(self):
| mock = MagicMock(return_value='A')
with patch.object(cassandra, '_nodetool', mock):
self.assertEqual(cassandra.tpstats(), 'A')
|
'Test for Return cassandra node info'
| def test_info(self):
| mock = MagicMock(return_value='A')
with patch.object(cassandra, '_nodetool', mock):
self.assertEqual(cassandra.info(), 'A')
|
'Test for Return ring info'
| def test_ring(self):
| mock = MagicMock(return_value='A')
with patch.object(cassandra, '_nodetool', mock):
self.assertEqual(cassandra.ring(), 'A')
|
'Test for Return existing keyspaces'
| def test_keyspaces(self):
| mock_keyspaces = ['A', 'B', 'C', 'D']
class MockSystemManager(object, ):
def list_keyspaces(self):
return mock_keyspaces
mock_sys_mgr = MagicMock(return_value=MockSystemManager())
with patch.object(cassandra, '_sys_mgr', mock_sys_mgr):
self.assertEqual(cassandra.keyspaces(), mock_keyspaces)
|
'Test for Return existing column families for all keyspaces'
| def test_column_families(self):
| mock_keyspaces = ['A', 'B']
class MockSystemManager(object, ):
def list_keyspaces(self):
return mock_keyspaces
def get_keyspace_column_families(self, keyspace):
if (keyspace == 'A'):
return {'a': 'saltines', 'b': 'biscuits'}
if (keyspace == 'B'):
return {'c': 'cheese', 'd': 'crackers'}
mock_sys_mgr = MagicMock(return_value=MockSystemManager())
with patch.object(cassandra, '_sys_mgr', mock_sys_mgr):
self.assertEqual(cassandra.column_families('Z'), None)
if six.PY3:
self.assertCountEqual(cassandra.column_families('A'), ['a', 'b'])
self.assertCountEqual(cassandra.column_families(), {'A': ['a', 'b'], 'B': ['c', 'd']})
else:
self.assertEqual(cassandra.column_families('A'), ['a', 'b'])
self.assertEqual(cassandra.column_families(), {'A': ['a', 'b'], 'B': ['c', 'd']})
|
'Test for Return a dictionary of column family definitions for the given
keyspace/column_family'
| def test_column_family_definition(self):
| class MockSystemManager(object, ):
def get_keyspace_column_families(self, keyspace):
if (keyspace == 'A'):
return {'a': object, 'b': object}
if (keyspace == 'B'):
raise Exception
mock_sys_mgr = MagicMock(return_value=MockSystemManager())
with patch.object(cassandra, '_sys_mgr', mock_sys_mgr):
self.assertEqual(cassandra.column_family_definition('A', 'a'), vars(object))
self.assertEqual(cassandra.column_family_definition('B', 'a'), None)
|
'Test shadow.gen_password'
| def test_gen_password(self):
| self.assertTrue(HAS_SHADOW)
for (algorithm, hash_info) in six.iteritems(_HASHES):
self.assertEqual(shadow.gen_password(_PASSWORD, crypt_salt=hash_info['pw_salt'], algorithm=algorithm), hash_info['pw_hash'])
|
'Test if it returns a list of all users'
| def test_list_users(self):
| self.assertTrue(shadow.list_users())
|
'If running windows, __virtual__ shouldn\'t register module'
| def test_virtual_bails_on_windows(self):
| with patch('salt.utils.platform.is_windows', (lambda : True)):
ret = parted.__virtual__()
err = (False, 'The parted execution module failed to load Windows systems are not supported.')
self.assertEqual(err, ret)
|
'If parted not in PATH, __virtual__ shouldn\'t register module'
| def test_virtual_bails_without_parted(self):
| with patch('salt.utils.path.which', (lambda exe: (not (exe == 'parted')))):
ret = parted.__virtual__()
err = (False, 'The parted execution module failed to load parted binary is not in the path.')
self.assertEqual(err, ret)
|
'If lsblk not in PATH, __virtual__ shouldn\'t register module'
| def test_virtual_bails_without_lsblk(self):
| with patch('salt.utils.path.which', (lambda exe: (not (exe == 'lsblk')))):
ret = parted.__virtual__()
err = (False, 'The parted execution module failed to load lsblk binary is not in the path.')
self.assertEqual(err, ret)
|
'If partprobe not in PATH, __virtual__ shouldn\'t register module'
| def test_virtual_bails_without_partprobe(self):
| with patch('salt.utils.path.which', (lambda exe: (not (exe == 'partprobe')))):
ret = parted.__virtual__()
err = (False, 'The parted execution module failed to load partprobe binary is not in the path.')
self.assertEqual(err, ret)
|
'On expected platform with correct utils in PATH, register
"partition" module'
| def test_virtual(self):
| with patch('salt.utils.platform.is_windows', (lambda : False)):
with patch('salt.utils.path.which', (lambda exe: (exe in ('parted', 'lsblk', 'partprobe')))):
ret = parted.__virtual__()
expect = 'partition'
self.assertEqual(ret, expect)
|
'Test - Get the certificate location contexts and their corresponding stores.'
| def test_get_stores(self):
| with patch.dict(win_pki.__salt__):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value=JSON_STORES)):
self.assertEqual(win_pki.get_stores(), STORES)
|
'Test - Get the available certificates in the given store.'
| def test_get_certs(self):
| with patch.dict(win_pki.__salt__):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value=JSON_CERTS)):
with patch('salt.modules.win_pki._validate_cert_path', MagicMock(return_value=None)):
self.assertEqual(win_pki.get_certs(), CERTS)
|
'Test - Get the details of the certificate file.'
| def test_get_cert_file(self):
| kwargs = {'name': CERT_PATH}
with patch.dict(win_pki.__salt__):
with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value=JSON_CERTS)):
self.assertEqual(win_pki.get_cert_file(**kwargs), CERTS[THUMBPRINT])
|
'Test - Import the certificate file into the given certificate store.'
| def test_import_cert(self):
| kwargs = {'name': CERT_PATH}
mock_value = MagicMock(return_value=CERT_PATH)
with patch.dict(win_pki.__salt__, {'cp.cache_file': mock_value}):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value=JSON_CERTS)):
with patch('salt.modules.win_pki._validate_cert_path', MagicMock(return_value=None)):
with patch('salt.modules.win_pki.get_cert_file', MagicMock(return_value=CERTS[THUMBPRINT])):
with patch('salt.modules.win_pki.get_certs', MagicMock(return_value=CERTS)):
self.assertTrue(win_pki.import_cert(**kwargs))
|
'Test - Export the certificate to a file from the given certificate store.'
| def test_export_cert(self):
| kwargs = {'name': CERT_PATH, 'thumbprint': THUMBPRINT}
with patch.dict(win_pki.__salt__):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value='True')):
with patch('salt.modules.win_pki._validate_cert_format', MagicMock(return_value=None)):
with patch('salt.modules.win_pki._validate_cert_path', MagicMock(return_value=None)):
self.assertTrue(win_pki.export_cert(**kwargs))
|
'Test - Check the certificate for validity.'
| def test_test_cert(self):
| with patch.dict(win_pki.__salt__):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value='True')):
with patch('salt.modules.win_pki._validate_cert_path', MagicMock(return_value=None)):
self.assertTrue(win_pki.test_cert(thumbprint=THUMBPRINT))
|
'Test - Remove the certificate from the given certificate store.'
| def test_remove_cert(self):
| with patch.dict(win_pki.__salt__):
with patch('salt.modules.win_pki._cmd_run', MagicMock(return_value=None)):
with patch('salt.modules.win_pki._validate_cert_path', MagicMock(return_value=None)):
with patch('salt.modules.win_pki.get_certs', MagicMock(return_value=CERTS)):
self.assertTrue(win_pki.remove_cert(thumbprint=THUMBPRINT[::(-1)]))
|
'Test if it return BTRFS version.'
| def test_version(self):
| mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
self.assertDictEqual(btrfs.version(), {'version': 'Salt'})
|
'Test if it get BTRFS filesystem information.'
| def test_info(self):
| with patch('salt.utils.fsutils._verify_run', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'Salt': 'salt'})
with patch.object(btrfs, '_parse_btrfs_info', mock):
self.assertDictEqual(btrfs.info('/dev/sda1'), {'Salt': 'salt'})
|
'Test if it get known BTRFS formatted devices on the system.'
| def test_devices(self):
| with patch('salt.utils.fsutils._blkid_output', MagicMock(return_value='Salt')):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
self.assertEqual(btrfs.devices(), 'Salt')
|
'Test if it defragment mounted BTRFS filesystem.'
| def test_defragment(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=False)):
with patch('os.path.exists', MagicMock(return_value=True)):
ret = [{'range': '/dev/sda1', 'mount_point': False, 'log': False, 'passed': True}]
mock_run = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock_run}):
mock_file = mock_open(read_data='/dev/sda1 / ext4 rw,data=ordered 0 0')
with patch.object(salt.utils.files, 'fopen', mock_file):
self.assertListEqual(btrfs.defragment('/dev/sda1'), ret)
|
'Test if it gives device not mount error'
| def test_defragment_error(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=True)):
mock_run = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock_run}):
mock_file = mock_open(read_data='/dev/sda1 / ext4 rw,data=ordered 0 0')
with patch.object(salt.utils.files, 'fopen', mock_file):
self.assertRaises(CommandExecutionError, btrfs.defragment, '/dev/sda1')
|
'Test if it list currently available BTRFS features.'
| def test_features(self):
| with patch('salt.utils.fsutils._verify_run', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
self.assertDictEqual(btrfs.features(), {})
|
'Test if it shows in which disk the chunks are allocated.'
| def test_usage(self):
| with patch('salt.utils.fsutils._verify_run', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'Salt': 'salt'})
with patch.object(btrfs, '_usage_specific', mock):
self.assertDictEqual(btrfs.usage('/dev/sda1'), {'Salt': 'salt'})
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Unallocated:\n'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': True})
with patch.object(btrfs, '_usage_unallocated', mock):
self.assertDictEqual(btrfs.usage('/dev/sda1'), {'unallocated': {'/dev/sda1': True}})
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Overall:\n'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': True})
with patch.object(btrfs, '_usage_overall', mock):
self.assertDictEqual(btrfs.usage('/dev/sda1'), {'overall': {'/dev/sda1': True}})
|
'Test if it create a file system on the specified device.'
| def test_mkfs(self):
| mock_cmd = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
mock_info = MagicMock(return_value=[])
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock_cmd, 'btrfs.info': mock_info}):
mock_file = mock_open(read_data='/dev/sda1 / ext4 rw,data=ordered 0 0')
with patch.object(salt.utils.files, 'fopen', mock_file):
self.assertDictEqual(btrfs.mkfs('/dev/sda1'), {'log': 'Salt'})
|
'Test if it No devices specified error'
| def test_mkfs_error(self):
| self.assertRaises(CommandExecutionError, btrfs.mkfs)
|
'Test if it device mount error'
| def test_mkfs_mount_error(self):
| mock = MagicMock(return_value={'/dev/sda1': True})
with patch.object(salt.utils.fsutils, '_get_mounts', mock):
self.assertRaises(CommandExecutionError, btrfs.mkfs, '/dev/sda1')
|
'Test if it resize filesystem.'
| def test_resize(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
mock_info = MagicMock(return_value=[])
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock, 'btrfs.info': mock_info}):
mock = MagicMock(return_value={'/dev/sda1': True})
with patch.object(salt.utils.fsutils, '_get_mounts', mock):
self.assertDictEqual(btrfs.resize('/dev/sda1', 'max'), {'log': 'Salt'})
|
'Test if it gives device should be mounted error'
| def test_resize_valid_error(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=False)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError, btrfs.resize, '/dev/sda1', 'max')
|
'Test if it gives mount point error'
| def test_resize_mount_error(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=True)):
mock = MagicMock(return_value={'/dev/sda1': False})
with patch.object(salt.utils.fsutils, '_get_mounts', mock):
self.assertRaises(CommandExecutionError, btrfs.resize, '/dev/sda1', 'max')
|
'Test if it gives unknown size error'
| def test_resize_size_error(self):
| self.assertRaises(CommandExecutionError, btrfs.resize, '/dev/sda1', '250m')
|
'Test if it convert ext2/3/4 to BTRFS'
| def test_convert(self):
| with patch('os.path.exists', MagicMock(return_value=True)):
ret = {'after': {'balance_log': 'Salt', 'ext4_image': 'removed', 'ext4_image_info': 'N/A', 'fsck_status': 'N/A', 'mount_point': None, 'type': 'ext4'}, 'before': {'fsck_status': 'Filesystem errors corrected', 'mount_point': None, 'type': 'ext4'}}
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda3': {'type': 'ext4'}})
with patch.object(salt.utils.fsutils, '_blkid_output', mock):
mock = MagicMock(return_value={'/dev/sda3': [{'mount_point': None}]})
with patch.object(salt.utils.fsutils, '_get_mounts', mock):
self.assertDictEqual(btrfs.convert('/dev/sda3', permanent=True), ret)
|
'Test if it gives device not found error'
| def test_convert_device_error(self):
| mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': False})
with patch.object(salt.utils.fsutils, '_blkid_output', mock):
self.assertRaises(CommandExecutionError, btrfs.convert, '/dev/sda1')
|
'Test if it gives file system error'
| def test_convert_filesystem_error(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': {'type': 'ext'}})
with patch.object(salt.utils.fsutils, '_blkid_output', mock):
self.assertRaises(CommandExecutionError, btrfs.convert, '/dev/sda1')
|
'Test if it gives error cannot convert root'
| def test_convert_error(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': {'type': 'ext4', 'mount_point': '/'}})
with patch.object(salt.utils.fsutils, '_blkid_output', mock):
mock = MagicMock(return_value={'/dev/sda1': [{'mount_point': '/'}]})
with patch.object(salt.utils.fsutils, '_get_mounts', mock):
self.assertRaises(CommandExecutionError, btrfs.convert, '/dev/sda1')
|
'Test if it gives migration error'
| def test_convert_migration_error(self):
| with patch('salt.utils.fsutils._is_device', MagicMock(return_value=True)):
mock_run = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock_run}):
mock_blk = MagicMock(return_value={'/dev/sda1': {'type': 'ext4'}})
with patch.object(salt.utils.fsutils, '_blkid_output', mock_blk):
mock_file = mock_open(read_data='/dev/sda1 / ext4 rw,data=ordered 0 0')
with patch.object(salt.utils.files, 'fopen', mock_file):
self.assertRaises(CommandExecutionError, btrfs.convert, '/dev/sda1')
|
'Test if it add a devices to a BTRFS filesystem.'
| def test_add(self):
| with patch('salt.modules.btrfs._restripe', MagicMock(return_value={})):
self.assertDictEqual(btrfs.add('/mountpoint', '/dev/sda1', '/dev/sda2'), {})
|
'Test if it delete a devices to a BTRFS filesystem.'
| def test_delete(self):
| with patch('salt.modules.btrfs._restripe', MagicMock(return_value={})):
self.assertDictEqual(btrfs.delete('/mountpoint', '/dev/sda1', '/dev/sda2'), {})
|
'Test if list properties for given btrfs object'
| def test_properties(self):
| with patch('salt.utils.fsutils._verify_run', MagicMock(return_value=True)):
mock = MagicMock(return_value={'retcode': 1, 'stderr': '', 'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
self.assertDictEqual(btrfs.properties('/dev/sda1', 'subvol'), {})
|
'Test if it gives unknown property error'
| def test_properties_unknown_error(self):
| self.assertRaises(CommandExecutionError, btrfs.properties, '/dev/sda1', 'a')
|
'Test if it gives exception error'
| def test_properties_error(self):
| self.assertRaises(CommandExecutionError, btrfs.properties, '/dev/sda1', 'subvol', True)
|
'Mock loads method.'
| def loads(self, content):
| if (self.flag == 1):
raise ValueError
return content
|
'Mock dumps method.'
| def dumps(self, dumps):
| if (self.flag == 1):
return None
return dumps
|
'Mock request method.'
| def return_request(self, url, data=None, **kwargs):
| self.url = url
self.data = data
self.kwargs = kwargs
requests = MockRequests()
if (self.flag == 1):
requests.status_code = 401
else:
requests.status_code = 200
return requests
|
'Mock post method.'
| def post(self, url, data=None, **kwargs):
| return self.return_request(url, data, **kwargs)
|
'Mock delete method.'
| def delete(self, url, **kwargs):
| return self.return_request(url, **kwargs)
|
'Mock get method.'
| def get(self, url, **kwargs):
| return self.return_request(url, **kwargs)
|
'Mock put method.'
| def put(self, url, data=None, **kwargs):
| return self.return_request(url, data, **kwargs)
|
'Tests if it returns requested Server Density
authentication value from pillar.'
| def test_get_sd_auth(self):
| with patch.dict(serverdensity_device.__pillar__, {'serverdensity': False}):
self.assertRaises(CommandExecutionError, serverdensity_device.get_sd_auth, '1')
with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'1': 'salt'}}):
self.assertEqual(serverdensity_device.get_sd_auth('1'), 'salt')
self.assertRaises(CommandExecutionError, serverdensity_device.get_sd_auth, '2')
|
'Tests if it create device in Server Density.'
| def test_create(self):
| with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'api_token': 'salt'}}):
self.assertTrue(serverdensity_device.create('rich_lama', group='lama_band'))
MockJson.flag = 1
self.assertRaises(CommandExecutionError, serverdensity_device.create, 'rich_lama', group='lama_band')
MockRequests.flag = 1
self.assertIsNone(serverdensity_device.create('rich_lama', group='lama_band'))
|
'Tests if it delete a device from Server Density.'
| def test_delete(self):
| with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'api_token': 'salt'}}):
MockRequests.flag = 0
MockJson.flag = 0
self.assertTrue(serverdensity_device.delete('51f7eaf'))
MockJson.flag = 1
self.assertRaises(CommandExecutionError, serverdensity_device.delete, '51f7eaf')
MockRequests.flag = 1
self.assertIsNone(serverdensity_device.delete('51f7eaf'))
|
'Tests if it list devices in Server Density.'
| def test_ls(self):
| with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'api_token': 'salt'}}):
MockRequests.flag = 0
MockJson.flag = 0
self.assertTrue(serverdensity_device.ls(name='lama'))
MockJson.flag = 1
self.assertRaises(CommandExecutionError, serverdensity_device.ls, name='lama')
MockRequests.flag = 1
self.assertIsNone(serverdensity_device.ls(name='lama'))
|
'Tests if it updates device information in Server Density.'
| def test_update(self):
| with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'api_token': 'salt'}}):
MockRequests.flag = 0
MockJson.flag = 0
self.assertTrue(serverdensity_device.update('51f7eaf', name='lama'))
MockJson.flag = 1
self.assertRaises(CommandExecutionError, serverdensity_device.update, '51f7eaf', name='lama')
MockRequests.flag = 1
self.assertIsNone(serverdensity_device.update('51f7eaf', name='lama'))
|
'Tests if it downloads Server Density installation agent,
and installs sd-agent with agent_key.'
| def test_install_agent(self):
| mock = MagicMock(return_value=True)
with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'account_url': 'salt'}}):
with patch.dict(serverdensity_device.__salt__, {'cmd.run': mock}):
with patch.dict(serverdensity_device.__opts__, {'cachedir': '/'}):
self.assertTrue(serverdensity_device.install_agent('51f7e'))
|
'Tests if it downloads Server Density installation agent,
and installs sd-agent with agent_key.'
| def test_install_agent_v2(self):
| mock = MagicMock(return_value=True)
with patch.dict(serverdensity_device.__pillar__, {'serverdensity': {'account_name': 'salt'}}):
with patch.dict(serverdensity_device.__salt__, {'cmd.run': mock}):
with patch.dict(serverdensity_device.__opts__, {'cachedir': '/'}):
self.assertTrue(serverdensity_device.install_agent('51f7e', agent_version=2))
|
'Mock loads method'
| @staticmethod
def loads(content):
| return content
|
'Mock dumps method'
| @staticmethod
def dumps(dumps):
| return dumps
|
'get_message method'
| def _get_message(self):
| return self._message
|
'set_message method'
| def _set_message(self, message):
| self._message = message
|
'Mock login method'
| @staticmethod
def login():
| return True
|
'Mock logout method'
| @staticmethod
def logout():
| return True
|
'Mock set_servicegroupname method'
| def set_servicegroupname(self, sg_name):
| self.sg_name = sg_name
return MockNSServiceGroup()
|
'Mock get method'
| @staticmethod
def get(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroup()
|
'Mock add method'
| @staticmethod
def add(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroup()
|
'Mock delete method'
| @staticmethod
def delete(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroup()
|
'Mock get_servers method'
| @staticmethod
def get_servers(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return [MockNSServiceGroup()]
|
'Mock enable_server method'
| @staticmethod
def enable_server(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroup()
|
'Mock disable_server method'
| @staticmethod
def disable_server(obj, servicegroup):
| if MockNSNitro.flag:
raise MockNSNitroError
return MockNSServiceGroup()
|
'Mock get_servername method'
| @staticmethod
def get_servername():
| return 'serviceGroupName'
|
'Mock get_state method'
| @staticmethod
def get_state():
| return 'ENABLED'
|
'Mock get_servicetype method'
| @staticmethod
def get_servicetype():
| return ''
|
'Mock set_servicetype method'
| @staticmethod
def set_servicetype(bol):
| return bol
|
'Mock set_servername method'
| def set_servername(self, sg_name):
| self.sg_name = sg_name
return MockNSServiceGroupServerBinding()
|
'Mock set_servicegroupname method'
| def set_servicegroupname(self, sg_name):
| self.sg_name = sg_name
return MockNSServiceGroupServerBinding()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.