x/cloudbase-init
Code Issues Proposed changes

Fixed assertEqual order in tests

Browse Source 
Correct order should be assertEqual(<expected value>, <actual value>)
This commit is contained in:
Robert Tingirica 2014-09-10 14:27:38 +03:00
parent b5a58e8662
commit 82293036cb
30 changed files with 194 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
cloudbaseinit/tests/metadata/services/osconfigdrive/test_windows.py
View File

@ -63,7 +63,7 @@ class TestWindowsConfigDriveManager(unittest.TestCase):
mock_osutils.get_volume_label.assert_called_once_with('fake drive')
if exists:
self.assertEqual(response, 'fake drive')
self.assertEqual('fake drive', response)
else:
self.assertIsNone(response)
@ -79,14 +79,14 @@ class TestWindowsConfigDriveManager(unittest.TestCase):
response = self._config_manager._c_char_array_to_c_ushort(mock_buf, 1)
self.assertEqual(self._ctypes_mock.cast.call_count, 2)
self.assertEqual(2, self._ctypes_mock.cast.call_count)
self._ctypes_mock.POINTER.assert_called_with(
self._ctypes_mock.wintypes.WORD)
self._ctypes_mock.cast.assert_called_with(
mock_buf.__getitem__(), self._ctypes_mock.POINTER.return_value)
self.assertEqual(response, contents.value.__lshift__().__add__())
self.assertEqual(contents.value.__lshift__().__add__(), response)
@mock.patch('cloudbaseinit.metadata.services.osconfigdrive.windows.'
'WindowsConfigDriveManager._c_char_array_to_c_ushort')
@ -147,7 +147,7 @@ class TestWindowsConfigDriveManager(unittest.TestCase):
mock_c_char_array_to_c_ushort.assert_has_calls(
mock.call(mock_buff, buf_off_volume),
mock.call(mock_buff, buf_off_block))
self.assertEqual(response, 10000)
self.assertEqual(10000, response)
def test_test_get_iso_disk_size(self):
self._test_get_iso_disk_size(

24
cloudbaseinit/tests/metadata/services/test_baseopenstackservice.py
View File

@ -37,7 +37,7 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_content('fake name')
path = posixpath.join('openstack', 'content', 'fake name')
mock_get_cache_data.assert_called_once_with(path)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)
@mock.patch("cloudbaseinit.metadata.services.baseopenstackservice"
".BaseOpenStackService._get_cache_data")
@ -45,7 +45,7 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_user_data()
path = posixpath.join('openstack', 'latest', 'user_data')
mock_get_cache_data.assert_called_once_with(path)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)
@mock.patch("cloudbaseinit.metadata.services.baseopenstackservice"
".BaseOpenStackService._get_cache_data")
@ -63,7 +63,8 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_instance_id()
mock_get_meta_data.assert_called_once_with()
mock_get_meta_data().get.assert_called_once_with('uuid')
self.assertEqual(response, mock_get_meta_data().get())
self.assertEqual(mock_get_meta_data.return_value.get.return_value,
response)
@mock.patch("cloudbaseinit.metadata.services.baseopenstackservice"
".BaseOpenStackService._get_meta_data")
@ -71,7 +72,8 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_host_name()
mock_get_meta_data.assert_called_once_with()
mock_get_meta_data().get.assert_called_once_with('hostname')
self.assertEqual(response, mock_get_meta_data().get())
self.assertEqual(mock_get_meta_data.return_value.get.return_value,
response)
@mock.patch("cloudbaseinit.metadata.services.baseopenstackservice"
".BaseOpenStackService._get_meta_data")
@ -79,7 +81,7 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_public_keys()
mock_get_meta_data.assert_called_once_with()
mock_get_meta_data().get.assert_called_once_with('public_keys')
self.assertEqual(response, mock_get_meta_data().get().values())
self.assertEqual(mock_get_meta_data().get().values(), response)
@mock.patch("cloudbaseinit.metadata.services.baseopenstackservice"
".BaseOpenStackService._get_meta_data")
@ -96,11 +98,11 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_admin_password()
mock_get_meta_data.assert_called_once_with()
if meta_data and 'admin_pass' in meta_data:
self.assertEqual(response, meta_data['admin_pass'])
self.assertEqual(meta_data['admin_pass'], response)
elif meta_data and 'admin_pass' in meta_data.get('meta'):
self.assertEqual(response, meta_data.get('meta')['admin_pass'])
self.assertEqual(meta_data.get('meta')['admin_pass'], response)
else:
self.assertEqual(response, None)
self.assertEqual(None, response)
def test_get_admin_pass(self):
self._test_get_admin_password(meta_data={'admin_pass': 'fake pass'})
@ -124,13 +126,13 @@ class BaseOpenStackServiceTest(unittest.TestCase):
response = self._service.get_client_auth_certs()
mock_get_meta_data.assert_called_once_with()
if 'meta' in meta_data:
self.assertEqual(response, ['fake cert'])
self.assertEqual(['fake cert'], response)
elif type(ret_value) is str and ret_value.startswith(
x509constants.PEM_HEADER):
mock_get_user_data.assert_called_once_with()
self.assertEqual(response, [ret_value])
self.assertEqual([ret_value], response)
elif ret_value is base.NotExistingMetadataException:
self.assertEqual(response, None)
self.assertEqual(None, response)
def test_get_client_auth_certs(self):
self._test_get_client_auth_certs(

8
cloudbaseinit/tests/metadata/services/test_configdrive.py
View File

@ -67,8 +67,8 @@ class ConfigDriveServiceTest(unittest.TestCase):
mock_get_config_drive_manager.assert_called_once_with()
mock_manager.get_config_drive_files.assert_called_once_with(
fake_path, CONF.config_drive_raw_hhd, CONF.config_drive_cdrom)
self.assertEqual(response, True)
self.assertEqual(self._config_drive._metadata_path, fake_path)
self.assertTrue(response)
self.assertEqual(fake_path, self._config_drive._metadata_path)
@mock.patch('os.path.normpath')
@mock.patch('os.path.join')
@ -77,7 +77,7 @@ class ConfigDriveServiceTest(unittest.TestCase):
with mock.patch('six.moves.builtins.open',
mock.mock_open(read_data='fake data'), create=True):
response = self._config_drive._get_data(fake_path)
self.assertEqual(response, 'fake data')
self.assertEqual('fake data', response)
mock_join.assert_called_with(
self._config_drive._metadata_path, fake_path)
@ -86,4 +86,4 @@ class ConfigDriveServiceTest(unittest.TestCase):
fake_path = os.path.join('fake', 'path')
self._config_drive._metadata_path = fake_path
self._config_drive.cleanup()
self.assertEqual(self._config_drive._metadata_path, None)
self.assertEqual(None, self._config_drive._metadata_path)

13
cloudbaseinit/tests/metadata/services/test_ec2service.py
View File

@ -66,7 +66,7 @@ class EC2ServiceTest(unittest.TestCase):
self._service._get_response, req)
else:
response = self._service._get_response(req)
self.assertEqual(response, ret_value)
self.assertEqual(ret_value, response)
mock_urlopen.assert_called_once_with(req)
def test_get_response(self):
@ -90,7 +90,8 @@ class EC2ServiceTest(unittest.TestCase):
fake_path = posixpath.join(CONF.ec2_metadata_base_url, 'fake')
mock_Request.assert_called_once_with(fake_path)
mock_get_response.assert_called_once_with(mock_Request())
self.assertEqual(response, mock_get_response().read())
self.assertEqual(mock_get_response.return_value.read.return_value,
response)
@mock.patch('cloudbaseinit.metadata.services.ec2service.EC2Service'
'._get_cache_data')
@ -98,7 +99,7 @@ class EC2ServiceTest(unittest.TestCase):
response = self._service.get_host_name()
mock_get_cache_data.assert_called_once_with(
'%s/meta-data/local-hostname' % self._service._metadata_version)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)
@mock.patch('cloudbaseinit.metadata.services.ec2service.EC2Service'
'._get_cache_data')
@ -106,7 +107,7 @@ class EC2ServiceTest(unittest.TestCase):
response = self._service.get_instance_id()
mock_get_cache_data.assert_called_once_with(
'%s/meta-data/instance-id' % self._service._metadata_version)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)
@mock.patch('cloudbaseinit.metadata.services.ec2service.EC2Service'
'._get_cache_data')
@ -120,5 +121,5 @@ class EC2ServiceTest(unittest.TestCase):
'idx)s/openssh-key' %
{'version': self._service._metadata_version,
'idx': 'key'})]
self.assertEqual(mock_get_cache_data.call_args_list, expected)
self.assertEqual(response, ['fake key'])
self.assertEqual(expected, mock_get_cache_data.call_args_list)
self.assertEqual(['fake key'], response)

