def test_maybe_install_ua_tools_noop_when_ua_tools_present(self, m_which):
"""Do nothing if ubuntu-advantage-tools already exists."""
m_which.return_value = '/usr/bin/ua' # already installed
distro = mock.MagicMock()
distro.update_package_sources.side_effect = RuntimeError(
'Some apt error')
maybe_install_ua_tools(cloud=FakeCloud(distro)) # No RuntimeError
def test_ntp_install_no_op_with_empty_pkg_list(self, mock_util):
"""ntp_install_client runs install_func with empty list"""
mock_util.which.return_value = None # check_exe not found
install_func = mock.MagicMock()
cc_ntp.install_ntp_client(install_func, packages=[],
check_exe='timesyncd')
install_func.assert_called_once_with([])
def test_send_ready_signal_sends_post_request(self):
with mock.patch.object(
azure_helper.GoalStateHealthReporter,
'build_report') as m_build_report:
client = azure_helper.AzureEndpointHttpClient(mock.MagicMock())
reporter = azure_helper.GoalStateHealthReporter(
azure_helper.GoalState(mock.MagicMock(), mock.MagicMock()),
client, self.test_endpoint)
reporter.send_ready_signal()
self.assertEqual(1, self.post.call_count)
self.assertEqual(
mock.call(
self.test_url,
data=m_build_report.return_value,
extra_headers=self.test_default_headers),
self.post.call_args)
def test_puppet_config_installs_puppet_aio(self, m_subp, m_aio, _):
"""Cloud-config with 'puppet' key installs
when 'install_type' is 'aio'."""
mycloud = self._get_cloud('ubuntu')
mycloud.distro = mock.MagicMock()
cfg = {'puppet': {'install': True, 'install_type': 'aio'}}
cc_puppet.handle('notimportant', cfg, mycloud, LOG, None)
m_aio.assert_called_with(cc_puppet.AIO_INSTALL_URL, None, None, True)
def test_handler_puppet_config_installs_puppet_version(self, m_subp, _):
"""Cloud-config 'puppet' configuration can specify a version."""
mycloud = self._get_cloud('ubuntu')
mycloud.distro = mock.MagicMock()
cfg = {'puppet': {'version': '3.8'}}
cc_puppet.handle('notimportant', cfg, mycloud, LOG, None)
self.assertEqual([mock.call(('puppet', '3.8'))],
mycloud.distro.install_packages.call_args_list)
def test_maybe_install_ua_tools_happy_path(self, m_which):
"""maybe_install_ua_tools installs ubuntu-advantage-tools."""
m_which.return_value = None
distro = mock.MagicMock() # No errors raised
maybe_install_ua_tools(cloud=FakeCloud(distro))
distro.update_package_sources.assert_called_once_with()
distro.install_packages.assert_called_once_with(
['ubuntu-advantage-tools'])
def test_ntp_install_not_needed(self, mock_subp):
"""ntp_install_client doesn't install when check_exe is found."""
client = 'chrony'
mock_subp.which.return_value = [client] # check_exe found.
install_func = mock.MagicMock()
cc_ntp.install_ntp_client(install_func, packages=[client],
check_exe=client)
install_func.assert_not_called()
def test_non_secure_get(self):
client = azure_helper.AzureEndpointHttpClient(mock.MagicMock())
url = 'MyTestUrl'
response = client.get(url, secure=False)
self.assertEqual(1, self.read_file_or_url.call_count)
self.assertEqual(self.read_file_or_url.return_value, response)
self.assertEqual(mock.call(url, headers=self.regular_headers),
self.read_file_or_url.call_args)
def test_handler_empty_puppet_config_installs_puppet(self, m_subp, m_auto):
"""Cloud-config empty 'puppet' configuration installs latest puppet."""
mycloud = self._get_cloud('ubuntu')
mycloud.distro = mock.MagicMock()
cfg = {'puppet': {}}
cc_puppet.handle('notimportant', cfg, mycloud, LOG, None)
self.assertEqual([mock.call(('puppet', None))],
mycloud.distro.install_packages.call_args_list)
def test_ntp_install(self, mock_util):
"""ntp_install installs via install_func when check_exe is absent."""
mock_util.which.return_value = None # check_exe not found.
install_func = mock.MagicMock()
cc_ntp.install_ntp(install_func, packages=['ntpx'], check_exe='ntpdx')
mock_util.which.assert_called_with('ntpdx')
install_func.assert_called_once_with(['ntpx'])
def test_handler_puppet_config_installs_puppet_on_true(self, m_subp, _):
"""Cloud-config with 'puppet' key installs when 'install' is True."""
mycloud = self._get_cloud('ubuntu')
mycloud.distro = mock.MagicMock()
cfg = {'puppet': {'install': True}}
cc_puppet.handle('notimportant', cfg, mycloud, LOG, None)
self.assertEqual([mock.call(('puppet', None))],
mycloud.distro.install_packages.call_args_list)
def test_snap_config_handle_no_config(self, mock_util, mock_add):
cfg = {}
cc = self._get_cloud('ubuntu')
cc.distro = mock.MagicMock()
cc.distro.name = 'ubuntu'
mock_util.which.return_value = None
snap_handle('snap_config', cfg, cc, LOG, None)
mock_add.assert_not_called()
def test_calls_shim_register_with_azure_and_fetch_data(self, shim):
m_pubkey_info = mock.MagicMock()
azure_helper.get_metadata_from_fabric(pubkey_info=m_pubkey_info)
self.assertEqual(
1, shim.return_value.register_with_azure_and_fetch_data.call_count)
self.assertEqual(
mock.call(pubkey_info=m_pubkey_info),
shim.return_value.register_with_azure_and_fetch_data.call_args)
def test_missing_certificates_skips_http_get(self):
m_azure_endpoint_client = mock.MagicMock()
goal_state = self._get_goal_state(
m_azure_endpoint_client=m_azure_endpoint_client,
certificates_url=None)
certificates_xml = goal_state.certificates_xml
self.assertEqual(0, m_azure_endpoint_client.get.call_count)
self.assertIsNone(certificates_xml)
def _assert_happy_path_taken(self, config, m_which, m_subp):
"""Positive path test through handle. Package should be installed."""
myCloud = mock.MagicMock()
drivers.handle('ubuntu_drivers', config, myCloud, None, None)
self.assertEqual([mock.call(['ubuntu-drivers-common'])],
myCloud.distro.install_packages.call_args_list)
self.assertEqual([mock.call(self.install_gpgpu)],
m_subp.call_args_list)
def test_false_disables_pipelining(self, m_write_file):
"""ensure that pipelining can be disabled with correct config"""
cc_apt_pipelining.handle('foo', {'apt_pipelining': 'false'}, None,
mock.MagicMock(), None)
self.assertEqual(1, m_write_file.call_count)
args, _ = m_write_file.call_args
self.assertEqual(cc_apt_pipelining.DEFAULT_FILE, args[0])
self.assertIn('Pipeline-Depth "0"', args[1])
def test_send_ready_signal_calls_build_report(self):
with mock.patch.object(
azure_helper.GoalStateHealthReporter, 'build_report'
) as m_build_report:
reporter = azure_helper.GoalStateHealthReporter(
azure_helper.GoalState(mock.MagicMock(), mock.MagicMock()),
azure_helper.AzureEndpointHttpClient(mock.MagicMock()),
self.test_endpoint)
reporter.send_ready_signal()
self.assertEqual(1, m_build_report.call_count)
self.assertEqual(
mock.call(
incarnation=self.default_parameters['incarnation'],
container_id=self.default_parameters['container_id'],
instance_id=self.default_parameters['instance_id'],
status=self.provisioning_success_status),
m_build_report.call_args)
def setUp(self):
super(TestAzureEndpointHttpClient, self).setUp()
patches = ExitStack()
self.addCleanup(patches.close)
self.readurl = patches.enter_context(
mock.patch.object(azure_helper.url_helper, 'readurl'))
patches.enter_context(
mock.patch.object(azure_helper.time, 'sleep', mock.MagicMock()))
def test_maybe_install_squashfuse_happy_path(self, m_container):
"""maybe_install_squashfuse logs and raises package install errors."""
m_container.return_value = True
distro = mock.MagicMock() # No errors raised
maybe_install_squashfuse(cloud=FakeCloud(distro))
self.assertEqual([mock.call()],
distro.update_package_sources.call_args_list)
self.assertEqual([mock.call(['squashfuse'])],
distro.install_packages.call_args_list)
def test_install_drivers_no_install_if_present(self, m_which, m_subp):
"""If 'ubuntu-drivers' is present, no package install should occur."""
pkg_install = mock.MagicMock()
drivers.install_drivers(self.cfg_accepted['drivers'],
pkg_install_func=pkg_install)
self.assertEqual(0, pkg_install.call_count)
self.assertEqual([mock.call('ubuntu-drivers')], m_which.call_args_list)
self.assertEqual([mock.call(self.install_gpgpu)],
m_subp.call_args_list)
def test_no_password(self):
'''
Attempt to register without the password key/value
'''
self.SM._sub_man_cli = mock.MagicMock(
side_effect=[util.ProcessExecutionError, (self.reg, 'bar')])
self.handle(self.name, self.config_no_password, self.cloud_init,
self.log, self.args)
self.assertEqual(self.SM._sub_man_cli.call_count, 0)
def test_maybe_install_squashfuse_raises_update_errors(self, m_container):
"""maybe_install_squashfuse logs and raises package update errors."""
m_container.return_value = True
distro = mock.MagicMock()
distro.update_package_sources.side_effect = RuntimeError(
'Some apt error')
with self.assertRaises(RuntimeError) as context_manager:
maybe_install_squashfuse(cloud=FakeCloud(distro))
self.assertEqual('Some apt error', str(context_manager.exception))
self.assertIn('Package update failed\nTraceback', self.logs.getvalue())
def mock_out_azure_moving_parts(self):
self.patches.enter_context(mock.patch.object(dsaz, 'invoke_agent'))
self.patches.enter_context(mock.patch.object(dsaz, 'wait_for_files'))
self.patches.enter_context(
mock.patch.object(dsaz, 'list_possible_azure_ds_devs',
mock.MagicMock(return_value=[])))
self.patches.enter_context(
mock.patch.object(dsaz, 'get_metadata_from_fabric',
mock.MagicMock(return_value={})))
def _dmi_mocks(key):
if key == 'system-uuid':
return 'test-instance-id'
elif key == 'chassis-asset-tag':
return '7783-7084-3265-9085-8269-3286-77'
raise RuntimeError('should not get here')
self.patches.enter_context(
mock.patch.object(dsaz.util, 'read_dmi_data',
mock.MagicMock(side_effect=_dmi_mocks)))
def setUp(self):
super(TestCloudStackPasswordFetching, self).setUp()
self.patches = ExitStack()
self.addCleanup(self.patches.close)
mod_name = 'cloudinit.sources.DataSourceCloudStack'
self.patches.enter_context(mock.patch('{0}.ec2'.format(mod_name)))
self.patches.enter_context(mock.patch('{0}.uhelp'.format(mod_name)))
default_gw = "192.201.20.0"
get_latest_lease = mock.MagicMock(return_value=None)
self.patches.enter_context(mock.patch(
mod_name + '.get_latest_lease', get_latest_lease))
get_default_gw = mock.MagicMock(return_value=default_gw)
self.patches.enter_context(mock.patch(
mod_name + '.get_default_gateway', get_default_gw))
get_networkd_server_address = mock.MagicMock(return_value=None)
self.patches.enter_context(mock.patch(
mod_name + '.dhcp.networkd_get_option_from_leases',
get_networkd_server_address))
def test_snap_config_handle_system_not_snappy(self, mock_util, mock_add):
cfg = {'snappy': {'assertions': self.test_assertions}}
cc = self._get_cloud('ubuntu')
cc.distro = mock.MagicMock()
cc.distro.name = 'ubuntu'
mock_util.which.return_value = None
mock_util.system_is_snappy.return_value = False
snap_handle('snap_config', cfg, cc, LOG, None)
mock_add.assert_not_called()
def test_post_with_extra_headers(self):
url = 'MyTestUrl'
client = azure_helper.AzureEndpointHttpClient(mock.MagicMock())
extra_headers = {'test': 'header'}
client.post(url, extra_headers=extra_headers)
self.assertEqual(1, self.read_file_or_url.call_count)
expected_headers = self.regular_headers.copy()
expected_headers.update(extra_headers)
self.assertEqual(
mock.call(mock.ANY, data=mock.ANY, headers=expected_headers),
self.read_file_or_url.call_args)
def test_certificates_xml_parsed_and_fetched_correctly(self):
http_client = mock.MagicMock()
certificates_url = 'TestCertificatesUrl'
goal_state = self._get_goal_state(http_client=http_client,
certificates_url=certificates_url)
certificates_xml = goal_state.certificates_xml
self.assertEqual(1, http_client.get.call_count)
self.assertEqual(certificates_url, http_client.get.call_args[0][0])
self.assertTrue(http_client.get.call_args[1].get('secure', False))
self.assertEqual(http_client.get.return_value.contents,
certificates_xml)
def test_simple_registration(self):
'''
Simple registration with username and password
'''
self.SM.log_success = mock.MagicMock()
reg = "The system has been registered with ID:" \
" 12345678-abde-abcde-1234-1234567890abc"
self.SM._sub_man_cli = mock.MagicMock(
side_effect=[util.ProcessExecutionError, (reg, 'bar')])
self.handle(self.name, self.config, self.cloud_init,
self.log, self.args)
self.assertIn(mock.call(['identity']),
self.SM._sub_man_cli.call_args_list)
self.assertIn(mock.call(['register', '[email protected]',
'--password=scooby-snacks'],
logstring_val=True),
self.SM._sub_man_cli.call_args_list)
self.assertEqual(self.SM.log_success.call_count, 1)
self.assertEqual(self.SM._sub_man_cli.call_count, 2)
def test_maybe_install_ua_raises_install_errors(self, m_which):
"""maybe_install_ua_tools logs and raises package install errors."""
m_which.return_value = None
distro = mock.MagicMock()
distro.update_package_sources.return_value = None
distro.install_packages.side_effect = RuntimeError(
'Some install error')
with self.assertRaises(RuntimeError) as context_manager:
maybe_install_ua_tools(cloud=FakeCloud(distro))
self.assertEqual('Some install error', str(context_manager.exception))
self.assertIn('Failed to install ubuntu-advantage-tools\n',
self.logs.getvalue())
def test_already_registered(self):
'''
Emulates a system that is already registered. Ensure it gets
a non-ProcessExecution error from is_registered()
'''
with mock.patch.object(cc_rh_subscription.SubscriptionManager,
'_sub_man_cli') as mockobj:
self.SM.log_success = mock.MagicMock()
self.handle(self.name, self.config, self.cloud_init,
self.log, self.args)
self.assertEqual(self.SM.log_success.call_count, 1)
self.assertEqual(mockobj.call_count, 1)
