예제 #1
0
    def test_wrong_b64_content(self):
        tmp = self._get_tempfile()
        code = textwrap.dedent("""
        write_files:
        -   content: l
            encoding: b64
            path: {}
        """.format(tmp))
        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdataplugins.cloudconfigplugins.'
                                   'write_files') as snatcher:
            self.plugin.process_non_multipart(code)

        self.assertTrue(
            snatcher.output[0].startswith("Fail to decode base64 content."))
예제 #2
0
    def test__http_request(self, mock_urllib_request):
        mock_urllib_request.Request.return_value = mock.sentinel.request
        with testutils.LogSnatcher('cloudbaseinit.metadata.services.'
                                   'cloudstack') as snatcher:
            self._service._http_request(mock.sentinel.url)

        expected_logging = [
            'Getting metadata from:  %s' % mock.sentinel.url,
        ]
        mock_urllib_request.Request.assert_called_once_with(mock.sentinel.url)
        mock_urllib_request.urlopen.assert_called_once_with(
            mock.sentinel.request)
        mock_urlopen = mock_urllib_request.urlopen.return_value
        mock_urlopen.read.assert_called_once_with()
        self.assertEqual(expected_logging, snatcher.output)
예제 #3
0
    def test_set_metadata_password_already_set(self):
        mock_service = mock.MagicMock()
        mock_service.is_password_set = True
        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'setuserpassword') as snatcher:
            response = self._setpassword_plugin._set_metadata_password(
                mock.sentinel.fake_password, mock_service)

        self.assertTrue(response)
        expected_logging = [
            'User\'s password already set in the '
            'instance metadata and it cannot be '
            'updated in the instance metadata'
        ]
        self.assertEqual(expected_logging, snatcher.output)
예제 #4
0
    def _test_execute(self,
                      mock_post_create_user,
                      mock_create_user,
                      mock_get_password,
                      mock_get_os_utils,
                      user_exists=True,
                      group_adding_works=True):
        shared_data = {}
        mock_osutils = mock.MagicMock()
        mock_service = mock.MagicMock()
        mock_get_password.return_value = 'password'
        mock_get_os_utils.return_value = mock_osutils
        mock_osutils.user_exists.return_value = user_exists
        if not group_adding_works:
            mock_osutils.add_user_to_local_group.side_effect = Exception

        with testutils.LogSnatcher("cloudbaseinit.plugins.common."
                                   "createuser") as snatcher:
            response = self._create_user.execute(mock_service, shared_data)

        mock_get_os_utils.assert_called_once_with()
        mock_get_password.assert_called_once_with(mock_osutils)
        mock_osutils.user_exists.assert_called_once_with(CONF.username)
        if user_exists:
            mock_osutils.set_user_password.assert_called_once_with(
                CONF.username, 'password')
            expected_logging = [
                "Setting password for existing user \"%s\"" % CONF.username
            ]
        else:
            mock_create_user.assert_called_once_with(CONF.username, 'password',
                                                     mock_osutils)
            expected_logging = [
                "Creating user \"%s\" and setting password" % CONF.username
            ]

        mock_post_create_user.assert_called_once_with(CONF.username,
                                                      'password', mock_osutils)

        self.assertEqual(expected_logging, snatcher.output[:1])
        if not group_adding_works:
            failed = snatcher.output[1].startswith(
                "Cannot add user to group \"Admins\"")
            self.assertTrue(failed)

        mock_osutils.add_user_to_local_group.assert_called_once_with(
            CONF.username, CONF.groups[0])
        self.assertEqual((base.PLUGIN_EXECUTION_DONE, False), response)