17
cloudbaseinit/tests/metadata/services/test_httpservice.py
View File

@ -43,9 +43,9 @@ class HttpServiceTest(unittest.TestCase):
CONF.metadata_base_url)
mock_get_meta_data.assert_called_once_with()
if side_effect:
self.assertEqual(response, False)
self.assertFalse(response)
else:
self.assertEqual(response, True)
self.assertTrue(response)
def test_load(self):
self._test_load(side_effect=None)
@ -68,7 +68,7 @@ class HttpServiceTest(unittest.TestCase):
else:
mock_urlopen.return_value = 'fake url'
response = self._httpservice._get_response(mock_req)
self.assertEqual(response, 'fake url')
self.assertEqual('fake url', response)
def test_get_response_fail_HTTPError(self):
err = error.HTTPError("http://169.254.169.254/", 404,
@ -102,7 +102,7 @@ class HttpServiceTest(unittest.TestCase):
mock_posix_join.assert_called_with(CONF.metadata_base_url, fake_path)
mock_Request.assert_called_once_with(mock_norm_path)
mock_get_response.assert_called_once_with(mock_req)
self.assertEqual(response, mock_data.read())
self.assertEqual(mock_data.read.return_value, response)
@mock.patch('cloudbaseinit.metadata.services.httpservice.HttpService'
'._get_response')
@ -125,13 +125,12 @@ class HttpServiceTest(unittest.TestCase):
fake_path)
mock_Request.assert_called_once_with(mock_norm_path, data=fake_data)
mock_get_response.assert_called_once_with(mock_req)
self.assertEqual(response, True)
self.assertTrue(response)
def test_get_password_path(self):
response = self._httpservice._get_password_path()
self.assertEqual(
response, 'openstack/%s/password' %
self._httpservice._POST_PASSWORD_MD_VER)
self.assertEqual('openstack/%s/password' %
self._httpservice._POST_PASSWORD_MD_VER, response)
@mock.patch('cloudbaseinit.metadata.services.httpservice.HttpService'
'._get_password_path')
@ -153,7 +152,7 @@ class HttpServiceTest(unittest.TestCase):
response = self._httpservice.post_password(
enc_password_b64='fake')
mock_get_password_path.assert_called_once_with()
self.assertEqual(response, ret_val)
self.assertEqual(ret_val, response)
def test_post_password(self):
self._test_post_password(ret_val='fake return')

19
cloudbaseinit/tests/metadata/services/test_maasservice.py
View File

@ -66,7 +66,7 @@ class MaaSHttpServiceTest(unittest.TestCase):
else:
response = self._maasservice._get_response(req=mock_request)
mock_urlopen.assert_called_once_with(mock_request)
self.assertEqual(response, ret_val)
self.assertEqual(ret_val, response)
def test_get_response(self):
self._test_get_response(ret_val='fake response')
@ -106,7 +106,7 @@ class MaaSHttpServiceTest(unittest.TestCase):
mock_req.sign_request.assert_called_once_with(
self.mock_oauth.OAuthSignatureMethod_PLAINTEXT(), mock_consumer,
mock_token)
self.assertEqual(response, mock_req.to_header())
self.assertEqual(mock_req.to_header.return_value, response)
@mock.patch("cloudbaseinit.metadata.services.maasservice.MaaSHttpService"
"._get_oauth_headers")
@ -124,7 +124,8 @@ class MaaSHttpServiceTest(unittest.TestCase):
mock_Request.assert_called_once_with(norm_path,
headers='fake headers')
mock_get_response.assert_called_once_with(mock_Request())
self.assertEqual(response, mock_get_response().read())
self.assertEqual(mock_get_response.return_value.read.return_value,
response)
@mock.patch("cloudbaseinit.metadata.services.maasservice.MaaSHttpService"
"._get_cache_data")
@ -133,7 +134,7 @@ class MaaSHttpServiceTest(unittest.TestCase):
mock_get_cache_data.assert_called_once_with(
'%s/meta-data/local-hostname' %
self._maasservice._metadata_version)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)
@mock.patch("cloudbaseinit.metadata.services.maasservice.MaaSHttpService"
"._get_cache_data")
@ -141,11 +142,11 @@ class MaaSHttpServiceTest(unittest.TestCase):
response = self._maasservice.get_instance_id()
mock_get_cache_data.assert_called_once_with(
'%s/meta-data/instance-id' % self._maasservice._metadata_version)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)
def test_get_list_from_text(self):
response = self._maasservice._get_list_from_text('fake:text', ':')
self.assertEqual(response, ['fake:', 'text:'])
self.assertEqual(['fake:', 'text:'], response)
@mock.patch("cloudbaseinit.metadata.services.maasservice.MaaSHttpService"
"._get_list_from_text")
@ -158,7 +159,7 @@ class MaaSHttpServiceTest(unittest.TestCase):
'%s/meta-data/public-keys' % self._maasservice._metadata_version)
mock_get_list_from_text.assert_called_once_with(mock_get_cache_data(),
"\n")
self.assertEqual(response, mock_get_list_from_text())
self.assertEqual(mock_get_list_from_text.return_value, response)
@mock.patch("cloudbaseinit.metadata.services.maasservice.MaaSHttpService"
"._get_list_from_text")
@ -171,7 +172,7 @@ class MaaSHttpServiceTest(unittest.TestCase):
'%s/meta-data/x509' % self._maasservice._metadata_version)
mock_get_list_from_text.assert_called_once_with(
mock_get_cache_data(), "%s\n" % x509constants.PEM_FOOTER)
self.assertEqual(response, mock_get_list_from_text())
self.assertEqual(mock_get_list_from_text.return_value, response)
@mock.patch("cloudbaseinit.metadata.services.maasservice.MaaSHttpService"
"._get_cache_data")
@ -180,4 +181,4 @@ class MaaSHttpServiceTest(unittest.TestCase):
mock_get_cache_data.assert_called_once_with(
'%s/user-data' %
self._maasservice._metadata_version)
self.assertEqual(response, mock_get_cache_data())
self.assertEqual(mock_get_cache_data.return_value, response)

