def testHandleClockSync(self, mock_call):
command = ['/sbin/hwclock', '--hctosys']
mock_sync = mock.create_autospec(clock_skew_daemon.ClockSkewDaemon)
mock_logger = mock.Mock()
mock_sync.logger = mock_logger
clock_skew_daemon.ClockSkewDaemon.HandleClockSync(
mock_sync, 'Response')
mock_call.assert_called_once_with(command)
expected_calls = [
mock.call.info(mock.ANY, 'Response'),
mock.call.info(mock.ANY),
]
self.assertEqual(mock_logger.mock_calls, expected_calls)
def testUpdateOsLoginDeactivate(self):
mocks = mock.Mock()
mocks.attach_mock(self.mock_logger, 'logger')
mocks.attach_mock(self.mock_oslogin, 'oslogin')
self.mock_oslogin._RunOsLoginControl.return_value = 0
self.mock_oslogin._GetStatus.return_value = True
oslogin_utils.OsLoginUtils.UpdateOsLogin(self.mock_oslogin, False)
expected_calls = [
mock.call.oslogin._GetStatus(),
mock.call.logger.warning(mock.ANY),
mock.call.oslogin._RunOsLoginControl('deactivate'),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testUpdateOsLoginUpdateCache(self, mock_time):
mocks = mock.Mock()
mocks.attach_mock(self.mock_oslogin, 'oslogin')
self.mock_oslogin._RunOsLoginControl.return_value = 0
self.mock_oslogin._GetStatus.return_value = True
mock_time.return_value = 6 * 60 * 60 + 1
oslogin_utils.OsLoginUtils.UpdateOsLogin(
self.mock_oslogin, True, two_factor=True)
expected_calls = [
mock.call.oslogin._GetStatus(two_factor=True),
mock.call.oslogin._RunOsLoginNssCache(),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testGetStatusNotInstalled(self):
mocks = mock.Mock()
self.mock_oslogin._RunOsLoginControl.return_value = None
mocks.attach_mock(self.mock_logger, 'logger')
self.assertTrue(self.mock_oslogin.oslogin_installed)
self.assertFalse(oslogin_utils.OsLoginUtils._GetStatus(self.mock_oslogin))
self.assertFalse(self.mock_oslogin.oslogin_installed)
self.assertFalse(oslogin_utils.OsLoginUtils._GetStatus(self.mock_oslogin))
# Should only log once, even though called twice.
expected_calls = [
mock.call.logger.warning(mock.ANY),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testUpdateUserNoLogin(self):
self.mock_utils._UpdateAuthorizedKeys = mock.Mock()
user = '******'
groups = ['a', 'b', 'c']
pw_shell = '/sbin/nologin'
pw_entry = accounts_utils.pwd.struct_passwd(
('', '', '', '', '', '', pw_shell))
self.mock_utils.groups = groups
self.mock_utils._GetUser.return_value = pw_entry
self.mock_utils._UpdateUserGroups.return_value = True
self.assertTrue(
accounts_utils.AccountsUtils.UpdateUser(self.mock_utils, user, []))
self.mock_utils._UpdateAuthorizedKeys.assert_not_called()
def setUp(self):
self.mock_logger = mock.Mock()
self.sudoers_group = 'google-sudoers'
self.sudoers_file = '/sudoers/file'
self.users_dir = '/users'
self.users_file = '/users/file'
self.mock_utils = mock.create_autospec(accounts_utils.AccountsUtils)
self.mock_utils.google_comment = accounts_utils.AccountsUtils.google_comment
self.mock_utils.google_sudoers_group = self.sudoers_group
self.mock_utils.google_sudoers_file = self.sudoers_file
self.mock_utils.google_users_dir = self.users_dir
self.mock_utils.google_users_file = self.users_file
self.mock_utils.logger = self.mock_logger
def testDownloadUrlWithRetry(self, mock_retrieve, mock_tempfile,
mock_time):
url = 'http://www.google.com/fake/url'
mock_tempfile.return_value = mock_tempfile
mock_tempfile.name = self.dest
mock_success = mock.Mock()
mock_success.getcode.return_value = script_retriever.httpclient.OK
# Success after 2 timeout. Since max_retry = 3, the final result is success.
mock_retrieve.side_effect = [
script_retriever.socket.timeout(),
script_retriever.socket.timeout(),
mock_success,
]
self.assertIsNotNone(self.retriever._DownloadUrl(url, self.dest_dir))
def testGetMetadataArgs(self):
mock_response = mock.Mock()
mock_response.return_value = {}
self.mock_watcher._HandleMetadataUpdate = mock_response
metadata_key = 'instance/id'
recursive = False
response = self.mock_watcher.GetMetadata(metadata_key=metadata_key,
recursive=recursive)
self.assertEqual(response, {})
mock_response.assert_called_once_with(metadata_key=metadata_key,
recursive=False,
wait=False)
self.mock_watcher.logger.exception.assert_not_called()
def testIpForwardingDaemonError(self, mock_lock, mock_logger, mock_watcher,
mock_utils):
mock_logger_instance = mock.Mock()
mock_logger.Logger.return_value = mock_logger_instance
mocks = mock.Mock()
mocks.attach_mock(mock_lock, 'lock')
mocks.attach_mock(mock_logger, 'logger')
mocks.attach_mock(mock_utils, 'utils')
mocks.attach_mock(mock_watcher, 'watcher')
mock_lock.LockFile.side_effect = IOError('Test Error')
with mock.patch.object(
ip_forwarding_daemon.IpForwardingDaemon, 'HandleNetworkInterfaces'):
ip_forwarding_daemon.IpForwardingDaemon()
expected_calls = [
mock.call.logger.Logger(
name=mock.ANY, debug=False, facility=mock.ANY),
mock.call.watcher.MetadataWatcher(logger=mock_logger_instance),
mock.call.utils.IpForwardingUtils(
logger=mock_logger_instance, proto_id=None),
mock.call.lock.LockFile(ip_forwarding_daemon.LOCKFILE),
mock.call.logger.Logger().warning('Test Error'),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testRunScripts(self, mock_mkdir, mock_rmtree, mock_executor,
mock_logger, mock_retriever):
mock_logger_instance = mock.Mock()
mock_logger.Logger.return_value = mock_logger_instance
mock_retriever_instance = mock.Mock()
mock_retriever.ScriptRetriever.return_value = mock_retriever_instance
mocks = mock.Mock()
mocks.attach_mock(mock_mkdir, 'mkdir')
mocks.attach_mock(mock_rmtree, 'rmtree')
mocks.attach_mock(mock_executor, 'executor')
mocks.attach_mock(mock_logger, 'logger')
mocks.attach_mock(mock_retriever, 'retriever')
script_type = 'test'
script_name = '%s-script' % script_type
script_prefix = '%s-' % script_type
test_dir = 'test-dir'
test_dict = {'test': 'dict'}
mock_mkdir.return_value = test_dir
mock_retriever_instance.GetScripts.return_value = test_dict
script_manager.ScriptManager(script_type)
expected_calls = [
mock.call.logger.Logger(name=script_name,
debug=False,
facility=mock.ANY),
mock.call.retriever.ScriptRetriever(mock_logger_instance,
script_type),
mock.call.executor.ScriptExecutor(mock_logger_instance,
script_type),
mock.call.mkdir(prefix=script_prefix),
mock.call.logger.Logger().info(mock.ANY, script_type),
mock.call.retriever.ScriptRetriever().GetScripts(test_dir),
mock.call.executor.ScriptExecutor().RunScripts(test_dict),
mock.call.logger.Logger().info(mock.ANY, script_type),
mock.call.rmtree(test_dir),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testGetScriptsFailed(self, mock_tempfile):
script_dest = '/tmp/script'
script_url_dest = None
metadata = {
'instance': {
'attributes': {
'%s-script' % self.script_type: 'a',
'%s-script-url' % self.script_type: 'b',
},
},
'project': {
'attributes': {
'%s-script' % self.script_type: 'c',
'%s-script-url' % self.script_type: 'd',
},
},
}
expected_data = {
'%s-script' % self.script_type: script_dest,
'%s-script-url' % self.script_type: script_url_dest,
}
self.mock_watcher.GetMetadata.return_value = metadata
self.retriever.watcher = self.mock_watcher
# Mock saving a script to a file.
mock_dest = mock.Mock()
mock_dest.name = script_dest
mock_tempfile.__enter__.return_value = mock_dest
mock_tempfile.return_value = mock_tempfile
# Mock downloading a script from a URL.
mock_download = mock.Mock()
mock_download.return_value = None
self.retriever._DownloadScript = mock_download
self.assertEqual(self.retriever.GetScripts(self.dest_dir),
expected_data)
self.assertEqual(self.mock_logger.info.call_count, 2)
self.assertEqual(self.mock_logger.warning.call_count, 1)
def testNetworkDaemonError(
self, mock_lock, mock_logger, mock_watcher, mock_network_utils,
mock_network_setup, mock_ip_forwarding):
mock_logger_instance = mock.Mock()
mock_logger.Logger.return_value = mock_logger_instance
mocks = mock.Mock()
mocks.attach_mock(mock_lock, 'lock')
mocks.attach_mock(mock_logger, 'logger')
mocks.attach_mock(mock_ip_forwarding, 'forwarding')
mocks.attach_mock(mock_network_setup, 'network_setup')
mocks.attach_mock(mock_network_utils, 'network')
mocks.attach_mock(mock_watcher, 'watcher')
self.mock_setup._ExtractInterfaceMetadata.return_value = []
mock_lock.LockFile.side_effect = IOError('Test Error')
with mock.patch.object(
network_daemon.NetworkDaemon, 'HandleNetworkInterfaces'):
network_daemon.NetworkDaemon(
ip_forwarding_enabled=False,
proto_id='66',
ip_aliases=None,
target_instance_ips=None,
dhclient_script='x',
dhcp_command='y',
network_setup_enabled=False,
debug=True)
expected_calls = [
mock.call.logger.Logger(name=mock.ANY, debug=True, facility=mock.ANY),
mock.call.forwarding.IpForwarding(proto_id='66', debug=True),
mock.call.network_setup.NetworkSetup(
debug=True, dhclient_script='x', dhcp_command='y'),
mock.call.network.NetworkUtils(logger=mock_logger_instance),
mock.call.watcher.MetadataWatcher(logger=mock_logger_instance),
mock.call.lock.LockFile(network_daemon.LOCKFILE),
mock.call.logger.Logger().warning('Test Error'),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testHandleNetworkInterfacesFeatures(self):
self.mock_setup.ip_aliases = True
self.mock_setup.target_instance_ips = True
mocks = mock.Mock()
mocks.attach_mock(self.mock_network_utils, 'network')
mocks.attach_mock(self.mock_setup, 'setup')
self.mock_network_utils.GetNetworkInterface.side_effect = [
'eth0', 'eth1', 'eth2', 'eth3', None]
result = [
{
'mac': '1',
'forwardedIps': ['a']
},
{
'mac': '2',
'forwardedIps': ['b'],
'ipAliases': ['banana'],
'targetInstanceIps': ['baklava'],
},
{
'mac': '3',
'ipAliases': ['cherry'],
'targetInstanceIps': ['cake'],
},
{
'mac': '4'
},
{
'forwardedIps': ['d'],
'ipAliases': ['date'],
'targetInstanceIps': ['doughnuts'],
},
]
ip_forwarding_daemon.IpForwardingDaemon.HandleNetworkInterfaces(
self.mock_setup, result)
expected_calls = [
mock.call.network.GetNetworkInterface('1'),
mock.call.setup._HandleForwardedIps(['a'], 'eth0'),
mock.call.network.GetNetworkInterface('2'),
mock.call.setup._HandleForwardedIps(['b', 'banana', 'baklava'], 'eth1'),
mock.call.network.GetNetworkInterface('3'),
mock.call.setup._HandleForwardedIps(['cherry', 'cake'], 'eth2'),
mock.call.network.GetNetworkInterface('4'),
mock.call.setup._HandleForwardedIps([], 'eth3'),
mock.call.network.GetNetworkInterface(None),
mock.call.setup.logger.warning(mock.ANY, None),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testGetStatusActive(self, mock_exists):
mocks = mock.Mock()
mocks.attach_mock(mock_exists, 'exists')
mocks.attach_mock(self.mock_oslogin, 'oslogin')
self.mock_oslogin._RunOsLoginControl.return_value = 0
mock_exists.return_value = True
self.assertTrue(
oslogin_utils.OsLoginUtils._GetStatus(self.mock_oslogin,
two_factor=False))
expected_calls = [
mock.call.oslogin._RunOsLoginControl(['status']),
mock.call.exists(self.oslogin_nss_cache),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testHandleClockSyncError(self, mock_call):
command = ['/sbin/hwclock', '--hctosys']
mock_sync = mock.create_autospec(clock_skew_daemon.ClockSkewDaemon)
mock_logger = mock.Mock()
mock_sync.logger = mock_logger
mock_call.side_effect = subprocess.CalledProcessError(1, 'Test')
clock_skew_daemon.ClockSkewDaemon.HandleClockSync(
mock_sync, 'Response')
mock_call.assert_called_once_with(command)
expected_calls = [
mock.call.info(mock.ANY, 'Response'),
mock.call.warning(mock.ANY),
]
self.assertEqual(mock_logger.mock_calls, expected_calls)
def testCreateConfig(self, mock_config, mock_logger, mock_watcher):
mock_config_instance = mock.Mock()
mock_config.ConfigManager.return_value = mock_config_instance
mocks = mock.Mock()
mocks.attach_mock(mock_config.ConfigManager, 'config')
mocks.attach_mock(mock_config_instance.SetOption, 'set')
mocks.attach_mock(mock_config_instance.WriteConfig, 'write')
mocks.attach_mock(mock_logger, 'logger')
mocks.attach_mock(mock_watcher, 'watcher')
mock_logger_instance = mock.Mock()
mock_logger.Logger.return_value = mock_logger_instance
boto_config.BotoConfig(self.project_id, debug=True)
expected_calls = [
mock.call.logger.Logger(name=mock.ANY, debug=True),
mock.call.watcher.MetadataWatcher(logger=mock_logger_instance),
mock.call.config(config_file='template',
config_header='/tmp/test.py template'),
mock.call.set('GSUtil', 'default_project_id', self.project_id),
mock.call.set('GSUtil', 'default_api_version', '2'),
mock.call.set('GoogleCompute', 'service_account', 'default'),
mock.call.write(config_file='config'),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testAccountsDaemonError(
self, mock_lock, mock_logger, mock_watcher, mock_utils):
mock_logger_instance = mock.Mock()
mock_logger.Logger.return_value = mock_logger_instance
mocks = mock.Mock()
mocks.attach_mock(mock_lock, 'lock')
mocks.attach_mock(mock_logger, 'logger')
mocks.attach_mock(mock_watcher, 'watcher')
mocks.attach_mock(mock_utils, 'utils')
mock_lock.LockFile.side_effect = IOError('Test Error')
with mock.patch.object(accounts_daemon.AccountsDaemon, 'HandleAccounts'):
accounts_daemon.AccountsDaemon()
expected_calls = [
mock.call.logger.Logger(
name=mock.ANY, debug=False, facility=mock.ANY),
mock.call.watcher.MetadataWatcher(logger=mock_logger_instance),
mock.call.utils.AccountsUtils(
logger=mock_logger_instance, groups=None, remove=False,
useradd_cmd=mock.ANY, userdel_cmd=mock.ANY, usermod_cmd=mock.ANY,
groupadd_cmd=mock.ANY),
mock.call.lock.LockFile(accounts_daemon.LOCKFILE),
mock.call.logger.Logger().warning('Test Error'),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testWatchMetadataException(self):
mock_response = mock.Mock()
mock_response.side_effect = metadata_watcher.socket.timeout()
self.mock_watcher._GetMetadataUpdate = mock_response
self.mock_logger.exception.side_effect = RuntimeError()
metadata_key = 'instance/id'
recursive = False
with self.assertRaises(RuntimeError):
self.mock_watcher.WatchMetadata(None,
metadata_key=metadata_key,
recursive=recursive)
mock_response.assert_called_once_with(metadata_key=metadata_key,
recursive=recursive,
wait=True)
def testCallSysctl(self, mock_call):
command = ['sysctl', '-w']
mock_logger = mock.Mock()
expected_log_calls = []
for name in ['foo', 'bar', 'baz']:
for value in ['foo', 'bar', 'baz']:
params = ['{name}={value}'.format(name=name, value=value)]
helpers.CallSysctl(mock_logger, name, value)
mock_call.assert_called_with(command + params)
expected_log_calls.append(mock.call.info(mock.ANY, name))
self.assertEqual(mock_logger.mock_calls, expected_log_calls)
mock_call.side_effect = subprocess.CalledProcessError(1, 'Test')
helpers.CallSysctl(mock_logger, 'fail', 1)
mock_logger.assert_has_calls([mock.call.warning(mock.ANY, 'fail')])
def testAccountsDaemon(self, mock_lock, mock_logger, mock_watcher,
mock_utils):
mock_logger_instance = mock.Mock()
mock_logger.Logger.return_value = mock_logger_instance
mocks = mock.Mock()
mocks.attach_mock(mock_lock, 'lock')
mocks.attach_mock(mock_logger, 'logger')
mocks.attach_mock(mock_watcher, 'watcher')
mocks.attach_mock(mock_utils, 'utils')
with mock.patch.object(accounts_daemon.AccountsDaemon,
'HandleAccounts') as mock_handle:
accounts_daemon.AccountsDaemon(groups='foo,bar',
remove=True,
debug=True)
expected_calls = [
mock.call.logger.Logger(name=mock.ANY,
debug=True,
facility=mock.ANY),
mock.call.watcher.MetadataWatcher(logger=mock_logger_instance),
mock.call.utils.AccountsUtils(logger=mock_logger_instance,
groups='foo,bar',
remove=True,
gpasswd_add_cmd=mock.ANY,
gpasswd_remove_cmd=mock.ANY,
groupadd_cmd=mock.ANY,
useradd_cmd=mock.ANY,
userdel_cmd=mock.ANY,
usermod_cmd=mock.ANY),
mock.call.lock.LockFile(accounts_daemon.LOCKFILE),
mock.call.lock.LockFile().__enter__(),
mock.call.logger.Logger().info(mock.ANY),
mock.call.watcher.MetadataWatcher().WatchMetadata(
mock_handle, recursive=True, timeout=mock.ANY),
mock.call.lock.LockFile().__exit__(None, None, None),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testUpdateOsLoginActivate(self):
mocks = mock.Mock()
mocks.attach_mock(self.mock_logger, 'logger')
mocks.attach_mock(self.mock_oslogin, 'oslogin')
self.mock_oslogin._RunOsLoginControl.return_value = 0
self.mock_oslogin._GetStatus.return_value = False
oslogin_utils.OsLoginUtils.UpdateOsLogin(self.mock_oslogin, True)
expected_calls = [
mock.call.oslogin._GetStatus(two_factor=False),
mock.call.logger.info(mock.ANY),
mock.call.oslogin._RunOsLoginControl(['activate']),
mock.call.oslogin._RunOsLoginNssCache(),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testRunIpRoute(self, mock_subprocess):
mock_process = mock.Mock()
mock_process.returncode = 0
mock_process.communicate.return_value = ('out', '')
mock_subprocess.Popen.return_value = mock_process
args = ['foo', 'bar']
options = {'one': 'two'}
self.assertEqual(
self.mock_utils._RunIpRoute(args=args, options=options), 'out')
command = ['ip', 'route', 'foo', 'bar', 'one', 'two']
mock_subprocess.Popen.assert_called_once_with(
command, stdout=mock_subprocess.PIPE, stderr=mock_subprocess.PIPE)
mock_process.communicate.assert_called_once_with()
self.mock_logger.warning.assert_not_called()
def testStartSshdSysVinit(self, mock_exists, mock_call):
mocks = mock.Mock()
mocks.attach_mock(mock_exists, 'exists')
mocks.attach_mock(mock_call, 'call')
mock_exists.side_effect = [False, False, True]
instance_setup.InstanceSetup._StartSshd(self.mock_setup)
expected_calls = [
mock.call.exists('/bin/systemctl'),
mock.call.exists('/etc/init.d/ssh'),
mock.call.exists('/etc/init/ssh.conf'),
mock.call.call(['service', 'ssh', 'start']),
mock.call.call(['service', 'ssh', 'reload']),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testHandleNetworkInterfaces(self):
mocks = mock.Mock()
mocks.attach_mock(self.mock_ip_forwarding, 'forwarding')
mocks.attach_mock(self.mock_network_setup, 'network_setup')
mocks.attach_mock(self.mock_setup, 'setup')
self.mock_setup.ip_aliases = None
self.mock_setup.target_instance_ips = None
self.mock_setup.ip_forwarding_enabled = True
self.mock_setup.network_setup_enabled = True
self.mock_setup._ExtractInterfaceMetadata.return_value = [
network_daemon.NetworkDaemon.NetworkInterface('a'),
network_daemon.NetworkDaemon.NetworkInterface('b'),
]
result = mock.Mock()
network_daemon.NetworkDaemon.HandleNetworkInterfaces(
self.mock_setup, result)
expected_calls = [
mock.call.setup._ExtractInterfaceMetadata(result),
mock.call.network_setup.EnableNetworkInterfaces(['b']),
mock.call.forwarding.HandleForwardedIps('a', None, None),
mock.call.forwarding.HandleForwardedIps('b', None, None),
]
self.assertEqual(mocks.mock_calls, expected_calls)
def testGetMetadataUpdateArgs(self):
mock_response = mock.Mock()
mock_response.return_value = mock_response
mock_response.headers = {'etag': 0}
mock_response.read.return_value = bytes(b'{}')
self.mock_watcher._GetMetadataRequest = mock_response
metadata_key = 'instance/id'
self.params['recursive'] = False
self.params['wait_for_change'] = False
request_url = os.path.join(self.url, metadata_key)
self.mock_watcher._GetMetadataUpdate(
metadata_key=metadata_key, recursive=False, wait=False, timeout=60)
self.assertEqual(self.mock_watcher.etag, 0)
mock_response.assert_called_once_with(
request_url, params=self.params, timeout=60)
def testGetForwardedIps(self, mock_netaddr, mock_netifaces):
mock_netifaces.AF_INET = 0
mock_netifaces.ifaddresses.return_value = [[
{'addr': 'a', 'netmask': 'a mask'},
{'addr': 'b', 'netmask': 'b mask'},
{'addr': 'c', 'netmask': 'c mask'},
]]
mock_netaddr.IPAddress().netmask_bits.return_value = 32
mock_parse = mock.Mock()
mock_parse.return_value = ['Test']
self.mock_utils.ParseForwardedIps = mock_parse
self.assertEqual(
self.mock_utils.GetForwardedIps('interface', 'ip'), ['Test'])
mock_netifaces.ifaddresses.assert_called_once_with('interface')
mock_parse.assert_called_once_with(['a/32', 'b/32', 'c/32'])
def testAddIpAlias(self, mock_netaddr):
mock_netaddr.IPNetwork.return_value = [
'1.1.1.0', '1.1.1.1', '1.1.1.2', '1.1.1.3'
]
mock_run = mock.Mock()
self.mock_utils._RunIfconfig = mock_run
self.mock_utils.AddForwardedIp('1.1.1.1/30', 'interface')
mock_netaddr.IPNetwork.assert_called_once_with('1.1.1.1/30')
expected_calls = [
mock.call(args=['interface', 'alias', '1.1.1.0/32']),
mock.call(args=['interface', 'alias', '1.1.1.1/32']),
mock.call(args=['interface', 'alias', '1.1.1.2/32']),
mock.call(args=['interface', 'alias', '1.1.1.3/32'])
]
self.assertEqual(mock_run.mock_calls, expected_calls)
def testDownloadUrlProcessError(self, mock_retrieve, mock_tempfile,
mock_time):
url = 'http://www.google.com/fake/url'
mock_tempfile.return_value = mock_tempfile
mock_tempfile.name = self.dest
mock_success = mock.Mock()
mock_success.getcode.return_value = script_retriever.httpclient.OK
# Success after 3 timeout. Since max_retry = 3, the final result is fail.
mock_retrieve.side_effect = [
script_retriever.socket.timeout(),
script_retriever.socket.timeout(),
script_retriever.socket.timeout(),
mock_success,
]
self.assertIsNone(self.retriever._DownloadUrl(url, self.dest_dir))
self.assertEqual(self.mock_logger.warning.call_count, 1)
def testUpdateEtag(self):
mock_response = mock.Mock()
mock_response.headers = {'etag': 1}
self.assertEqual(self.mock_watcher.etag, 0)
# Update the etag if the etag is set.
self.assertTrue(self.mock_watcher._UpdateEtag(mock_response))
self.assertEqual(self.mock_watcher.etag, 1)
# Do not update the etag if the etag is unchanged.
self.assertFalse(self.mock_watcher._UpdateEtag(mock_response))
self.assertEqual(self.mock_watcher.etag, 1)
# Do not update the etag if the etag is not set.
mock_response.headers = {}
self.assertFalse(self.mock_watcher._UpdateEtag(mock_response))
self.assertEqual(self.mock_watcher.etag, 1)
def testEnableNetworkInterfaces(self, mock_call):
mocks = mock.Mock()
mocks.attach_mock(mock_call, 'call')
mocks.attach_mock(self.mock_logger, 'logger')
mocks.attach_mock(
self.mock_setup.distro_utils.EnableNetworkInterfaces, 'enable')
mock_call.side_effect = [None, subprocess.CalledProcessError(1, 'Test')]
# Return immediately with fewer than two interfaces.
network_setup.NetworkSetup.EnableNetworkInterfaces(self.mock_setup, None)
network_setup.NetworkSetup.EnableNetworkInterfaces(self.mock_setup, [])
# Enable interfaces.
network_setup.NetworkSetup.EnableNetworkInterfaces(
self.mock_setup, ['A', 'B'])
self.assertEqual(self.mock_setup.interfaces, set(['A', 'B']))
# Add a new interface.
network_setup.NetworkSetup.EnableNetworkInterfaces(
self.mock_setup, ['A', 'B', 'C'])
self.assertEqual(self.mock_setup.interfaces, set(['A', 'B', 'C']))
# Interfaces are already enabled.
network_setup.NetworkSetup.EnableNetworkInterfaces(
self.mock_setup, ['A', 'B', 'C'])
self.assertEqual(self.mock_setup.interfaces, set(['A', 'B', 'C']))
# Run a user supplied command successfully.
self.mock_setup.dhcp_command = 'success'
network_setup.NetworkSetup.EnableNetworkInterfaces(
self.mock_setup, ['D', 'E'])
self.assertEqual(self.mock_setup.interfaces, set(['D', 'E']))
# Run a user supplied command and logger error messages.
self.mock_setup.dhcp_command = 'failure'
network_setup.NetworkSetup.EnableNetworkInterfaces(
self.mock_setup, ['F', 'G'])
self.assertEqual(self.mock_setup.interfaces, set(['F', 'G']))
expected_calls = [
mock.call.logger.info(mock.ANY, ['A', 'B']),
mock.call.enable(['A', 'B'], mock.ANY, dhclient_script='/bin/script'),
mock.call.logger.info(mock.ANY, ['A', 'B', 'C']),
mock.call.enable(
['A', 'B', 'C'], mock.ANY, dhclient_script='/bin/script'),
mock.call.logger.info(mock.ANY, ['D', 'E']),
mock.call.call(['success']),
mock.call.logger.info(mock.ANY, ['F', 'G']),
mock.call.call(['failure']),
mock.call.logger.warning(mock.ANY),
]
self.assertEqual(mocks.mock_calls, expected_calls)
