def _rubocop(self,
                 serverspec_dir,
                 debug=False,
                 pattern='/**/*.rb',
                 out=util.callback_info,
                 err=util.callback_error):
        """
        Executes rubocop against specified directory/pattern and returns a
        :func:`sh` response object.

        :param serverspec_dir: A string containing the directory with files
        to lint.
        :param debug: An optional bool to toggle debug output.
        :param pattern: A string containing the pattern of files to lint.
        :param out: An optional function to process STDOUT for underlying
         :func:`sh` call.
        :param err: An optional function to process STDERR for underlying
         :func:`sh` call.
        :return: :func:`sh` response object.
        """
        kwargs = {'_out': out, '_err': err, 'debug': debug}

        msg = 'Executing rubocop on *.rb files found in {}/...'.format(
            serverspec_dir)
        util.print_info(msg)
        match = serverspec_dir + pattern

        try:
            cmd = sh.rubocop.bake(match, **kwargs)
        except sh.CommandNotFound:
            msg = 'Verifier missing, gem install rubocop.'
            util.print_error(msg)
            util.sysexit()
        return util.run_command(cmd, debug=self._debug)

    def execute(self, exit=True):
        util.print_info(
            'Idempotence test in progress (can take a few minutes)...')

        c = converge.Converge(self.command_args, self.args, self.molecule)
        status, output = c.execute(idempotent=True,
                                   exit=False,
                                   hide_errors=True)
        if status is not None:
            msg = 'Skipping due to errors during converge.'
            util.print_info(msg)
            return status, None

        idempotent, changed_tasks = self.molecule._parse_provisioning_output(
            output)

        if idempotent:
            util.print_success('Idempotence test passed.')
            return None, None

        # Display the details of the idempotence test.
        if changed_tasks:
            LOG.error(
                'Idempotence test failed because of the following tasks:')
            LOG.error('{}'.format('\n'.join(changed_tasks)))
        else:
            # But in case the idempotence callback plugin was not found, we just display an error message.
            LOG.error('Idempotence test failed.')
            warning_msg = "The idempotence plugin was not found or did not provide the required information. " \
                          "Therefore the failure details cannot be displayed."

            LOG.warning(warning_msg)
        if exit:
            util.sysexit()
        return 1, None

    def _rubocop(self,
                 serverspec_dir,
                 debug=False,
                 env=os.environ.copy(),
                 pattern='/**/*.rb',
                 out=LOG.info,
                 err=LOG.error):
        """
        Runs rubocop against specified directory with specified pattern.

        :param serverspec_dir: Directory to search for files to lint
        :param debug: Pass debug flag to rubocop
        :param pattern: Search pattern to pass to rubocop
        :param env: Environment to pass to underlying sh call
        :param out: Function to process STDOUT for underlying sh call
        :param err: Function to process STDERR for underlying sh call
        :return: sh response object
        """
        kwargs = {'_env': env, '_out': out, '_err': err, 'debug': debug}

        if 'HOME' not in kwargs['_env']:
            kwargs['_env']['HOME'] = os.path.expanduser('~')

        msg = 'Executing rubocop on *.rb files found in {}/.'.format(
            serverspec_dir)
        util.print_info(msg)
        match = serverspec_dir + pattern

        return sh.rubocop(match, **kwargs)

    def execute(self, exit=True):
        """
        Execute the actions necessary to perform a `molecule create` and
        return a tuple.

        :param exit: An optional flag to toggle the exiting of the module
         on command failure.
        :return: Return a tuple of None, otherwise sys.exit on command failure.
        """
        self.molecule.remove_inventory_file()
        self.molecule.create_templates()
        try:
            util.print_info('Creating instances...')
            self.molecule.driver.up(no_provision=True)
            self.molecule.state.change_state('created', True)
            if self.command_args.get('platform') == 'all':
                self.molecule.state.change_state('multiple_platforms', True)
        except subprocess.CalledProcessError as e:
            util.print_error(str(e))
            if exit:
                util.sysexit(e.returncode)
            return e.returncode, e.message
        self.molecule.create_inventory_file()
        self.molecule.write_instances_state()
        return None, None

    def execute(self, exit=True):
        """
        Execute the actions necessary to perform a `molecule idempotence` and
        return a tuple.

        :param exit: An optional flag to toggle the exiting of the module
         on command failure.
        :return: Return a tuple of (`exit status`, `command output`), otherwise
         sys.exit on command failure.
        """
        util.print_info("Idempotence test in progress (can take a few minutes) ...")

        c = converge.Converge(self.command_args, self.args, self.molecule)
        status, output = c.execute(idempotent=True, exit=False, hide_errors=True)
        if status is not None:
            msg = "Skipping due to errors during converge."
            util.print_info(msg)
            return status, None

        idempotent = self._is_idempotent(output)
        if idempotent:
            util.print_success("Idempotence test passed.")
            return None, None
        else:
            LOG.error("Idempotence test failed because of the following tasks:")
            LOG.error("\n".join(self._non_idempotent_tasks(output)))
            if exit:
                util.sysexit()

            return 1, None

    def _rake(self,
              rakefile,
              debug=False,
              env=os.environ.copy(),
              out=LOG.info,
              err=LOG.error):
        """
        Runs rake with specified rakefile.

        :param rakefile: Path to rakefile
        :param debug: Pass trace flag to rake
        :param env: Environment to pass to underlying sh call
        :param out: Function to process STDOUT for underlying sh call
        :param err: Function to process STDERR for underlying sh call
        :return: sh response object
        """
        kwargs = {'_env': env,
                  '_out': out,
                  '_err': err,
                  'trace': debug,
                  'rakefile': rakefile}

        if 'HOME' not in kwargs['_env']:
            kwargs['_env']['HOME'] = os.path.expanduser('~')

        msg = 'Executing serverspec tests found in {}/.'.format(
            self._serverspec_dir)
        util.print_info(msg)

        return sh.rake(**kwargs)

    def _rubocop(self,
                 serverspec_dir,
                 debug=False,
                 pattern='/**/*.rb',
                 out=LOG.info,
                 err=LOG.error):
        """
        Executes rubocop against specified directory/pattern, and returns a
        :func:`sh` response object.

        :param serverspec_dir: A string containing the directory with files
        to lint.
        :param debug: An optional bool to toggle debug output.
        :param pattern: A string containing the pattern of files to lint.
        :param out: An optional function to process STDOUT for underlying
         :func:`sh` call.
        :param err: An optional function to process STDERR for underlying
         :func:`sh` call.
        :return: :func:`sh` response object.
        """
        kwargs = {'_out': out, '_err': err, 'debug': debug}

        msg = 'Executing rubocop on *.rb files found in {}/.'.format(
            serverspec_dir)
        util.print_info(msg)
        match = serverspec_dir + pattern

        return sh.rubocop(match, **kwargs)

    def _testinfra(self,
                   tests,
                   debug=False,
                   ansible_env={},
                   out=LOG.info,
                   err=LOG.error,
                   **kwargs):
        """
        Executes testinfra against specified tests, and returns a :func:`sh`
        response object.

        :param tests: A list of testinfra tests.
        :param debug: An optional bool to toggle debug output.
        :param pattern: A string containing the pattern of files to lint.
        :param ansible_env: An optional environment to pass to underlying
         :func:`sh` call.
        :param out: An optional function to process STDOUT for underlying
         :func:`sh` call.
        :param err: An optional function to process STDERR for underlying
         :func:`sh` call.
        :return: :func:`sh` response object.
        """
        kwargs['debug'] = debug
        kwargs['_env'] = ansible_env
        kwargs['_out'] = out
        kwargs['_err'] = err

        msg = 'Executing testinfra tests found in {}/.'.format(
            self._testinfra_dir)
        util.print_info(msg)

        return sh.testinfra(tests, **kwargs)

    def _testinfra(self,
                   tests,
                   debug=False,
                   env=os.environ.copy(),
                   out=LOG.info,
                   err=LOG.error,
                   **kwargs):
        """
        Runs testinfra and returns a sh response object.

        :param tests: List of testinfra tests
        :param debug: Pass debug flag to testinfra
        :param env: Environment to pass to underlying sh call
        :param out: Function to process STDOUT for underlying sh call
        :param err: Function to process STDERR for underlying sh call
        :return: sh response object
        """
        kwargs['debug'] = debug
        kwargs['_env'] = env
        kwargs['_out'] = out
        kwargs['_err'] = err

        if 'HOME' not in kwargs['_env']:
            kwargs['_env']['HOME'] = os.path.expanduser('~')

        msg = 'Executing testinfra tests found in {}/.'.format(
            self._testinfra_dir)
        util.print_info(msg)

        return sh.testinfra(tests, **kwargs)

    def _rake(self, rakefile, debug=False, out=LOG.info, err=LOG.error):
        """
        Executes rake against specified rakefile, and returns a :func:`sh`
        response object.

        :param rakefile: A string containing path to the rakefile.
        :param debug: An optional bool to toggle debug output.
        :param out: An optional function to process STDOUT for underlying
         :func:`sh` call.
        :param err: An optional function to process STDERR for underlying
         :func:`sh` call.
        :return: :func:`sh` response object.
        """
        kwargs = {
            '_out': out,
            '_err': err,
            'trace': debug,
            'rakefile': rakefile
        }

        msg = 'Executing serverspec tests found in {}/.'.format(
            self._serverspec_dir)
        util.print_info(msg)

        return sh.rake(**kwargs)

    def execute(self, exit=True):
        """
        Execute the actions that should run prior to a converge and return a
        tuple.

        :param exit: (Unused) Provided to complete method signature.
        :return: Return a tuple provided by :meth:`.AnsiblePlaybook.execute`.
        """
        debug = self.args.get('debug')
        if self.molecule.state.installed_deps:
            return (None, None)
        dependency_name = self.molecule.dependency
        if dependency_name == 'galaxy':
            dd = self.molecule.config.config.get('dependency')
            if dd.get('requirements_file'):
                msg = "Downloading dependencies with '{}'...".format(
                    dependency_name)
                util.print_info(msg)
                g = ansible_galaxy.AnsibleGalaxy(
                    self.molecule.config.config, debug=debug)
                g.execute()
                self.molecule.state.change_state('installed_deps', True)
        elif dependency_name == 'shell':
            dd = self.molecule.config.config.get('dependency')
            if dd.get('command'):
                msg = "Downloading dependencies with '{}'...".format(
                    dependency_name)
                util.print_info(msg)
                s = shell.Shell(self.molecule.config.config, debug=debug)
                s.execute()
                self.molecule.state.change_state('installed_deps', True)

        return (None, None)

    def execute(self, exit=True):
        """
        Execute the actions necessary to perform a `molecule check` and
        return a tuple.

        :param exit: (Unused) Provided to complete method signature.
        :return: Return a tuple provided by :meth:`.AnsiblePlaybook.execute`.
        """
        if not self.molecule.state.created:
            msg = ('Instance(s) not created, `check` should be run '
                   'against created instance(s).')
            util.print_error(msg)
            util.sysexit()

        debug = self.args.get('debug')
        ansible = ansible_playbook.AnsiblePlaybook(
            self.molecule.config.config['ansible'],
            self.molecule.driver.ansible_connection_params,
            debug=debug)
        ansible.add_cli_arg('check', True)

        util.print_info("Performing a 'Dry Run' of playbook...")
        return ansible.execute(hide_errors=True)

        return (None, None)

    def _rake(self,
              rakefile,
              debug=False,
              out=util.callback_info,
              err=util.callback_error):
        """
        Executes rake against specified rakefile and returns a :func:`sh`
        response object.

        :param rakefile: A string containing path to the rakefile.
        :param debug: An optional bool to toggle debug output.
        :param out: An optional function to process STDOUT for underlying
         :func:`sh` call.
        :param err: An optional function to process STDERR for underlying
         :func:`sh` call.
        :return: :func:`sh` response object.
        """
        kwargs = {
            '_out': out,
            '_err': err,
            'trace': debug,
            'rakefile': rakefile
        }

        msg = 'Executing serverspec tests found in {}/...'.format(
            self._serverspec_dir)
        util.print_info(msg)

        try:
            cmd = sh.rake.bake(**kwargs)
        except sh.CommandNotFound:
            msg = 'Verifier missing, gem install rake.'
            util.print_error(msg)
            util.sysexit()
        return util.run_command(cmd, debug=self._debug)

