desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Tests the return of successful assign function'
| def test_assign_success(self):
| with patch('os.path.exists', MagicMock(return_value=True)):
cmd = {'pid': 1337, 'retcode': 0, 'stderr': '', 'stdout': 'net.ipv4.ip_forward = 1'}
ret = {'net.ipv4.ip_forward': '1'}
mock_cmd = MagicMock(return_value=cmd)
with patch.dict(linux_sysctl.__salt__, {'cmd.run_all': mock... |
'Tests adding of config file failure'
| def test_persist_no_conf_failure(self):
| asn_cmd = {'pid': 1337, 'retcode': 0, 'stderr': 'sysctl: permission denied', 'stdout': ''}
mock_asn_cmd = MagicMock(return_value=asn_cmd)
cmd = 'sysctl -w net.ipv4.ip_forward=1'
mock_cmd = MagicMock(return_value=cmd)
with patch.dict(linux_sysctl.__salt__, {'cmd.run_stdout': mock_cmd, 'cm... |
'Tests successful add of config file when previously not one'
| def test_persist_no_conf_success(self):
| with patch('os.path.isfile', MagicMock(return_value=False)):
with patch('os.path.exists', MagicMock(return_value=True)):
asn_cmd = {'pid': 1337, 'retcode': 0, 'stderr': '', 'stdout': 'net.ipv4.ip_forward = 1'}
mock_asn_cmd = MagicMock(return_value=asn_cmd)
sys_cmd =... |
'Tests sysctl.conf read success'
| def test_persist_read_conf_success(self):
| with patch('os.path.isfile', MagicMock(return_value=True)):
with patch('os.path.exists', MagicMock(return_value=True)):
asn_cmd = {'pid': 1337, 'retcode': 0, 'stderr': '', 'stdout': 'net.ipv4.ip_forward = 1'}
mock_asn_cmd = MagicMock(return_value=asn_cmd)
sys_cmd = ... |
'Test if it get current timezone (i.e. Asia/Calcutta)'
| def test_get_zone(self):
| mock_cmd = MagicMock(side_effect=['India Standard Time', 'Indian Standard Time'])
with patch.dict(win_timezone.__salt__, {'cmd.run': mock_cmd}):
self.assertEqual(win_timezone.get_zone(), 'Asia/Calcutta')
self.assertFalse(win_timezone.get_zone())
|
'Test if it get current numeric timezone offset from UCT (i.e. +0530)'
| def test_get_offset(self):
| time = '(UTC+05:30) Chennai, Kolkata, Mumbai, New Delhi\nIndia Standard Time'
mock_cmd = MagicMock(side_effect=['India Standard Time', time])
with patch.dict(win_timezone.__salt__, {'cmd.run': mock_cmd}):
self.assertEqual(win_timezone.get_of... |
'Test if it get current timezone (i.e. PST, MDT, etc)'
| def test_get_zonecode(self):
| self.assertFalse(win_timezone.get_zonecode())
|
'Test if it unlinks, then symlinks /etc/localtime to the set timezone.'
| def test_set_zone(self):
| mock_cmd = MagicMock(return_value=0)
with patch.dict(win_timezone.__salt__, {'cmd.retcode': mock_cmd}):
self.assertTrue(win_timezone.set_zone('Asia/Calcutta'))
|
'Test if it checks the md5sum between the given timezone, and
the one set in /etc/localtime. Returns True if they match,
and False if not. Mostly useful for running state checks.'
| def test_zone_compare(self):
| mock_cmd = MagicMock(return_value='India Standard Time')
with patch.dict(win_timezone.__salt__, {'cmd.run': mock_cmd}):
self.assertTrue(win_timezone.zone_compare('Asia/Calcutta'))
|
'Test if it get current hardware clock setting (UTC or localtime)'
| def test_get_hwclock(self):
| self.assertEqual(win_timezone.get_hwclock(), 'localtime')
|
'Test if it sets the hardware clock to be either UTC or localtime'
| def test_set_hwclock(self):
| self.assertFalse(win_timezone.set_hwclock('UTC'))
|
'Tests if specified group was added'
| def test_add(self):
| mock = MagicMock(return_value={'retcode': 0})
with patch.dict(groupadd.__salt__, {'cmd.run_all': mock}):
self.assertTrue(groupadd.add('test', 100))
with patch.dict(groupadd.__grains__, {'kernel': 'Linux'}):
with patch.dict(groupadd.__salt__, {'cmd.run_all': mock}):
self.assertTru... |
'Tests the return of group information'
| def test_info(self):
| getgrnam = grp.struct_group(('foo', '*', 20, ['test']))
with patch('grp.getgrnam', MagicMock(return_value=getgrnam)):
ret = {'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}
self.assertEqual(groupadd.info('foo'), ret)
|
'Tests the formatting of returned group information'
| def test_format_info(self):
| group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
with patch('salt.modules.groupadd._format_info', MagicMock(return_value=group)):
data = grp.struct_group(('wheel', '*', 0, ['root']))
ret = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
self.assertDic... |
'Tests the return of information on all groups'
| def test_getent(self):
| getgrnam = grp.struct_group(('foo', '*', 20, ['test']))
with patch('grp.getgrall', MagicMock(return_value=[getgrnam])):
ret = [{'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}]
self.assertEqual(groupadd.getent(), ret)
|
'Tests if the group id is the same as argument'
| def test_chgid_gid_same(self):
| mock_pre_gid = MagicMock(return_value=10)
with patch.dict(groupadd.__salt__, {'file.group_to_gid': mock_pre_gid}):
self.assertTrue(groupadd.chgid('test', 10))
|
'Tests the gid for a named group was changed'
| def test_chgid(self):
| mock_pre_gid = MagicMock(return_value=0)
mock_cmdrun = MagicMock(return_value=0)
with patch.dict(groupadd.__salt__, {'file.group_to_gid': mock_pre_gid}):
with patch.dict(groupadd.__salt__, {'cmd.run': mock_cmdrun}):
self.assertFalse(groupadd.chgid('test', 500))
|
'Tests if the specified group was deleted'
| def test_delete(self):
| mock_ret = MagicMock(return_value={'retcode': 0})
with patch.dict(groupadd.__salt__, {'cmd.run_all': mock_ret}):
self.assertTrue(groupadd.delete('test'))
|
'Tests if specified user gets added in the group.'
| def test_adduser(self):
| os_version_list = [{'grains': {'kernel': 'Linux', 'os_family': 'RedHat', 'osmajorrelease': '5'}, 'cmd': ('gpasswd', '-a', 'root', 'test')}, {'grains': {'kernel': 'Linux', 'os_family': 'Suse', 'osmajorrelease': '11'}, 'cmd': ('usermod', '-A', 'test', 'root')}, {'grains': {'kernel': 'Linux'}, 'cmd': ('gpasswd', '--ad... |
'Tests if specified user gets deleted from the group.'
| def test_deluser(self):
| os_version_list = [{'grains': {'kernel': 'Linux', 'os_family': 'RedHat', 'osmajorrelease': '5'}, 'cmd': ('gpasswd', '-d', 'root', 'test')}, {'grains': {'kernel': 'Linux', 'os_family': 'Suse', 'osmajorrelease': '11'}, 'cmd': ('usermod', '-R', 'test', 'root')}, {'grains': {'kernel': 'Linux'}, 'cmd': ('gpasswd', '--de... |
'Tests if members of the group, get replaced with a provided list.'
| def test_members(self):
| os_version_list = [{'grains': {'kernel': 'Linux', 'os_family': 'RedHat', 'osmajorrelease': '5'}, 'cmd': ('gpasswd', '-M', 'foo', 'test')}, {'grains': {'kernel': 'Linux', 'os_family': 'Suse', 'osmajorrelease': '11'}, 'cmd': ('groupmod', '-A', 'foo', 'test')}, {'grains': {'kernel': 'Linux'}, 'cmd': ('gpasswd', '--mem... |
'tests that given a valid instance id and valid ELB that
register_instances returns True.'
| @mock_ec2
@mock_elb
def test_register_instances_valid_id_result_true(self):
| conn_ec2 = boto.ec2.connect_to_region(region, **boto_conn_parameters)
conn_elb = boto.ec2.elb.connect_to_region(region, **boto_conn_parameters)
zones = [zone.name for zone in conn_ec2.get_all_zones()]
elb_name = 'TestRegisterInstancesValidIdResult'
conn_elb.create_load_balancer(elb_name, zones, [(80... |
'tests that given a string containing a instance id and valid ELB that
register_instances adds the given instance to an ELB'
| @mock_ec2
@mock_elb
def test_register_instances_valid_id_string(self):
| conn_ec2 = boto.ec2.connect_to_region(region, **boto_conn_parameters)
conn_elb = boto.ec2.elb.connect_to_region(region, **boto_conn_parameters)
zones = [zone.name for zone in conn_ec2.get_all_zones()]
elb_name = 'TestRegisterInstancesValidIdResult'
conn_elb.create_load_balancer(elb_name, zones, [(80... |
'tests that given an valid id the boto_elb deregister_instances method
removes exactly one of a number of ELB registered instances'
| @mock_ec2
@mock_elb
def test_deregister_instances_valid_id_result_true(self):
| conn_ec2 = boto.ec2.connect_to_region(region, **boto_conn_parameters)
conn_elb = boto.ec2.elb.connect_to_region(region, **boto_conn_parameters)
zones = [zone.name for zone in conn_ec2.get_all_zones()]
elb_name = 'TestDeregisterInstancesValidIdResult'
load_balancer = conn_elb.create_load_balancer(elb... |
'tests that given an valid id the boto_elb deregister_instances method
removes exactly one of a number of ELB registered instances'
| @mock_ec2
@mock_elb
def test_deregister_instances_valid_id_string(self):
| conn_ec2 = boto.ec2.connect_to_region(region, **boto_conn_parameters)
conn_elb = boto.ec2.elb.connect_to_region(region, **boto_conn_parameters)
zones = [zone.name for zone in conn_ec2.get_all_zones()]
elb_name = 'TestDeregisterInstancesValidIdString'
load_balancer = conn_elb.create_load_balancer(elb... |
'tests that given an valid ids in the form of a list that the boto_elb
deregister_instances all members of the given list'
| @mock_ec2
@mock_elb
def test_deregister_instances_valid_id_list(self):
| conn_ec2 = boto.ec2.connect_to_region(region, **boto_conn_parameters)
conn_elb = boto.ec2.elb.connect_to_region(region, **boto_conn_parameters)
zones = [zone.name for zone in conn_ec2.get_all_zones()]
elb_name = 'TestDeregisterInstancesValidIdList'
load_balancer = conn_elb.create_load_balancer(elb_n... |
'Test if it updates the pkgutil repo database (pkgutil -U).'
| def test_refresh_db(self):
| mock = MagicMock(return_value=0)
with patch.dict(pkgutil.__salt__, {'cmd.retcode': mock}):
with patch.object(salt.utils.pkg, 'clear_rtag', Mock()):
self.assertTrue(pkgutil.refresh_db())
|
'Test if there is an upgrade available for a certain package.'
| def test_upgrade_available(self):
| mock = MagicMock(return_value='A\n B\n SAME')
with patch.dict(pkgutil.__salt__, {'cmd.run_stdout': mock}):
self.assertEqual(pkgutil.upgrade_available('CSWpython'), '')
mock = MagicMock(side_effect=['A\n B\n SALT', None])
with patch.dict(pkgutil.__salt__, {'cmd.run_stdout': mock}):
... |
'Test if it list all available package upgrades on this system.'
| def test_list_upgrades(self):
| mock_run = MagicMock(return_value='A DCTB B DCTB SAME')
mock_ret = MagicMock(return_value=0)
with patch.dict(pkgutil.__salt__, {'cmd.run_stdout': mock_run, 'cmd.retcode': mock_ret}):
with patch.object(salt.utils.pkg, 'clear_rtag', Mock()):
self.assertDictEqual(pkgutil.list_upgrad... |
'Test if it upgrade all of the packages to the latest available version.'
| def test_upgrade(self):
| mock_run = MagicMock(return_value='A DCTB B DCTB SAME')
mock_ret = MagicMock(return_value=0)
mock_pkg = MagicMock(return_value='')
with patch.dict(pkgutil.__salt__, {'cmd.run_stdout': mock_run, 'cmd.retcode': mock_ret, 'pkg_resource.stringify': mock_pkg, 'pkg_resource.sort_pkglist': mock_pkg, 'c... |
'Test if it list the packages currently installed as a dict.'
| def test_list_pkgs(self):
| mock_run = MagicMock(return_value='A DCTB B DCTB SAME')
mock_ret = MagicMock(return_value=True)
mock_pkg = MagicMock(return_value='')
with patch.dict(pkgutil.__salt__, {'cmd.run_stdout': mock_run, 'cmd.retcode': mock_ret, 'pkg_resource.stringify': mock_pkg, 'pkg_resource.sort_pkglist': mock_pkg,... |
'Test if it returns a version if the package is installed.'
| def test_version(self):
| mock_ret = MagicMock(return_value=True)
with patch.dict(pkgutil.__salt__, {'pkg_resource.version': mock_ret}):
self.assertTrue(pkgutil.version('CSWpython'))
|
'Test if it return the latest version of the named package
available for upgrade or installation.'
| def test_latest_version(self):
| self.assertEqual(pkgutil.latest_version(), '')
mock_run_all = MagicMock(return_value='A DCTB B DCTB SAME')
mock_run = MagicMock(return_value={'stdout': ''})
mock_ret = MagicMock(return_value=True)
mock_pkg = MagicMock(return_value='')
with patch.dict(pkgutil.__salt__, {'cmd.retcode': moc... |
'Test if it install packages using the pkgutil tool.'
| def test_install(self):
| mock_pkg = MagicMock(side_effect=MinionError)
with patch.dict(pkgutil.__salt__, {'pkg_resource.parse_targets': mock_pkg}):
self.assertRaises(CommandExecutionError, pkgutil.install)
mock_ret = MagicMock(return_value=True)
mock_pkg = MagicMock(return_value=[''])
with patch.dict(pkgutil.__salt_... |
'Test if it remove a package and all its dependencies
which are not in use by other packages.'
| def test_remove(self):
| mock_pkg = MagicMock(side_effect=MinionError)
with patch.dict(pkgutil.__salt__, {'pkg_resource.parse_targets': mock_pkg}):
self.assertRaises(CommandExecutionError, pkgutil.remove)
mock_ret = MagicMock(return_value=True)
mock_run = MagicMock(return_value='A DCTB B DCTB SAME')
mock_run... |
'Test if it package purges are not supported,
this function is identical to ``remove()``.'
| def test_purge(self):
| mock_pkg = MagicMock(side_effect=MinionError)
with patch.dict(pkgutil.__salt__, {'pkg_resource.parse_targets': mock_pkg}):
self.assertRaises(CommandExecutionError, pkgutil.purge)
|
'Test for finger'
| def test_finger(self):
| with patch.object(os.path, 'join', return_value='A'):
with patch.object(salt.utils, 'pem_finger', return_value='A'):
with patch.dict(key.__opts__, {'pki_dir': MagicMock(return_value='A'), 'hash_type': 'sha256'}):
self.assertEqual(key.finger(), 'A')
|
'Test for finger'
| def test_finger_master(self):
| with patch.object(os.path, 'join', return_value='A'):
with patch.object(salt.utils, 'pem_finger', return_value='A'):
with patch.dict(key.__opts__, {'pki_dir': 'A', 'hash_type': 'sha256'}):
self.assertEqual(key.finger_master(), 'A')
|
'Test for Run nagios plugin and return all
the data execution with cmd.run'
| def test_run(self):
| with patch.object(nagios, '_execute_cmd', return_value='A'):
self.assertEqual(nagios.run('plugin'), 'A')
|
'Test for Run one nagios plugin and return retcode of the execution'
| def test_retcode(self):
| with patch.object(nagios, '_execute_cmd', return_value='A'):
self.assertEqual(nagios.retcode('plugin', key_name='key'), {'key': {'status': 'A'}})
|
'Test for Run nagios plugin and return all
the data execution with cmd.run_all'
| def test_run_all(self):
| with patch.object(nagios, '_execute_cmd', return_value='A'):
self.assertEqual(nagios.run_all('plugin'), 'A')
|
'Test for Run one or more nagios plugins from pillar data and
get the result of cmd.retcode'
| def test_retcode_pillar(self):
| with patch.dict(nagios.__salt__, {'pillar.get': MagicMock(return_value={})}):
self.assertEqual(nagios.retcode_pillar('pillar_name'), {})
|
'Test for Run one or more nagios plugins from pillar data
and get the result of cmd.run'
| def test_run_pillar(self):
| with patch.object(nagios, '_execute_pillar', return_value='A'):
self.assertEqual(nagios.run_pillar('pillar'), 'A')
|
'Test for Run one or more nagios plugins from pillar data
and get the result of cmd.run'
| def test_run_all_pillar(self):
| with patch.object(nagios, '_execute_pillar', return_value='A'):
self.assertEqual(nagios.run_all_pillar('pillar'), 'A')
|
'Test for List all the nagios plugins'
| def test_list_plugins(self):
| with patch.object(os, 'listdir', return_value=[]):
self.assertEqual(nagios.list_plugins(), [])
|
'Test if the parsing function works'
| def test_read_file(self):
| with patch('salt.utils.files.fopen', mock_open(read_data=MOCK_FILE)):
self.assertListEqual(pam.read_file('/etc/pam.d/login'), [{'arguments': [], 'control_flag': 'ok', 'interface': 'ok', 'module': 'ignore'}])
|
'Tests to add the specified group'
| def test_add(self):
| mock = MagicMock(return_value={'retcode': 0})
with patch.dict(pw_group.__salt__, {'cmd.run_all': mock}):
self.assertTrue(pw_group.add('a'))
|
'Tests to remove the named group'
| def test_delete(self):
| mock = MagicMock(return_value={'retcode': 0})
with patch.dict(pw_group.__salt__, {'cmd.run_all': mock}):
self.assertTrue(pw_group.delete('a'))
|
'Tests to return information about a group'
| def test_info(self):
| self.assertDictEqual(pw_group.info('name'), {})
mock = MagicMock(return_value={'gr_name': 'A', 'gr_passwd': 'B', 'gr_gid': 1, 'gr_mem': ['C', 'D']})
with patch.dict(pw_group.grinfo, mock):
self.assertDictEqual(pw_group.info('name'), {})
|
'Tests for return info on all groups'
| def test_getent(self):
| mock_getent = [{'passwd': 'x', 'gid': 0, 'name': 'root'}]
with patch.dict(pw_group.__context__, {'group.getent': mock_getent}):
self.assertDictContainsSubset({'passwd': 'x', 'gid': 0, 'name': 'root'}, pw_group.getent()[0])
mock = MagicMock(return_value='A')
with patch.object(pw_group, 'info', mo... |
'tests to change the gid for a named group'
| def test_chgid(self):
| mock = MagicMock(return_value=1)
with patch.dict(pw_group.__salt__, {'file.group_to_gid': mock}):
self.assertTrue(pw_group.chgid('name', 1))
mock = MagicMock(side_effect=[1, 0])
with patch.dict(pw_group.__salt__, {'file.group_to_gid': mock}):
mock = MagicMock(return_value=None)
w... |
'Test for retrieving cert base path'
| def test_cert_base_path(self):
| ca_path = '/etc/tls'
mock_opt = MagicMock(return_value=ca_path)
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
self.assertEqual(tls.cert_base_path(), ca_path)
|
'Test for setting the cert base path'
| def test_set_ca_cert_path(self):
| ca_path = '/tmp/ca_cert_test_path'
mock_opt = MagicMock(return_value='/etc/tls')
ret = {'ca.contextual_cert_base_path': '/tmp/ca_cert_test_path'}
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
tls.set_ca_path(ca_path)
self.assertEqual(tls.__context__, ret)
|
'Test to see if ca does not exist'
| def test_ca_exists(self):
| ca_path = '/tmp/test_tls'
ca_name = 'test_ca'
mock_opt = MagicMock(return_value=ca_path)
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
with patch('os.path.exists', MagicMock(return_value=False)):
with patch('salt.modules.tls.maybe_fix_ssl_version', MagicMock(return_valu... |
'Test to see if ca exists'
| def test_ca_exists_true(self):
| ca_path = '/tmp/test_tls'
ca_name = 'test_ca'
mock_opt = MagicMock(return_value=ca_path)
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
with patch('os.path.exists', MagicMock(return_value=True)):
with patch('salt.modules.tls.maybe_fix_ssl_version', MagicMock(return_value... |
'Test get_ca failure'
| def test_get_ca_fail(self):
| ca_path = '/tmp/test_tls'
ca_name = 'test_ca'
mock_opt = MagicMock(return_value=ca_path)
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
with patch('os.path.exists', MagicMock(return_value=False)):
with patch('salt.modules.tls.maybe_fix_ssl_version', MagicMock(return_valu... |
'Test get_ca text'
| def test_get_ca_text(self):
| ca_path = '/tmp/test_tls'
ca_name = 'test_ca'
mock_opt = MagicMock(return_value=ca_path)
with patch('salt.utils.files.fopen', mock_open(read_data=_TLS_TEST_DATA['ca_cert'])):
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
with patch('os.path.exists', MagicMock(return_val... |
'Test get_ca'
| def test_get_ca(self):
| ca_path = '/tmp/test_tls'
ca_name = 'test_ca'
certp = '{0}/{1}/{2}_ca_cert.crt'.format(ca_path, ca_name, ca_name)
mock_opt = MagicMock(return_value=ca_path)
with patch.dict(tls.__salt__, {'config.option': mock_opt}):
with patch('os.path.exists', MagicMock(return_value=True)):
wit... |
'Test cert info'
| def test_cert_info(self):
| self.maxDiff = None
with patch('os.path.exists', MagicMock(return_value=True)):
with patch('salt.modules.tls.maybe_fix_ssl_version', MagicMock(return_value=True)):
ca_path = '/tmp/test_tls'
ca_name = 'test_ca'
certp = '{0}/{1}/{2}_ca_cert.crt'.format(ca_path, ca_name,... |
'Test creating CA cert'
| def test_create_ca(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/{2}_ca_cert.crt'.format(ca_path, ca_name, ca_name)
certk = '{0}/{1}/{2}_ca_cert.key'.format(ca_path, ca_name, ca_name)
ret = 'Created Private Key: "{0}." Created CA "{1}": "{2}."'.f... |
'Test creating CA cert when one already exists'
| def test_recreate_ca(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/{2}_ca_cert.crt'.format(ca_path, ca_name, ca_name)
certk = '{0}/{1}/{2}_ca_cert.key'.format(ca_path, ca_name, ca_name)
ret = 'Created Private Key: "{0}." Created CA "{1}": "{2}."'.f... |
'Test creating certificate signing request'
| def test_create_csr(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/certs/{2}.csr'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
certk = '{0}/{1}/certs/{2}.key'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created Private Key: ... |
'Test creating certificate signing request when one already exists'
| def test_recreate_csr(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/certs/{2}.csr'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
certk = '{0}/{1}/certs/{2}.key'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created Private Key: ... |
'Test creating self signed certificate'
| def test_create_self_signed_cert(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
tls_dir = 'test_tls'
certp = '{0}/{1}/certs/{2}.crt'.format(ca_path, tls_dir, _TLS_TEST_DATA['create_ca']['CN'])
certk = '{0}/{1}/certs/{2}.key'.format(ca_path, tls_dir, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created Private Key: ... |
'Test creating self signed certificate when one already exists'
| def test_recreate_self_signed_cert(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
tls_dir = 'test_tls'
certp = '{0}/{1}/certs/{2}.crt'.format(ca_path, tls_dir, _TLS_TEST_DATA['create_ca']['CN'])
certk = '{0}/{1}/certs/{2}.key'.format(ca_path, tls_dir, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created Private Key: ... |
'Test signing certificate from request'
| def test_create_ca_signed_cert(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/certs/{2}.crt'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created Certificate for "{0}": "{1}"'.format(_TLS_TEST_DATA['create_ca']['CN'], certp)
mock_opt = MagicMock(... |
'Test signing certificate from request when certificate exists'
| def test_recreate_ca_signed_cert(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/certs/{2}.crt'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created Certificate for "{0}": "{1}"'.format(_TLS_TEST_DATA['create_ca']['CN'], certp)
mock_opt = MagicMock(... |
'Test creating pkcs12'
| def test_create_pkcs12(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/certs/{2}.p12'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created PKCS#12 Certificate for "{0}": "{1}"'.format(_TLS_TEST_DATA['create_ca']['CN'], certp)
mock_opt =... |
'Test creating pkcs12 when it already exists'
| def test_recreate_pkcs12(self):
| ca_path = tempfile.mkdtemp(dir=TMP)
try:
ca_name = 'test_ca'
certp = '{0}/{1}/certs/{2}.p12'.format(ca_path, ca_name, _TLS_TEST_DATA['create_ca']['CN'])
ret = 'Created PKCS#12 Certificate for "{0}": "{1}"'.format(_TLS_TEST_DATA['create_ca']['CN'], certp)
mock_opt =... |
'Test extension logic with different pyOpenSSL versions'
| def test_pyOpenSSL_version(self):
| pillarval = {'csr': {'extendedKeyUsage': 'serverAuth'}}
mock_pgt = MagicMock(return_value=pillarval)
with patch.dict(tls.__dict__, {'OpenSSL_version': LooseVersion('0.1.1'), 'X509_EXT_ENABLED': False}):
self.assertEqual(tls.__virtual__(), (False, 'PyOpenSSL version 0.10 or later must ... |
'Test extension logic with different pyOpenSSL versions'
| def test_pyOpenSSL_version_destructive(self):
| pillarval = {'csr': {'extendedKeyUsage': 'serverAuth'}}
mock_pgt = MagicMock(return_value=pillarval)
ca_path = tempfile.mkdtemp(dir=TMP)
ca_name = 'test_ca'
certp = '{0}/{1}/{2}_ca_cert.crt'.format(ca_path, ca_name, ca_name)
certk = '{0}/{1}/{2}_ca_cert.key'.format(ca_path, ca_name, ca_name)
... |
'Test for Answers to debconf questions for all packages'
| def test_get_selections(self):
| mock = MagicMock(return_value=[])
with patch.dict(debconfmod.__salt__, {'cmd.run_stdout': mock}):
with patch.object(debconfmod, '_unpack_lines', mock):
self.assertEqual(debconfmod.get_selections(False), {})
|
'Test for Answers to debconf questions for a package'
| def test_show(self):
| mock = MagicMock(return_value={})
with patch.object(debconfmod, 'get_selections', mock):
self.assertEqual(debconfmod.show('name'), None)
|
'Test for Set answers to debconf questions for a package.'
| def test_set_(self):
| mock = MagicMock(return_value=None)
with patch.object(os, 'write', mock):
with patch.object(os, 'close', mock):
with patch.object(debconfmod, '_set_file', mock):
with patch.object(os, 'unlink', mock):
self.assertTrue(debconfmod.set_('package', 'question', ... |
'Test for Set answers to debconf questions from a template.'
| def test_set_template(self):
| mock = MagicMock(return_value='A')
with patch.dict(debconfmod.__salt__, {'cp.get_template': mock}):
with patch.object(debconfmod, 'set_file', mock):
self.assertEqual(debconfmod.set_template('path', 'template', 'context', 'defaults', 'saltenv'), 'A')
|
'Test for Set answers to debconf questions from a file.'
| def test_set_file(self):
| mock = MagicMock(return_value='A')
with patch.dict(debconfmod.__salt__, {'cp.cache_file': mock}):
mock = MagicMock(return_value=None)
with patch.object(debconfmod, '_set_file', mock):
self.assertTrue(debconfmod.set_file('path'))
mock = MagicMock(return_value=False)
with patch... |
'Mock sendmail method'
| def sendmail(self, sender, recipient, msg):
| if (self.flag == 1):
raise SMTPRecipientsRefused('All recipients were refused.')
elif (self.flag == 2):
raise SMTPHeloError('Helo error')
elif (self.flag == 3):
raise SMTPSenderRefused('Sender Refused')
elif (self.flag == 4):
raise SMTPDataError('Data er... |
'Mock login method'
| def login(self, username, password):
| if (self.flag == 5):
raise SMTPAuthenticationError('SMTP Authentication Failure')
return (username, password)
|
'Mock quit method'
| @staticmethod
def quit():
| return True
|
'Mock ehlo method'
| @staticmethod
def ehlo():
| return True
|
'Mock has_extn method'
| @staticmethod
def has_extn(name):
| return name
|
'Mock starttls method'
| def starttls(self):
| if (self.flag == 1):
raise SMTPHeloError('Helo error')
elif (self.flag == 2):
raise SMTPException('Exception error')
elif (self.flag == 3):
raise RuntimeError
return True
|
'Mock sendmail method'
| def sendmail(self, sender, recipient, msg):
| if (self.flag == 1):
raise SMTPRecipientsRefused('All recipients were refused.')
elif (self.flag == 2):
raise SMTPHeloError('Helo error')
elif (self.flag == 3):
raise SMTPSenderRefused('Sender Refused')
elif (self.flag == 4):
raise SMTPDataError('Data er... |
'Mock quit method'
| @staticmethod
def quit():
| return True
|
'Mock SMTP_SSL method'
| def SMTP_SSL(self, server):
| self.server = server
if (self.flag == 1):
raise MockGaierror('gaierror')
return MockSMTPSSL('server')
|
'Mock SMTP method'
| def SMTP(self, server):
| self.server = server
if (self.flag == 1):
raise MockGaierror('gaierror')
return MockSMTP('server')
|
'Tests if it send a message to an SMTP recipient.'
| def test_send_msg(self):
| mock = MagicMock(return_value={'smtp.server': '', 'smtp.tls': 'True', 'smtp.sender': '', 'smtp.username': '', 'smtp.password': ''})
with patch.dict(smtp.__salt__, {'config.option': mock}):
self.assertTrue(smtp.send_msg('admin@example.com', 'This is a salt module test', profile='my-smtp-ac... |
'Tests checking event existence when the event already exists'
| def test_that_when_checking_if_a_rule_exists_and_a_rule_exists_the_rule_exists_method_returns_true(self):
| self.conn.list_rules.return_value = {'Rules': [rule_ret]}
result = boto_cloudwatch_event.exists(Name=rule_name, **conn_parameters)
self.assertTrue(result['exists'])
|
'Tests checking rule existence when the rule does not exist'
| def test_that_when_checking_if_a_rule_exists_and_a_rule_does_not_exist_the_exists_method_returns_false(self):
| self.conn.list_rules.return_value = {'Rules': []}
result = boto_cloudwatch_event.exists(Name=rule_name, **conn_parameters)
self.assertFalse(result['exists'])
|
'Tests checking rule existence when boto returns an error'
| def test_that_when_checking_if_a_rule_exists_and_boto3_returns_an_error_the_rule_exists_method_returns_error(self):
| self.conn.list_rules.side_effect = ClientError(error_content, 'list_rules')
result = boto_cloudwatch_event.exists(Name=rule_name, **conn_parameters)
self.assertEqual(result.get('error', {}).get('message'), error_message.format('list_rules'))
|
'Tests describe rule for an existing rule'
| def test_that_when_describing_rule_and_rule_exists_the_describe_rule_method_returns_rule(self):
| self.conn.describe_rule.return_value = rule_ret
result = boto_cloudwatch_event.describe(Name=rule_name, **conn_parameters)
self.assertEqual(result.get('rule'), rule_ret)
|
'Tests describe rule for an non existent rule'
| def test_that_when_describing_rule_and_rule_does_not_exists_the_describe_method_returns_none(self):
| self.conn.describe_rule.side_effect = not_found_error
result = boto_cloudwatch_event.describe(Name=rule_name, **conn_parameters)
self.assertNotEqual(result.get('error'), None)
|
'tests True when rule created'
| def test_that_when_creating_a_rule_succeeds_the_create_rule_method_returns_true(self):
| self.conn.put_rule.return_value = create_rule_ret
result = boto_cloudwatch_event.create_or_update(Name=rule_name, Description=rule_desc, ScheduleExpression=rule_sched, **conn_parameters)
self.assertTrue(result['created'])
|
'tests False when rule not created'
| def test_that_when_creating_a_rule_fails_the_create_method_returns_error(self):
| self.conn.put_rule.side_effect = ClientError(error_content, 'put_rule')
result = boto_cloudwatch_event.create_or_update(Name=rule_name, Description=rule_desc, ScheduleExpression=rule_sched, **conn_parameters)
self.assertEqual(result.get('error', {}).get('message'), error_message.format('put_rule'))
|
'tests True when delete rule succeeds'
| def test_that_when_deleting_a_rule_succeeds_the_delete_method_returns_true(self):
| self.conn.delete_rule.return_value = {}
result = boto_cloudwatch_event.delete(Name=rule_name, **conn_parameters)
self.assertTrue(result.get('deleted'))
self.assertEqual(result.get('error'), None)
|
'tests False when delete rule fails'
| def test_that_when_deleting_a_rule_fails_the_delete_method_returns_error(self):
| self.conn.delete_rule.side_effect = ClientError(error_content, 'delete_rule')
result = boto_cloudwatch_event.delete(Name=rule_name, **conn_parameters)
self.assertFalse(result.get('deleted'))
self.assertEqual(result.get('error', {}).get('message'), error_message.format('delete_rule'))
|
'Tests listing targets for an existing rule'
| def test_that_when_listing_targets_and_rule_exists_the_list_targets_method_returns_targets(self):
| self.conn.list_targets_by_rule.return_value = {'Targets': [target_ret]}
result = boto_cloudwatch_event.list_targets(Rule=rule_name, **conn_parameters)
self.assertEqual(result.get('targets'), [target_ret])
|
'Tests list targets for an non existent rule'
| def test_that_when_listing_targets_and_rule_does_not_exist_the_list_targets_method_returns_error(self):
| self.conn.list_targets_by_rule.side_effect = not_found_error
result = boto_cloudwatch_event.list_targets(Rule=rule_name, **conn_parameters)
self.assertNotEqual(result.get('error'), None)
|
'tests None when targets added'
| def test_that_when_putting_targets_succeeds_the_put_target_method_returns_no_failures(self):
| self.conn.put_targets.return_value = {'FailedEntryCount': 0}
result = boto_cloudwatch_event.put_targets(Rule=rule_name, Targets=[], **conn_parameters)
self.assertIsNone(result['failures'])
|
'tests False when thing type not created'
| def test_that_when_putting_targets_fails_the_put_targets_method_returns_error(self):
| self.conn.put_targets.side_effect = ClientError(error_content, 'put_targets')
result = boto_cloudwatch_event.put_targets(Rule=rule_name, Targets=[], **conn_parameters)
self.assertEqual(result.get('error', {}).get('message'), error_message.format('put_targets'))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.