2
cloudbaseinit/tests/metadata/test_factory.py
View File

@ -29,7 +29,7 @@ class MetadataServiceFactoryTests(unittest.TestCase):
self.assertRaises(Exception, factory.get_metadata_service)
else:
response = factory.get_metadata_service()
self.assertEqual(response, mock_load_class()())
self.assertEqual(mock_load_class()(), response)
def test_get_metadata_service(self):
m = mock.MagicMock()

73
cloudbaseinit/tests/osutils/test_windows.py
View File

@ -163,13 +163,13 @@ class WindowsUtilsTest(unittest.TestCase):
unsanitised = ' \' '
response = self._winutils._sanitize_wmi_input(unsanitised)
sanitised = ' \'\' '
self.assertEqual(response, sanitised)
self.assertEqual(sanitised, response)
def test_sanitize_shell_input(self):
unsanitised = ' " '
response = self._winutils.sanitize_shell_input(unsanitised)
sanitised = ' \\" '
self.assertEqual(response, sanitised)
self.assertEqual(sanitised, response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'._set_user_password_expiration')
@ -274,7 +274,7 @@ class WindowsUtilsTest(unittest.TestCase):
self._ctypes_mock.byref(cbSid), domainName,
self._ctypes_mock.byref(cchReferencedDomainName),
self._ctypes_mock.byref(sidNameUse))
self.assertEqual(response, (sid, domainName.value))
self.assertEqual((sid, domainName.value), response)
def test_get_user_sid_and_domain(self):
fake_obj = mock.Mock()
@ -510,7 +510,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_network_adapters()
conn.return_value.query.assert_called_with(wql)
self.assertEqual(response, [mock_response.Name])
self.assertEqual([mock_response.Name], response)
def test_get_network_adapters(self):
self._test_get_network_adapters(False)
@ -636,10 +636,10 @@ class WindowsUtilsTest(unittest.TestCase):
def _test_get_config_key_name(self, section):
response = self._winutils._get_config_key_name(section)
if section:
self.assertEqual(
response, self._winutils._config_key + section + '\\')
self.assertEqual(self._winutils._config_key + section + '\\',
response)
else:
self.assertEqual(response, self._winutils._config_key)
self.assertEqual(self._winutils._config_key, response)
def test_get_config_key_name_with_section(self):
self._test_get_config_key_name(self._SECTION)
@ -695,7 +695,7 @@ class WindowsUtilsTest(unittest.TestCase):
self.windows_utils.WindowsError]
response = self._winutils.get_config_value(self._CONFIG_NAME,
self._SECTION)
self.assertEqual(response, None)
self.assertEqual(None, response)
else:
mock_get_config_key_name.return_value = key_name
@ -708,7 +708,7 @@ class WindowsUtilsTest(unittest.TestCase):
mock_get_config_key_name.assert_called_with(self._SECTION)
self._winreg_mock.QueryValueEx.assert_called_with(
self._winreg_mock.OpenKey().__enter__(), self._CONFIG_NAME)
self.assertEqual(response, value)
self.assertEqual(value, response)
def test_get_config_value_type_int(self):
self._test_get_config_value(1)
@ -746,7 +746,7 @@ class WindowsUtilsTest(unittest.TestCase):
conn.assert_called_with(moniker='//./root/cimv2')
conn.return_value.Win32_Service.assert_called_with(Name='fake name')
self.assertEqual(response, 'fake name')
self.assertEqual('fake name', response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'._get_service')
@ -755,7 +755,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.check_service_exists('fake name')
self.assertEqual(response, True)
self.assertTrue(response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'._get_service')
@ -765,7 +765,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_service_status('fake name')
self.assertEqual(response, mock_service.State)
self.assertEqual(mock_service.State, response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'._get_service')
@ -775,7 +775,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_service_start_mode('fake name')
self.assertEqual(response, mock_service.StartMode)
self.assertEqual(mock_service.StartMode, response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'._get_service')
@ -859,9 +859,9 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_default_gateway()
mock_get_ipv4_routing_table.assert_called_once_with()
if routing_table[0] == '0.0.0.0':
self.assertEqual(response, (routing_table[3], routing_table[2]))
self.assertEqual((routing_table[3], routing_table[2]), response)
else:
self.assertEqual(response, (None, None))
self.assertEqual((None, None), response)
def test_get_default_gateway(self):
routing_table = ['0.0.0.0', '1.1.1.1', self._GATEWAY, '8.8.8.8']
@ -937,15 +937,16 @@ class WindowsUtilsTest(unittest.TestCase):
self._ctypes_mock.sizeof.assert_called_once_with(
self.windows_utils.Win32_OSVERSIONINFOEX_W)
self.assertEqual(
self._windll_mock.kernel32.VerSetConditionMask.call_count, 3)
3, self._windll_mock.kernel32.VerSetConditionMask.call_count)
self._windll_mock.kernel32.VerifyVersionInfoW.assert_called_with(
self._ctypes_mock.byref(), 1 | 2 | 3 | 7, 2)
self._ctypes_mock.byref.return_value, 1 | 2 | 3 | 7, 2)
if error_value is old_version:
self._windll_mock.kernel32.GetLastError.assert_called_with()
self.assertEqual(response, False)
self.assertFalse(response)
else:
self.assertEqual(response, True)
self.assertTrue(response)
def test_check_os_version(self):
m = mock.MagicMock()
@ -995,7 +996,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.generate_random_password(length)
mock_generate_random_password.assert_called_once_with(length)
self.assertEqual(response, 'Passw0rd')
self.assertEqual('Passw0rd', response)
def _test_get_logical_drives(self, buf_length):
mock_buf = mock.MagicMock()
@ -1013,7 +1014,7 @@ class WindowsUtilsTest(unittest.TestCase):
self._ctypes_mock.create_unicode_buffer.assert_called_with(261)
mock_get_drives.assert_called_with(260, mock_buf)
self.assertEqual(response, ['1'])
self.assertEqual(['1'], response)
def test_get_logical_drives_exception(self):
self._test_get_logical_drives(buf_length=None)
@ -1031,7 +1032,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_cdrom_drives()
mock_get_logical_drives.assert_called_with()
self.assertEqual(response, ['drive'])
self.assertEqual(['drive'], response)
@mock.patch('cloudbaseinit.osutils.windows.msvcrt')
@mock.patch('cloudbaseinit.osutils.windows.kernel32')
@ -1078,12 +1079,13 @@ class WindowsUtilsTest(unittest.TestCase):
else:
response = self._winutils.get_physical_disks()
self.assertEqual(self._ctypes_mock.sizeof.call_args_list,
sizeof_calls)
self.assertEqual(sizeof_calls,
self._ctypes_mock.sizeof.call_args_list)
self.assertEqual(
mock_setupapi.SetupDiEnumDeviceInterfaces.call_args_list,
device_interfaces_calls)
device_interfaces_calls,
mock_setupapi.SetupDiEnumDeviceInterfaces.call_args_list)
if not interface_detail:
mock_kernel32.GetLastError.assert_called_once_with()
@ -1092,8 +1094,7 @@ class WindowsUtilsTest(unittest.TestCase):
mock_msvcrt.malloc.assert_called_with(
self._wintypes_mock.DWORD.return_value)
self.assertEqual(self._ctypes_mock.cast.call_args_list,
cast_calls)
self.assertEqual(cast_calls, self._ctypes_mock.cast.call_args_list)
mock_setup_interface.assert_called_with(
handle_disks, self._ctypes_mock.byref.return_value,
@ -1113,7 +1114,7 @@ class WindowsUtilsTest(unittest.TestCase):
self._ctypes_mock.sizeof.return_value,
self._ctypes_mock.byref.return_value, None)
self.assertEqual(response, ["\\\\.\PHYSICALDRIVE1"])
self.assertEqual(["\\\\.\PHYSICALDRIVE1"], response)
mock_setupapi.SetupDiDestroyDeviceInfoList.assert_called_once_with(
handle_disks)
@ -1173,7 +1174,7 @@ class WindowsUtilsTest(unittest.TestCase):
self._winutils.firewall_create_rule(
name='fake name', port=9999, protocol=self._winutils.PROTOCOL_TCP)
self.assertEqual(self._client_mock.Dispatch.call_args_list, expected)
self.assertEqual(expected, self._client_mock.Dispatch.call_args_list)
mock_get_fw_protocol.assert_called_once_with(
self._winutils.PROTOCOL_TCP)
@ -1204,7 +1205,7 @@ class WindowsUtilsTest(unittest.TestCase):
mock_IsWow64Process.assert_called_once_with(
mock_GetCurrentProcess(), self._ctypes_mock.byref.return_value)
self.assertEqual(response, True)
self.assertTrue(response)
def test_is_wow64(self):
self._test_is_wow64(ret_val=True)
@ -1218,7 +1219,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_system32_dir()
self.assertEqual(response, 'fake_system32')
self.assertEqual('fake_system32', response)
@mock.patch('os.path.expandvars')
def test_get_sysnative_dir(self, mock_expandvars):
@ -1226,7 +1227,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_sysnative_dir()
self.assertEqual(response, 'fake_sysnative')
self.assertEqual('fake_sysnative', response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'.get_sysnative_dir')
@ -1238,7 +1239,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.check_sysnative_dir_exists()
self.assertEqual(response, True)
self.assertTrue(response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'.check_sysnative_dir_exists')
@ -1270,7 +1271,7 @@ class WindowsUtilsTest(unittest.TestCase):
mock_get_system32_dir.assert_called_once_with()
mock_execute_process.assert_called_with(args, False)
self.assertEqual(response, mock_execute_process())
self.assertEqual(mock_execute_process.return_value, response)
def test_execute_powershell_script_sysnative(self):
self._test_execute_powershell_script(ret_val=True)
@ -1289,7 +1290,7 @@ class WindowsUtilsTest(unittest.TestCase):
response = self._winutils.get_dhcp_hosts_in_use()
mock_get_adapter_addresses.assert_called()
self.assertEqual(response, [('fake mac address', 'fake dhcp server')])
self.assertEqual([('fake mac address', 'fake dhcp server')], response)
@mock.patch('cloudbaseinit.osutils.windows.WindowsUtils'
'.check_sysnative_dir_exists')