def test_print_info_without_pretty(capsys):
    util.print_info("test", pretty=False)
    result, _ = capsys.readouterr()

    print "{}".format("test".rstrip())
    expected, _ = capsys.readouterr()

    assert expected == result

def test_print_info(capsys):
    util.print_info('test')
    result, _ = capsys.readouterr()

    print '--> {}{}'.format(colorama.Fore.CYAN, 'test'.rstrip())
    expected, _ = capsys.readouterr()

    assert expected == result

    def install(self):
        """
        A wrapper to :meth:`.AnsibleGalaxy.execute`.
,
        .. todo:: Remove in favor of simply using execute.
        """
        util.print_info('Installing role dependencies ...')
        self.bake()
        self.execute()

    def _init_new_role(self, role, role_path, driver, verifier):
        extra_context = self._get_cookiecutter_context(role, driver, verifier)

        util.print_info('Initializing role {} ...'.format(role))
        for template in [
                'galaxy_init', 'playbook', 'driver/{}'.format(driver),
                'verifier/{}'.format(verifier)
        ]:
            util.process_templates(template, extra_context, role_path)

    def _init_existing_role(self, role, role_path, driver, verifier):
        extra_context = self._get_cookiecutter_context(role, driver, verifier)

        util.print_info('Initializing molecule in current directory...')
        for template in [
                'playbook', 'driver/{}'.format(driver),
                'verifier/{}'.format(verifier)
        ]:
            util.process_templates(template, extra_context, role_path)

    def execute(self):
        """
        Executes ansible-lint against the configured playbook, and returns
        None.

        :return: None
        """
        if "ansible_lint" not in self._molecule.disabled:
            msg = "Executing ansible-lint."
            util.print_info(msg)
            sh.ansible_lint(self._playbook, _env=self._env, _out=LOG.info, _err=LOG.error)

    def _get_temp_keypair(self):
        kpn = self._get_temp_keyname()

        if not self._openstack.search_keypairs(kpn):
            msg = '\tCreating openstack keypair {}...'.format(kpn)
            util.print_info(msg)
            pub_key_file = self._get_keyfile() + '.pub'
            self._openstack.create_keypair(kpn,
                                           open(pub_key_file,
                                                'r').read().strip())

        return kpn