예제 #5
0
    def _test_configure_host(self,
                             mock_get_metadata_service,
                             mock_get_os_utils,
                             mock_load_plugins,
                             mock_get_version,
                             mock_check_latest_version,
                             mock_handle_plugins_stage,
                             expected_logging,
                             version,
                             name,
                             instance_id,
                             reboot=True):

        mock_get_version.return_value = version
        fake_service = mock.MagicMock()
        fake_plugin = mock.MagicMock()
        mock_load_plugins.return_value = [fake_plugin]
        mock_get_os_utils.return_value = self.osutils
        mock_get_metadata_service.return_value = fake_service
        fake_service.get_name.return_value = name
        fake_service.get_instance_id.return_value = instance_id
        mock_handle_plugins_stage.side_effect = [False, False, True]
        stages = [
            base.PLUGIN_STAGE_PRE_NETWORKING,
            base.PLUGIN_STAGE_PRE_METADATA_DISCOVERY, base.PLUGIN_STAGE_MAIN
        ]
        stage_calls_list = [[self.osutils, None, None, stage]
                            for stage in stages]
        stage_calls_list[2][1] = fake_service
        stage_calls_list[2][2] = instance_id
        stage_calls = [mock.call(*args) for args in stage_calls_list]

        with testutils.LogSnatcher('cloudbaseinit.init') as snatcher:
            self._init.configure_host()
        self.assertEqual(expected_logging, snatcher.output)
        mock_check_latest_version.assert_called_once_with()
        if CONF.reset_service_password:
            self.osutils.reset_service_password.assert_called_once_with()
        self.osutils.wait_for_boot_completion.assert_called_once_with()
        mock_get_metadata_service.assert_called_once_with()
        fake_service.get_name.assert_called_once_with()
        fake_service.get_instance_id.assert_called_once_with()
        fake_service.cleanup.assert_called_once_with()
        mock_handle_plugins_stage.assert_has_calls(stage_calls)
        if reboot:
            self.osutils.reboot.assert_called_once_with()
        else:
            self.assertFalse(self.osutils.reboot.called)
예제 #6
0
    def test_execute_hostname_to_be_truncated(self):
        new_hostname = 'x' * (hostname.NETBIOS_HOST_NAME_MAX_LEN + 1)
        expected_new_hostname = new_hostname[:-1]
        with testutils.LogSnatcher('cloudbaseinit.utils.'
                                   'hostname') as snatcher:
            self._test_set_hostname(
                new_hostname=new_hostname,
                expected_new_hostname=expected_new_hostname)

        expected = [
            'Truncating host name for Netbios compatibility. '
            'Old name: {0}, new name: {1}'.format(new_hostname,
                                                  expected_new_hostname),
            'Setting hostname: xxxxxxxxxxxxxxx'
        ]
        self.assertEqual(expected, snatcher.output)
    def test_processing_plugin_failed(self, mock_write_files):
        mock_write_files.side_effect = ValueError
        code = textwrap.dedent("""
        write_files:
        -   content: NDI=
            path: random_cloudbaseinit_test
        """)

        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdataplugins.cloudconfig') as snatcher:
            self.plugin.process_non_multipart(code)

        self.assertTrue(snatcher.output[0].startswith(
            "Processing plugin write_files failed"))
        self.assertTrue(snatcher.output[0].endswith("ValueError"))
        self.assertFalse(os.path.exists('random_cloudbaseinit_test'))
예제 #8
0
 def setUp(self):
     self.mock_wmi = mock.MagicMock()
     self._moves_mock = mock.MagicMock()
     patcher = mock.patch.dict(
         "sys.modules",
         {
             "wmi": self.mock_wmi,
             "six.moves": self._moves_mock
         }
     )
     patcher.start()
     self.addCleanup(patcher.stop)
     self._winreg_mock = self._moves_mock.winreg
     self._azureguestagent = importlib.import_module(MODPATH)
     self._azureagentplugin = self._azureguestagent.AzureGuestAgentPlugin()
     self.snatcher = testutils.LogSnatcher(MODPATH)
    def test_missing_required_keys(self):
        code = textwrap.dedent("""
        write_files:
        -   c0ntent: NDI=
        """)
        expected_return = [
            "Missing required keys from file "
            "information {'c0ntent': 'NDI='}"
        ]

        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdataplugins.cloudconfigplugins.'
                                   'write_files') as snatcher:
            self.plugin.process_non_multipart(code)

        self.assertEqual(expected_return, snatcher.output)