2
cloudbaseinit/tests/plugins/test_factory.py
View File

@ -32,5 +32,5 @@ class PluginFactoryTests(unittest.TestCase):
for path in CONF.plugins:
expected.append(mock.call(path))
response = factory.load_plugins()
self.assertEqual(mock_load_class.call_args_list, expected)
self.assertEqual(expected, mock_load_class.call_args_list)
self.assertTrue(response is not None)

4
cloudbaseinit/tests/plugins/windows/test_createuser.py
View File

@ -35,7 +35,7 @@ class CreateUserPluginTests(unittest.TestCase):
mock_osutils.generate_random_password.return_value = 'fake password'
response = self._create_user._get_password(mock_osutils)
mock_osutils.generate_random_password.assert_called_once_with(14)
self.assertEqual(response, 'fake password')
self.assertEqual('fake password', response)
@mock.patch('cloudbaseinit.osutils.factory.get_os_utils')
@mock.patch('cloudbaseinit.plugins.windows.createuser.CreateUserPlugin'
@ -69,7 +69,7 @@ class CreateUserPluginTests(unittest.TestCase):
mock_token)
mock_osutils.add_user_to_local_group.assert_called_once_with(
CONF.username, CONF.groups[0])
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
def test_execute_user_exists(self):
self._test_execute(user_exists=True)

8
cloudbaseinit/tests/plugins/windows/test_extendvolumes.py
View File

