Merge lp:~nick-moffitt/charm-helpers/commandant into lp:~mew/charm-helpers/commandant

[Nick Moffitt]

$ bin/chlp --help
usage: chlp [-h] [--format FMT | -y | -p | -r | -j | -t | -c]
            {mounts,service} ...

Perform common charm tasks

positional arguments:
  {mounts,service} Commands

optional arguments:
  -h, --help show this help message and exit
  --format FMT Select output format for returned data, where FMT is one
                    of: ['yaml', 'python', 'raw', 'json', 'tab', 'csv']
  -y, --yaml Output data in YAML format
  -p, --python Output data as a nicely-formatted python data structure
  -r, --raw Output data as raw string
  -j, --json Output data in JSON format
  -t, --tab Output data in excel-compatible tab-delimited format
  -c, --csv Output data as excel-compatible CSV

$ bin/chlp --format=tab mounts | cut -f 2 | sort -u
/dev/disk/by-uuid/5237fceb-23d0-412d-84d9-b8f8b3bf28af
/home/nick/.Private
binfmt_misc
cgroup
devpts
gvfsd-fuse
none
proc
rootfs
sysfs
tmpfs
udev
$ ./chlp -y mounts
- [/, rootfs]
- [/sys, sysfs]
- [/proc, proc]
- [/dev, udev]
- [/dev/pts, devpts]
- [/run, tmpfs]
- [/, /dev/disk/by-uuid/5237fceb-23d0-412d-84d9-b8f8b3bf28af]
- [/sys/fs/cgroup, none]
- [/sys/fs/fuse/connections, none]
- [/sys/kernel/debug, none]
- [/sys/kernel/security, none]
- [/run/lock, none]
- [/run/shm, none]
- [/run/user, none]
- [/sys/fs/cgroup/cpuset, cgroup]
- [/sys/fs/cgroup/cpu, cgroup]
- [/sys/fs/cgroup/cpuacct, cgroup]
- [/sys/fs/cgroup/memory, cgroup]
- [/sys/fs/cgroup/devices, cgroup]
- [/sys/fs/cgroup/freezer, cgroup]
- [/sys/fs/cgroup/blkio, cgroup]
- [/sys/fs/cgroup/perf_event, cgroup]
- [/sys/fs/cgroup/hugetlb, cgroup]
- [/proc/sys/fs/binfmt_misc, binfmt_misc]
- [/var/lib/schroot/mount/lp0-0b9ed0ed-191c-4195-a6ff-ae429d90f821, /dev/disk/by-uuid/5237fceb-23d0-412d-84d9-b8f8b3bf28af]
- [/var/lib/schroot/mount/lp0-efa0ce0d-8b91-445b-ad51-69336f1b59c2, /dev/disk/by-uuid/5237fceb-23d0-412d-84d9-b8f8b3bf28af]
- [/home/nick/Private, /home/nick/.Private]
- [/run/user/nick/gvfs, gvfsd-fuse]

[lp:~nick-moffitt/charm-helpers/commandant]

26. By Nick Moffitt on 2013-06-27

fix tests

27. By Nick Moffitt on 2013-06-27

Begin testing the command-wrapping decorators. Fixed the optional argument syntax to include dashes.

=== modified file 'charmhelpers/cli/__init__.py'
--- charmhelpers/cli/__init__.py	2013-06-19 23:00:23 +0000
+++ charmhelpers/cli/__init__.py	2013-06-27 15:47:32 +0000
@@ -1,15 +1,82 @@
 import inspect
 import itertools
 import argparse
+import sys
+
+class OutputFormatter(object):
+    def __init__(self, outfile=sys.stdout):
+        self.formats = { 'raw': self.raw,
+                         'python': self.pprint,
+                         'json': self.json,
+                         'yaml': self.yaml,
+                         'csv': self.csv,
+                         'tab': self.tab,
+                       }
+        self.outfile = outfile
+
+    @property
+    def supported_formats(self):
+        return self.formats.keys()
+
+    def raw(self, output):
+        """Output data as raw string"""
+        try:
+            self.outfile.writelines(output)
+        except TypeError:
+            self.outfile.write(str(output))
+
+    def pprint(self, output):
+        """Output data as a nicely-formatted python data structure"""
+        import pprint
+        pprint.pprint(output, stream=self.outfile)
+
+    def json(self, output):
+        """Output data in JSON format"""
+        import json
+        json.dump(output, self.outfile)
+
+    def yaml(self, output):
+        """Output data in YAML format"""
+        import yaml
+        yaml.safe_dump(output, self.outfile)
+
+    def csv(self, output):
+        """Output data as excel-compatible CSV"""
+        import csv
+        csvwriter = csv.writer(self.outfile)
+        csvwriter.writerows(output)
+
+    def tab(self, output):
+        """Output data in excel-compatible tab-delimited format"""
+        import csv
+        csvwriter = csv.writer(self.outfile, dialect=csv.excel_tab)
+        csvwriter.writerows(output)
+
+    def format_output(self, output, fmt='raw'):
+        fmtfunc = self.formats[fmt]
+        fmtfunc(output)
 
 
 class CommandLine(object):
     argument_parser = None
     subparsers = None
+    formatter = None
 
     def __init__(self):
         if not self.argument_parser:
             self.argument_parser = argparse.ArgumentParser(description='Perform common charm tasks')