예제 #10
0
 def test_exec_plugin_exception_occurs(self):
     fake_name = 'fake name'
     mock_plugin = mock.MagicMock()
     mock_plugin.get_name.return_value = fake_name
     mock_plugin.execute.side_effect = Exception
     expected_logging = [
         "Executing plugin 'fake name'",
         "plugin 'fake name' failed with error ''"
     ]
     with testutils.LogSnatcher('cloudbaseinit.init') as snatcher:
         self._init._exec_plugin(osutils=self.osutils,
                                 service='fake service',
                                 plugin=mock_plugin,
                                 instance_id='fake id',
                                 shared_data='shared data')
     self.assertEqual(expected_logging, snatcher.output[:2])
예제 #11
0
    def test_process_permissions(self):
        for permissions in (0o644, '0644', '0o644', 420, 420.1):
            self.assertEqual(420,
                             write_files._convert_permissions(permissions))

        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdataplugins.cloudconfigplugins.'
                                   'write_files') as snatcher:
            response = write_files._convert_permissions(mock.sentinel.invalid)

        expected_logging = [
            'Fail to process permissions %s, assuming 420' %
            mock.sentinel.invalid
        ]
        self.assertEqual(expected_logging, snatcher.output)
        self.assertEqual(write_files.DEFAULT_PERMISSIONS, response)
예제 #12
0
    def _test_execute(self,
                      mock_get_os_utils,
                      mock_set_metadata_password,
                      mock_set_password,
                      is_password_set,
                      can_post_password,
                      can_update_password=False):
        mock_service = mock.MagicMock()
        mock_osutils = mock.MagicMock()
        fake_shared_data = mock.MagicMock()
        fake_shared_data.get.return_value = 'fake username'
        mock_service.is_password_set = is_password_set
        mock_service.can_post_password = can_post_password
        mock_service.can_update_password = can_update_password
        mock_get_os_utils.return_value = mock_osutils
        mock_osutils.user_exists.return_value = True
        mock_set_password.return_value = 'fake password'

        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'setuserpassword') as snatcher:
            response = self._setpassword_plugin.execute(
                mock_service, fake_shared_data)
        mock_get_os_utils.assert_called_once_with()
        fake_shared_data.get.assert_called_with(constants.SHARED_DATA_USERNAME,
                                                CONF.username)
        mock_osutils.user_exists.assert_called_once_with('fake username')
        mock_set_password.assert_called_once_with(mock_service, mock_osutils,
                                                  'fake username',
                                                  fake_shared_data)

        expected_logging = [
            "Password succesfully updated for user fake username",
        ]
        if can_post_password:
            mock_set_metadata_password.assert_called_once_with(
                'fake password', mock_service)
        else:
            expected_logging.append("Cannot set the password in the metadata "
                                    "as it is not supported by this service")
            self.assertFalse(mock_set_metadata_password.called)

        if can_update_password:
            self.assertEqual((2, False), response)
        else:
            self.assertEqual((1, False), response)

        self.assertEqual(expected_logging, snatcher.output)