@ -143,7 +143,7 @@ class ExtendVolumesPluginTests(unittest.TestCase):
self._ctypes_mock.pointer.assert_called_once_with(
mock_VDS_DISK_EXTENT())
self.assertEqual(response, [])
self.assertEqual([], response)
self._ctypes_mock.windll.ole32.CoTaskMemFree.assert_called_with(
mock_extents_p)
@ -166,7 +166,7 @@ class ExtendVolumesPluginTests(unittest.TestCase):
mock_VDS_QUERY_SOFTWARE_PROVIDERS)
mock_enum.Next.assert_called_with(1)
mock_unk.QueryInterface.assert_called_once_with(mock_IVdsSwProvider)
self.assertEqual(response, ['fake providers'])
self.assertEqual(['fake providers'], response)
@mock.patch('cloudbaseinit.utils.windows.vds.IVdsPack')
def test_query_packs(self, mock_IVdsPack):
@ -183,12 +183,12 @@ class ExtendVolumesPluginTests(unittest.TestCase):
mock_provider.QueryPacks.assert_called_once_with()
mock_enum.Next.assert_called_with(1)
mock_unk.QueryInterface.assert_called_once_with(mock_IVdsPack)
self.assertEqual(response, ['fake packs'])
self.assertEqual(['fake packs'], response)
def test_get_volumes_to_extend(self):
CONF.set_override('volumes_to_extend', '1')
response = self._extend_volumes._get_volumes_to_extend()
self.assertEqual(response, [1])
self.assertEqual([1], response)
@mock.patch('cloudbaseinit.utils.windows.vds.load_vds_service')
@mock.patch('cloudbaseinit.plugins.windows.extendvolumes.'

2
cloudbaseinit/tests/plugins/windows/test_fileexecutils.py
View File

@ -47,7 +47,7 @@ class TestFileExecutilsPlugin(unittest.TestCase):
mock_osutils.execute_powershell_script.assert_called_once_with(
filename)
else:
self.assertEqual(response, 0)
self.assertEqual(0, response)
def test_process_cmd(self):
self._test_exec_file(filename='fake.cmd')

10
cloudbaseinit/tests/plugins/windows/test_licensing.py
View File

@ -53,7 +53,7 @@ class WindowsLicensingPluginTests(unittest.TestCase):
else:
response = self._licensing._run_slmgr(osutils=mock_osutils,
args=['fake args'])
self.assertEqual(response, 'fake output')
self.assertEqual('fake output', response)
mock_osutils.check_sysnative_dir_exists.assert_called_once_with()
if sysnative:
@ -63,8 +63,8 @@ class WindowsLicensingPluginTests(unittest.TestCase):
mock_osutils.execute_process.assert_called_once_with(
[cscript_path, slmgr_path, 'fake args'], False)
self.assertEqual(mock_osutils.get_system32_dir.call_args_list,
get_system32_dir_calls)
self.assertEqual(get_system32_dir_calls,
mock_osutils.get_system32_dir.call_args_list)
def test_run_slmgr_sysnative(self):
self._test_run_slmgr(sysnative=True, exit_code=None)
@ -91,8 +91,8 @@ class WindowsLicensingPluginTests(unittest.TestCase):
if activate_windows:
run_slmgr_calls.append(mock.call(mock_osutils, ['/ato']))
self.assertEqual(mock_run_slmgr.call_args_list, run_slmgr_calls)
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual(run_slmgr_calls, mock_run_slmgr.call_args_list)
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
def test_execute_activate_windows_true(self):
self._test_execute(activate_windows=True)

8
cloudbaseinit/tests/plugins/windows/test_localscripts.py
View File

@ -37,9 +37,9 @@ class LocalScriptsPluginTests(unittest.TestCase):
mock_listdir.return_value = fake_file_list
response = self._localscripts._get_files_in_dir(fake_path)
mock_listdir.assert_called_once_with(fake_path)
self.assertEqual(sorted(os.path.join(fake_path,
f) for f in fake_file_list),
response)
self.assertEqual(
sorted(os.path.join(fake_path, f) for f in fake_file_list),
response)
@mock.patch('cloudbaseinit.plugins.windows.localscripts'
'.LocalScriptsPlugin._get_files_in_dir')
@ -55,4 +55,4 @@ class LocalScriptsPluginTests(unittest.TestCase):
mock_get_files_in_dir.assert_called_once_with(CONF.local_scripts_path)
mock_exec_file.assert_called_once_with(fake_path)
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)

2
cloudbaseinit/tests/plugins/windows/test_networkconfig.py
View File

@ -68,7 +68,7 @@ class NetworkConfigPluginPluginTests(unittest.TestCase):
search_result.group('broadcast'),
search_result.group('gateway'),
search_result.group('dnsnameservers').strip().split(' '))
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
def test_execute(self):
m = mock.MagicMock()

6
cloudbaseinit/tests/plugins/windows/test_ntpclient.py
View File

@ -106,13 +106,13 @@ class NTPClientPluginTests(unittest.TestCase):
mock_options_data.get.assert_called_once_with(dhcp.OPTION_NTP_SERVERS)
if ntp_data:
mock_inet_ntoa.assert_called_once_with(ntp_data[:4])
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
mock_check_w32time_svc_status.assert_called_once_with(mock_osutils)
mock_osutils.set_ntp_client_config.assert_called_once_with(
'fake host')
else:
self.assertEqual(response,
(base.PLUGIN_EXECUTE_ON_NEXT_BOOT, False))
self.assertEqual((base.PLUGIN_EXECUTE_ON_NEXT_BOOT, False),
response)
def test_execute_no_ntp_options_data(self):
self._test_execute(ntp_data=None)

6
cloudbaseinit/tests/plugins/windows/test_sethostname.py
View File

@ -78,9 +78,9 @@ class SetHostNamePluginPluginTests(unittest.TestCase):
else:
mock_osutils.set_host_name.assert_called_once_with(hostname)
self.assertEqual(
response, (base.PLUGIN_EXECUTION_DONE,
hostname_exists and not hostname_already_set))
self.assertEqual((base.PLUGIN_EXECUTION_DONE,
hostname_exists and not hostname_already_set),
response)
def test_execute_hostname_already_set(self):
self._test_execute(hostname_already_set=True)

12
cloudbaseinit/tests/plugins/windows/test_setuserpassword.py
View File

@ -50,7 +50,7 @@ class SetUserPasswordPluginTests(unittest.TestCase):
mock_load_ssh_key.assert_called_with(fake_ssh_pub_key)
mock_rsa.__enter__().public_encrypt.assert_called_with('fake password')
mock_b64encode.assert_called_with('public encrypted')
self.assertEqual(response, 'encrypted password')
self.assertEqual('encrypted password', response)
def _test_get_ssh_public_key(self, data_exists):
mock_service = mock.MagicMock()
@ -58,7 +58,7 @@ class SetUserPasswordPluginTests(unittest.TestCase):
mock_service.get_public_keys.return_value = public_keys
response = self._setpassword_plugin._get_ssh_public_key(mock_service)
mock_service.get_public_keys.assert_called_with()
self.assertEqual(response, public_keys[0])
self.assertEqual(public_keys[0], response)
def test_get_ssh_plublic_key(self):
self._test_get_ssh_public_key(data_exists=True)
@ -78,7 +78,7 @@ class SetUserPasswordPluginTests(unittest.TestCase):
mock_service.get_admin_password.assert_called_with()
else:
mock_osutils.generate_random_password.assert_called_once_with(14)
self.assertEqual(response, 'Passw0rd')
self.assertEqual('Passw0rd', response)
def test_get_password_inject_true(self):
self._test_get_password(inject_password=True)
@ -100,14 +100,14 @@ class SetUserPasswordPluginTests(unittest.TestCase):
response = self._setpassword_plugin._set_metadata_password(
fake_passw0rd, mock_service)
if ssh_pub_key is None:
self.assertEqual(response, True)
self.assertTrue(response)
else:
mock_get_key.assert_called_once_with(mock_service)
mock_encrypt_password.assert_called_once_with(ssh_pub_key,
fake_passw0rd)
mock_service.post_password.assert_called_with(
'encrypted password')
self.assertEqual(response, 'value')
self.assertEqual('value', response)
def test_set_metadata_password_with_ssh_key(self):
fake_key = 'fake key'
@ -156,4 +156,4 @@ class SetUserPasswordPluginTests(unittest.TestCase):
'fake username')
mock_set_metadata_password.assert_called_once_with('fake password',
mock_service)
self.assertEqual(response, (2, False))
self.assertEqual((2, False), response)

