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)