Merge lp:~dobey/ubuntuone-dev-tools/runner-tests into lp:ubuntuone-dev-tools

[dobey]

Test the new options parser
Fix up handling of temp-directory and the test path args for non-txrunner usage
Use unicode_literals and print_function
Implement synonyms usage in options so some options work more correctly
Use unicode_literals and print_function
Ignore the .coverage file

[Roberto Alsina (ralsina)]

review: Approve

[Alejandro J. Cura (alecu)]

+1

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2010-07-14 21:39:08 +0000
+++ .bzrignore	2012-08-13 21:10:25 +0000
@@ -1,3 +1,4 @@
+.coverage
 MANIFEST
 build
 dist

=== modified file 'ubuntuone/devtools/runners/__init__.py'
--- ubuntuone/devtools/runners/__init__.py	2012-07-27 19:02:53 +0000
+++ ubuntuone/devtools/runners/__init__.py	2012-08-13 21:10:25 +0000
@@ -26,6 +26,8 @@
 # files in the program, then also delete it here.
 """The base test runner object."""
 
+from __future__ import print_function, unicode_literals
+
 import coverage
 import gc
 import inspect
@@ -195,26 +197,28 @@
                      ['ignore-modules', 'i', '', None],
                      ['ignore-paths', 'p', '', None],
                      ['runner', None, 'txrunner', None],
+                     ['temp-directory', None, '_trial_temp', None],
                      ]
 
     def __init__(self, *args, **kwargs):
+        super(BaseTestOptions, self).__init__(*args, **kwargs)
         self['tests'] = set()
-        super(BaseTestOptions, self).__init__(*args, **kwargs)
 
     def opt_help_runners(self):
         """List the runners which are supported."""
+        sys.exit(0)
 
     def opt_ignore_modules(self, option):
         """Comma-separate list of test modules to ignore,
            e.g: test_gtk.py, test_account.py
            """
-        self['ignore-modules'] = map(str.strip, option.split(','))
+        self['ignore-modules'] = map(unicode.strip, option.split(','))
 
     def opt_ignore_paths(self, option):
         """Comma-separated list of relative paths to ignore,
            e.g: tests/platform/windows, tests/platform/macosx
            """
-        self['ignore-paths'] = map(str.strip, option.split(','))
+        self['ignore-paths'] = map(unicode.strip, option.split(','))
 
     def opt_loop(self, option):
         """Loop tests the specified number of times."""
@@ -223,10 +227,23 @@
         except ValueError:
             raise UsageError('A positive integer value must be specified.')
 
+    def opt_temp_directory(self, option):
+        """Path to use as a working directory for tests.
+           [default: _trial_temp]
+           """
+        self['temp-directory'] = option
+
     def opt_test(self, option):
         """Run specific tests, e.g: className.methodName"""
         self['test'] = option
 
+    # We use some camelcase names for trial compatibility here.
+    # pylint: disable=C0103
+    def parseArgs(self, *args):
+        """Handle the extra arguments."""
+        self['tests'].update(args)
+    # pylint: enable=C0103
+
 
 def _get_runner_options(runner_name):
     """Return the test runner module, and its options object."""