5
cloudbaseinit/tests/plugins/windows/test_sshpublickeys.py
View File

@ -59,11 +59,10 @@ class SetUserSSHPublicKeysPluginTests(unittest.TestCase):
fake_shared_data)
mock_service.get_public_keys.assert_called_with()
mock_osutils.get_user_home.assert_called_with('fake user')
self.assertEqual(mock_os_path.join.call_count, 2)
self.assertEqual(2, mock_os_path.join.call_count)
mock_os_makedirs.assert_called_once_with(mock_os_path.join())
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE,
False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
def test_execute_with_user_home(self):
fake_user_home = os.path.join('fake', 'home')

18
cloudbaseinit/tests/plugins/windows/test_userdata.py
View File

@ -115,10 +115,11 @@ class UserDataPluginTest(unittest.TestCase):
mock_parse_mime.assert_called_once_with(user_data)
mock_process_part.assert_called_once_with(mock_part,
mock_load_plugins(), {})
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, reboot))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, reboot), response)
else:
mock_process_non_multi_part.assert_called_once_with(user_data)
self.assertEqual(response, mock_process_non_multi_part())
self.assertEqual(mock_process_non_multi_part.return_value,
response)
def test_process_user_data_multipart_reboot_true(self):
self._test_process_user_data(user_data='Content-Type: multipart',
@ -158,15 +159,15 @@ class UserDataPluginTest(unittest.TestCase):
mock_user_handlers.get.assert_called_once_with(
_content_type)
if handler_func and handler_func is Exception:
self.assertEqual(mock_part.get_content_type.call_count, 2)
self.assertEqual(mock_part.get_filename.call_count, 2)
self.assertEqual(2, mock_part.get_content_type.call_count)
self.assertEqual(2, mock_part.get_filename.call_count)
elif handler_func:
handler_func.assert_called_once_with(None, _content_type,
mock_part.get_filename(),
mock_part.get_payload())
self.assertEqual(mock_part.get_content_type.call_count, 1)
self.assertEqual(mock_part.get_filename.call_count, 2)
self.assertEqual(1, mock_part.get_content_type.call_count)
self.assertEqual(2, mock_part.get_filename.call_count)
else:
mock_user_data_plugins.get.assert_called_once_with(_content_type)
if user_data_plugin and content_type:
@ -177,7 +178,8 @@ class UserDataPluginTest(unittest.TestCase):
elif user_data_plugin and not content_type:
mock_get_plugin_return_value.assert_called_once_with(
user_data_plugin.process())
self.assertEqual(response, mock_get_plugin_return_value())
self.assertEqual(mock_get_plugin_return_value.return_value,
response)
def test_process_part(self):
handler_func = mock.MagicMock()
@ -253,4 +255,4 @@ class UserDataPluginTest(unittest.TestCase):
mock_execute_user_data_script.assert_called_once_with(user_data)
mock_get_plugin_return_value.assert_called_once_with(
mock_execute_user_data_script())
self.assertEqual(response, mock_get_plugin_return_value())
self.assertEqual(mock_get_plugin_return_value.return_value, response)

8
cloudbaseinit/tests/plugins/windows/test_userdatautils.py
View File

@ -92,18 +92,18 @@ class UserDataUtilsTest(unittest.TestCase):
mock.mock_open(), create=True):
response = userdatautils.execute_user_data_script(fake_user_data)
mock_gettempdir.assert_called_once_with()
self.assertEqual(mock_re_search.call_count, number_of_calls)
self.assertEqual(number_of_calls, mock_re_search.call_count)
if args:
mock_osutils.execute_process.assert_called_with(args, shell)
mock_os_remove.assert_called_once_with(path + extension)
self.assertEqual(response, None)
self.assertEqual(None, response)
elif powershell:
mock_osutils.execute_powershell_script.assert_called_with(
path + extension, sysnative)
mock_os_remove.assert_called_once_with(path + extension)
self.assertEqual(response, None)
self.assertEqual(None, response)
else:
self.assertEqual(response, 0)
self.assertEqual(0, response)
def test_handle_batch(self):
fake_user_data = '^rem cmd\s'

10
cloudbaseinit/tests/plugins/windows/test_winrmcertificateauth.py
View File

