desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test lising the beacons'
| def test_list(self):
| ret = self.run_function('beacons.list', return_yaml=False)
if ('enabled' in ret):
self.assertEqual(ret, {'ps': [{'apache2': 'stopped'}], 'enabled': True})
else:
self.assertEqual(ret, {'ps': {'apache': 'stopped'}})
|
'Start all services when they are not running.'
| def test_start_all(self):
| self.start_supervisord(autostart=False)
ret = self.run_function('supervisord.start', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertIn('sleep_service: started', ret)
self.assertIn('sleep_service2: started', ret)
|
'Start all services when they are running.'
| def test_start_all_already_running(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.start', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, '')
|
'Start a specific service that is not running.'
| def test_start_one(self):
| self.start_supervisord(autostart=False)
ret = self.run_function('supervisord.start', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, 'sleep_service: started')
|
'Try to start a specific service that is running.'
| def test_start_one_already_running(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.start', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, 'sleep_service: ERROR (already started)')
|
'Restart all services when they are running.'
| def test_restart_all(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.restart', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertIn('sleep_service: stopped', ret)
self.assertIn('sleep_service2: stopped', ret)
self.assertIn('sleep_service: started', ret)
self.assertIn('sleep_service2: started', ret)
|
'Restart all services when they are not running.'
| def test_restart_all_not_running(self):
| self.start_supervisord(autostart=False)
ret = self.run_function('supervisord.restart', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertIn('sleep_service: started', ret)
self.assertIn('sleep_service2: started', ret)
|
'Restart a specific service that is running.'
| def test_restart_one(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.restart', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, 'sleep_service: stopped\nsleep_service: started')
|
'Restart a specific service that is not running.'
| def test_restart_one_not_running(self):
| self.start_supervisord(autostart=False)
ret = self.run_function('supervisord.restart', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertIn('sleep_service: ERROR (not running)', ret)
self.assertIn('sleep_service: started', ret)
|
'Stop all services when they are running.'
| def test_stop_all(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.stop', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertIn('sleep_service: stopped', ret)
self.assertIn('sleep_service2: stopped', ret)
|
'Stop all services when they are not running.'
| def test_stop_all_not_running(self):
| self.start_supervisord(autostart=False)
ret = self.run_function('supervisord.stop', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, '')
|
'Stop a specific service that is running.'
| def test_stop_one(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.stop', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, 'sleep_service: stopped')
|
'Stop a specific service that is not running.'
| def test_stop_one_not_running(self):
| self.start_supervisord(autostart=False)
ret = self.run_function('supervisord.stop', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, 'sleep_service: ERROR (not running)')
|
'Status for all services'
| def test_status_all(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.status', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(list(ret.keys()), ['sleep_service', 'sleep_service2'])
|
'Status for a specific service.'
| def test_status_one(self):
| self.start_supervisord(autostart=True)
ret = self.run_function('supervisord.status', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertTrue(ret)
|
'Sets up test requirements'
| def setUp(self):
| os_grain = self.run_function('grains.item', ['kernel'])
if (os_grain['kernel'] not in 'Darwin'):
self.skipTest("Test not applicable to '{kernel}' kernel".format(**os_grain))
self.run_function('assistive.install', [OSA_SCRIPT, True])
|
'Clean up after tests'
| def tearDown(self):
| osa_script = self.run_function('assistive.installed', [OSA_SCRIPT])
if osa_script:
self.run_function('assistive.remove', [OSA_SCRIPT])
smile_bundle = 'com.smileonmymac.textexpander'
smile_bundle_present = self.run_function('assistive.installed', [smile_bundle])
if smile_bundle_present:
self.run_function('assistive.remove', [smile_bundle])
|
'Tests installing and removing a bundled ID or command to use assistive access.'
| def test_install_and_remove(self):
| new_bundle = 'com.smileonmymac.textexpander'
self.assertTrue(self.run_function('assistive.install', [new_bundle]))
self.assertTrue(self.run_function('assistive.remove', [new_bundle]))
|
'Tests the True and False return of assistive.installed.'
| def test_installed(self):
| self.assertTrue(self.run_function('assistive.installed', [OSA_SCRIPT]))
self.run_function('assistive.remove', [OSA_SCRIPT])
self.assertFalse(self.run_function('assistive.installed', [OSA_SCRIPT]))
|
'Tests setting the enabled status of a bundled ID or command.'
| def test_enable(self):
| self.assertTrue(self.run_function('assistive.enable', [OSA_SCRIPT, False]))
self.assertFalse(self.run_function('assistive.enabled', [OSA_SCRIPT]))
self.assertTrue(self.run_function('assistive.enable', [OSA_SCRIPT]))
self.assertTrue(self.run_function('assistive.enabled', [OSA_SCRIPT]))
|
'Tests if a bundled ID or command is listed in assistive access returns True.'
| def test_enabled(self):
| self.assertTrue(self.run_function('assistive.enabled', [OSA_SCRIPT]))
self.run_function('assistive.enable', [OSA_SCRIPT, False])
self.assertFalse(self.run_function('assistive.enabled', [OSA_SCRIPT]))
|
'Tests using the saltutil.wheel function when passing only a function.'
| def test_wheel_just_function(self):
| time.sleep(3)
ret = self.run_function('saltutil.wheel', ['minions.connected'])
self.assertIn('minion', ret['return'])
self.assertIn('sub_minion', ret['return'])
|
'Tests using the saltutil.wheel function when passing a function and an arg.'
| def test_wheel_with_arg(self):
| ret = self.run_function('saltutil.wheel', ['key.list', 'minion'])
self.assertEqual(ret['return'], {})
|
'Tests using the saltutil.wheel function when passing a function that requires
an arg, but one isn\'t supplied.'
| def test_wheel_no_arg_raise_error(self):
| self.assertRaises(TypeError, 'saltutil.wheel', ['key.list'])
|
'Tests using the saltutil.wheel function when passing a function and a kwarg.
This function just generates a key pair, but doesn\'t do anything with it. We
just need this for testing purposes.'
| def test_wheel_with_kwarg(self):
| ret = self.run_function('saltutil.wheel', ['key.gen'], keysize=1024)
self.assertIn('pub', ret['return'])
self.assertIn('priv', ret['return'])
|
'Test syncing all ModuleCase'
| def test_sync_all(self):
| expected_return = {'engines': [], 'clouds': [], 'grains': [], 'beacons': [], 'utils': [], 'returners': [], 'modules': ['modules.override_test', 'modules.runtests_decorators', 'modules.runtests_helpers', 'modules.salttest'], 'renderers': [], 'log_handlers': [], 'states': [], 'sdb': [], 'proxymodules': [], 'output': []}
ret = self.run_function('saltutil.sync_all')
self.assertEqual(ret, expected_return)
|
'Test syncing all ModuleCase with whitelist'
| def test_sync_all_whitelist(self):
| expected_return = {'engines': [], 'clouds': [], 'grains': [], 'beacons': [], 'utils': [], 'returners': [], 'modules': ['modules.salttest'], 'renderers': [], 'log_handlers': [], 'states': [], 'sdb': [], 'proxymodules': [], 'output': []}
ret = self.run_function('saltutil.sync_all', extmod_whitelist={'modules': ['salttest']})
self.assertEqual(ret, expected_return)
|
'Test syncing all ModuleCase with blacklist'
| def test_sync_all_blacklist(self):
| expected_return = {'engines': [], 'clouds': [], 'grains': [], 'beacons': [], 'utils': [], 'returners': [], 'modules': ['modules.override_test', 'modules.runtests_helpers', 'modules.salttest'], 'renderers': [], 'log_handlers': [], 'states': [], 'sdb': [], 'proxymodules': [], 'output': []}
ret = self.run_function('saltutil.sync_all', extmod_blacklist={'modules': ['runtests_decorators']})
self.assertEqual(ret, expected_return)
|
'Test syncing all ModuleCase with whitelist and blacklist'
| def test_sync_all_blacklist_and_whitelist(self):
| expected_return = {'engines': [], 'clouds': [], 'grains': [], 'beacons': [], 'utils': [], 'returners': [], 'modules': [], 'renderers': [], 'log_handlers': [], 'states': [], 'sdb': [], 'proxymodules': [], 'output': []}
ret = self.run_function('saltutil.sync_all', extmod_whitelist={'modules': ['runtests_decorators']}, extmod_blacklist={'modules': ['runtests_decorators']})
self.assertEqual(ret, expected_return)
|
'Sets up test requirements'
| def setUp(self):
| super(MacUserModuleTest, self).setUp()
os_grain = self.run_function('grains.item', ['kernel'])
if (os_grain['kernel'] not in 'Darwin'):
self.skipTest("Test not applicable to '{kernel}' kernel".format(**os_grain))
|
'Tests the add function'
| def test_mac_user_add(self):
| try:
self.run_function('user.add', [ADD_USER])
user_info = self.run_function('user.info', [ADD_USER])
self.assertEqual(ADD_USER, user_info['name'])
except CommandExecutionError:
self.run_function('user.delete', [ADD_USER])
raise
|
'Tests the delete function'
| def test_mac_user_delete(self):
| if (self.run_function('user.add', [DEL_USER]) is not True):
self.run_function('user.delete', [DEL_USER])
self.skipTest('Failed to create a user to delete')
try:
ret = self.run_function('user.delete', [DEL_USER])
self.assertTrue(ret)
except CommandExecutionError:
raise
|
'Tests the primary_group function'
| def test_mac_user_primary_group(self):
| if (self.run_function('user.add', [PRIMARY_GROUP_USER]) is not True):
self.run_function('user.delete', [PRIMARY_GROUP_USER])
self.skipTest('Failed to create a user')
try:
primary_group = self.run_function('user.primary_group', [PRIMARY_GROUP_USER])
uid_info = self.run_function('user.info', [PRIMARY_GROUP_USER])
self.assertIn(primary_group, uid_info['groups'])
except AssertionError:
self.run_function('user.delete', [PRIMARY_GROUP_USER])
raise
|
'Tests mac_user functions that change user properties'
| def test_mac_user_changes(self):
| if (self.run_function('user.add', [CHANGE_USER]) is not True):
self.run_function('user.delete', [CHANGE_USER])
self.skipTest('Failed to create a user')
try:
self.run_function('user.chuid', [CHANGE_USER, 4376])
uid_info = self.run_function('user.info', [CHANGE_USER])
self.assertEqual(uid_info['uid'], 4376)
self.run_function('user.chgid', [CHANGE_USER, 4376])
gid_info = self.run_function('user.info', [CHANGE_USER])
self.assertEqual(gid_info['gid'], 4376)
self.run_function('user.chshell', [CHANGE_USER, '/bin/zsh'])
shell_info = self.run_function('user.info', [CHANGE_USER])
self.assertEqual(shell_info['shell'], '/bin/zsh')
self.run_function('user.chhome', [CHANGE_USER, '/Users/foo'])
home_info = self.run_function('user.info', [CHANGE_USER])
self.assertEqual(home_info['home'], '/Users/foo')
self.run_function('user.chfullname', [CHANGE_USER, 'Foo Bar'])
fullname_info = self.run_function('user.info', [CHANGE_USER])
self.assertEqual(fullname_info['fullname'], 'Foo Bar')
self.run_function('user.chgroups', [CHANGE_USER, 'wheel'])
groups_info = self.run_function('user.info', [CHANGE_USER])
self.assertEqual(groups_info['groups'], ['wheel'])
except AssertionError:
self.run_function('user.delete', [CHANGE_USER])
raise
|
'Clean up after tests'
| def tearDown(self):
| add_info = self.run_function('user.info', [ADD_USER])
if add_info:
self.run_function('user.delete', [ADD_USER])
del_info = self.run_function('user.info', [DEL_USER])
if del_info:
self.run_function('user.delete', [DEL_USER])
change_info = self.run_function('user.info', [CHANGE_USER])
if change_info:
self.run_function('user.delete', [CHANGE_USER])
|
'Get current settings'
| def setUp(self):
| self.COMPUTER_SLEEP = self.run_function('power.get_computer_sleep')
self.DISPLAY_SLEEP = self.run_function('power.get_display_sleep')
self.HARD_DISK_SLEEP = self.run_function('power.get_harddisk_sleep')
|
'Reset to original settings'
| def tearDown(self):
| self.run_function('power.set_computer_sleep', [self.COMPUTER_SLEEP])
self.run_function('power.set_display_sleep', [self.DISPLAY_SLEEP])
self.run_function('power.set_harddisk_sleep', [self.HARD_DISK_SLEEP])
|
'Test power.get_computer_sleep
Test power.set_computer_sleep'
| @destructiveTest
def test_computer_sleep(self):
| self.assertTrue(self.run_function('power.set_computer_sleep', [90]))
self.assertEqual(self.run_function('power.get_computer_sleep'), 'after 90 minutes')
self.assertTrue(self.run_function('power.set_computer_sleep', ['Off']))
self.assertEqual(self.run_function('power.get_computer_sleep'), 'Never')
self.assertIn('Invalid String Value for Minutes', self.run_function('power.set_computer_sleep', ['spongebob']))
self.assertIn('Invalid Integer Value for Minutes', self.run_function('power.set_computer_sleep', [0]))
self.assertIn('Invalid Integer Value for Minutes', self.run_function('power.set_computer_sleep', [181]))
self.assertIn('Invalid Boolean Value for Minutes', self.run_function('power.set_computer_sleep', [True]))
|
'Test power.get_display_sleep
Test power.set_display_sleep'
| @destructiveTest
def test_display_sleep(self):
| self.assertTrue(self.run_function('power.set_display_sleep', [90]))
self.assertEqual(self.run_function('power.get_display_sleep'), 'after 90 minutes')
self.assertTrue(self.run_function('power.set_display_sleep', ['Off']))
self.assertEqual(self.run_function('power.get_display_sleep'), 'Never')
self.assertIn('Invalid String Value for Minutes', self.run_function('power.set_display_sleep', ['spongebob']))
self.assertIn('Invalid Integer Value for Minutes', self.run_function('power.set_display_sleep', [0]))
self.assertIn('Invalid Integer Value for Minutes', self.run_function('power.set_display_sleep', [181]))
self.assertIn('Invalid Boolean Value for Minutes', self.run_function('power.set_display_sleep', [True]))
|
'Test power.get_harddisk_sleep
Test power.set_harddisk_sleep'
| @destructiveTest
def test_harddisk_sleep(self):
| self.assertTrue(self.run_function('power.set_harddisk_sleep', [90]))
self.assertEqual(self.run_function('power.get_harddisk_sleep'), 'after 90 minutes')
self.assertTrue(self.run_function('power.set_harddisk_sleep', ['Off']))
self.assertEqual(self.run_function('power.get_harddisk_sleep'), 'Never')
self.assertIn('Invalid String Value for Minutes', self.run_function('power.set_harddisk_sleep', ['spongebob']))
self.assertIn('Invalid Integer Value for Minutes', self.run_function('power.set_harddisk_sleep', [0]))
self.assertIn('Invalid Integer Value for Minutes', self.run_function('power.set_harddisk_sleep', [181]))
self.assertIn('Invalid Boolean Value for Minutes', self.run_function('power.set_harddisk_sleep', [True]))
|
'Test power.get_restart_freeze
Test power.set_restart_freeze'
| def test_restart_freeze(self):
| self.assertTrue(self.run_function('power.set_restart_freeze', ['on']))
self.assertTrue(self.run_function('power.get_restart_freeze'))
self.assertFalse(self.run_function('power.set_restart_freeze', ['off']))
self.assertTrue(self.run_function('power.get_restart_freeze'))
|
'Check if function is available
Get existing value'
| def setUp(self):
| ret = self.run_function('power.get_sleep_on_power_button')
if isinstance(ret, bool):
self.SLEEP_ON_BUTTON = self.run_function('power.get_sleep_on_power_button')
|
'Reset to original value'
| def tearDown(self):
| if (self.SLEEP_ON_BUTTON is not None):
self.run_function('power.set_sleep_on_power_button', [self.SLEEP_ON_BUTTON])
|
'Test power.get_sleep_on_power_button
Test power.set_sleep_on_power_button'
| def test_sleep_on_power_button(self):
| if (self.SLEEP_ON_BUTTON is None):
ret = self.run_function('power.get_sleep_on_power_button')
self.assertIn('Error', ret)
else:
self.assertTrue(self.run_function('power.set_sleep_on_power_button', ['on']))
self.assertTrue(self.run_function('power.get_sleep_on_power_button'))
self.assertTrue(self.run_function('power.set_sleep_on_power_button', ['off']))
self.assertFalse(self.run_function('power.get_sleep_on_power_button'))
|
'Check if function is available
Get existing value'
| def setUp(self):
| ret = self.run_function('power.get_restart_power_failure')
if isinstance(ret, bool):
self.RESTART_POWER = ret
|
'Reset to original value'
| def tearDown(self):
| if (self.RESTART_POWER is not None):
self.run_function('power.set_sleep_on_power_button', [self.SLEEP_ON_BUTTON])
|
'Test power.get_restart_power_failure
Test power.set_restart_power_failure'
| def test_restart_power_failure(self):
| if (self.RESTART_POWER is None):
ret = self.run_function('power.get_restart_power_failure')
self.assertIn('Error', ret)
else:
self.assertTrue(self.run_function('power.set_restart_power_failure', ['on']))
self.assertTrue(self.run_function('power.get_restart_power_failure'))
self.assertTrue(self.run_function('power.set_restart_power_failure', ['off']))
self.assertFalse(self.run_function('power.get_restart_power_failure'))
|
'Check if function is available
Get existing value'
| def setUp(self):
| ret = self.run_function('power.get_wake_on_network')
if isinstance(ret, bool):
self.WAKE_ON_NET = ret
|
'Reset to original value'
| def tearDown(self):
| if (self.WAKE_ON_NET is not None):
self.run_function('power.set_wake_on_network', [self.WAKE_ON_NET])
|
'Test power.get_wake_on_network
Test power.set_wake_on_network'
| def test_wake_on_network(self):
| if (self.WAKE_ON_NET is None):
ret = self.run_function('power.get_wake_on_network')
self.assertIn('Error', ret)
else:
self.assertTrue(self.run_function('power.set_wake_on_network', ['on']))
self.assertTrue(self.run_function('power.get_wake_on_network'))
self.assertTrue(self.run_function('power.set_wake_on_network', ['off']))
self.assertFalse(self.run_function('power.get_wake_on_network'))
|
'Check if function is available
Get existing value'
| def setUp(self):
| ret = self.run_function('power.get_wake_on_modem')
if isinstance(ret, bool):
self.WAKE_ON_MODEM = ret
|
'Reset to original value'
| def tearDown(self):
| if (self.WAKE_ON_MODEM is not None):
self.run_function('power.set_wake_on_modem', [self.WAKE_ON_MODEM])
|
'Test power.get_wake_on_modem
Test power.set_wake_on_modem'
| def test_wake_on_modem(self):
| if (self.WAKE_ON_MODEM is None):
ret = self.run_function('power.get_wake_on_modem')
self.assertIn('Error', ret)
else:
self.assertTrue(self.run_function('power.set_wake_on_modem', ['on']))
self.assertTrue(self.run_function('power.get_wake_on_modem'))
self.assertTrue(self.run_function('power.set_wake_on_modem', ['off']))
self.assertFalse(self.run_function('power.get_wake_on_modem'))
|
'Set up test environment'
| def setUp(self):
| super(GentoolkitModuleTest, self).setUp()
ret_grain = self.run_function('grains.item', ['os'])
if (ret_grain['os'] not in 'Gentoo'):
self.skipTest('For Gentoo only')
|
'Get current settings'
| def setUp(self):
| self.USE_NETWORK_TIME = self.run_function('timezone.get_using_network_time')
self.TIME_SERVER = self.run_function('timezone.get_time_server')
self.TIME_ZONE = self.run_function('timezone.get_zone')
self.CURRENT_DATE = self.run_function('timezone.get_date')
self.CURRENT_TIME = self.run_function('timezone.get_time')
self.run_function('timezone.set_using_network_time', [False])
self.run_function('timezone.set_zone', ['America/Denver'])
|
'Reset to original settings'
| def tearDown(self):
| self.run_function('timezone.set_time_server', [self.TIME_SERVER])
self.run_function('timezone.set_using_network_time', [self.USE_NETWORK_TIME])
self.run_function('timezone.set_zone', [self.TIME_ZONE])
if (not self.USE_NETWORK_TIME):
self.run_function('timezone.set_date', [self.CURRENT_DATE])
self.run_function('timezone.set_time', [self.CURRENT_TIME])
|
'Test timezone.get_date
Test timezone.set_date'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_get_set_date(self):
| self.assertTrue(self.run_function('timezone.set_date', ['2/20/2011']))
self.assertEqual(self.run_function('timezone.get_date'), '2/20/2011')
self.assertEqual(self.run_function('timezone.set_date', ['13/12/2014']), "ERROR executing 'timezone.set_date': Invalid Date/Time Format: 13/12/2014")
|
'Test timezone.get_time'
| def test_get_time(self):
| text_time = self.run_function('timezone.get_time')
self.assertNotEqual(text_time, 'Invalid Timestamp')
obj_date = datetime.datetime.strptime(text_time, '%H:%M:%S')
self.assertIsInstance(obj_date, datetime.date)
|
'Test timezone.set_time'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_set_time(self):
| self.assertTrue(self.run_function('timezone.set_time', ['3:14']))
self.assertEqual(self.run_function('timezone.set_time', ['3:71']), "ERROR executing 'timezone.set_time': Invalid Date/Time Format: 3:71")
|
'Test timezone.get_zone
Test timezone.set_zone'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_get_set_zone(self):
| self.assertTrue(self.run_function('timezone.set_zone', ['Pacific/Wake']))
self.assertEqual(self.run_function('timezone.get_zone'), 'Pacific/Wake')
self.assertEqual(self.run_function('timezone.set_zone', ['spongebob']), "ERROR executing 'timezone.set_zone': Invalid Timezone: spongebob")
|
'Test timezone.get_offset'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_get_offset(self):
| self.assertTrue(self.run_function('timezone.set_zone', ['Pacific/Wake']))
self.assertIsInstance(self.run_function('timezone.get_offset'), str)
self.assertEqual(self.run_function('timezone.get_offset'), '+1200')
self.assertTrue(self.run_function('timezone.set_zone', ['America/Los_Angeles']))
self.assertIsInstance(self.run_function('timezone.get_offset'), str)
self.assertEqual(self.run_function('timezone.get_offset'), '-0700')
|
'Test timezone.get_zonecode
Test timezone.set_zonecode'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_get_set_zonecode(self):
| self.assertTrue(self.run_function('timezone.set_zone', ['America/Los_Angeles']))
self.assertIsInstance(self.run_function('timezone.get_zonecode'), str)
self.assertEqual(self.run_function('timezone.get_zonecode'), 'PDT')
self.assertTrue(self.run_function('timezone.set_zone', ['Pacific/Wake']))
self.assertIsInstance(self.run_function('timezone.get_zonecode'), str)
self.assertEqual(self.run_function('timezone.get_zonecode'), 'WAKT')
|
'Test timezone.list_zones'
| def test_list_zones(self):
| zones = self.run_function('timezone.list_zones')
self.assertIsInstance(self.run_function('timezone.list_zones'), list)
self.assertIn('America/Denver', self.run_function('timezone.list_zones'))
self.assertIn('America/Los_Angeles', self.run_function('timezone.list_zones'))
|
'Test timezone.zone_compare'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_zone_compare(self):
| self.assertTrue(self.run_function('timezone.set_zone', ['America/Denver']))
self.assertTrue(self.run_function('timezone.zone_compare', ['America/Denver']))
self.assertFalse(self.run_function('timezone.zone_compare', ['Pacific/Wake']))
|
'Test timezone.get_using_network_time
Test timezone.set_using_network_time'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_get_set_using_network_time(self):
| self.assertTrue(self.run_function('timezone.set_using_network_time', [True]))
self.assertTrue(self.run_function('timezone.get_using_network_time'))
self.assertTrue(self.run_function('timezone.set_using_network_time', [False]))
self.assertFalse(self.run_function('timezone.get_using_network_time'))
|
'Test timezone.get_time_server
Test timezone.set_time_server'
| @skipIf(True, 'Skip until we can figure out why modifying the system clock causes ZMQ errors')
@destructiveTest
def test_get_set_time_server(self):
| self.assertTrue(self.run_function('timezone.set_time_server', ['spongebob.com']))
self.assertEqual(self.run_function('timezone.get_time_server'), 'spongebob.com')
|
'disk.usage'
| def test_usage(self):
| ret = self.run_function('disk.usage')
self.assertTrue(isinstance(ret, dict))
if (not isinstance(ret, dict)):
return
if salt.utils.platform.is_darwin():
for (key, val) in six.iteritems(ret):
self.assertTrue(('filesystem' in val))
self.assertTrue(('512-blocks' in val))
self.assertTrue(('used' in val))
self.assertTrue(('available' in val))
self.assertTrue(('capacity' in val))
self.assertTrue(('iused' in val))
self.assertTrue(('ifree' in val))
self.assertTrue(('%iused' in val))
else:
for (key, val) in six.iteritems(ret):
self.assertTrue(('filesystem' in val))
self.assertTrue(('1K-blocks' in val))
self.assertTrue(('used' in val))
self.assertTrue(('available' in val))
self.assertTrue(('capacity' in val))
|
'disk.inodeusage'
| @skipIf(salt.utils.platform.is_windows(), 'inode info not available on Windows')
def test_inodeusage(self):
| ret = self.run_function('disk.inodeusage')
self.assertTrue(isinstance(ret, dict))
if (not isinstance(ret, dict)):
return
for (key, val) in six.iteritems(ret):
self.assertTrue(('inodes' in val))
self.assertTrue(('used' in val))
self.assertTrue(('free' in val))
self.assertTrue(('use' in val))
self.assertTrue(('filesystem' in val))
|
'Clean up any LXCs created.'
| def tearDown(self):
| r = self.run_function('lxc.list')
for (k, v) in six.iteritems(r):
for x in v:
if x.startswith(self.prefix):
self.run_function('lxc.destroy', [x])
|
'Test basic create/destroy of an LXC.'
| def test_create_destroy(self):
| r = self.run_function('lxc.create', [self.prefix], template='sshd')
self.assertEqual(r, {'state': {'new': 'stopped', 'old': None}, 'result': True})
self.assertTrue(self.run_function('lxc.exists', [self.prefix]))
r = self.run_function('lxc.destroy', [self.prefix])
self.assertEqual(r, {'state': None, 'change': True})
self.assertFalse(self.run_function('lxc.exists', [self.prefix]))
|
'Test basic init functionality.'
| def test_init(self):
| r = self.run_function('lxc.init', [self.prefix], profile='sshd', seed=False)
self.assertTrue(r.get('created', False))
self.assertTrue(self.run_function('lxc.exists', [self.prefix]))
|
'Regression test for macvlan nic profile.'
| def test_macvlan(self):
| p = {'macvlan': {'eth0': {'macvlan.mode': 'bridge', 'link': 'eth0', 'type': 'macvlan'}}}
self.run_function('grains.setval', ['lxc.nic', p])
self.run_function('lxc.init', [self.prefix], profile='sshd', nic='macvlan', seed=False, start=False)
f = '/var/lib/lxc/{0}/config'.format(self.prefix)
conf = self.run_function('lxc.read_conf', [f])
self.run_function('cmd.run', ['truncate -s 0 {0}'.format(f)])
self.assertEqual(conf.get('lxc.network.type'), 'macvlan')
|
'cp.get_file'
| def test_get_file(self):
| tgt = os.path.join(paths.TMP, 'scene33')
self.run_function('cp.get_file', ['salt://grail/scene33', tgt])
with salt.utils.files.fopen(tgt, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_file'
| def test_get_file_to_dir(self):
| tgt = os.path.join(paths.TMP, '')
self.run_function('cp.get_file', ['salt://grail/scene33', tgt])
with salt.utils.files.fopen((tgt + 'scene33'), 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_file'
| def test_get_file_templated_paths(self):
| tgt = os.path.join(paths.TMP, 'cheese')
self.run_function('cp.get_file', ['salt://{{grains.test_grain}}', tgt.replace('cheese', '{{grains.test_grain}}')], template='jinja')
with salt.utils.files.fopen(tgt, 'r') as cheese:
data = cheese.read()
self.assertIn('Gromit', data)
self.assertNotIn('bacon', data)
|
'cp.get_file'
| def test_get_file_gzipped(self):
| tgt = os.path.join(paths.TMP, 'file.big')
src = os.path.join(paths.FILES, 'file', 'base', 'file.big')
with salt.utils.files.fopen(src, 'r') as fp_:
data = fp_.read()
if six.PY3:
data = salt.utils.stringutils.to_bytes(data)
hash_str = hashlib.md5(data).hexdigest()
self.run_function('cp.get_file', ['salt://file.big', tgt], gzip=5)
with salt.utils.files.fopen(tgt, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
if six.PY3:
data = salt.utils.stringutils.to_bytes(data)
self.assertEqual(hash_str, hashlib.md5(data).hexdigest())
|
'cp.get_file'
| def test_get_file_makedirs(self):
| tgt = os.path.join(paths.TMP, 'make', 'dirs', 'scene33')
self.run_function('cp.get_file', ['salt://grail/scene33', tgt], makedirs=True)
self.addCleanup(shutil.rmtree, os.path.join(paths.TMP, 'make'), ignore_errors=True)
with salt.utils.files.fopen(tgt, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_template'
| def test_get_template(self):
| tgt = os.path.join(paths.TMP, 'scene33')
self.run_function('cp.get_template', ['salt://grail/scene33', tgt], spam='bacon')
with salt.utils.files.fopen(tgt, 'r') as scene:
data = scene.read()
self.assertIn('bacon', data)
self.assertNotIn('spam', data)
|
'cp.get_dir'
| def test_get_dir(self):
| tgt = os.path.join(paths.TMP, 'many')
self.run_function('cp.get_dir', ['salt://grail', tgt])
self.assertIn('grail', os.listdir(tgt))
self.assertIn('36', os.listdir(os.path.join(tgt, 'grail')))
self.assertIn('empty', os.listdir(os.path.join(tgt, 'grail')))
self.assertIn('scene', os.listdir(os.path.join(tgt, 'grail', '36')))
|
'cp.get_dir'
| def test_get_dir_templated_paths(self):
| tgt = os.path.join(paths.TMP, 'many')
self.run_function('cp.get_dir', ['salt://{{grains.script}}', tgt.replace('many', '{{grains.alot}}')])
self.assertIn('grail', os.listdir(tgt))
self.assertIn('36', os.listdir(os.path.join(tgt, 'grail')))
self.assertIn('empty', os.listdir(os.path.join(tgt, 'grail')))
self.assertIn('scene', os.listdir(os.path.join(tgt, 'grail', '36')))
|
'cp.get_url with salt:// source given'
| def test_get_url(self):
| tgt = os.path.join(paths.TMP, 'scene33')
self.run_function('cp.get_url', ['salt://grail/scene33', tgt])
with salt.utils.files.fopen(tgt, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_url'
| def test_get_url_makedirs(self):
| tgt = os.path.join(paths.TMP, 'make', 'dirs', 'scene33')
self.run_function('cp.get_url', ['salt://grail/scene33', tgt], makedirs=True)
self.addCleanup(shutil.rmtree, os.path.join(paths.TMP, 'make'), ignore_errors=True)
with salt.utils.files.fopen(tgt, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_url with salt:// source given and destination omitted.'
| def test_get_url_dest_empty(self):
| ret = self.run_function('cp.get_url', ['salt://grail/scene33'])
with salt.utils.files.fopen(ret, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_url with salt:// source given and destination set as None'
| def test_get_url_no_dest(self):
| tgt = None
ret = self.run_function('cp.get_url', ['salt://grail/scene33', tgt])
self.assertIn("KNIGHT: They're nervous, sire.", ret)
|
'cp.get_url with nonexistent salt:// source given'
| def test_get_url_nonexistent_source(self):
| tgt = None
ret = self.run_function('cp.get_url', ['salt://grail/nonexistent_scene', tgt])
self.assertEqual(ret, False)
|
'cp.get_url with salt:// source'
| def test_get_url_to_dir(self):
| tgt = os.path.join(paths.TMP, '')
self.run_function('cp.get_url', ['salt://grail/scene33', tgt])
with salt.utils.files.fopen((tgt + 'scene33'), 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_url with https:// source given'
| def test_get_url_https(self):
| tgt = os.path.join(paths.TMP, 'test_get_url_https')
self.run_function('cp.get_url', ['https://repo.saltstack.com/index.html', tgt])
with salt.utils.files.fopen(tgt, 'r') as instructions:
data = instructions.read()
self.assertIn('Bootstrap', data)
self.assertIn('Debian', data)
self.assertIn('Windows', data)
self.assertNotIn('AYBABTU', data)
|
'cp.get_url with https:// source given and destination omitted.'
| def test_get_url_https_dest_empty(self):
| ret = self.run_function('cp.get_url', ['https://repo.saltstack.com/index.html'])
with salt.utils.files.fopen(ret, 'r') as instructions:
data = instructions.read()
self.assertIn('Bootstrap', data)
self.assertIn('Debian', data)
self.assertIn('Windows', data)
self.assertNotIn('AYBABTU', data)
|
'cp.get_url with https:// source given and destination set as None'
| def test_get_url_https_no_dest(self):
| tgt = None
ret = self.run_function('cp.get_url', ['https://repo.saltstack.com/index.html', tgt])
self.assertIn('Bootstrap', ret)
self.assertIn('Debian', ret)
self.assertIn('Windows', ret)
self.assertNotIn('AYBABTU', ret)
|
'cp.get_url with file:// source given'
| def test_get_url_file(self):
| tgt = ''
src = os.path.join('file://', paths.FILES, 'file', 'base', 'file.big')
ret = self.run_function('cp.get_url', [src, tgt])
with salt.utils.files.fopen(ret, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.get_url with file:// source given and destination set as None'
| def test_get_url_file_no_dest(self):
| tgt = None
src = os.path.join('file://', paths.FILES, 'file', 'base', 'file.big')
ret = self.run_function('cp.get_url', [src, tgt])
self.assertIn("KNIGHT: They're nervous, sire.", ret)
self.assertNotIn('bacon', ret)
|
'cp.get_file_str with salt:// source given'
| def test_get_file_str_salt(self):
| src = 'salt://grail/scene33'
ret = self.run_function('cp.get_file_str', [src])
self.assertIn("KNIGHT: They're nervous, sire.", ret)
|
'cp.get_file_str with nonexistent salt:// source given'
| def test_get_file_str_nonexistent_source(self):
| src = 'salt://grail/nonexistent_scene'
ret = self.run_function('cp.get_file_str', [src])
self.assertEqual(ret, False)
|
'cp.get_file_str with https:// source given'
| def test_get_file_str_https(self):
| src = 'https://repo.saltstack.com/index.html'
ret = self.run_function('cp.get_file_str', [src])
self.assertIn('Bootstrap', ret)
self.assertIn('Debian', ret)
self.assertIn('Windows', ret)
self.assertNotIn('AYBABTU', ret)
|
'cp.get_file_str with file:// source given'
| def test_get_file_str_local(self):
| src = os.path.join('file://', paths.FILES, 'file', 'base', 'file.big')
ret = self.run_function('cp.get_file_str', [src])
self.assertIn("KNIGHT: They're nervous, sire.", ret)
self.assertNotIn('bacon', ret)
|
'cp.cache_file'
| def test_cache_file(self):
| ret = self.run_function('cp.cache_file', ['salt://grail/scene33'])
with salt.utils.files.fopen(ret, 'r') as scene:
data = scene.read()
self.assertIn("KNIGHT: They're nervous, sire.", data)
self.assertNotIn('bacon', data)
|
'cp.cache_files'
| def test_cache_files(self):
| ret = self.run_function('cp.cache_files', [['salt://grail/scene33', 'salt://grail/36/scene']])
for path in ret:
with salt.utils.files.fopen(path, 'r') as scene:
data = scene.read()
self.assertIn('ARTHUR:', data)
self.assertNotIn('bacon', data)
|
'cp.cache_master'
| def test_cache_master(self):
| ret = self.run_function('cp.cache_master')
for path in ret:
self.assertTrue(os.path.exists(path))
|
'cp.cache_local_file'
| def test_cache_local_file(self):
| src = os.path.join(paths.TMP, 'random')
with salt.utils.files.fopen(src, 'w+') as fn_:
fn_.write('foo')
ret = self.run_function('cp.cache_local_file', [src])
with salt.utils.files.fopen(ret, 'r') as cp_:
self.assertEqual(cp_.read(), 'foo')
|
'cp.cache_file'
| @skipIf((not salt.utils.path.which('nginx')), 'nginx not installed')
@skip_if_not_root
def test_cache_remote_file(self):
| nginx_port = get_unused_localhost_port()
url_prefix = 'http://localhost:{0}/'.format(nginx_port)
temp_dir = tempfile.mkdtemp(dir=paths.TMP)
self.addCleanup(shutil.rmtree, temp_dir, ignore_errors=True)
nginx_root_dir = os.path.join(temp_dir, 'root')
nginx_conf_dir = os.path.join(temp_dir, 'conf')
nginx_conf = os.path.join(nginx_conf_dir, 'nginx.conf')
nginx_pidfile = os.path.join(nginx_conf_dir, 'nginx.pid')
file_contents = 'Hello world!'
for dirname in (nginx_root_dir, nginx_conf_dir):
os.mkdir(dirname)
with salt.utils.files.fopen(os.path.join(nginx_root_dir, 'actual_file'), 'w') as fp_:
fp_.write(file_contents)
with salt.utils.files.fopen(nginx_conf, 'w') as fp_:
fp_.write(textwrap.dedent(' user root;\n worker_processes 1;\n error_log {nginx_conf_dir}/server_error.log;\n pid {nginx_pidfile};\n\n events {{\n worker_connections 1024;\n }}\n\n http {{\n include /etc/nginx/mime.types;\n default_type application/octet-stream;\n\n access_log {nginx_conf_dir}/access.log;\n error_log {nginx_conf_dir}/error.log;\n\n server {{\n listen {nginx_port} default_server;\n server_name cachefile.local;\n root {nginx_root_dir};\n\n location ~ ^/301$ {{\n return 301 /actual_file;\n }}\n\n location ~ ^/302$ {{\n return 302 /actual_file;\n }}\n }}\n }}'.format(**locals())))
self.run_function('cmd.run', [['nginx', '-c', nginx_conf]], python_shell=False)
with salt.utils.files.fopen(nginx_pidfile) as fp_:
nginx_pid = int(fp_.read().strip())
nginx_proc = psutil.Process(pid=nginx_pid)
self.addCleanup(nginx_proc.send_signal, signal.SIGQUIT)
for code in ('', '301', '302'):
url = (url_prefix + (code or 'actual_file'))
log.debug('attempting to cache %s', url)
ret = self.run_function('cp.cache_file', [url])
with salt.utils.files.fopen(ret) as fp_:
cached_contents = fp_.read()
self.assertEqual(cached_contents, file_contents)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.