Merge "Revert "Remove senlin CLI commands""

senlinclient/cliargs.py

@@ -0,0 +1,210 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import argparse
+
+from senlinclient.common.i18n import _
+from senlinclient.common import sdk
+from senlinclient.common import utils
+
+
+def add_global_identity_args(parser):
+    parser.add_argument(
+        '--os-auth-plugin', dest='auth_plugin', metavar='AUTH_PLUGIN',
+        default=utils.env('OS_AUTH_PLUGIN', default=None),
+        help=_('Authentication plugin, default to env[OS_AUTH_PLUGIN]'))
+
+    parser.add_argument(
+        '--os-auth-url', dest='auth_url', metavar='AUTH_URL',
+        default=utils.env('OS_AUTH_URL'),
+        help=_('Defaults to env[OS_AUTH_URL]'))
+
+    parser.add_argument(
+        '--os-project-id', dest='project_id', metavar='PROJECT_ID',
+        default=utils.env('OS_PROJECT_ID'),
+        help=_('Defaults to env[OS_PROJECT_ID].'))
+
+    parser.add_argument(
+        '--os-project-name', dest='project_name', metavar='PROJECT_NAME',
+        default=utils.env('OS_PROJECT_NAME'),
+        help=_('Defaults to env[OS_PROJECT_NAME].'))
+
+    parser.add_argument(
+        '--os-tenant-id', dest='tenant_id', metavar='TENANT_ID',
+        default=utils.env('OS_TENANT_ID'),
+        help=_('Defaults to env[OS_TENANT_ID].'))
+
+    parser.add_argument(
+        '--os-tenant-name', dest='tenant_name', metavar='TENANT_NAME',
+        default=utils.env('OS_TENANT_NAME'),
+        help=_('Defaults to env[OS_TENANT_NAME].'))
+
+    parser.add_argument(
+        '--os-domain-id', dest='domain_id', metavar='DOMAIN_ID',
+        default=utils.env('OS_DOMAIN_ID'),
+        help=_('Domain ID for scope of authorization, defaults to '
+               'env[OS_DOMAIN_ID].'))
+
+    parser.add_argument(
+        '--os-domain-name', dest='domain_name', metavar='DOMAIN_NAME',
+        default=utils.env('OS_DOMAIN_NAME'),
+        help=_('Domain name for scope of authorization, defaults to '
+               'env[OS_DOMAIN_NAME].'))
+
+    parser.add_argument(
+        '--os-project-domain-id', dest='project_domain_id',
+        metavar='PROJECT_DOMAIN_ID',
+        default=utils.env('OS_PROJECT_DOMAIN_ID'),
+        help=_('Project domain ID for scope of authorization, defaults to '
+               'env[OS_PROJECT_DOMAIN_ID].'))
+
+    parser.add_argument(
+        '--os-project-domain-name', dest='project_domain_name',
+        metavar='PROJECT_DOMAIN_NAME',
+        default=utils.env('OS_PROJECT_DOMAIN_NAME'),
+        help=_('Project domain name for scope of authorization, defaults to '
+               'env[OS_PROJECT_DOMAIN_NAME].'))
+
+    parser.add_argument(
+        '--os-user-domain-id', dest='user_domain_id',
+        metavar='USER_DOMAIN_ID',
+        default=utils.env('OS_USER_DOMAIN_ID'),
+        help=_('User domain ID for scope of authorization, defaults to '
+               'env[OS_USER_DOMAIN_ID].'))
+
+    parser.add_argument(
+        '--os-user-domain-name', dest='user_domain_name',
+        metavar='USER_DOMAIN_NAME',
+        default=utils.env('OS_USER_DOMAIN_NAME'),
+        help=_('User domain name for scope of authorization, defaults to '
+               'env[OS_USER_DOMAIN_NAME].'))
+
+    parser.add_argument(
+        '--os-username', dest='username', metavar='USERNAME',
+        default=utils.env('OS_USERNAME'),
+        help=_('Defaults to env[OS_USERNAME].'))
+
+    parser.add_argument(
+        '--os-user-id', dest='user_id', metavar='USER_ID',
+        default=utils.env('OS_USER_ID'),
+        help=_('Defaults to env[OS_USER_ID].'))
+
+    parser.add_argument(
+        '--os-password', dest='password', metavar='PASSWORD',
+        default=utils.env('OS_PASSWORD'),
+        help=_('Defaults to env[OS_PASSWORD]'))
+
+    parser.add_argument(
+        '--os-trust-id', dest='trust_id', metavar='TRUST_ID',
+        default=utils.env('OS_TRUST_ID'),
+        help=_('Defaults to env[OS_TRUST_ID]'))
+
+    verify_group = parser.add_mutually_exclusive_group()
+
+    verify_group.add_argument(
+        '--os-cacert', dest='verify', metavar='CA_BUNDLE_FILE',
+        default=utils.env('OS_CACERT', default=True),
+        help=_('Path of CA TLS certificate(s) used to verify the remote '
+               'server\'s certificate. Without this option senlin looks '
+               'for the default system CA certificates.'))
+
+    verify_group.add_argument(
+        '--verify',
+        action='store_true',
+        help=_('Verify server certificate (default)'))
+
+    verify_group.add_argument(
+        '--insecure', dest='verify', action='store_false',
+        help=_('Explicitly allow senlinclient to perform "insecure SSL" '
+               '(HTTPS) requests. The server\'s certificate will not be '
+               'verified against any certificate authorities. This '
+               'option should be used with caution.'))
+
+    parser.add_argument(
+        '--os-token', dest='token', metavar='TOKEN',
+        default=utils.env('OS_TOKEN', default=None),
+        help=_('A string token to bootstrap the Keystone database, defaults '
+               'to env[OS_TOKEN]'))
+
+    parser.add_argument(
+        '--os-access-info', dest='access_info', metavar='ACCESS_INFO',
+        default=utils.env('OS_ACCESS_INFO'),
+        help=_('Access info, defaults to env[OS_ACCESS_INFO]'))
+
+    parser.add_argument(
+        '--os-api-name', dest='user_preferences',
+        metavar='<service>=<name>',
+        action=sdk.ProfileAction,
+        default=sdk.ProfileAction.env('OS_API_NAME'),
+        help=_('Desired API names, defaults to env[OS_API_NAME]'))
+
+    parser.add_argument(
+        '--os-api-region', dest='user_preferences',
+        metavar='<service>=<region>',
+        action=sdk.ProfileAction,
+        default=sdk.ProfileAction.env('OS_API_REGION', 'OS_REGION_NAME'),
+        help=_('Desired API region, defaults to env[OS_API_REGION]'))
+
+    parser.add_argument(
+        '--os-api-version', dest='user_preferences',
+        metavar='<service>=<version>',
+        action=sdk.ProfileAction,
+        default=sdk.ProfileAction.env('OS_API_VERSION'),
+        help=_('Desired API versions, defaults to env[OS_API_VERSION]'))
+
+    parser.add_argument(
+        '--os-api-interface', dest='user_preferences',
+        metavar='<service>=<interface>',
+        action=sdk.ProfileAction,
+        default=sdk.ProfileAction.env('OS_INTERFACE'),
+        help=_('Desired API interface, defaults to env[OS_INTERFACE]'))
+
+
+#    parser.add_argument(
+#        '--os-cert',
+#        help=_('Path of certificate file to use in SSL connection. This '
+#               'file can optionally be prepended with the private key.'))
+#
+#    parser.add_argument(
+#        '--os-key',
+#        help=_('Path of client key to use in SSL connection. This option is '
+#               'not necessary if your key is prepended to your cert file.'))
+
+
+def add_global_args(parser, version):
+    # GLOBAL ARGUMENTS
+    parser.add_argument(
+        '-h', '--help', action='store_true',
+        help=argparse.SUPPRESS)
+
+    parser.add_argument(
+        '--version', action='version', version=version,
+        help=_("Shows the client version and exits."))
+
+    parser.add_argument(
+        '-d', '--debug', action='store_true',
+        default=bool(utils.env('SENLINCLIENT_DEBUG')),
+        help=_('Defaults to env[SENLINCLIENT_DEBUG].'))
+
+    parser.add_argument(
+        '-v', '--verbose', action="store_true", default=False,
+        help=_("Print more verbose output."))
+
+    parser.add_argument(
+        '--api-timeout',
+        help=_('Number of seconds to wait for an API response, '
+               'defaults to system socket timeout'))
+
+    parser.add_argument(
+        '--senlin-api-version',
+        default=utils.env('SENLIN_API_VERSION', default='1'),
+        help=_('Version number for Senlin API to use, Default to "1".'))