예제 #13
0
    def _test_set_password(self,
                           mock_get_password,
                           mock_change_logon_behaviour,
                           password,
                           can_update_password,
                           is_password_changed,
                           max_password_length=20,
                           injected=False):
        expected_password = password
        expected_logging = []
        user = '******'

        mock_get_password.return_value = (password, injected)

        mock_service = mock.MagicMock()
        mock_osutils = mock.MagicMock()
        if not password:
            expected_password = "******" * CONF.user_password_length

        mock_osutils.generate_random_password.return_value = expected_password
        mock_service.can_update_password = can_update_password
        mock_service.is_password_changed.return_value = is_password_changed

        with testutils.ConfPatcher('user_password_length',
                                   max_password_length):
            with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                       'setuserpassword') as snatcher:
                response = self._setpassword_plugin._set_password(
                    mock_service, mock_osutils, user,
                    mock.sentinel.shared_data)

        if can_update_password and not is_password_changed:
            expected_logging.append('Updating password is not required.')
            expected_password = None

        if not password:
            expected_logging.append('Generating a random user password')

        if not can_update_password or is_password_changed:
            mock_get_password.assert_called_once_with(
                mock_service, mock.sentinel.shared_data)

        self.assertEqual(expected_password, response)
        self.assertEqual(expected_logging, snatcher.output)
        if password and can_update_password and is_password_changed:
            mock_change_logon_behaviour.assert_called_once_with(
                user, password_injected=injected)
예제 #14
0
    def test__bind_dhcp_client_socket(self, mock_time_sleep):
        mock_socket = mock.Mock()
        exc = socket.error()
        exc.errno = 48
        mock_socket.bind = mock.Mock(side_effect=exc)

        with testutils.LogSnatcher('cloudbaseinit.utils.dhcp') as snatcher:
            with self.assertRaises(socket.error):
                dhcp._bind_dhcp_client_socket(
                    mock_socket,
                    max_bind_attempts=4,
                    bind_retry_interval=mock.sentinel.bind_retry_interval)

        expected_occurences = sum(
            1 for item in snatcher.output
            if item.startswith("Retrying to bind DHCP client port in "))
        self.assertEqual(3, expected_occurences)
예제 #15
0
    def test_old_plugin_mapping(self, mock_load_class):
        with testutils.LogSnatcher('cloudbaseinit.plugins.'
                                   'factory') as snatcher:
            factory.load_plugins(None)

        expected = [
            "Old plugin module 'cloudbaseinit.plugins.windows."
            "localscripts.LocalScriptsPlugin' was found. "
            "The new name is 'cloudbaseinit.plugins.common."
            "localscripts.LocalScriptsPlugin'. The old name will not "
            "be supported starting with cloudbaseinit 1.0",
        ]
        expected_call = mock.call('cloudbaseinit.plugins.common.'
                                  'localscripts.LocalScriptsPlugin')
        self.assertEqual(expected, snatcher.output)
        called = mock_load_class.mock_calls[0]
        self.assertEqual(expected_call, called)
예제 #16
0
 def setUp(self):
     self.mock_wmi = mock.MagicMock()
     self._moves_mock = mock.MagicMock()
     patcher = mock.patch.dict(
         "sys.modules",
         {
             "wmi": self.mock_wmi,
             "six.moves": self._moves_mock
         }
     )
     patcher.start()
     self.addCleanup(patcher.stop)
     rdp = importlib.import_module(
         "cloudbaseinit.plugins.windows.rdp")
     self.rdp_settings = rdp.RDPSettingsPlugin()
     self.rdp_post = rdp.RDPPostCertificateThumbprintPlugin()
     self.snatcher = testutils.LogSnatcher(MODPATH)
예제 #17
0
    def test__create_user_logon_fails(self):
        mock_osutils = mock.Mock()
        mock_osutils.create_user_logon_session.side_effect = Exception

        with testutils.LogSnatcher('cloudbaseinit.plugins.windows.'
                                   'createuser') as snatcher:
            self._create_user._create_user_logon(mock.sentinel.user_name,
                                                 mock.sentinel.password,
                                                 mock_osutils)

        mock_osutils.create_user_logon_session.assert_called_once_with(
            mock.sentinel.user_name, mock.sentinel.password, True)
        self.assertFalse(mock_osutils.close_user_logon_session.called)
        logging_message = (
            "Cannot create a user logon session for user: \"%s\"" %
            mock.sentinel.user_name)
        self.assertTrue(snatcher.output[0].startswith(logging_message))