@ -57,10 +57,12 @@ class ConfigWinRMCertificateAuthPluginTests(unittest.TestCase):
response = self._certif_auth._get_credentials(mock_shared_data)
expected = [mock.call(constants.SHARED_DATA_USERNAME),
mock.call(constants.SHARED_DATA_PASSWORD)]
self.assertEqual(mock_shared_data.get.call_args_list, expected)
self.assertEqual(expected, mock_shared_data.get.call_args_list)
mock_shared_data.__setitem__.assert_called_once_with(
'admin_password', None)
self.assertEqual(response, (fake_user, fake_password))
self.assertEqual((fake_user, fake_password), response)
def test_test_get_credentials(self):
self._test_get_credentials(fake_user='fake user',
@ -93,7 +95,7 @@ class ConfigWinRMCertificateAuthPluginTests(unittest.TestCase):
shared_data='fake data')
mock_service.get_client_auth_certs.assert_called_once_with()
if not cert_data:
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
else:
mock_get_credentials.assert_called_once_with('fake data')
mock_import_cert.assert_called_once_with(
@ -108,7 +110,7 @@ class ConfigWinRMCertificateAuthPluginTests(unittest.TestCase):
mock_WinRMConfig().create_cert_mapping.assert_called_once_with(
mock_cert_thumprint, cert_upn, 'fake user',
'fake password')
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
def test_execute(self):
cert_data = 'fake cert data'

10
cloudbaseinit/tests/plugins/windows/test_winrmlistener.py
View File

@ -56,7 +56,7 @@ class ConfigWinRMListenerPluginTests(unittest.TestCase):
response = self._winrmlistener._check_winrm_service(mock_osutils)
if not service_exists:
self.assertEqual(response, False)
self.assertFalse(response)
else:
mock_osutils.get_service_start_mode.assert_called_once_with(
@ -70,7 +70,7 @@ class ConfigWinRMListenerPluginTests(unittest.TestCase):
self._winrmlistener._winrm_service_name)
mock_osutils.start_service.assert_called_once_with(
self._winrmlistener._winrm_service_name)
self.assertEqual(response, True)
self.assertTrue(response)
def test_check_winrm_service(self):
self._test_check_winrm_service(service_exists=True)
@ -104,8 +104,8 @@ class ConfigWinRMListenerPluginTests(unittest.TestCase):
mock_check_winrm_service.assert_called_once_with(mock_osutils)
if not service_status:
self.assertEqual(response, (base.PLUGIN_EXECUTE_ON_NEXT_BOOT,
service_status))
self.assertEqual((base.PLUGIN_EXECUTE_ON_NEXT_BOOT,
service_status), response)
else:
mock_WinRMConfig().set_auth_config.assert_called_once_with(
basic=CONF.winrm_enable_basic_auth)
@ -121,7 +121,7 @@ class ConfigWinRMListenerPluginTests(unittest.TestCase):
mock_listener_config.get.assert_called_once_with("Port")
mock_osutils.firewall_create_rule.assert_called_once_with(
"WinRM HTTPS", 9999, mock_osutils.PROTOCOL_TCP)
self.assertEqual(response, (base.PLUGIN_EXECUTION_DONE, False))
self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
def test_execute(self):
self._test_execute(service_status=True)

3
cloudbaseinit/tests/plugins/windows/userdataplugins/test_heat.py
View File

@ -54,7 +54,8 @@ class HeatUserDataHandlerTests(unittest.TestCase):
if filename == self._heat._heat_user_data_filename:
mock_execute_user_data_script.assert_called_with(
mock_part.get_payload())
self.assertEqual(response, mock_execute_user_data_script())
self.assertEqual(mock_execute_user_data_script.return_value,
response)
else:
self.assertTrue(response is None)

4
cloudbaseinit/tests/plugins/windows/userdataplugins/test_parthandler.py
View File

@ -49,5 +49,5 @@ class PartHandlerPluginTests(unittest.TestCase):
mock_load_module.assert_called_once_with(os.path.join(
'fake_directory', 'fake_name'))
mock_part_handler.list_types.assert_called_once_with()
self.assertEqual(response, {'fake part':
mock_part_handler.handle_part})
self.assertEqual({'fake part': mock_part_handler.handle_part},
response)

2
cloudbaseinit/tests/plugins/windows/userdataplugins/test_shellscript.py
View File

@ -49,7 +49,7 @@ class ShellScriptPluginTests(unittest.TestCase):
mock_part.get_payload.assert_called_once_with()
mock_gettempdir.assert_called_once_with()
if not exception:
self.assertEqual(response, 'fake response')
self.assertEqual('fake response', response)
def test_process(self):
self._test_process(exception=False)

6
cloudbaseinit/tests/test_init.py
View File

@ -55,11 +55,11 @@ class InitManagerTest(unittest.TestCase):
def _test_get_plugin_section(self, instance_id):
response = self._init._get_plugins_section(instance_id=instance_id)
if not instance_id:
self.assertEqual(response, self._init._PLUGINS_CONFIG_SECTION)
self.assertEqual(self._init._PLUGINS_CONFIG_SECTION, response)
else:
self.assertEqual(
response,
instance_id + "/" + self._init._PLUGINS_CONFIG_SECTION)
instance_id + "/" + self._init._PLUGINS_CONFIG_SECTION,
response)
@mock.patch('cloudbaseinit.init.InitManager._get_plugins_section')
def test_get_plugin_status(self, mock_get_plugins_section):

16
cloudbaseinit/tests/utils/test_dhcp.py
View File