senlinclient/shell.py

@@ -0,0 +1,321 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+Command-line interface to the Senlin clustering API.
+"""
+
+from __future__ import print_function
+
+import argparse
+import logging
+import sys
+
+from oslo_utils import encodeutils
+from oslo_utils import importutils
+import six
+
+import senlinclient
+from senlinclient import cliargs
+from senlinclient import client as senlin_client
+from senlinclient.common import exc
+from senlinclient.common.i18n import _
+from senlinclient.common import utils
+
+osprofiler_profiler = importutils.try_import("osprofiler.profiler")
+USER_AGENT = 'python-senlinclient'
+LOG = logging.getLogger(__name__)
+
+
+class HelpFormatter(argparse.HelpFormatter):
+    def start_section(self, heading):
+        # Title-case the headings
+        heading = '%s%s' % (heading[0].upper(), heading[1:])
+        super(HelpFormatter, self).start_section(heading)
+
+
+class SenlinShell(object):
+    def _setup_logging(self, debug):
+        log_lvl = logging.DEBUG if debug else logging.WARNING
+        logging.basicConfig(format="%(levelname)s (%(module)s) %(message)s",
+                            level=log_lvl)
+        logging.getLogger('iso8601').setLevel(logging.WARNING)
+        logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
+
+    def _setup_verbose(self, verbose):
+        if verbose:
+            exc.verbose = 1
+
+    def _find_actions(self, subparsers, actions_module):
+        for attr in (a for a in dir(actions_module) if a.startswith('do_')):
+            command = attr[3:].replace('_', '-')
+            callback = getattr(actions_module, attr)
+
+            # get callback documentation string
+            desc = callback.__doc__ or ''
+            help = desc.strip().split('\n')[0]
+            arguments = getattr(callback, 'arguments', [])
+
+            subparser = subparsers.add_parser(command,
+                                              help=help,
+                                              description=desc,
+                                              add_help=False,
+                                              formatter_class=HelpFormatter)
+
+            subparser.add_argument('-h', '--help',
+                                   action='help',
+                                   help=argparse.SUPPRESS)
+
+            for (args, kwargs) in arguments:
+                subparser.add_argument(*args, **kwargs)
+            subparser.set_defaults(func=callback)
+
+            self.subcommands[command] = subparser
+
+    def do_bash_completion(self, args):
+        """Prints all of the commands and options to stdout.
+
+        The senlin.bash_completion script doesn't have to hard code them.
+        """
+        commands = set()
+        options = set()
+        for sc_str, sc in self.subcommands.items():
+            if sc_str == 'bash_completion' or sc_str == 'bash-completion':
+                continue
+
+            commands.add(sc_str)
+            for option in list(sc._optionals._option_string_actions):
+                options.add(option)
+
+        print(' '.join(commands | options))
+
+    def add_profiler_args(self, parser):
+        if osprofiler_profiler:
+            parser.add_argument(
+                '--profile', metavar='HMAC_KEY',
+                help=_('HMAC key to use for encrypting context data for '
+                       'performance profiling of operation. This key should '
+                       'be the value of HMAC key configured in osprofiler '
+                       'middleware in senlin, it is specified in the paste '
+                       'deploy configuration (/etc/senlin/api-paste.ini). '
+                       'Without the key, profiling will not be triggered '
+                       'even if osprofiler is enabled on server side.'))
+
+    def _add_bash_completion_subparser(self, subparsers):
+        subparser = subparsers.add_parser('bash_completion',
+                                          add_help=False,
+                                          formatter_class=HelpFormatter)
+
+        subparser.set_defaults(func=self.do_bash_completion)
+        self.subcommands['bash_completion'] = subparser
+
+    def get_subcommand_parser(self, base_parser, version):
+        parser = base_parser
+
+        self.subcommands = {}
+        subparsers = parser.add_subparsers(metavar='<subcommand>')
+        submodule = utils.import_versioned_module(version, 'shell')
+        self._find_actions(subparsers, submodule)
+        self._find_actions(subparsers, self)
+        self._add_bash_completion_subparser(subparsers)
+
+        return parser
+
+    @utils.arg('command', metavar='<subcommand>', nargs='?',
+               help=_('Display help for <subcommand>.'))
+    def do_help(self, args):
+        """Display help about this program or one of its subcommands."""
+        if getattr(args, 'command', None):
+            if args.command in self.subcommands:
+                self.subcommands[args.command].print_help()
+            else:
+                raise exc.CommandError("'%s' is not a valid subcommand" %
+                                       args.command)
+        else:
+            self.parser.print_help()
+
+    def _check_identity_arguments(self, args):
+        # TODO(Qiming): validate the token authentication path and the trust
+        # authentication path
+
+        if not args.auth_url:
+            msg = _('You must provide an auth url via --os-auth-url (or '
+                    ' env[OS_AUTH_URL])')
+            raise exc.CommandError(msg)
+
+        # username or user_id or token must be specified
+        if not (args.username or args.user_id or args.token):
+            msg = _('You must provide a user name, a user_id or a '
+                    'token for authentication')
+            raise exc.CommandError(msg)
+
+        # if both username and user_id are specified, user_id takes precedence
+        if (args.username and args.user_id):
+            msg = _('Both user name and user ID are specified, Senlin will '
+                    'use user ID for authentication')
+            print(_('WARNING: %s') % msg)
+
+        if 'v3' in args.auth_url:
+            if (args.username and not args.user_id):
+                if not (args.user_domain_id or args.user_domain_name):
+                    msg = _('Either user domain ID (--user-domain-id / '
+                            'env[OS_USER_DOMAIN_ID]) or user domain name '
+                            '(--user-domain-name / env[OS_USER_DOMAIN_NAME]) '
+                            'must be specified, because user name may not be '
+                            'unique.')
+                    raise exc.CommandError(msg)
+
+        # password is needed if username or user_id is present
+        if (args.username or args.user_id) and not (args.password):
+            msg = _('You must provide a password for user %s') % (
+                args.username or args.user_id)
+            raise exc.CommandError(msg)
+
+        # project name or ID is needed, or else sdk may find the wrong project
+        if (not (args.project_id or args.project_name or args.tenant_id
+                 or args.tenant_name)):
+            if not (args.user_id):
+                msg = _('Either project/tenant ID or project/tenant name '
+                        'must be specified, or else Senlin cannot know '
+                        'which project to use.')
+                raise exc.CommandError(msg)
+            else:
+                msg = _('Neither project ID nor project name is specified. '
+                        'Senlin will use user\'s default project which may '
+                        'result in authentication error.')
+                print(_('WARNING: %s') % msg)
+
+        # both project name and ID are specified, ID takes precedence
+        if ((args.project_id or args.tenant_id) and
+                (args.project_name or args.tenant_name)):
+            msg = _('Both project/tenant name and project/tenant ID are '
+                    'specified, Senlin will use project ID for '
+                    'authentication')
+            print(_('WARNING: %s') % msg)
+
+        # project name may not be unique
+        if 'v3' in args.auth_url:
+            if (not (args.project_id or args.tenant_id) and
+                    (args.project_name or args.tenant_name) and
+                    not (args.project_domain_id or args.project_domain_name)):
+                msg = _('Either project domain ID (--project-domain-id / '
+                        'env[OS_PROJECT_DOMAIN_ID]) orr project domain name '
+                        '(--project-domain-name / env[OS_PROJECT_DOMAIN_NAME '
+                        'must be specified, because project/tenant name may '
+                        'not be unique.')
+                raise exc.CommandError(msg)
+
+    def _setup_senlin_client(self, api_ver, args):
+        """Create senlin client using given args."""
+        kwargs = {
+            'auth_plugin': args.auth_plugin or 'password',
+            'auth_url': args.auth_url,
+            'project_name': args.project_name or args.tenant_name,
+            'project_id': args.project_id or args.tenant_id,
+            'domain_name': args.domain_name,
+            'domain_id': args.domain_id,
+            'project_domain_name': args.project_domain_name,
+            'project_domain_id': args.project_domain_id,
+            'user_domain_name': args.user_domain_name,
+            'user_domain_id': args.user_domain_id,
+            'username': args.username,
+            'user_id': args.user_id,
+            'password': args.password,
+            'verify': args.verify,
+            'token': args.token,
+            'trust_id': args.trust_id,
+        }
+
+        return senlin_client.Client('1', args.user_preferences, USER_AGENT,
+                                    **kwargs)
+
+    def main(self, argv):
+        # Parse args once to find version
+        parser = argparse.ArgumentParser(
+            prog='senlin',
+            description=__doc__.strip(),
+            epilog=_('Type "senlin help <COMMAND>" for help on a specific '
+                     'command.'),
+            add_help=False,
+            formatter_class=HelpFormatter,
+        )
+
+        cliargs.add_global_args(parser, version=senlinclient.__version__)
+        cliargs.add_global_identity_args(parser)
+        self.add_profiler_args(parser)
+        base_parser = parser
+
+        (options, args) = base_parser.parse_known_args(argv)
+
+        self._setup_logging(options.debug)
+        self._setup_verbose(options.verbose)
+
+        # build available subcommands based on version
+        api_ver = options.senlin_api_version
+        LOG.info(api_ver)
+        subcommand_parser = self.get_subcommand_parser(base_parser, api_ver)
+        self.parser = subcommand_parser
+
+        # Handle top-level --help/-h before attempting to parse
+        # a command off the command line
+        if not args and options.help or not argv:
+            self.do_help(options)
+            return 0
+
+        # Parse args again and call whatever callback was selected
+        args = subcommand_parser.parse_args(argv)
+
+        # Short-circuit and deal with help command right away.
+        if args.func == self.do_help:
+            self.do_help(args)
+            return 0
+        elif args.func == self.do_bash_completion:
+            self.do_bash_completion(args)
+            return 0
+
+        # Check if identity information are sufficient
+        self._check_identity_arguments(args)
+
+        # Setup Senlin client connection
+        sc = self._setup_senlin_client(api_ver, args)
+
+        profile = osprofiler_profiler and options.profile
+        if profile:
+            osprofiler_profiler.init(options.profile)
+
+        args.func(sc.service, args)
+
+        if profile:
+            trace_id = osprofiler_profiler.get().get_base_id()
+            print(_("Trace ID: %s") % trace_id)
+            print(_("To display trace use next command:\n"
+                  "osprofiler trace show --html %s ") % trace_id)
+
+
+def main(args=None):
+    try:
+        if args is None:
+            args = sys.argv[1:]
+
+        SenlinShell().main(args)
+    except KeyboardInterrupt:
+        print(_("... terminating senlin client"), file=sys.stderr)
+        sys.exit(130)
+    except Exception as e:
+        if '--debug' in args or '-d' in args:
+            raise
+        else:
+            print(encodeutils.safe_encode(six.text_type(e)), file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

senlinclient/tests/unit/test_cliargs.py

@@ -0,0 +1,78 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import mock
+import testtools
+
+from senlinclient import cliargs
+
+
+class TestCliArgs(testtools.TestCase):
+
+    def test_add_global_identity_args(self):
+        parser = mock.Mock()
+
+        cliargs.add_global_identity_args(parser)
+        expected = [
+            '--os-auth-plugin',
+            '--os-auth-url',
+            '--os-project-id',
+            '--os-project-name',
+            '--os-tenant-id',
+            '--os-tenant-name',
+            '--os-domain-id',
+            '--os-domain-name',
+            '--os-project-domain-id',
+            '--os-project-domain-name',
+            '--os-user-domain-id',
+            '--os-user-domain-name',
+            '--os-username',
+            '--os-user-id',
+            '--os-password',
+            '--os-trust-id',
+            '--os-token',
+            '--os-access-info',
+            '--os-api-name',
+            '--os-api-region',
+            '--os-api-version',
+            '--os-api-interface'
+        ]
+
+        options = [arg[0][0] for arg in parser.add_argument.call_args_list]
+        self.assertEqual(expected, options)
+
+        parser.add_mutually_exclusive_group.assert_called_once_with()
+        group = parser.add_mutually_exclusive_group.return_value
+
+        verify_opts = [arg[0][0] for arg in group.add_argument.call_args_list]
+        verify_args = [
+            '--os-cacert',
+            '--verify',
+            '--insecure'
+        ]
+        self.assertEqual(verify_args, verify_opts)
+
+    def test_add_global_args(self):
+        parser = mock.Mock()
+
+        cliargs.add_global_args(parser, '1')
+        expected = [
+            '-h',
+            '--version',
+            '-d',
+            '-v',
+            '--api-timeout',
+            '--senlin-api-version'
+        ]
+
+        options = [arg[0][0] for arg in parser.add_argument.call_args_list]
+        self.assertEqual(expected, options)

senlinclient/tests/unit/test_shell.py

@@ -0,0 +1,373 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import argparse
+import logging
+import sys
+
+import mock
+import six
+from six.moves import builtins
+import testtools
+
+from senlinclient import client as senlin_client
+from senlinclient.common import exc
+from senlinclient.common.i18n import _
+from senlinclient.common import sdk
+from senlinclient.common import utils
+from senlinclient import shell
+from senlinclient.tests.unit import fakes
+
+
+class HelpFormatterTest(testtools.TestCase):
+
+    def test_start_section(self):
+        fmtr = shell.HelpFormatter('senlin')
+        res = fmtr.start_section(('heading', 'text1', 30))
+        self.assertIsNone(res)
+        h = fmtr._current_section.heading
+        self.assertEqual("HEADING('text1', 30)", h)
+
+
+class TestArgs(testtools.TestCase):
+
+    def __init__(self):
+        self.auth_url = 'http://fakeurl/v3'
+        self.auth_plugin = 'test_plugin'
+        self.username = 'test_user_name'
+        self.user_id = 'test_user_id'
+        self.token = 'test_token'
+        self.project_id = 'test_project_id'
+        self.project_name = 'test_project_name'
+        self.tenant_id = 'test_tenant_id'
+        self.tenant_name = 'test_tenant_name'
+        self.password = 'test_password'
+        self.user_domain_id = 'test_user_domain_id'
+        self.user_domain_name = 'test_user_domain_name'
+        self.project_domain_id = 'test_project_domain_id'
+        self.project_domain_name = 'test_project_domain_name'
+        self.domain_name = 'test_domain_name'
+        self.domain_id = 'test_domain_id'
+        self.verify = 'test_verify'
+        self.user_preferences = 'test_preferences'
+        self.trust_id = 'test_trust'
+
+
+class ShellTest(testtools.TestCase):
+
+    def setUp(self):
+        super(ShellTest, self).setUp()
+
+    def SHELL(self, func, *args, **kwargs):
+        orig_out = sys.stdout
+        sys.stdout = six.StringIO()
+        func(*args, **kwargs)
+        output = sys.stdout.getvalue()
+        sys.stdout.close()
+        sys.stdout = orig_out
+
+        return output
+
+    @mock.patch.object(logging, 'basicConfig')
+    @mock.patch.object(logging, 'getLogger')
+    def test_setup_logging_debug(self, x_get, x_config):
+        sh = shell.SenlinShell()
+        sh._setup_logging(True)
+
+        x_config.assert_called_once_with(
+            format="%(levelname)s (%(module)s) %(message)s",
+            level=logging.DEBUG)
+        mock_calls = [
+            mock.call('iso8601'),
+            mock.call().setLevel(logging.WARNING),
+            mock.call('urllib3.connectionpool'),
+            mock.call().setLevel(logging.WARNING),
+        ]
+        x_get.assert_has_calls(mock_calls)
+
+    @mock.patch.object(logging, 'basicConfig')
+    @mock.patch.object(logging, 'getLogger')
+    def test_setup_logging_no_debug(self, x_get, x_config):
+        sh = shell.SenlinShell()
+        sh._setup_logging(False)
+
+        x_config.assert_called_once_with(
+            format="%(levelname)s (%(module)s) %(message)s",
+            level=logging.WARNING)
+        mock_calls = [
+            mock.call('iso8601'),
+            mock.call().setLevel(logging.WARNING),
+            mock.call('urllib3.connectionpool'),
+            mock.call().setLevel(logging.WARNING),
+        ]
+        x_get.assert_has_calls(mock_calls)
+
+    def test_setup_verbose(self):
+        sh = shell.SenlinShell()
+        sh._setup_verbose(True)
+        self.assertEqual(1, exc.verbose)
+
+        sh._setup_verbose(False)
+        self.assertEqual(1, exc.verbose)
+
+    def test_find_actions(self):
+        sh = shell.SenlinShell()
+        sh.subcommands = {}
+        subparsers = mock.Mock()
+        x_subparser1 = mock.Mock()
+        x_subparser2 = mock.Mock()
+        x_add_parser = mock.MagicMock(side_effect=[x_subparser1, x_subparser2])
+        subparsers.add_parser = x_add_parser
+
+        # subparsers.add_parser = mock.Mock(return_value=x_subparser)
+        sh._find_actions(subparsers, fakes)
+
+        self.assertEqual({'command-bar': x_subparser1,
+                          'command-foo': x_subparser2},
+                         sh.subcommands)
+        add_calls = [
+            mock.call('command-bar', help='This is the command doc.',
+                      description='This is the command doc.',
+                      add_help=False,
+                      formatter_class=shell.HelpFormatter),
+            mock.call('command-foo', help='Pydoc for command foo.',
+                      description='Pydoc for command foo.',
+                      add_help=False,
+                      formatter_class=shell.HelpFormatter),
+        ]
+        x_add_parser.assert_has_calls(add_calls)
+
+        calls_1 = [
+            mock.call('-h', '--help', action='help',
+                      help=argparse.SUPPRESS),
+            mock.call('-F', '--flag', metavar='<FLAG>',
+                      help='Flag desc.'),
+            mock.call('arg1', metavar='<ARG1>',
+                      help='Arg1 desc')
+        ]
+        x_subparser1.add_argument.assert_has_calls(calls_1)
+        x_subparser1.set_defaults.assert_called_once_with(
+            func=fakes.do_command_bar)
+
+        calls_2 = [
+            mock.call('-h', '--help', action='help',
+                      help=argparse.SUPPRESS),
+        ]
+        x_subparser2.add_argument.assert_has_calls(calls_2)
+        x_subparser2.set_defaults.assert_called_once_with(
+            func=fakes.do_command_foo)
+
+    def test_do_bash_completion(self):
+        sh = shell.SenlinShell()
+        sc1 = mock.Mock()
+        sc2 = mock.Mock()
+        sc1._optionals._option_string_actions = ('A1', 'A2', 'C')
+        sc2._optionals._option_string_actions = ('B1', 'B2', 'C')
+        sh.subcommands = {
+            'command-foo': sc1,
+            'command-bar': sc2,
+            'bash-completion': None,
+            'bash_completion': None,
+        }
+
+        output = self.SHELL(sh.do_bash_completion, None)
+
+        output = output.split('\n')[0]
+        output_list = output.split(' ')
+        for option in ('A1', 'A2', 'C', 'B1', 'B2',
+                       'command-foo', 'command-bar'):
+            self.assertIn(option, output_list)
+
+    def test_do_add_profiler_args(self):
+        sh = shell.SenlinShell()
+        parser = mock.Mock()
+
+        sh.add_profiler_args(parser)
+
+        self.assertEqual(0, parser.add_argument.call_count)
+
+    def test_add_bash_completion_subparser(self):
+        sh = shell.SenlinShell()
+        sh.subcommands = {}
+        x_subparser = mock.Mock()
+        x_subparsers = mock.Mock()
+        x_subparsers.add_parser.return_value = x_subparser
+
+        sh._add_bash_completion_subparser(x_subparsers)
+
+        x_subparsers.add_parser.assert_called_once_with(
+            'bash_completion', add_help=False,
+            formatter_class=shell.HelpFormatter)
+        self.assertEqual({'bash_completion': x_subparser}, sh.subcommands)
+        x_subparser.set_defaults.assert_called_once_with(
+            func=sh.do_bash_completion)
+
+    @mock.patch.object(utils, 'import_versioned_module')
+    @mock.patch.object(shell.SenlinShell, '_find_actions')
+    @mock.patch.object(shell.SenlinShell, '_add_bash_completion_subparser')
+    def test_get_subcommand_parser(self, x_add, x_find, x_import):
+        x_base = mock.Mock()
+        x_module = mock.Mock()
+        x_import.return_value = x_module
+        sh = shell.SenlinShell()
+
+        res = sh.get_subcommand_parser(x_base, 'v100')
+
+        self.assertEqual(x_base, res)
+        x_base.add_subparsers.assert_called_once_with(
+            metavar='<subcommand>')
+        x_subparsers = x_base.add_subparsers.return_value
+        x_import.assert_called_once_with('v100', 'shell')
+        find_calls = [
+            mock.call(x_subparsers, x_module),
+            mock.call(x_subparsers, sh)
+        ]
+
+        x_find.assert_has_calls(find_calls)
+        x_add.assert_called_once_with(x_subparsers)
+
+    @mock.patch.object(argparse.ArgumentParser, 'print_help')
+    def test_do_help(self, mock_print):
+        sh = shell.SenlinShell()
+        args = mock.Mock()
+        args.command = mock.Mock()
+        sh.subcommands = {args.command: argparse.ArgumentParser}
+        sh.do_help(args)
+        self.assertTrue(mock_print.called)
+
+        sh.subcommands = {}
+        ex = self.assertRaises(exc.CommandError,
+                               sh.do_help, args)
+        msg = _("'%s' is not a valid subcommand") % args.command
+        self.assertEqual(msg, six.text_type(ex))
+
+    @mock.patch.object(builtins, 'print')
+    def test_check_identity_arguments(self, mock_print):
+        sh = shell.SenlinShell()
+        # auth_url is not specified.
+        args = TestArgs()
+        args.auth_url = None
+        ex = self.assertRaises(exc.CommandError,
+                               sh._check_identity_arguments, args)
+        msg = _('You must provide an auth url via --os-auth-url (or '
+                ' env[OS_AUTH_URL])')
+        self.assertEqual(msg, six.text_type(ex))
+        # username, user_id and token are not specified.
+        args = TestArgs()
+        args.username = None
+        args.user_id = None
+        args.token = None
+        msg = _('You must provide a user name, a user_id or a '
+                'token for authentication')
+        ex = self.assertRaises(exc.CommandError,
+                               sh._check_identity_arguments, args)
+        self.assertEqual(msg, six.text_type(ex))
+        # Both username and user_id are specified.
+        args = TestArgs()
+        args.project_id = None
+        args.tenant_id = None
+        sh._check_identity_arguments(args)
+        msg = _('WARNING: Both user name and user ID are specified, '
+                'Senlin will use user ID for authentication')
+        mock_print.assert_called_with(msg)
+
+        # 'v3' in auth_url but neither user_domain_id nor user_domain_name
+        # is specified.
+        args = TestArgs()
+        args.user_id = None
+        args.user_domain_id = None
+        args.user_domain_name = None
+        msg = _('Either user domain ID (--user-domain-id / '
+                'env[OS_USER_DOMAIN_ID]) or user domain name '
+                '(--user-domain-name / env[OS_USER_DOMAIN_NAME]) '
+                'must be specified, because user name may not be '
+                'unique.')
+        ex = self.assertRaises(exc.CommandError,
+                               sh._check_identity_arguments, args)
+        self.assertEqual(msg, six.text_type(ex))
+        # user_id, project_id, project_name, tenant_id and tenant_name are all
+        # not specified.
+        args = TestArgs()
+        args.project_id = None
+        args.project_name = None
+        args.tenant_id = None
+        args.tenant_name = None
+        args.user_id = None
+        msg = _('Either project/tenant ID or project/tenant name '
+                'must be specified, or else Senlin cannot know '
+                'which project to use.')
+        ex = self.assertRaises(exc.CommandError,
+                               sh._check_identity_arguments, args)
+        self.assertEqual(msg, six.text_type(ex))
+        args.user_id = 'test_user_id'
+        sh._check_identity_arguments(args)
+        msg = _('Neither project ID nor project name is specified. '
+                'Senlin will use user\'s default project which may '
+                'result in authentication error.')
+        mock_print.assert_called_with(_('WARNING: %s') % msg)
+
+        # Both project_name and project_id are specified
+        args = TestArgs()
+        args.user_id = None
+        sh._check_identity_arguments(args)
+        msg = _('Both project/tenant name and project/tenant ID are '
+                'specified, Senlin will use project ID for '
+                'authentication')
+        mock_print.assert_called_with(_('WARNING: %s') % msg)
+        # Project name may not be unique
+        args = TestArgs()
+        args.user_id = None
+        args.project_id = None
+        args.tenant_id = None
+        args.project_domain_id = None
+        args.project_domain_name = None
+        msg = _('Either project domain ID (--project-domain-id / '
+                'env[OS_PROJECT_DOMAIN_ID]) orr project domain name '
+                '(--project-domain-name / env[OS_PROJECT_DOMAIN_NAME '
+                'must be specified, because project/tenant name may '
+                'not be unique.')
+        ex = self.assertRaises(exc.CommandError,
+                               sh._check_identity_arguments, args)
+        self.assertEqual(msg, six.text_type(ex))
+
+    @mock.patch.object(sdk, 'create_connection')
+    def test_setup_senlinclient(self, mock_conn):
+        USER_AGENT = 'python-senlinclient'
+        args = TestArgs()
+        kwargs = {
+            'auth_plugin': args.auth_plugin,
+            'auth_url': args.auth_url,
+            'project_name': args.project_name or args.tenant_name,
+            'project_id': args.project_id or args.tenant_id,
+            'domain_name': args.domain_name,
+            'domain_id': args.domain_id,
+            'project_domain_name': args.project_domain_name,
+            'project_domain_id': args.project_domain_id,
+            'user_domain_name': args.user_domain_name,
+            'user_domain_id': args.user_domain_id,
+            'username': args.username,
+            'user_id': args.user_id,
+            'password': args.password,
+            'verify': args.verify,
+            'token': args.token,
+            'trust_id': args.trust_id,
+        }
+        sh = shell.SenlinShell()
+        conn = mock.Mock()
+        mock_conn.return_value = conn
+        conn.session = mock.Mock()
+        sh._setup_senlin_client('1', args)
+        mock_conn.assert_called_once_with(args.user_preferences, USER_AGENT,
+                                          **kwargs)
+        client = mock.Mock()
+        senlin_client.Client = mock.MagicMock(return_value=client)
+        self.assertEqual(client, sh._setup_senlin_client('1', args))

setup.cfg

@@ -23,6 +23,9 @@ packages =
     senlinclient
 
 [entry_points]
+console_scripts =
+    senlin = senlinclient.shell:main
+
 openstack.cli.extension =
     clustering = senlinclient.plugin