예제 #18
0
    def test_get_password(self, mock_password_client):
        headers = {"DomU_Request": "send_my_password"}
        expected_password = "******"
        mock_password_client.return_value = expected_password
        expected_output = [
            "Try to get password from the Password Server.",
            "The password server returned a valid password "
            "for the current instance."
        ]

        with testutils.LogSnatcher('cloudbaseinit.metadata.services.'
                                   'cloudstack') as snatcher:
            password = self._service._get_password()

        mock_password_client.assert_called_once_with(headers=headers)
        self.assertEqual(expected_password, password)
        self.assertEqual(expected_output, snatcher.output)
예제 #19
0
 def test_process_user(self, mock_get_os_utils, mock_create_user):
     fake_data = [
         {
             'name': 'fake_user',
             'gecos': 'fake user name',
             'primary_group': 'Users',
             'groups': 'test',
             'ssh_authorized_keys': ["test2", "test1"],
             'inactive': False,
             'expiredate': '2020-09-01',
             'passwd': 'Passw0rd'
         }
     ]
     with testutils.LogSnatcher(MODPATH) as snatcher:
         res = self.users_plugin.process(fake_data)
     self.assertEqual([], snatcher.output)
     self.assertEqual(res, False)
예제 #20
0
    def test_process_non_multipart_dont_process_x509(
            self, mock_execute_user_data_script):
        user_data = textwrap.dedent('''
        -----BEGIN CERTIFICATE-----
        MIIC9zCCAd8CAgPoMA0GCSqGSIb3DQEBBQUAMBsxGTAXBgNVBAMUEHVidW50dUBs
        b2NhbGhvc3QwHhcNMTUwNjE1MTAyODUxWhcNMjUwNjEyMTAyODUxWjAbMRkwFwYD
        -----END CERTIFICATE-----
        ''').encode()
        with testutils.LogSnatcher('cloudbaseinit.plugins.'
                                   'common.userdata') as snatcher:
            status, reboot = self._userdata._process_non_multi_part(user_data=user_data)

        expected_logging = ['Found X509 certificate in userdata']
        self.assertFalse(mock_execute_user_data_script.called)
        self.assertEqual(expected_logging, snatcher.output)
        self.assertEqual(1, status)
        self.assertFalse(reboot)
예제 #21
0
    def _test_process(self,
                      mock_write_file,
                      mock_exec_file,
                      mock_gettempdir,
                      mock_get_os_utils,
                      mock_os_remove,
                      mock_path_exists,
                      exception=False):

        mock_path_exists.return_value = True
        fake_dir_path = os.path.join("fake", "dir")
        mock_osutils = mock.MagicMock()
        mock_part = mock.MagicMock()
        mock_part.get_filename.return_value = "fake_filename"
        mock_gettempdir.return_value = fake_dir_path
        mock_get_os_utils.return_value = mock_osutils
        fake_target = os.path.join(fake_dir_path, "fake_filename")
        mock_exec_file.return_value = 'fake response'

        if exception:
            mock_exec_file.side_effect = [Exception]
        with mock.patch(
                "cloudbaseinit.plugins.common.userdataplugins."
                "shellscript.open",
                mock.mock_open(),
                create=True):
            with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                       'userdataplugins.'
                                       'shellscript') as snatcher:
                response = self._shellscript.process(mock_part)

        mock_part.get_filename.assert_called_once_with()
        mock_write_file.assert_called_once_with(
            fake_target, mock_part.get_payload.return_value)
        mock_exec_file.assert_called_once_with(fake_target)
        mock_part.get_payload.assert_called_once_with(decode=True)
        mock_gettempdir.assert_called_once_with()
        if not exception:
            self.assertEqual('fake response', response)
        else:
            expected_logging = 'An error occurred during user_data execution'
            self.assertTrue(snatcher.output[0].startswith(expected_logging))

        mock_os_remove.assert_called_once_with(fake_target)
        mock_path_exists.assert_called_once_with(fake_target)