=== added file 'ubuntuone/devtools/tests/test_utils.py'
--- ubuntuone/devtools/tests/test_utils.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/tests/test_utils.py	2012-08-13 21:10:25 +0000
@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Test the utils module."""
+
+from __future__ import print_function, unicode_literals
+
+from twisted.internet.defer import inlineCallbacks
+from ubuntuone.devtools.errors import UsageError
+from ubuntuone.devtools.testcases import BaseTestCase
+from ubuntuone.devtools.utils import OptionParser
+
+
+class FakeOptions(OptionParser):
+    """Fake options class for testing."""
+
+    optFlags = [['foo', 'f', 'Save the manatees.'],
+                ['bar', None, 'Beyond all recognition.'],
+                ]
+
+    optParameters = [['stuff', 's', 'things'],
+                     ]
+
+    def __init__(self, *args, **kwargs):
+        super(FakeOptions, self).__init__(*args, **kwargs)
+
+    def opt_foo(self):
+        """Handle the foo flag."""
+        pass
+
+    def opt_stuff(self, option):
+        """Handle the stuff option."""
+        self['stuff'] = option
+
+
+class OptionParserTestCase(BaseTestCase):
+    """Test the OptionParser class."""
+
+    @inlineCallbacks
+    def setUp(self, *args, **kwargs):
+        yield super(OptionParserTestCase, self).setUp(*args, **kwargs)
+        self.options = FakeOptions()
+
+    def test_get_flags_long_arg(self):
+        """Test that getting a flag works properly."""
+        args = ['--foo', 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertTrue(self.options['foo'])
+
+    def test_get_flags_short_arg(self):
+        """Test that using the short version of a flag works."""
+        args = ['-f', 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertTrue(self.options['foo'])
+
+    def test_get_params_combined_arg(self):
+        """Test that getting a parameter works properly."""
+        expected = 'baz'
+        args = ['--stuff=' + expected, 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertEqual(expected, self.options['stuff'])
+
+    def test_get_params_missing_arg(self):
+        """Test that passing no parameter argument fails correctly."""
+        args = ['--stuff']
+        self.assertRaises(UsageError, self.options.parseOptions, options=args)
+
+    def test_get_params_short_arg(self):
+        """Test that using the short version of a parameter works."""
+        expected = 'baz'
+        args = ['-s', expected, 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertEqual(expected, self.options['stuff'])
+
+    def test_get_params_split_arg(self):
+        """Test that passing a parameter argument separately works."""
+        expected = 'baz'
+        args = ['--stuff', expected, 'pathname']
+        self.options.parseOptions(options=args)
+        self.assertEqual(expected, self.options['stuff'])
+
+    def test_unknown_option(self):
+        """Test that passing an unknown option fails."""
+        args = ['--unknown', 'pathname']
+        self.assertRaises(UsageError, self.options.parseOptions, options=args)

=== modified file 'ubuntuone/devtools/utils.py'
--- ubuntuone/devtools/utils.py	2012-08-02 15:43:42 +0000
+++ ubuntuone/devtools/utils.py	2012-08-13 21:10:25 +0000
@@ -26,6 +26,8 @@
 # files in the program, then also delete it here.
 """Utilities for Ubuntu One developer tools."""
 
+from __future__ import print_function, unicode_literals
+
 import getopt
 import sys
 
@@ -63,6 +65,7 @@
         self.short_opts = ''
         self.docs = {}
         self.defaults = {}
+        self.synonyms = {}
         self.dispatch = {}
 
         # Get the options and defaults
@@ -76,6 +79,7 @@
             self.docs.update(docs)
             self.update(defaults)
             self.defaults.update(defaults)
+            self.synonyms.update(syns)
             self.dispatch.update(dispatch)
 
     # We use some camelcase names for trial compatibility here.
@@ -97,11 +101,14 @@
             else:
                 opt = opt[1:]
 
-            if (opt not in self.long_opts and
-                (len(opt) == 1 and opt not in self.short_opts)):
+            if (opt not in self.synonyms.keys()):
                 raise UsageError('No such options: "%s"' % opt)
 
-            self.dispatch[opt](arg)
+            opt = self.synonyms[opt]
+            if self.defaults[opt] is False:
+                self[opt] = True
+            else:
+                self.dispatch[opt](arg)
 
         try:
             self.parseArgs(*args)
@@ -117,13 +124,13 @@
         """Override to handle extra arguments specially."""
     # pylint: enable=C0103
 
-    def _parse_arguments(self, has_default=False):
+    def _parse_arguments(self, arg_type=None, has_default=False):
         """Parse the arguments as either flags or parameters."""
         long_opts, short_opts = [], ''
-        docs, defaults, dispatch = {}, {}, {}
+        docs, defaults, syns, dispatch = {}, {}, {}, {}
 
         _args = []
-        accumulate_list_attr(self.__class__, 'optFlags', _args)
+        accumulate_list_attr(self.__class__, arg_type, _args)
 
         for _arg in _args:
             try:
@@ -149,19 +156,25 @@
                 dispatch[l_opt] = lambda arg: True
 
             defaults[l_opt] = default
-            long_opts.append(l_opt)
+            if has_default:
+                long_opts.append(l_opt + '=')
+            else:
+                long_opts.append(l_opt)
+
+            syns[l_opt] = l_opt
             if s_opt is not None:
                 short_opts = short_opts + s_opt
-                docs[s_opt] = docs[l_opt]
-                dispatch[s_opt] = dispatch[l_opt]
-                defaults[s_opt] = defaults[l_opt]
+                if has_default:
+                    short_opts = short_opts + ':'
+                syns[s_opt] = l_opt
 
-        return long_opts, short_opts, docs, defaults, None, dispatch
+        return long_opts, short_opts, docs, defaults, syns, dispatch
 
     def _get_flags(self):
         """Get the flag options."""
-        return self._parse_arguments(has_default=False)
+        return self._parse_arguments(arg_type='optFlags', has_default=False)
 
     def _get_params(self):
         """Get the parameters options."""
-        return self._parse_arguments(has_default=True)
+        return self._parse_arguments(arg_type='optParameters',
+                                     has_default=True)