+        if not self.formatter:
+            self.formatter = OutputFormatter()
+            formatgroup = self.argument_parser.add_mutually_exclusive_group()
+            choices = self.formatter.supported_formats
+            formatgroup.add_argument("--format", metavar='FMT',
+                    help="Select output format for returned data, "
+                         "where FMT is one of: {}".format(choices),
+                    choices=choices, default='raw')
+            for fmt, fmtfunc in self.formatter.formats.iteritems():
+                formatgroup.add_argument("-{}".format(fmt[0]),
+                        "--{}".format(fmt), action='store_const', const=fmt,
+                        dest='format', help=fmtfunc.__doc__)
         if not self.subparsers:
             self.subparsers = self.argument_parser.add_subparsers(help='Commands')
 
@@ -55,7 +122,7 @@
             vargs = getattr(arguments, argspec.vargs)
         for arg in argspec.args:
             kwargs[arg] = getattr(arguments, arg)
-        arguments.func(*vargs, **kwargs)
+        self.formatter.format_output(arguments.func(*vargs, **kwargs), arguments.format)
 
 
 cmdline = CommandLine()
@@ -72,7 +139,7 @@
         positional_args = argspec.args[:len(argspec.defaults)]
         keyword_names = argspec.args[-len(argspec.defaults):]
         for arg, default in itertools.izip(keyword_names, argspec.defaults):
-            yield (arg,), {'default': default}
+            yield ('--{}'.format(arg),), {'default': default}
     else:
         positional_args = argspec.args
 

=== modified file 'charmhelpers/cli/host.py'
--- charmhelpers/cli/host.py	2013-06-19 23:00:23 +0000
+++ charmhelpers/cli/host.py	2013-06-27 15:47:32 +0000
@@ -5,9 +5,7 @@
 @cmdline.subcommand()
 def mounts():
     "List mounts"
-    for mount in host.mounts():
-        print mount
-
+    return host.mounts()
 
 @cmdline.subcommand_builder('service', description="Control system services")
 def service(subparser):

=== renamed directory 'tests/commandant' => 'tests/cli'
=== added file 'tests/cli/test_command_decorators.py'
--- tests/cli/test_command_decorators.py	1970-01-01 00:00:00 +0000
+++ tests/cli/test_command_decorators.py	2013-06-27 15:47:32 +0000
@@ -0,0 +1,46 @@
+"""Tests for the commandant code that analyzes a function signature to
+determine the parameters to argparse."""
+
+from testtools import TestCase, matchers
+from mock import patch
+
+from charmhelpers import cli
+
+@patch('sys.exit')
+class SubCommandTest(TestCase):
+    """Test creation of subcommands"""
+
+    def test_subcommand_wrapper(self, mock_sys_exit):
+        """Test function name detection"""
+        cmdline = cli.CommandLine()
+        @cmdline.subcommand()
+        def payload():
+            "A function that does work."
+            pass
+        args = cmdline.argument_parser.parse_args(['payload'])
+        self.assertEqual(args.func, payload)
+        self.assertEqual(mock_sys_exit.mock_calls, [])
+
+    def test_bogus_arguments(self, mock_sys_exit):
+        """Test function name detection"""
+        cmdline = cli.CommandLine()
+        @cmdline.subcommand()
+        def payload():
+            "A function that does work."
+            pass
+        self.assertRaises(TypeError, cmdline.argument_parser.parse_args,
+                ['deliberately bad input'])
+        mock_sys_exit.assert_called_once_with(2)
+
+    def test_cmdline_options(self, mock_sys_exit):
+        """Test detection of positional arguments and optional parameters."""
+        cmdline = cli.CommandLine()
+        @cmdline.subcommand()
+        def payload(x, y=None):
+            "A function that does work."
+            return x
+        args = cmdline.argument_parser.parse_args(['payload', 'positional', '--y=optional'])
+        self.assertEqual(args.func, payload)
+        self.assertEqual(args.x, 'positional')
+        self.assertEqual(args.y, 'optional')
+        self.assertEqual(mock_sys_exit.mock_calls, [])

=== modified file 'tests/cli/test_function_signature_analysis.py'
--- tests/commandant/test_function_signature_analysis.py	2013-06-06 16:58:35 +0000
+++ tests/cli/test_function_signature_analysis.py	2013-06-27 15:47:32 +0000
@@ -3,35 +3,35 @@
 
 from testtools import TestCase, matchers
 
-from charmhelpers.commandant import signature
+from charmhelpers import cli
 
 class FunctionSignatureTest(TestCase):
     """Test a variety of function signatures."""
 
     def test_positional_arguments(self):
         """Finite number of order-dependent required arguments."""
-        argparams = signature.describe_arguments(lambda x, y, z: False)
+        argparams = cli.describe_arguments(lambda x, y, z: False)
         self.assertEqual(tuple(argparams),
                 ((('x',), {}), (('y',), {}), (('z',), {})))
 
     def test_keyword_arguments(self):
         """Function has optional parameters with default values."""
-        argparams = tuple(signature.describe_arguments(
+        argparams = tuple(cli.describe_arguments(
             lambda x, y=3, z="bar": False))
-        self.assertIn((('y',), {'default': 3}), argparams)
-        self.assertIn((('z',), {'default': 'bar'}), argparams)
+        self.assertIn((('--y',), {'default': 3}), argparams)
+        self.assertIn((('--z',), {'default': 'bar'}), argparams)
 
     def test_varargs(self):
         """Function has a splat-operator parameter to catch an arbitrary number
         of positional parameters."""
-        argparams = tuple(signature.describe_arguments(
+        argparams = tuple(cli.describe_arguments(
             lambda x, y=3, *z: False))
         self.assertIn((('z',), {'nargs': '*'}), argparams)
 
     def test_keyword_splat_missing(self):
         """Double-splat arguments can't be represented in the current version
         of commandant."""
-        args = signature.describe_arguments(
+        args = cli.describe_arguments(
                 lambda x, y=3, *z, **missing: False)
         for opts, _ in args:
             # opts should be ('varname',) at this point