예제 #22
0
 def setUp(self):
     self.mock_wmi = mock.MagicMock()
     self._moves_mock = mock.MagicMock()
     patcher = mock.patch.dict(
         "sys.modules", {
             "wmi": self.mock_wmi,
             "six.moves": self._moves_mock,
             'ctypes': mock.MagicMock(),
             'ctypes.windll': mock.MagicMock(),
             'ctypes.wintypes': mock.MagicMock(),
             'winioctlcon': mock.MagicMock()
         })
     patcher.start()
     self.addCleanup(patcher.stop)
     bootconfig = importlib.import_module(MODPATH)
     self.boot_policy_plugin = bootconfig.BootStatusPolicyPlugin()
     self.bcd_config = bootconfig.BCDConfigPlugin()
     self.snatcher = testutils.LogSnatcher(MODPATH)
예제 #23
0
    def test_exec_file_no_executor(self, mock_execute_user_data_script,
                                   mock_get_command, _):
        mock_get_command.return_value = None
        with testutils.create_tempfile() as temp:
            with mock.patch(
                    'cloudbaseinit.plugins.common.userdatautils'
                    '.open',
                    create=True):
                with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                           'fileexecutils') as snatcher:
                    retval = fileexecutils.exec_file(temp)

        expected_logging = [
            'No valid extension or header found'
            ' in the userdata: %s' % temp
        ]
        self.assertEqual(0, retval)
        self.assertEqual(expected_logging, snatcher.output)
예제 #24
0
    def test_process_basic_data(self, mock_os_utils, mock_userdata):
        run_commands = ['echo 1', 'echo 2', ['echo', '1'], 'exit 1003']
        mock_userdata.return_value = 1003
        mock_utils = mock.MagicMock()
        mock_utils.get_default_script_exec_header.return_value = 'fake_header'
        mock_os_utils.return_value = mock_utils
        expected_logging = [
            "Running cloud-config runcmd entries.",
            "Found 4 cloud-config runcmd entries.",
        ]
        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdataplugins.cloudconfigplugins.'
                                   'runcmd') as snatcher:
            result_process = self._runcmd_plugin.process(run_commands)

        mock_utils.get_default_script_exec_header.assert_called_with()
        self.assertEqual(expected_logging, snatcher.output)
        self.assertEqual(result_process, True)
예제 #25
0
    def test_unknown_encoding(self):
        tmp = self._get_tempfile()
        code = textwrap.dedent("""
        write_files:
        -   content: NDI=
            path: {}
            permissions: '0o466'
        """.format(tmp))
        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdataplugins.cloudconfigplugins.'
                                   'write_files') as snatcher:
            self.plugin.process_non_multipart(code)

        self.assertTrue(os.path.exists(tmp), "Expected path does not exist.")
        with open(tmp) as stream:
            self.assertEqual('NDI=', stream.read())

        self.assertEqual(["Unknown encoding, doing nothing."], snatcher.output)
예제 #26
0
    def test_parse_mime(self, mock_get_as_string, mock_message_from_string):
        fake_user_data = textwrap.dedent('''
        -----BEGIN CERTIFICATE-----
        MIIDGTCCAgGgAwIBAgIJAN5fj7R5dNrMMA0GCSqGSIb3DQEBCwUAMCExHzAdBgNV
        BAMTFmNsb3VkYmFzZS1pbml0LWV4YW1wbGUwHhcNMTUwNDA4MTIyNDI1WhcNMjUw
        ''')
        expected_logging = ['User data content:\n%s' % fake_user_data]
        mock_get_as_string.return_value = fake_user_data

        with testutils.LogSnatcher('cloudbaseinit.plugins.common.'
                                   'userdata') as snatcher:
            response = self._userdata._parse_mime(user_data=fake_user_data)

        mock_get_as_string.assert_called_once_with(fake_user_data)
        mock_message_from_string.assert_called_once_with(
            mock_get_as_string.return_value)
        self.assertEqual(response, mock_message_from_string().walk())
        self.assertEqual(expected_logging, snatcher.output)
