desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Perform some tests around creation of the given grants'
| def _addGrantRoutine(self, grant, user, db, grant_option=False, escape=True, **kwargs):
| ret = self.run_function('mysql.grant_add', grant=grant, database=db, user=user, grant_option=grant_option, escape=escape, **kwargs)
self.assertEqual(True, ret, "Calling grant_add on user '{0}' and grants '{1}' did not return True: {2}".format(user, grant, repr(ret)))
ret = self.run_function('mysql.grant_exists', grant=grant, database=db, user=user, grant_option=grant_option, escape=escape, **kwargs)
self.assertEqual(True, ret, "Calling grant_exists on user '{0}' and grants '{1}' did not return True: {2}".format(user, grant, repr(ret)))
|
'Test user grant methods'
| @destructiveTest
def testGrants(self):
| self._addGrantRoutine(grant='SELECT, INSERT,UPDATE, CREATE', user=self.users['user1']['name'], db=(self.testdb1 + '.*'), grant_option=True, escape=True, connection_user=self.user, connection_pass=self.password)
self._addGrantRoutine(grant='INSERT, SELECT', user=self.users['user1']['name'], db=((self.testdb2 + '.') + self.table1), grant_option=True, escape=True, connection_user=self.user, connection_pass=self.password)
self._addGrantRoutine(grant=' SELECT, UPDATE,DELETE, CREATE TEMPORARY TABLES', user=self.users['user2']['name'], db=(self.testdb1 + '.*'), grant_option=True, escape=True, connection_user=self.user, connection_pass=self.password)
self._addGrantRoutine(grant='select, ALTER,CREATE TEMPORARY TABLES, EXECUTE ', user=self.users['user3']['name'], db=(self.testdb1 + '.*'), grant_option=True, escape=True, connection_user=self.user, connection_pass=self.password)
self._addGrantRoutine(grant='SELECT, INSERT', user=self.users['user4']['name'], db=((self.testdb2 + '.') + self.table2), grant_option=False, escape=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self._addGrantRoutine(grant='CREATE', user=self.users['user4']['name'], db=(self.testdb2 + '.*'), grant_option=False, escape=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self._addGrantRoutine(grant='SELECT, INSERT', user=self.users['user4']['name'], db=((self.testdb2 + '.') + self.table1), grant_option=False, escape=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self._addGrantRoutine(grant='DELETE', user='', db=(self.testdb3 + '.*'), grant_option=False, escape=True, connection_user=self.user, connection_pass=self.password)
ret = self.run_function('mysql.user_grants', user=self.users['user1']['name'], host='localhost', connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, ["GRANT USAGE ON *.* TO 'foo'@'localhost'", 'GRANT SELECT, INSERT, UPDATE, CREATE ON `tes.t\'"saltdb`.* TO \'foo\'@\'localhost\' WITH GRANT OPTION', "GRANT SELECT, INSERT ON `t_st ``(:=salt%b)`.`foo` TO 'foo'@'localhost' WITH GRANT OPTION"])
ret = self.run_function('mysql.user_grants', user=self.users['user2']['name'], host='localhost', connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, ['GRANT USAGE ON *.* TO \'user ";--,?:&/\\\'@\'localhost\'', 'GRANT SELECT, UPDATE, DELETE, CREATE TEMPORARY TABLES ON `tes.t\'"saltdb`.* TO \'user ";--,?:&/\\\'@\'localhost\' WITH GRANT OPTION'])
ret = self.run_function('mysql.user_grants', user=self.users['user3']['name'], host='localhost', connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, ["GRANT USAGE ON *.* TO 'user( @ )=foobar'@'localhost'", 'GRANT SELECT, ALTER, CREATE TEMPORARY TABLES, EXECUTE ON `tes.t\'"saltdb`.* TO \'user( @ )=foobar\'@\'localhost\' WITH GRANT OPTION'])
ret = self.run_function('mysql.user_grants', user=self.users['user4']['name'], host='localhost', connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertEqual(ret, ["GRANT USAGE ON *.* TO 'user \xe6\xa8\x99'@'localhost'", "GRANT CREATE ON `t\\_st ``(:=salt\\%b)`.* TO 'user \xe6\xa8\x99'@'localhost'", "GRANT SELECT, INSERT ON `t_st ``(:=salt%b)`.`foo ``'%_bar` TO 'user \xe6\xa8\x99'@'localhost'", "GRANT SELECT, INSERT ON `t_st ``(:=salt%b)`.`foo` TO 'user \xe6\xa8\x99'@'localhost'"])
ret = self.run_function('mysql.user_grants', user='', host='localhost', connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, ["GRANT USAGE ON *.* TO ''@'localhost'", "GRANT DELETE ON `test ``(:=salteeb)`.* TO ''@'localhost'"])
|
'Sets up the 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))
|
'Tests that writes and reads macdefaults'
| def test_macdefaults_write_read(self):
| write_domain = self.run_function('macdefaults.write', [DEFAULT_DOMAIN, DEFAULT_KEY, DEFAULT_VALUE])
self.assertTrue(write_domain)
read_domain = self.run_function('macdefaults.read', [DEFAULT_DOMAIN, DEFAULT_KEY])
self.assertTrue(read_domain)
self.assertEqual(read_domain, DEFAULT_VALUE)
|
'Get current settings'
| def setUp(self):
| self.IGNORED_LIST = self.run_function('softwareupdate.list_ignored')
self.SCHEDULE = self.run_function('softwareupdate.schedule')
self.CATALOG = self.run_function('softwareupdate.get_catalog')
super(MacSoftwareUpdateModuleTest, self).setUp()
|
'Reset to original settings'
| def tearDown(self):
| if self.IGNORED_LIST:
for item in self.IGNORED_LIST:
self.run_function('softwareupdate.ignore', [item])
else:
self.run_function('softwareupdate.reset_ignored')
self.run_function('softwareupdate.schedule', [self.SCHEDULE])
if (self.CATALOG == 'Default'):
self.run_function('softwareupdate.reset_catalog')
else:
self.run_function('softwareupdate.set_catalog', [self.CATALOG])
super(MacSoftwareUpdateModuleTest, self).tearDown()
|
'Test softwareupdate.list_available'
| def test_list_available(self):
| self.assertIsInstance(self.run_function('softwareupdate.list_available'), dict)
|
'Test softwareupdate.ignore
Test softwareupdate.list_ignored
Test softwareupdate.reset_ignored'
| @destructiveTest
def test_ignore(self):
| self.assertTrue(self.run_function('softwareupdate.reset_ignored'))
self.assertEqual(self.run_function('softwareupdate.list_ignored'), [])
self.assertTrue(self.run_function('softwareupdate.ignore', ['spongebob']))
self.assertTrue(self.run_function('softwareupdate.ignore', ['squidward']))
self.assertIn('spongebob', self.run_function('softwareupdate.list_ignored'))
self.assertIn('squidward', self.run_function('softwareupdate.list_ignored'))
|
'Test softwareupdate.schedule_enable
Test softwareupdate.schedule_enabled'
| @destructiveTest
def test_schedule(self):
| self.assertTrue(self.run_function('softwareupdate.schedule_enable', [True]))
self.assertTrue(self.run_function('softwareupdate.schedule_enabled'))
self.assertTrue(self.run_function('softwareupdate.schedule_enable', [False]))
self.assertFalse(self.run_function('softwareupdate.schedule_enabled'))
|
'Test softwareupdate.update_all
Test softwareupdate.update
Test softwareupdate.update_available
Need to know the names of updates that are available to properly test
the update functions...'
| @destructiveTest
def test_update(self):
| self.assertIsInstance(self.run_function('softwareupdate.update_all'), dict)
self.assertFalse(self.run_function('softwareupdate.update_available', ['spongebob']))
self.assertIn('Update not available', self.run_function('softwareupdate.update', ['spongebob']))
|
'Test softwareupdate.list_downloads'
| def test_list_downloads(self):
| self.assertIsInstance(self.run_function('softwareupdate.list_downloads'), list)
|
'Test softwareupdate.download
Need to know the names of updates that are available to properly test
the download function'
| @destructiveTest
def test_download(self):
| self.assertIn('Update not available', self.run_function('softwareupdate.download', ['spongebob']))
|
'Test softwareupdate.download_all'
| @destructiveTest
def test_download_all(self):
| self.assertIsInstance(self.run_function('softwareupdate.download_all'), list)
|
'Test softwareupdate.download_all'
| @destructiveTest
def test_get_set_reset_catalog(self):
| self.assertTrue(self.run_function('softwareupdate.reset_catalog'))
self.assertEqual(self.run_function('softwareupdate.get_catalog'), 'Default')
self.assertTrue(self.run_function('softwareupdate.set_catalog', ['spongebob']))
self.assertEqual(self.run_function('softwareupdate.get_catalog'), 'spongebob')
self.assertTrue(self.run_function('softwareupdate.reset_catalog'))
self.assertEqual(self.run_function('softwareupdate.get_catalog'), 'Default')
|
'Get current settings'
| def setUp(self):
| super(GroupModuleTest, self).setUp()
self._user = self.__random_string()
self._user1 = self.__random_string()
self._no_user = self.__random_string()
self._group = self.__random_string()
self._no_group = self.__random_string()
self._gid = 64989
self._new_gid = 64998
os_grain = self.run_function('grains.item', ['kernel'])
if (os_grain['kernel'] not in 'Linux'):
self.skipTest("Test not applicable to '{kernel}' kernel".format(**os_grain))
|
'Reset to original settings'
| @destructiveTest
def tearDown(self):
| self.run_function('user.delete', [self._user])
self.run_function('user.delete', [self._user1])
self.run_function('group.delete', [self._group])
|
'Generates a random names'
| def __random_string(self, size=6):
| return ('tg-' + ''.join((random.choice((string.ascii_lowercase + string.digits)) for x in range(size))))
|
'Test the add group function'
| @destructiveTest
def test_add(self):
| self.assertTrue(self.run_function('group.add', [self._group, self._gid]))
group_info = self.run_function('group.info', [self._group])
self.assertEqual(group_info['name'], self._group)
self.assertEqual(group_info['gid'], self._gid)
self.assertFalse(self.run_function('group.add', [self._group, self._gid]))
|
'Test the delete group function'
| @destructiveTest
def test_delete(self):
| self.assertTrue(self.run_function('group.add', [self._group]))
self.assertTrue(self.run_function('group.delete', [self._group]))
self.assertFalse(self.run_function('group.delete', [self._no_group]))
|
'Test the info group function'
| @destructiveTest
def test_info(self):
| self.run_function('group.add', [self._group, self._gid])
self.run_function('user.add', [self._user])
self.run_function('group.adduser', [self._group, self._user])
group_info = self.run_function('group.info', [self._group])
self.assertEqual(group_info['name'], self._group)
self.assertEqual(group_info['gid'], self._gid)
self.assertIn(self._user, group_info['members'])
|
'Test the change gid function'
| @destructiveTest
def test_chgid(self):
| self.run_function('group.add', [self._group, self._gid])
self.assertTrue(self.run_function('group.chgid', [self._group, self._new_gid]))
group_info = self.run_function('group.info', [self._group])
self.assertEqual(group_info['gid'], self._new_gid)
|
'Test the add user to group function'
| @destructiveTest
def test_adduser(self):
| self.run_function('group.add', [self._group, self._gid])
self.run_function('user.add', [self._user])
self.assertTrue(self.run_function('group.adduser', [self._group, self._user]))
group_info = self.run_function('group.info', [self._group])
self.assertIn(self._user, group_info['members'])
self.assertFalse(self.run_function('group.adduser', [self._group, self._no_user]))
self.assertFalse(self.run_function('group.adduser', [self._no_group, self._user]))
self.assertFalse(self.run_function('group.adduser', [self._no_group, self._no_user]))
|
'Test the delete user from group function'
| @destructiveTest
def test_deluser(self):
| self.run_function('group.add', [self._group, self._gid])
self.run_function('user.add', [self._user])
self.run_function('group.adduser', [self._group, self._user])
self.assertTrue(self.run_function('group.deluser', [self._group, self._user]))
group_info = self.run_function('group.info', [self._group])
self.assertNotIn(self._user, group_info['members'])
|
'Test the members function'
| @destructiveTest
def test_members(self):
| self.run_function('group.add', [self._group, self._gid])
self.run_function('user.add', [self._user])
self.run_function('user.add', [self._user1])
m = '{0},{1}'.format(self._user, self._user1)
self.assertTrue(self.run_function('group.members', [self._group, m]))
group_info = self.run_function('group.info', [self._group])
self.assertIn(self._user, group_info['members'])
self.assertIn(self._user1, group_info['members'])
|
'Test the getent function'
| @destructiveTest
def test_getent(self):
| self.run_function('group.add', [self._group, self._gid])
self.run_function('user.add', [self._user])
self.run_function('group.adduser', [self._group, self._user])
ginfo = self.run_function('user.getent')
self.assertIn(self._group, str(ginfo))
self.assertIn(self._user, str(ginfo))
self.assertNotIn(self._no_group, str(ginfo))
self.assertNotIn(self._no_user, str(ginfo))
|
'test key.finger to ensure we receive a valid fingerprint'
| def test_key_finger(self):
| out = self.run_function('key.finger')
match = re.match('([0-9a-z]{2}:){15,}[0-9a-z]{2}$', out)
self.assertTrue(match)
|
'test key.finger_master to ensure we receive a valid fingerprint'
| def test_key_finger_master(self):
| out = self.run_function('key.finger_master')
match = re.match('([0-9a-z]{2}:){15,}[0-9a-z]{2}$', out)
self.assertTrue(match)
|
'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))
|
'Tests the return of get_output_volume.'
| def test_get_output_volume(self):
| ret = self.run_function('desktop.get_output_volume')
self.assertIsNotNone(ret)
|
'Tests the return of set_output_volume.'
| def test_set_output_volume(self):
| current_vol = self.run_function('desktop.get_output_volume')
to_set = 10
if (current_vol == str(to_set)):
to_set += 2
new_vol = self.run_function('desktop.set_output_volume', [str(to_set)])
check_vol = self.run_function('desktop.get_output_volume')
self.assertEqual(new_vol, check_vol)
self.run_function('desktop.set_output_volume', [current_vol])
|
'Tests the return of the screensaver function.'
| def test_screensaver(self):
| self.assertTrue(self.run_function('desktop.screensaver'))
|
'Tests the return of the lock function.'
| def test_lock(self):
| self.assertTrue(self.run_function('desktop.lock'))
|
'Tests the return of the say function.'
| def test_say(self):
| self.assertTrue(self.run_function('desktop.say', ['hello', 'world']))
|
'Tests the primary_group function'
| def test_user_primary_group(self):
| name = 'saltyuser'
if (self.run_function('user.add', [name]) is not True):
self.run_function('user.delete', [name])
self.skipTest('Failed to create a user')
try:
primary_group = self.run_function('user.primary_group', [name])
uid_info = self.run_function('user.info', [name])
self.assertIn(primary_group, uid_info['groups'])
except:
self.run_function('user.delete', [name])
raise
|
'Test adding a user'
| def test_add_user(self):
| user_name = self.__random_string()
try:
if (self.run_function('user.add', [user_name]) is False):
self.run_function('user.delete', [user_name, True, True])
self.skipTest('Failed to create user')
user_list = self.run_function('user.list_users')
self.assertIn(user_name, user_list)
except AssertionError:
raise
finally:
self.run_function('user.delete', [user_name, True, True])
|
'Test adding a user'
| def test_add_group(self):
| group_name = self.__random_string()
try:
if (self.run_function('group.add', [group_name]) is False):
self.run_function('group.delete', [group_name, True, True])
self.skipTest('Failed to create group')
group_list = self.run_function('group.list_groups')
self.assertIn(group_name, group_list)
except AssertionError:
raise
finally:
self.run_function('group.delete', [group_name])
|
'Test adding a user to a group'
| def test_add_user_to_group(self):
| group_name = self.__random_string()
user_name = self.__random_string()
try:
if (self.run_function('group.add', [group_name])['result'] is not True):
self.run_function('group.delete', [group_name, True, True])
self.skipTest('Failed to create group')
if (self.run_function('user.add', [user_name], groups=group_name) is False):
self.run_function('user.delete', [user_name, True, True])
self.skipTest('Failed to create user')
user_info = self.run_function('user.info', [user_name])
self.assertIn(group_name, user_info['groups'])
except AssertionError:
raise
finally:
self.run_function('user.delete', [user_name, True, True])
self.run_function('group.delete', [group_name])
|
'Get current settings'
| def setUp(self):
| self.ATRUN_ENABLED = self.run_function('service.enabled', ['com.apple.atrun'])
self.REMOTE_LOGIN_ENABLED = self.run_function('system.get_remote_login')
self.REMOTE_EVENTS_ENABLED = self.run_function('system.get_remote_events')
self.COMPUTER_NAME = self.run_function('system.get_computer_name')
self.SUBNET_NAME = self.run_function('system.get_subnet_name')
self.KEYBOARD_DISABLED = self.run_function('system.get_disable_keyboard_on_lock')
|
'Reset to original settings'
| def tearDown(self):
| if (not self.ATRUN_ENABLED):
atrun = '/System/Library/LaunchDaemons/com.apple.atrun.plist'
self.run_function('service.stop', [atrun])
self.run_function('system.set_remote_login', [self.REMOTE_LOGIN_ENABLED])
self.run_function('system.set_remote_events', [self.REMOTE_EVENTS_ENABLED])
self.run_function('system.set_computer_name', [self.COMPUTER_NAME])
self.run_function('system.set_subnet_name', [self.SUBNET_NAME])
self.run_function('system.set_disable_keyboard_on_lock', [self.KEYBOARD_DISABLED])
|
'Test system.get_remote_login
Test system.set_remote_login'
| @destructiveTest
def test_get_set_remote_login(self):
| self.assertTrue(self.run_function('system.set_remote_login', [True]))
self.assertTrue(self.run_function('system.get_remote_login'))
self.assertTrue(self.run_function('system.set_remote_login', [False]))
self.assertFalse(self.run_function('system.get_remote_login'))
self.assertTrue(self.run_function('system.set_remote_login', [True]))
self.assertTrue(self.run_function('system.set_remote_login', [False]))
self.assertTrue(self.run_function('system.set_remote_login', ['yes']))
self.assertTrue(self.run_function('system.set_remote_login', ['no']))
self.assertTrue(self.run_function('system.set_remote_login', ['On']))
self.assertTrue(self.run_function('system.set_remote_login', ['Off']))
self.assertTrue(self.run_function('system.set_remote_login', [1]))
self.assertTrue(self.run_function('system.set_remote_login', [0]))
self.assertIn('Invalid String Value for Enabled', self.run_function('system.set_remote_login', ['spongebob']))
|
'Test system.get_remote_events
Test system.set_remote_events'
| @destructiveTest
def test_get_set_remote_events(self):
| self.assertTrue(self.run_function('system.set_remote_events', [True]))
self.assertTrue(self.run_function('system.get_remote_events'))
self.assertTrue(self.run_function('system.set_remote_events', [False]))
self.assertFalse(self.run_function('system.get_remote_events'))
self.assertTrue(self.run_function('system.set_remote_events', [True]))
self.assertTrue(self.run_function('system.set_remote_events', [False]))
self.assertTrue(self.run_function('system.set_remote_events', ['yes']))
self.assertTrue(self.run_function('system.set_remote_events', ['no']))
self.assertTrue(self.run_function('system.set_remote_events', ['On']))
self.assertTrue(self.run_function('system.set_remote_events', ['Off']))
self.assertTrue(self.run_function('system.set_remote_events', [1]))
self.assertTrue(self.run_function('system.set_remote_events', [0]))
self.assertIn('Invalid String Value for Enabled', self.run_function('system.set_remote_events', ['spongebob']))
|
'Test system.get_computer_name
Test system.set_computer_name'
| @destructiveTest
def test_get_set_computer_name(self):
| self.assertTrue(self.run_function('system.set_computer_name', [SET_COMPUTER_NAME]))
self.assertEqual(self.run_function('system.get_computer_name'), SET_COMPUTER_NAME)
|
'Test system.get_subnet_name
Test system.set_subnet_name'
| @destructiveTest
def test_get_set_subnet_name(self):
| self.assertTrue(self.run_function('system.set_subnet_name', [SET_SUBNET_NAME]))
self.assertEqual(self.run_function('system.get_subnet_name'), SET_SUBNET_NAME)
|
'Test system.get_startup_disk
Test system.list_startup_disks
Don\'t know how to test system.set_startup_disk as there\'s usually only
one startup disk available on a system'
| def test_get_list_startup_disk(self):
| ret = self.run_function('system.list_startup_disks')
self.assertIsInstance(ret, list)
self.assertIn(self.run_function('system.get_startup_disk'), ret)
self.assertIn('Invalid value passed for path.', self.run_function('system.set_startup_disk', ['spongebob']))
|
'Test system.get_restart_delay
Test system.set_restart_delay
system.set_restart_delay does not work due to an apple bug, see docs
may need to disable this test as we can\'t control the delay value'
| @skipIf(True, 'Skip this test until mac fixes it.')
def test_get_set_restart_delay(self):
| self.assertTrue(self.run_function('system.set_restart_delay', [90]))
self.assertEqual(self.run_function('system.get_restart_delay'), '90 seconds')
self.assertIn('Invalid value passed for seconds.', self.run_function('system.set_restart_delay', [70]))
|
'Test system.get_disable_keyboard_on_lock
Test system.set_disable_keyboard_on_lock'
| def test_get_set_disable_keyboard_on_lock(self):
| self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', [True]))
self.assertTrue(self.run_function('system.get_disable_keyboard_on_lock'))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', [False]))
self.assertFalse(self.run_function('system.get_disable_keyboard_on_lock'))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', [True]))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', [False]))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', ['yes']))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', ['no']))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', ['On']))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', ['Off']))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', [1]))
self.assertTrue(self.run_function('system.set_disable_keyboard_on_lock', [0]))
self.assertIn('Invalid String Value for Enabled', self.run_function('system.set_disable_keyboard_on_lock', ['spongebob']))
|
'Test system.get_boot_arch
Test system.set_boot_arch
system.set_boot_arch does not work due to an apple bug, see docs
may need to disable this test as we can\'t set the boot architecture'
| @skipIf(True, 'Skip this test until mac fixes it.')
def test_get_set_boot_arch(self):
| self.assertTrue(self.run_function('system.set_boot_arch', ['i386']))
self.assertEqual(self.run_function('system.get_boot_arch'), 'i386')
self.assertTrue(self.run_function('system.set_boot_arch', ['default']))
self.assertEqual(self.run_function('system.get_boot_arch'), 'default')
self.assertIn('Invalid value passed for arch', self.run_function('system.set_boot_arch', ['spongebob']))
|
'Set up Linux test environment'
| def setUp(self):
| ret_grain = self.run_function('grains.item', ['kernel'])
if ('Linux' not in ret_grain['kernel']):
self.skipTest('For Linux only')
super(TimezoneLinuxModuleTest, self).setUp()
|
'Set up Solaris test environment'
| def setUp(self):
| ret_grain = self.run_function('grains.item', ['os_family'])
if ('Solaris' not in ret_grain['os_family']):
self.skipTest('For Solaris only')
super(TimezoneSolarisModuleTest, self).setUp()
|
'pillar.data'
| def test_data(self):
| grains = self.run_function('grains.items')
pillar = self.run_function('pillar.data')
self.assertEqual(pillar['os'], grains['os'])
self.assertEqual(pillar['monty'], 'python')
if (grains['os'] == 'Fedora'):
self.assertEqual(pillar['class'], 'redhat')
else:
self.assertEqual(pillar['class'], 'other')
|
'pillar[\'master\'][\'file_roots\'] is overwritten by the master
in order to use the fileclient interface to read the pillar
files. We should restore the actual file_roots when we send
the pillar back to the minion.'
| def test_issue_5449_report_actual_file_roots_in_pillar(self):
| self.assertIn(TMP_STATE_TREE, self.run_function('pillar.data')['master']['file_roots']['base'])
|
'pillar.data for ext_pillar cmd.yaml'
| def test_ext_cmd_yaml(self):
| self.assertEqual(self.run_function('pillar.data')['ext_spam'], 'eggs')
|
'Test to ensure we get expected output
from pillar.items'
| def test_pillar_items(self):
| get_items = self.run_function('pillar.items')
self.assertDictContainsSubset({'monty': 'python'}, get_items)
self.assertDictContainsSubset({'knights': ['Lancelot', 'Galahad', 'Bedevere', 'Robin']}, get_items)
|
'Test git.add with a directory'
| def test_add_dir(self):
| newdir = 'quux'
newdir_path = os.path.join(self.repo, newdir)
_makedirs(newdir_path)
files = [os.path.join(newdir_path, x) for x in self.files]
files_relpath = [os.path.join(newdir, x) for x in self.files]
for path in files:
with salt.utils.files.fopen(path, 'w') as fp_:
fp_.write('This is a test file with relative path {0}.\n'.format(path))
ret = self.run_function('git.add', [self.repo, newdir])
res = '\n'.join(sorted(["add '{0}'".format(x) for x in files_relpath]))
if salt.utils.platform.is_windows():
res = res.replace('\\', '/')
self.assertEqual(ret, res)
|
'Test git.add with a file'
| def test_add_file(self):
| filename = 'quux'
file_path = os.path.join(self.repo, filename)
with salt.utils.files.fopen(file_path, 'w') as fp_:
fp_.write((('This is a test file named ' + filename) + '.\n'))
ret = self.run_function('git.add', [self.repo, filename])
self.assertEqual(ret, "add '{0}'".format(filename))
|
'Test git.archive'
| def test_archive(self):
| tar_archive = os.path.join(TMP, 'test_archive.tar.gz')
self.assertTrue(self.run_function('git.archive', [self.repo, tar_archive], prefix='foo/'))
self.assertTrue(tarfile.is_tarfile(tar_archive))
with closing(tarfile.open(tar_archive, 'r')) as tar_obj:
self.assertEqual(tar_obj.getnames(), ['foo', 'foo/bar', 'foo/baz', 'foo/foo', 'foo/qux', 'foo/qux/bar', 'foo/qux/baz', 'foo/qux/foo'])
os.unlink(tar_archive)
|
'Test git.archive on a subdir, giving only a partial copy of the repo in
the resulting archive'
| def test_archive_subdir(self):
| tar_archive = os.path.join(TMP, 'test_archive.tar.gz')
self.assertTrue(self.run_function('git.archive', [os.path.join(self.repo, 'qux'), tar_archive], prefix='foo/'))
self.assertTrue(tarfile.is_tarfile(tar_archive))
with closing(tarfile.open(tar_archive, 'r')) as tar_obj:
self.assertEqual(tar_obj.getnames(), ['foo', 'foo/bar', 'foo/baz', 'foo/foo'])
os.unlink(tar_archive)
|
'Test creating, renaming, and deleting a branch using git.branch'
| def test_branch(self):
| renamed_branch = 'ihavebeenrenamed'
self.assertTrue(self.run_function('git.branch', [self.repo, self.branches[1]]))
self.assertTrue(self.run_function('git.branch', [self.repo, renamed_branch], opts=('-m ' + self.branches[1])))
self.assertTrue(self.run_function('git.branch', [self.repo, renamed_branch], opts='-D'))
|
'Test checking out a new branch and then checking out master again'
| def test_checkout(self):
| new_branch = 'iamanothernewbranch'
self.assertEqual(self.run_function('git.checkout', [self.repo, 'HEAD'], opts=('-b ' + new_branch)), (("Switched to a new branch '" + new_branch) + "'"))
self.assertTrue(("Switched to branch 'master'" in self.run_function('git.checkout', [self.repo, 'master'])))
|
'Test git.checkout without a rev, both with -b in opts and without'
| def test_checkout_no_rev(self):
| new_branch = 'iamanothernewbranch'
self.assertEqual(self.run_function('git.checkout', [self.repo], rev=None, opts=('-b ' + new_branch)), (("Switched to a new branch '" + new_branch) + "'"))
self.assertTrue(("'rev' argument is required unless -b or -B in opts" in self.run_function('git.checkout', [self.repo])))
|
'Test cloning an existing repo'
| def test_clone(self):
| clone_parent_dir = tempfile.mkdtemp(dir=TMP)
self.assertTrue(self.run_function('git.clone', [clone_parent_dir, self.repo]))
shutil.rmtree(clone_parent_dir, True)
|
'Test cloning an existing repo with an alternate name for the repo dir'
| def test_clone_with_alternate_name(self):
| clone_parent_dir = tempfile.mkdtemp(dir=TMP)
clone_name = os.path.basename(self.repo)
self.assertTrue(self.run_function('git.clone', [clone_parent_dir, self.repo], name=clone_name))
shutil.rmtree(clone_parent_dir, True)
|
'Test git.commit two ways:
1) First using git.add, then git.commit
2) Using git.commit with the \'filename\' argument to skip staging'
| def test_commit(self):
| filename = 'foo'
commit_re_prefix = '^\\[master [0-9a-f]+\\] '
with salt.utils.files.fopen(os.path.join(self.repo, filename), 'a') as fp_:
fp_.write('Added a line\n')
self.run_function('git.add', [self.repo, filename])
commit_msg = ('Add a line to ' + filename)
ret = self.run_function('git.commit', [self.repo, commit_msg])
self.assertTrue(bool(re.search((commit_re_prefix + commit_msg), ret)))
with salt.utils.files.fopen(os.path.join(self.repo, filename), 'a') as fp_:
fp_.write('Added another line\n')
commit_msg = ('Add another line to ' + filename)
ret = self.run_function('git.commit', [self.repo, commit_msg], filename=filename)
self.assertTrue(bool(re.search((commit_re_prefix + commit_msg), ret)))
|
'Test setting, getting, and unsetting config values
WARNING: This test will modify and completely remove a config section
\'foo\', both in the repo created in setUp() and in the user\'s global
.gitconfig.'
| def test_config(self):
| def _clear_config():
cmds = (['git', 'config', '--remove-section', 'foo'], ['git', 'config', '--global', '--remove-section', 'foo'])
for cmd in cmds:
with salt.utils.files.fopen(os.devnull, 'w') as devnull:
try:
subprocess.check_call(cmd, stderr=devnull)
except subprocess.CalledProcessError:
pass
cfg_local = {'foo.single': ['foo'], 'foo.multi': ['foo', 'bar', 'baz']}
cfg_global = {'foo.single': ['abc'], 'foo.multi': ['abc', 'def', 'ghi']}
_clear_config()
try:
log.debug('Try to specify both single and multivar (should raise error)')
self.assertTrue(("Only one of 'value' and 'multivar' is permitted" in self.run_function('git.config_set', ['foo.single'], value=cfg_local['foo.single'][0], multivar=cfg_local['foo.multi'], cwd=self.repo)))
log.debug('Try to set single local value without cwd (should raise error)')
self.assertTrue(("'cwd' argument required unless global=True" in self.run_function('git.config_set', ['foo.single'], value=cfg_local['foo.single'][0])))
log.debug('Set single local value')
self.assertEqual(self.run_function('git.config_set', ['foo.single'], value=cfg_local['foo.single'][0], cwd=self.repo), cfg_local['foo.single'])
log.debug('Set single global value')
self.assertEqual(self.run_function('git.config_set', ['foo.single'], value=cfg_global['foo.single'][0], **{'global': True}), cfg_global['foo.single'])
log.debug('Set local multivar')
self.assertEqual(self.run_function('git.config_set', ['foo.multi'], multivar=cfg_local['foo.multi'], cwd=self.repo), cfg_local['foo.multi'])
log.debug('Set global multivar')
self.assertEqual(self.run_function('git.config_set', ['foo.multi'], multivar=cfg_global['foo.multi'], **{'global': True}), cfg_global['foo.multi'])
log.debug('Get single local value')
self.assertEqual(self.run_function('git.config_get', ['foo.single'], cwd=self.repo), cfg_local['foo.single'][0])
log.debug('Get single value from local multivar')
self.assertEqual(self.run_function('git.config_get', ['foo.multi'], cwd=self.repo), cfg_local['foo.multi'][(-1)])
log.debug('Get all values from multivar (includes globals)')
self.assertEqual(self.run_function('git.config_get', ['foo.multi'], cwd=self.repo, **{'all': True}), cfg_local['foo.multi'])
log.debug('Get single global value')
self.assertEqual(self.run_function('git.config_get', ['foo.single'], **{'global': True}), cfg_global['foo.single'][0])
log.debug('Get single value from global multivar')
self.assertEqual(self.run_function('git.config_get', ['foo.multi'], **{'global': True}), cfg_global['foo.multi'][(-1)])
log.debug('Get all values from global multivar')
self.assertEqual(self.run_function('git.config_get', ['foo.multi'], **{'all': True, 'global': True}), cfg_global['foo.multi'])
log.debug('Get all local keys/values using regex')
self.assertEqual(self.run_function('git.config_get_regexp', ['foo.(single|multi)'], cwd=self.repo), cfg_local)
log.debug('Get all global keys/values using regex')
self.assertEqual(self.run_function('git.config_get_regexp', ['foo.(single|multi)'], cwd=self.repo, **{'global': True}), cfg_global)
log.debug("Get just the local foo.multi values containing 'a'")
self.assertEqual(self.run_function('git.config_get_regexp', ['foo.multi'], value_regex='a', cwd=self.repo), {'foo.multi': [x for x in cfg_local['foo.multi'] if ('a' in x)]})
log.debug("Get just the global foo.multi values containing 'a'")
self.assertEqual(self.run_function('git.config_get_regexp', ['foo.multi'], value_regex='a', cwd=self.repo, **{'global': True}), {'foo.multi': [x for x in cfg_global['foo.multi'] if ('a' in x)]})
log.debug('Unset a single local value')
self.assertTrue(self.run_function('git.config_unset', ['foo.single'], cwd=self.repo))
log.debug('Unset an entire local multivar')
self.assertTrue(self.run_function('git.config_unset', ['foo.multi'], cwd=self.repo, **{'all': True}))
log.debug('Unset a single global value')
self.assertTrue(self.run_function('git.config_unset', ['foo.single'], **{'global': True}))
log.debug('Unset an entire local multivar')
self.assertTrue(self.run_function('git.config_unset', ['foo.multi'], **{'all': True, 'global': True}))
except Exception:
raise
finally:
_clear_config()
|
'Test git.current_branch'
| def test_current_branch(self):
| self.assertEqual(self.run_function('git.current_branch', [self.repo]), 'master')
|
'Test git.describe'
| def test_describe(self):
| self.assertEqual(self.run_function('git.describe', [self.repo]), self.tags[0])
|
'Use git.init to init a new repo'
| def test_init(self):
| new_repo = tempfile.mkdtemp(dir=TMP)
if salt.utils.platform.is_windows():
new_repo = new_repo.replace('\\', '/')
tmp_dir = os.path.basename(new_repo)
git_ret = self.run_function('git.init', [new_repo]).lower()
self.assertIn('Initialized empty Git repository in'.lower(), git_ret)
self.assertIn(tmp_dir, git_ret)
else:
self.assertEqual(self.run_function('git.init', [new_repo]).lower(), 'Initialized empty Git repository in {0}/.git/'.format(new_repo).lower())
shutil.rmtree(new_repo)
|
'Test git.list_branches'
| def test_list_branches(self):
| self.assertEqual(self.run_function('git.list_branches', [self.repo]), sorted(self.branches))
|
'Test git.list_tags'
| def test_list_tags(self):
| self.assertEqual(self.run_function('git.list_tags', [self.repo]), sorted(self.tags))
|
'Test git.merge
# TODO: Test more than just a fast-forward merge'
| def test_merge(self):
| ret = self.run_function('git.merge', [self.repo], rev=self.branches[1])
self.assertTrue(('Fast-forward' in ret.splitlines()))
|
'Test git.merge_base, git.merge_tree and git.revision
TODO: Test all of the arguments'
| def test_merge_base_and_tree(self):
| head_rev = self.run_function('git.revision', [self.repo], rev='HEAD')
self.assertTrue((len(head_rev) == 40))
second_rev = self.run_function('git.revision', [self.repo], rev=self.branches[1])
self.assertTrue((len(second_rev) == 40))
self.assertEqual(self.run_function('git.merge_base', [self.repo], refs=','.join((head_rev, second_rev))), head_rev)
ret = self.run_function('git.merge_tree', [self.repo, head_rev, second_rev]).splitlines()
self.assertTrue((len([x for x in ret if x.startswith('@@')]) == 1))
|
'Test git.rebase'
| def test_rebase(self):
| file_path = os.path.join(self.repo, self.files[1])
with salt.utils.files.fopen(file_path, 'a') as fp_:
fp_.write('Added a line\n')
self.assertTrue(('ERROR' not in self.run_function('git.commit', [self.repo, ('Added a line to ' + self.files[1])], filename=self.files[1])))
self.assertTrue(('ERROR' not in self.run_function('git.checkout', [self.repo], rev=self.branches[1])))
self.assertEqual(self.run_function('git.rebase', [self.repo]), ('First, rewinding head to replay your work on top of it...\nApplying: Added a line to ' + self.files[0]))
|
'Test setting a remote (git.remote_set), and getting a remote
(git.remote_get and git.remotes)
TODO: Properly mock fetching a remote (git.fetch), and build out more
robust testing that confirms that the https auth bits work.'
| def test_remotes(self):
| remotes = {'first': {'fetch': '/dev/null', 'push': '/dev/null'}, 'second': {'fetch': '/dev/null', 'push': '/dev/stdout'}}
self.assertEqual(self.run_function('git.remote_set', [self.repo, remotes['first']['fetch']], remote='first'), remotes['first'])
self.assertEqual(self.run_function('git.remote_set', [self.repo, remotes['second']['fetch']], remote='second', push_url=remotes['second']['push']), remotes['second'])
self.assertEqual(self.run_function('git.remotes', [self.repo]), remotes)
|
'Test git.reset
TODO: Test more than just a hard reset'
| def test_reset(self):
| self.assertTrue(('ERROR' not in self.run_function('git.checkout', [self.repo], rev=self.branches[1])))
self.run_function('git.reset', [self.repo], opts='--hard HEAD~1')
head_rev = self.run_function('git.revision', [self.repo], rev='HEAD')
self.assertTrue((len(head_rev) == 40))
master_rev = self.run_function('git.revision', [self.repo], rev='master')
self.assertTrue((len(master_rev) == 40))
self.assertEqual(head_rev, master_rev)
|
'Test git.rev_parse'
| def test_rev_parse(self):
| self.assertEqual(self.run_function('git.rev_parse', [self.repo, 'HEAD'], opts='--abbrev-ref'), 'master')
|
'Test git.rm'
| def test_rm(self):
| single_file = self.files[0]
entire_dir = self.dirs[1]
self.assertEqual(self.run_function('git.rm', [self.repo, single_file]), (("rm '" + single_file) + "'"))
expected = '\n'.join(sorted([(("rm '" + os.path.join(entire_dir, x)) + "'") for x in self.files]))
if salt.utils.platform.is_windows():
expected = expected.replace('\\', '/')
self.assertEqual(self.run_function('git.rm', [self.repo, entire_dir], opts='-r'), expected)
|
'Test git.stash
# TODO: test more stash actions'
| def test_stash(self):
| file_path = os.path.join(self.repo, self.files[0])
with salt.utils.files.fopen(file_path, 'a') as fp_:
fp_.write('Temp change to be stashed')
self.assertTrue(('ERROR' not in self.run_function('git.stash', [self.repo])))
ret = self.run_function('git.stash', [self.repo], action='list')
self.assertTrue(('ERROR' not in ret))
self.assertTrue((len(ret.splitlines()) == 1))
self.assertTrue(('ERROR' not in self.run_function('git.stash', [self.repo], action='apply', opts='stash@{0}')))
self.assertTrue(('ERROR' not in self.run_function('git.stash', [self.repo], action='drop', opts='stash@{0}')))
|
'Test git.status'
| def test_status(self):
| changes = {'modified': ['foo'], 'new': ['thisisdefinitelyanewfile'], 'deleted': ['bar'], 'untracked': ['thisisalsoanewfile']}
for filename in changes['modified']:
with salt.utils.files.fopen(os.path.join(self.repo, filename), 'a') as fp_:
fp_.write('Added a line\n')
for filename in changes['new']:
with salt.utils.files.fopen(os.path.join(self.repo, filename), 'w') as fp_:
fp_.write((('This is a new file named ' + filename) + '.'))
self.assertTrue(('ERROR' not in self.run_function('git.add', [self.repo, filename])))
for filename in changes['deleted']:
self.run_function('git.rm', [self.repo, filename])
for filename in changes['untracked']:
with salt.utils.files.fopen(os.path.join(self.repo, filename), 'w') as fp_:
fp_.write((('This is a new file named ' + filename) + '.'))
self.assertEqual(self.run_function('git.status', [self.repo]), changes)
|
'Test git.symbolic_ref'
| def test_symbolic_ref(self):
| self.assertEqual(self.run_function('git.symbolic_ref', [self.repo, 'HEAD'], opts='--quiet'), 'refs/heads/master')
|
'This tests git.worktree_add, git.is_worktree, git.worktree_rm, and
git.worktree_prune. Tests for \'git worktree list\' are covered in
tests.unit.modules.git_test.'
| @skipIf((not _worktrees_supported()), 'Git 2.5 or newer required for worktree support')
def test_worktree_add_rm(self):
| if (_git_version() >= LooseVersion('2.6.0')):
worktree_add_prefix = 'Preparing '
else:
worktree_add_prefix = 'Enter '
worktree_path = tempfile.mkdtemp(dir=TMP)
worktree_basename = os.path.basename(worktree_path)
worktree_path2 = tempfile.mkdtemp(dir=TMP)
if salt.utils.platform.is_windows():
worktree_path = worktree_path.replace('\\', '/')
worktree_path2 = worktree_path2.replace('\\', '/')
ret = self.run_function('git.worktree_add', [self.repo, worktree_path])
self.assertTrue(((worktree_add_prefix + worktree_path) in ret))
ret = self.run_function('git.worktree_add', [self.repo, worktree_path2])
self.assertTrue(((worktree_add_prefix + worktree_path2) in ret))
self.assertTrue(self.run_function('git.is_worktree', [worktree_path]))
self.assertFalse(self.run_function('git.is_worktree', [self.repo]))
empty_dir = tempfile.mkdtemp(dir=TMP)
self.assertFalse(self.run_function('git.is_worktree', [empty_dir]))
shutil.rmtree(empty_dir)
self.assertTrue(self.run_function('git.worktree_rm', [worktree_path]))
prune_message = 'Removing worktrees/{0}: gitdir file points to non-existent location'.format(worktree_basename)
result = self.run_function('git.worktree_prune', [self.repo], dry_run=True)
self.assertEqual(result, prune_message)
self.assertEqual(self.run_function('git.worktree_prune', [self.repo]), prune_message)
|
'Helper function to check if two datetime objects
are close enough to the same time.'
| def _same_times(self, t1, t2, seconds_diff=30):
| return (abs((t1 - t2)) < datetime.timedelta(seconds=seconds_diff))
|
'Some builds of hwclock don\'t include the `--compare` function
needed to test hw/sw clock synchronization. Returns false on
systems where it\'s not present so that we can skip the
comparison portion of the test.'
| def _hwclock_has_compare(self):
| res = self.run_function('cmd.run_all', cmd='hwclock -h')
return ((res['retcode'] == 0) and (res['stdout'].find('--compare') > 0))
|
'Check that hw and sw clocks are sync\'d.'
| def _test_hwclock_sync(self):
| if (not self.run_function('system.has_settable_hwclock')):
return None
if (not self._hwclock_has_compare()):
return None
class CompareTimeout(BaseException, ):
pass
def _alrm_handler(sig, frame):
log.warning('hwclock --compare failed to produce output after 3 seconds')
raise CompareTimeout
for _ in range(2):
try:
orig_handler = signal.signal(signal.SIGALRM, _alrm_handler)
signal.alarm(3)
(rpipeFd, wpipeFd) = os.pipe()
log.debug('Comparing hwclock to sys clock')
with os.fdopen(rpipeFd, 'r') as rpipe:
with os.fdopen(wpipeFd, 'w') as wpipe:
with salt.utils.files.fopen(os.devnull, 'r') as nulFd:
p = subprocess.Popen(args=['hwclock', '--compare'], stdin=nulFd, stdout=wpipeFd, stderr=subprocess.PIPE)
p.communicate()
rpipe.readline()
timeCompStr = rpipe.readline()
p.terminate()
timeComp = timeCompStr.split()
hwTime = float(timeComp[0])
swTime = float(timeComp[1])
diff = abs((hwTime - swTime))
self.assertTrue((diff <= 2.0), msg=('hwclock difference too big: ' + str(timeCompStr)))
break
except CompareTimeout:
p.terminate()
finally:
signal.alarm(0)
signal.signal(signal.SIGALRM, orig_handler)
else:
log.error('Failed to check hwclock sync')
|
'Test we are able to get the correct time'
| def test_get_system_date_time(self):
| t1 = datetime.datetime.now()
res = self.run_function('system.get_system_date_time')
t2 = datetime.datetime.strptime(res, self.fmt_str)
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(t1, t2)
self.assertTrue(self._same_times(t1, t2, seconds_diff=2), msg=msg)
|
'Test we are able to get the correct time with utc'
| def test_get_system_date_time_utc(self):
| t1 = datetime.datetime.utcnow()
res = self.run_function('system.get_system_date_time', utc_offset='+0000')
t2 = datetime.datetime.strptime(res, self.fmt_str)
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(t1, t2)
self.assertTrue(self._same_times(t1, t2, seconds_diff=2), msg=msg)
|
'Test changing the system clock. We are only able to set it up to a
resolution of a second so this test may appear to run in negative time.'
| @destructiveTest
@skip_if_not_root
def test_set_system_date_time(self):
| self._save_time()
cmp_time = (datetime.datetime.now() - datetime.timedelta(days=7))
result = self._set_time(cmp_time)
time_now = datetime.datetime.now()
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(time_now, cmp_time)
self.assertTrue((result and self._same_times(time_now, cmp_time)), msg=msg)
self._test_hwclock_sync()
|
'Test changing the system clock. We are only able to set it up to a
resolution of a second so this test may appear to run in negative time.'
| @destructiveTest
@skip_if_not_root
def test_set_system_date_time_utc(self):
| self._save_time()
cmp_time = (datetime.datetime.utcnow() - datetime.timedelta(days=7))
result = self._set_time(cmp_time, offset='+0000')
time_now = datetime.datetime.utcnow()
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(time_now, cmp_time)
self.assertTrue(result)
self.assertTrue(self._same_times(time_now, cmp_time), msg=msg)
self._test_hwclock_sync()
|
'Test changing the system clock. We are only able to set it up to a
resolution of a second so this test may appear to run in negative time.'
| @destructiveTest
@skip_if_not_root
def test_set_system_date_time_utcoffset_east(self):
| self._save_time()
cmp_time = (datetime.datetime.utcnow() - datetime.timedelta(days=7))
time_to_set = (cmp_time - datetime.timedelta(seconds=25200))
result = self._set_time(time_to_set, offset='-0700')
time_now = datetime.datetime.utcnow()
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(time_now, cmp_time)
self.assertTrue(result)
self.assertTrue(self._same_times(time_now, cmp_time), msg=msg)
self._test_hwclock_sync()
|
'Test changing the system clock. We are only able to set it up to a
resolution of a second so this test may appear to run in negative time.'
| @destructiveTest
@skip_if_not_root
def test_set_system_date_time_utcoffset_west(self):
| self._save_time()
cmp_time = (datetime.datetime.utcnow() - datetime.timedelta(days=7))
time_to_set = (cmp_time + datetime.timedelta(seconds=7200))
result = self._set_time(time_to_set, offset='+0200')
time_now = datetime.datetime.utcnow()
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(time_now, cmp_time)
self.assertTrue(result)
self.assertTrue(self._same_times(time_now, cmp_time), msg=msg)
self._test_hwclock_sync()
|
'Test setting the system time without adjusting the date.'
| @destructiveTest
@skip_if_not_root
def test_set_system_time(self):
| cmp_time = datetime.datetime.now().replace(hour=10, minute=5, second=0)
self._save_time()
result = self.run_function('system.set_system_time', ['10:05:00'])
time_now = datetime.datetime.now()
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(time_now, cmp_time)
self.assertTrue(result)
self.assertTrue(self._same_times(time_now, cmp_time), msg=msg)
self._test_hwclock_sync()
|
'Test setting the system date without adjusting the time.'
| @destructiveTest
@skip_if_not_root
def test_set_system_date(self):
| cmp_time = (datetime.datetime.now() - datetime.timedelta(days=7))
self._save_time()
result = self.run_function('system.set_system_date', [cmp_time.strftime('%Y-%m-%d')])
time_now = datetime.datetime.now()
msg = 'Difference in times is too large. Now: {0} Fake: {1}'.format(time_now, cmp_time)
self.assertTrue(result)
self.assertTrue(self._same_times(time_now, cmp_time), msg=msg)
self._test_hwclock_sync()
|
'Test getting the system hostname'
| @skip_if_not_root
def test_get_computer_desc(self):
| res = self.run_function('system.get_computer_desc')
hostname_cmd = salt.utils.path.which('hostnamectl')
if hostname_cmd:
desc = self.run_function('cmd.run', ['hostnamectl status --pretty'])
self.assertEqual(res, desc)
elif (not os.path.isfile('/etc/machine-info')):
self.assertFalse(res)
else:
with salt.utils.files.fopen('/etc/machine-info', 'r') as mach_info:
data = mach_info.read()
self.assertIn(res, data.decode('string_escape'))
|
'Test setting the system hostname'
| @destructiveTest
@skip_if_not_root
def test_set_computer_desc(self):
| self._save_machine_info()
desc = 'test'
ret = self.run_function('system.set_computer_desc', [desc])
computer_desc = self.run_function('system.get_computer_desc')
self.assertTrue(ret)
self.assertIn(desc, computer_desc)
|
'Verify platform has a settable hardware clock, if possible.'
| @skip_if_not_root
def test_has_hwclock(self):
| if (self.run_function('grains.get', ['os_family']) == 'NILinuxRT'):
self.assertTrue(self.run_function('system._has_settable_hwclock'))
self.assertTrue(self._hwclock_has_compare())
|
'Checks to see if a download error looks transitory'
| def _check_download_error(self, ret):
| return any(((w in ret) for w in ['URLError', 'Download error']))
|
'isolate regex for extracting `successful install` message from pip'
| def pip_successful_install(self, target, expect=('flake8', 'pep8')):
| expect = set(expect)
expect_str = '|'.join(expect)
success = re.search('^.*Successfully installed\\s([^\\n]+)(?:Clean.*)?', target, (re.M | re.S))
success_for = (re.findall('({0})(?:-(?:[\\d\\.-]))?'.format(expect_str), success.groups()[0]) if success else [])
return expect.issubset(set(success_for))
|
'Test adding and deleting a beacon'
| def test_add_and_delete(self):
| _add = self.run_function('beacons.add', ['ps', [{'apache2': 'stopped'}]])
self.assertTrue(_add['result'])
_save = self.run_function('beacons.save')
self.assertTrue(_save['result'])
_delete = self.run_function('beacons.delete', ['ps'])
self.assertTrue(_delete['result'])
self.run_function('beacons.save')
|
'Test disabling beacons'
| def test_disable(self):
| _list = self.run_function('beacons.list', return_yaml=False)
self.assertIn('ps', _list)
ret = self.run_function('beacons.disable')
self.assertTrue(ret['result'])
_list = self.run_function('beacons.list', return_yaml=False)
self.assertFalse(_list['enabled'])
ret = self.run_function('beacons.disable_beacon', ['ps'])
self.assertTrue(ret['result'])
_list = self.run_function('beacons.list', return_yaml=False)
for bdict in _list['ps']:
if ('enabled' in bdict):
self.assertFalse(bdict['enabled'])
break
|
'Test enabling beacons'
| def test_enable(self):
| _list = self.run_function('beacons.list', return_yaml=False)
self.assertIn('ps', _list)
ret = self.run_function('beacons.enable')
self.assertTrue(ret['result'])
_list = self.run_function('beacons.list', return_yaml=False)
self.assertTrue(_list['enabled'])
|
'Test enabled specific beacon'
| @skipIf(True, 'Skip until https://github.com/saltstack/salt/issues/31516 problems are resolved.')
def test_enabled_beacons(self):
| ret = self.run_function('beacons.enable_beacon', ['ps'])
self.assertTrue(ret['result'])
_list = self.run_function('beacons.list', return_yaml=False)
self.assertTrue(_list['ps']['enabled'])
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.