@ -57,7 +57,7 @@ class DHCPUtilsTests(unittest.TestCase):
response = dhcp._get_dhcp_request_data(
id_req=9999, mac_address=fake_mac_address,
requested_options=[100], vendor_id='fake id')
self.assertEqual(response, data)
self.assertEqual(data, response)
@mock.patch('struct.unpack')
def _test_parse_dhcp_reply(self, mock_unpack, message_type,
@ -76,13 +76,13 @@ class DHCPUtilsTests(unittest.TestCase):
response = dhcp._parse_dhcp_reply(data=fake_data, id_req=9999)
if message_type != 2:
self.assertEqual(response, (False, {}))
self.assertEqual((False, {}), response)
elif id_reply != 9999:
self.assertEqual(response, (False, {}))
self.assertEqual((False, {}), response)
elif fake_data[236:240] != dhcp._DHCP_COOKIE:
self.assertEqual(response, (False, {}))
self.assertEqual((False, {}), response)
else:
self.assertEqual(response, (True, {100: b'fake'}))
self.assertEqual((True, {100: b'fake'}), response)
def test_parse_dhcp_reply(self):
self._test_parse_dhcp_reply(message_type=2, id_reply=9999,
@ -115,8 +115,8 @@ class DHCPUtilsTests(unittest.TestCase):
mock_interfaces.assert_called_once_with()
mock_ifaddresses.assert_called_once_with('fake interface')
self.assertEqual(response,
fake_addresses[netifaces.AF_LINK][0]['addr'])
self.assertEqual(fake_addresses[netifaces.AF_LINK][0]['addr'],
response)
@mock.patch('random.randint')
@mock.patch('socket.socket')
@ -153,4 +153,4 @@ class DHCPUtilsTests(unittest.TestCase):
mock_parse_dhcp_reply.assert_called_once_with(mock_socket().recv(),
'fake int')
mock_socket().close.assert_called_once_with()
self.assertEqual(response, 'fake replied options')
self.assertEqual('fake replied options', response)

50
cloudbaseinit/tests/utils/windows/test_winrmconfig.py
View File

@ -47,7 +47,7 @@ class WinRMConfigTests(unittest.TestCase):
self._win32com_mock.client.Dispatch.assert_called_once_with(
'WSMan.Automation')
mock_wsman.CreateSession.assert_called_once_with()
self.assertEqual(response, mock_wsman.CreateSession())
self.assertEqual(mock_wsman.CreateSession.return_value, response)
@mock.patch('re.match')
def test_get_node_tag(self, mock_match):
@ -56,7 +56,7 @@ class WinRMConfigTests(unittest.TestCase):
response = self._winrmconfig._get_node_tag(mock_tag)
mock_match.assert_called_once_with("^{.*}(.*)$", mock_tag)
self.assertEqual(response, mock_match().groups().__getitem__())
self.assertEqual(mock_match().groups().__getitem__(), response)
@mock.patch('xml.etree.ElementTree.fromstring')
@mock.patch('cloudbaseinit.utils.windows.winrmconfig.WinRMConfig.'
@ -73,25 +73,25 @@ class WinRMConfigTests(unittest.TestCase):
response = self._winrmconfig._parse_listener_xml(data_xml=data_xml)
if data_xml is None:
self.assertEqual(response, None)
self.assertEqual(None, response)
else:
mock_fromstring.assert_called_once_with(data_xml)
mock_get_node_tag.assert_called_once_with(tag)
if tag is "ListeningOn":
self.assertEqual(response, {'ListeningOn': ['Fake']})
self.assertEqual({'ListeningOn': ['Fake']}, response)
elif tag is "Enabled":
if text is 'true':
self.assertEqual(response, {'ListeningOn': [],
'Enabled': True})
self.assertEqual({'ListeningOn': [],
'Enabled': True}, response)
else:
self.assertEqual(response, {'ListeningOn': [],
'Enabled': False})
self.assertEqual({'ListeningOn': [],
'Enabled': False}, response)
elif tag is 'Port':
self.assertEqual(response, {'ListeningOn': [],
'Port': int(text)})
self.assertEqual({'ListeningOn': [],
'Port': int(text)}, response)
else:
self.assertEqual(response, {'ListeningOn': [],
tag: text})
self.assertEqual({'ListeningOn': [],
tag: text}, response)
def test_parse_listener_xml_no_data(self):
self._test_parse_listener_xml(data_xml=None)
@ -137,11 +137,11 @@ class WinRMConfigTests(unittest.TestCase):
mock_get_node_tag.assert_called_once_with(tag)
if tag is "Enabled":
if text is 'true':
self.assertEqual(response, {'Enabled': True})
self.assertEqual({'Enabled': True}, response)
else:
self.assertEqual(response, {'Enabled': False})
self.assertEqual({'Enabled': False}, response)
else:
self.assertEqual(response, {tag: text})
self.assertEqual({tag: text}, response)
def test_parse_cert_mapping_xml_no_data(self):
self._test_parse_cert_mapping_xml(data_xml=None)
@ -161,9 +161,9 @@ class WinRMConfigTests(unittest.TestCase):
def _test_get_xml_bool(self, value):
response = self._winrmconfig._get_xml_bool(value)
if value:
self.assertEqual(response, 'true')
self.assertEqual('true', response)
else:
self.assertEqual(response, 'false')
self.assertEqual('false', response)
def test_get_xml_bool_true(self):
self._test_get_xml_bool(value='fake value')
@ -187,7 +187,7 @@ class WinRMConfigTests(unittest.TestCase):
mock_get_wsman_session.assert_called_once_with()
fake_session.Get.assert_called_once_with(fake_uri)
self.assertEqual(response, resource)
self.assertEqual(resource, response)
def test_get_resource(self):
self._test_get_resource(resource='fake resource')
@ -235,7 +235,7 @@ class WinRMConfigTests(unittest.TestCase):
mock_parse_cert_mapping_xml.assert_called_with('fake resource')
mock_get_resource.assert_called_with(
self._winrmconfig._SERVICE_CERTMAPPING_URI % fake_dict)
self.assertEqual(response, 'fake response')
self.assertEqual('fake response', response)
@mock.patch('cloudbaseinit.utils.windows.winrmconfig.WinRMConfig.'
'_delete_resource')
@ -293,7 +293,7 @@ class WinRMConfigTests(unittest.TestCase):
mock_get_resource.assert_called_with(
self._winrmconfig._SERVICE_LISTENER_URI % dict)
mock_parse_listener_xml.assert_called_once_with('fake resource')
self.assertEqual(response, 'fake response')
self.assertEqual('fake response', response)
@mock.patch('cloudbaseinit.utils.windows.winrmconfig.WinRMConfig.'
'_delete_resource')
@ -353,7 +353,7 @@ class WinRMConfigTests(unittest.TestCase):
self._winrmconfig._SERVICE_AUTH_URI)
mock_fromstring.assert_called_once_with('fake data xml')
mock_get_node_tag.assert_called_once_with(mock_node.tag)
self.assertEqual(response, {'tag': 'value'})
self.assertEqual({'tag': 'value'}, response)
@mock.patch('xml.etree.ElementTree.fromstring')
@mock.patch('xml.etree.ElementTree.tostring')
@ -396,10 +396,10 @@ class WinRMConfigTests(unittest.TestCase):
certificate='certificate', credSSP='credSSP',
cbt_hardening_level='cbt_hardening_level')
self.assertEqual(sorted(mock_tree.find.call_args_list),
sorted(expected_find))
self.assertEqual(sorted(mock_get_xml_bool.call_args_list),
sorted(expected_get_xml_bool))
self.assertEqual(sorted(expected_find),
sorted(mock_tree.find.call_args_list))
self.assertEqual(sorted(expected_get_xml_bool),
sorted(mock_get_xml_bool.call_args_list))
mock_get_wsman_session.assert_called_once_with()
mock_session.Get.assert_called_with(

22
cloudbaseinit/tests/utils/windows/test_x509.py
View File

@ -73,12 +73,13 @@ class CryptoAPICertManagerTests(unittest.TestCase):
fake_cert_context_p)
self.assertEqual(
mock_CertGetCertificateContextProperty.call_args_list,
expected)
expected,
mock_CertGetCertificateContextProperty.call_args_list)
mock_malloc.assert_called_with(mock_DWORD.return_value)
mock_cast.assert_called_with(mock_malloc(), mock_pointer)
mock_free.assert_called_with(mock_malloc())
self.assertEqual(response, '10')
self.assertEqual('10', response)
def test_get_cert_thumprint(self):
self._test_get_cert_thumprint(ret_val=True)
@ -229,7 +230,7 @@ class CryptoAPICertManagerTests(unittest.TestCase):
mock_CertCreateSelfSignCertificate())
mock_free.assert_called_once_with(mock_cast())
self.assertEqual(response, mock_get_cert_thumprint())
self.assertEqual(mock_get_cert_thumprint.return_value, response)
mock_generate_key.assert_called_once_with('fake_name', True)
@ -281,7 +282,7 @@ class CryptoAPICertManagerTests(unittest.TestCase):
fake_cert_data += 'fake cert' + '\n'
fake_cert_data += x509constants.PEM_FOOTER
response = self._x509_manager._get_cert_base64(fake_cert_data)
self.assertEqual(response, 'fake cert')
self.assertEqual('fake cert', response)
@mock.patch('cloudbaseinit.utils.windows.x509.free')
@mock.patch('cloudbaseinit.utils.windows.x509.CryptoAPICertManager'
@ -348,8 +349,8 @@ class CryptoAPICertManagerTests(unittest.TestCase):
response = self._x509_manager.import_cert(fake_cert_data)
mock_cast.assert_called_with(mock_malloc(), mock_POINTER())
self.assertEqual(mock_CryptStringToBinaryA.call_args_list,
expected)
self.assertEqual(expected,
mock_CryptStringToBinaryA.call_args_list)
mock_CertOpenStore.assert_called_with(
self.x509.cryptoapi.CERT_STORE_PROV_SYSTEM, 0, 0,
self.x509.cryptoapi.CERT_SYSTEM_STORE_LOCAL_MACHINE,
@ -364,7 +365,7 @@ class CryptoAPICertManagerTests(unittest.TestCase):
mock_byref())
mock_create_unicode_buffer.assert_called_with(2)
self.assertEqual(mock_CertGetNameString.call_args_list, expected2)
self.assertEqual(expected2, mock_CertGetNameString.call_args_list)
mock_get_cert_thumprint.assert_called_once_with(mock_POINTER()())
mock_CertFreeCertificateContext.assert_called_once_with(
@ -373,8 +374,9 @@ class CryptoAPICertManagerTests(unittest.TestCase):
mock_CertOpenStore(), 0)
mock_free.assert_called_once_with(mock_cast())
self.assertEqual(response, (mock_get_cert_thumprint(),
mock_create_unicode_buffer().value))
self.assertEqual(
(mock_get_cert_thumprint(),
mock_create_unicode_buffer().value), response)
mock_get_cert_base64.assert_called_with(fake_cert_data)