예제 #27
0
    def test_delete_password(self, mock_password_client):
        fake_url_error = urllib.error.HTTPError(url='127.0.0.1',
                                                code=404,
                                                hdrs={},
                                                fp=None,
                                                msg='error')
        fake_connection_error = OSError(10061, "Connection error")
        mock_password_client.side_effect = [
            cloudstack.SAVED_PASSWORD, cloudstack.BAD_REQUEST, fake_url_error,
            fake_connection_error
        ]
        expected_output = [
            [
                'Remove the password for this instance from the '
                'Password Server.',
                'Removing password failed due to a connection failure.',
                'Failed to remove the password from the Password Server.'
            ],
            [
                'Remove the password for this instance from the '
                'Password Server.', 'Removing password failed: 404',
                'Failed to remove the password from the Password Server.'
            ],
            [
                'Remove the password for this instance from the '
                'Password Server.',
                'Failed to remove the password from the Password Server.'
            ],
            [
                'Remove the password for this instance from the '
                'Password Server.',
                'The password was removed from the Password Server.'
            ],
        ]

        expected_output_len = len(expected_output)
        for _ in range(expected_output_len):
            with testutils.LogSnatcher('cloudbaseinit.metadata.services.'
                                       'cloudstack') as snatcher:
                self.assertIsNone(self._service._delete_password())
                self.assertEqual(expected_output.pop(), snatcher.output)

        self.assertEqual(expected_output_len, mock_password_client.call_count)
예제 #28
0
    def _test_load(self, mock_get_cache_data, ip, cache_data_fails=False):
        if cache_data_fails:
            mock_get_cache_data.side_effect = Exception

        with testutils.ConfPatcher('metadata_base_url', ip, "maas"):
            with testutils.LogSnatcher('cloudbaseinit.metadata.services.'
                                       'maasservice') as snatcher:
                response = self._maasservice.load()

            if ip is not None:
                if not cache_data_fails:
                    mock_get_cache_data.assert_called_once_with(
                        '%s/meta-data/' % self._maasservice._metadata_version)
                    self.assertTrue(response)
                else:
                    expected_logging = 'Metadata not found at URL \'%s\'' % ip
                    self.assertEqual(expected_logging, snatcher.output[-1])
            else:
                self.assertFalse(response)
예제 #29
0
    def setUp(self):
        self._win32com_mock = mock.MagicMock()
        self._ctypes_mock = mock.MagicMock()
        self._ctypes_util_mock = mock.MagicMock()
        self._win32com_client_mock = mock.MagicMock()
        self._pywintypes_mock = mock.MagicMock()
        self._module_patcher = mock.patch.dict(
            'sys.modules',
            {'win32com': self._win32com_mock,
             'ctypes': self._ctypes_mock,
             'ctypes.util': self._ctypes_util_mock,
             'win32com.client': self._win32com_client_mock,
             'pywintypes': self._pywintypes_mock})
        self._module_patcher.start()
        self.addCleanup(self._module_patcher.stop)

        self._packet_module = importlib.import_module(MODULE_PATH)
        self._packet_service = self._packet_module.PacketService()
        self.snatcher = testutils.LogSnatcher(MODULE_PATH)
예제 #30
0
    def _test_is_vfat_drive(self, execute_process_value, expected_logging,
                            expected_response):

        mock_osutils = mock.Mock()
        mock_osutils.execute_process.return_value = execute_process_value

        with testutils.LogSnatcher('cloudbaseinit.utils.windows.'
                                   'vfat') as snatcher:
            with testutils.ConfPatcher('mtools_path', 'mtools_path'):

                response = vfat.is_vfat_drive(mock_osutils,
                                              mock.sentinel.drive)

                mdir = os.path.join(CONF.mtools_path, "mlabel.exe")
                mock_osutils.execute_process.assert_called_once_with(
                    [mdir, "-i", mock.sentinel.drive, "-s"], shell=False)

        self.assertEqual(expected_logging, snatcher.output)
        self.assertEqual(expected_response, response)