Merge lp:~thomir-deactivatedaccount/autopilot/add-launch-command-args into lp:~thomir-deactivatedaccount/autopilot/split-tests

[Thomi Richards]

Pass additional arguments to the 'launch' command to the application launched.

This branch fixes autopilot so you can run:

autopilot launch gnome-control-center credentials

and the "credentals" argument will be passed to the application launched. In order to do this, I moved the parse_arguments code into the autopilot module, and added a full suite of unit tests to ensure it works as we expect.

[lp:~thomir-deactivatedaccount/autopilot/add-launch-command-args]

201. By Thomi Richards on 2013-05-06

PEP8 fixes.

202. By Thomi Richards on 2013-05-06

merged trunk.

Unmerged revisions

202. By Thomi Richards on 2013-05-06

merged trunk.

201. By Thomi Richards on 2013-05-06

PEP8 fixes.

200. By Thomi Richards on 2013-05-06

autopilot launch command now passes remaining arguments to the application itself.

199. By Thomi Richards on 2013-05-06

Fully tested command line argument parsing code.

198. By Thomi Richards on 2013-05-06

command line args parser now accepts application arguments.

197. By Thomi Richards on 2013-05-06

Merged code that splits tests, since we're about to add more test.

196. By Thomi Richards on 2013-05-06

moved the code that specifies command line arguments into the autopilot module, so it can be tested properly.

195. By PS Jenkins bot on 2013-05-06

Releasing 1.3daily13.05.06ubuntu.unity.next-0ubuntu1 to ubuntu.

Approved by PS Jenkins bot.

=== modified file 'autopilot/__init__.py'
--- autopilot/__init__.py	2013-04-23 04:15:54 +0000
+++ autopilot/__init__.py	2013-05-06 23:30:33 +0000
@@ -17,6 +17,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from argparse import ArgumentParser, REMAINDER
 
 version = '1.3'
 
@@ -31,3 +32,84 @@
             + original_exception.message
             )
         self.original_exception = original_exception
+
+
+def parse_arguments(argv=None):
+    """Parse command-line arguments, and return an argparse arguments
+    object.
+    """
+    parser = ArgumentParser(description="Autopilot test tool.")
+    subparsers = parser.add_subparsers(help='Run modes', dest="mode")
+
+    parser_run = subparsers.add_parser('run', help="Run autopilot tests")
+    parser_run.add_argument('-o', "--output", required=False,
+                            help='Write test result report to file.\
+                            Defaults to stdout.\
+                            If given a directory instead of a file will \
+                            write to a file in that directory named: \
+                            <hostname>_<dd.mm.yyy_HHMMSS>.log')
+    parser_run.add_argument('-f', "--format", choices=['text', 'xml'],
+                            default='text',
+                            required=False,
+                            help='Specify desired output format. \
+                            Default is "text".')
+    parser_run.add_argument('-r', '--record', action='store_true',
+                            default=False, required=False,
+                            help="Record failing tests. Required \
+                            'recordmydesktop' app to be installed.\
+                            Videos are stored in /tmp/autopilot.")
+    parser_run.add_argument("-rd", "--record-directory", required=False,
+                            default="/tmp/autopilot", type=str,
+                            help="Directory to put recorded tests \
+                            (only if -r) specified.")
+    parser_run.add_argument('-v', '--verbose', default=False, required=False,
+                            action='count',
+                            help="If set, autopilot will output test log data \
+                            to stderr during a test run. Set twice to also log \
+                            data useful for debugging autopilot itself.")
+    parser_run.add_argument("suite", nargs="+",
+                            help="Specify test suite(s) to run.")
+
+    parser_list = subparsers.add_parser('list', help="List autopilot tests")
+    parser_list.add_argument("-ro", "--run-order", required=False, default=False,
+                            action="store_true",
+                            help="List tests in run order, rather than alphabetical \
+                            order (the default).")
+    parser_list.add_argument("suite", nargs="+",
+                             help="Specify test suite(s) to run.")
+
+    if have_vis():
+        parser_vis = subparsers.add_parser('vis',
+                                          help="Open the Autopilot visualiser tool")
+        parser_vis.add_argument('-v', '--verbose', required=False, default=False,
+                                action='count', help="Show autopilot log messages. \
+                                Set twice to also log data useful for debugging \
+                                autopilot itself.")
+
+    parser_launch = subparsers.add_parser('launch',
+                            help="Launch an application with introspection enabled")
+    parser_launch.add_argument('-i', '--interface',
+                            choices=('Gtk', 'Qt', 'Auto'), default='Auto',
+                            help="Specify which introspection interface to load. \
+                            The default ('Auto') uses ldd to try and detect which \
+                            interface to load.")
+    parser_launch.add_argument('-v', '--verbose', required=False, default=False,
+                            action='count', help="Show autopilot log messages. \
+                            Set twice to also log data useful for debugging \
+                            autopilot itself.")
+    parser_launch.add_argument('application', nargs=REMAINDER, type=str,
+                            help="The application to launch. Can be a full path, \
+                            or just an application name (in which case Autopilot \
+                                will search for it in $PATH).")
+    args = parser.parse_args(args=argv)
+
+    return args
+
+
+def have_vis():
+    """Return true if the vis package is installed."""
+    try:
+        from autopilot.vis import vis_main
+        return True
+    except ImportError:
+        return False

=== added file 'autopilot/tests/unit/test_command_line_args.py'
--- autopilot/tests/unit/test_command_line_args.py	1970-01-01 00:00:00 +0000
+++ autopilot/tests/unit/test_command_line_args.py	2013-05-06 23:30:33 +0000
@@ -0,0 +1,234 @@
+#!/usr/bin/env python
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2012-2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY 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/>.
+#
+
+
+"Unit tests for the command line parser in autopilot."
+
+
+from mock import patch
+from StringIO import StringIO
+from testtools import TestCase
+from testtools.matchers import Equals
+from unittest import expectedFailure
+
+from autopilot import parse_arguments
+
+
+class CommandLineArgsTests(TestCase):
+
+    def parse_args(self, args):
+        if isinstance(args, basestring):
+            args = args.split()
+        try:
+            return parse_arguments(args)
+        except SystemExit as e:
+            self.fail("Caught exception: %r" % e)
+
+    def test_launch_command_accepts_application(self):
+        args = self.parse_args("launch app")
+        self.assertThat(args.mode, Equals("launch"))
+
+    def test_launch_command_has_correct_default_interface(self):
+        args = self.parse_args("launch app")
+        self.assertThat(args.interface, Equals("Auto"))
+
+    def test_launch_command_can_specify_Qt_interface(self):
+        args = self.parse_args("launch -i Qt app")
+        self.assertThat(args.interface, Equals("Qt"))
+
+    def test_launch_command_can_specify_Gtk_interface(self):
+        args = self.parse_args("launch -i Gtk app")
+        self.assertThat(args.interface, Equals("Gtk"))
+
+    @patch('sys.stderr', new=StringIO())
+    @expectedFailure
+    def test_launch_command_fails_on_unknown_interface(self):
+        self.parse_args("launch -i unknown app")
+
+    def test_launch_command_has_correct_default_verbosity(self):
+        args = self.parse_args("launch app")
+        self.assertThat(args.verbose, Equals(False))
+
+    def test_launch_command_can_specify_verbosity(self):
+        args = self.parse_args("launch -v app")
+        self.assertThat(args.verbose, Equals(1))
+
+    def test_launch_command_can_specify_extra_verbosity(self):
+        args = self.parse_args("launch -vv app")
+        self.assertThat(args.verbose, Equals(2))
+        args = self.parse_args("launch -v -v app")
+        self.assertThat(args.verbose, Equals(2))
+
+    def test_launch_command_stores_application(self):
+        args = self.parse_args("launch app")
+        self.assertThat(args.application, Equals(["app"]))
+
+    def test_launch_command_stores_application_with_args(self):
+        args = self.parse_args("launch app arg1 arg2")
+        self.assertThat(args.application, Equals(["app", "arg1", "arg2"]))
+
+    def test_launch_command_accepts_different_app_arg_formats(self):
+        args = self.parse_args("launch app -s --long --key=val arg1 arg2")
+        self.assertThat(args.application,
+            Equals(["app", "-s", "--long", "--key=val", "arg1", "arg2"]))
+
+    @patch('autopilot.have_vis', new=lambda: True)
+    def test_vis_present_when_vis_module_installed(self):
+        args = self.parse_args('vis')
+        self.assertThat(args.mode, Equals("vis"))
+
+    @patch('autopilot.have_vis', new=lambda: False)
+    @patch('sys.stderr', new=StringIO())
+    @expectedFailure
+    def test_vis_not_present_when_vis_module_not_installed(self):
+        self.parse_args('vis')
+
+    @patch('autopilot.have_vis', new=lambda: True)
+    def test_vis_default_verbosity(self):
+        args = self.parse_args('vis')
+        self.assertThat(args.verbose, Equals(False))
+
+    @patch('autopilot.have_vis', new=lambda: True)
+    def test_vis_single_verbosity(self):
+        args = self.parse_args('vis -v')
+        self.assertThat(args.verbose, Equals(1))
+
+    @patch('autopilot.have_vis', new=lambda: True)
+    def test_vis_double_verbosity(self):
+        args = self.parse_args('vis -vv')
+        self.assertThat(args.verbose, Equals(2))
+        args = self.parse_args('vis -v -v')
+        self.assertThat(args.verbose, Equals(2))
+
+    def test_list_mode(self):
+        args = self.parse_args('list foo')
+        self.assertThat(args.mode, Equals("list"))
+
+    def test_list_mode_accepts_suite_name(self):
+        args = self.parse_args('list foo')
+        self.assertThat(args.suite, Equals(["foo"]))
+
+    def test_list_mode_accepts_many_suite_names(self):
+        args = self.parse_args('list foo bar baz')
+        self.assertThat(args.suite, Equals(["foo", "bar", "baz"]))
+
+    def test_list_run_order_long_option(self):
+        args = self.parse_args('list --run-order foo')
+        self.assertThat(args.run_order, Equals(True))
+
+    def test_list_run_order_short_option(self):
+        args = self.parse_args('list -ro foo')
+        self.assertThat(args.run_order, Equals(True))
+
+    def test_list_no_run_order(self):
+        args = self.parse_args('list foo')
+        self.assertThat(args.run_order, Equals(False))
+
+    def test_run_mode(self):
+        args = self.parse_args('run foo')
+        self.assertThat(args.mode, Equals("run"))
+
+    def test_run_mode_accepts_suite_name(self):
+        args = self.parse_args('run foo')
+        self.assertThat(args.suite, Equals(["foo"]))
+
+    def test_run_mode_accepts_many_suite_names(self):
+        args = self.parse_args('run foo bar baz')
+        self.assertThat(args.suite, Equals(["foo", "bar", "baz"]))
+
+    def test_run_command_default_output(self):
+        args = self.parse_args('run foo')
+        self.assertThat(args.output, Equals(None))
+
+    def test_run_command_path_output_short(self):
+        args = self.parse_args('run -o /path/to/file foo')
+        self.assertThat(args.output, Equals("/path/to/file"))
+
+    def test_run_command_path_output_long(self):
+        args = self.parse_args('run --output ../file foo')
+        self.assertThat(args.output, Equals("../file"))
+
+    def test_run_command_default_format(self):
+        args = self.parse_args('run foo')
+        self.assertThat(args.format, Equals("text"))
+
+    def test_run_command_text_format_short_version(self):
+        args = self.parse_args('run -f text foo')
+        self.assertThat(args.format, Equals("text"))
+
+    def test_run_command_text_format_long_version(self):
+        args = self.parse_args('run --format text foo')
+        self.assertThat(args.format, Equals("text"))
+
+    def test_run_command_xml_format_short_version(self):
+        args = self.parse_args('run -f xml foo')
+        self.assertThat(args.format, Equals("xml"))
+
+    def test_run_command_xml_format_long_version(self):
+        args = self.parse_args('run --format xml foo')
+        self.assertThat(args.format, Equals("xml"))
+
+    @patch('sys.stderr', new=StringIO())
+    @expectedFailure
+    def test_run_command_unknown_format_short_version(self):
+        self.parse_args('run -f unknown foo')
+
+    @patch('sys.stderr', new=StringIO())
+    @expectedFailure
+    def test_run_command_unknown_format_long_version(self):
+        self.parse_args('run --format unknown foo')
+
+    def test_run_command_record_flag_default(self):
+        args = self.parse_args("run foo")
+        self.assertThat(args.record, Equals(False))
+
+    def test_run_command_record_flag_short(self):
+        args = self.parse_args("run -r foo")
+        self.assertThat(args.record, Equals(True))
+
+    def test_run_command_record_flag_long(self):
+        args = self.parse_args("run --record foo")
+        self.assertThat(args.record, Equals(True))
+
+    def test_run_command_record_dir_flag_default(self):
+        args = self.parse_args("run foo")
+        self.assertThat(args.record_directory, Equals("/tmp/autopilot"))
+
+    def test_run_command_record_dir_flag_short(self):
+        args = self.parse_args("run -rd /path/to/dir foo")
+        self.assertThat(args.record_directory, Equals("/path/to/dir"))
+
+    def test_run_command_record_dir_flag_long(self):
+        args = self.parse_args("run --record-directory /path/to/dir foo")
+        self.assertThat(args.record_directory, Equals("/path/to/dir"))
+
+    def test_run_default_verbosity(self):
+        args = self.parse_args('run foo')
+        self.assertThat(args.verbose, Equals(False))
+
+    def test_run_single_verbosity(self):
+        args = self.parse_args('run -v foo')
+        self.assertThat(args.verbose, Equals(1))
+
+    def test_run_double_verbosity(self):
+        args = self.parse_args('run -vv foo')
+        self.assertThat(args.verbose, Equals(2))
+        args = self.parse_args('run -v -v foo')
+        self.assertThat(args.verbose, Equals(2))

=== modified file 'bin/autopilot'
--- bin/autopilot	2013-05-02 22:24:57 +0000
+++ bin/autopilot	2013-05-06 23:30:33 +0000
@@ -39,8 +39,6 @@
 import subprocess
 from testtools import iterate_tests
 from testtools import TextTestResult
-from textwrap import dedent
-from argparse import ArgumentParser
 from unittest.loader import TestLoader
 from unittest import TestSuite
 
@@ -48,80 +46,6 @@
 _output_stream=None
 
 
-def parse_arguments():
-    """Parse command-line arguments, and return an argparse arguments
-    object.
-    """
-    parser = ArgumentParser(description=dedent("""\
-        Autopilot test tool.
-        """))
-    subparsers = parser.add_subparsers(help='Run modes', dest="mode")
-
-    parser_run = subparsers.add_parser('run', help="Run autopilot tests")
-    parser_run.add_argument('-o', "--output", required=False,
-                            help='Write test result report to file.\
-                            Defaults to stdout.\
-                            If given a directory instead of a file will \
-                            write to a file in that directory named: \
-                            <hostname>_<dd.mm.yyy_HHMMSS>.log')
-    parser_run.add_argument('-f', "--format", choices=['text', 'xml'],
-                            default='text',
-                            required=False,
-                            help='Specify desired output format. \
-                            Default is "text".')
-    parser_run.add_argument('-r', '--record', action='store_true',
-                            default=False, required=False,
-                            help="Record failing tests. Required \
-                            'recordmydesktop' app to be installed.\
-                            Videos are stored in /tmp/autopilot.")
-    parser_run.add_argument("-rd", "--record-directory", required=False,
-                            default="/tmp/autopilot", type=str,
-                            help="Directory to put recorded tests \
-                            (only if -r) specified.")
-    parser_run.add_argument('-v', '--verbose', default=False, required=False,
-                            action='count',
-                            help="If set, autopilot will output test log data \
-                            to stderr during a test run. Set twice to also log \
-                            data useful for debugging autopilot itself.")
-    parser_run.add_argument("suite", nargs="+",
-                            help="Specify test suite(s) to run.")
-
-    parser_list = subparsers.add_parser('list', help="List autopilot tests")
-    parser_list.add_argument("-ro", "--run-order", required=False, default=False,
-                            action="store_true",
-                            help="List tests in run order, rather than alphabetical \
-                            order (the default).")
-    parser_list.add_argument("suite", nargs="+",
-                             help="Specify test suite(s) to run.")
-
-    if have_vis():
-        parser_vis = subparsers.add_parser('vis',
-                                          help="Open the Autopilot visualiser tool")
-        parser_vis.add_argument('-v', '--verbose', required=False, default=False,
-                                action='count', help="Show autopilot log messages. \
-                                Set twice to also log data useful for debugging \
-                                autopilot itself.")
-
-    parser_launch = subparsers.add_parser('launch',
-                            help="Launch an application with introspection enabled")
-    parser_launch.add_argument('-i', '--interface',
-                            choices=('Gtk', 'Qt', 'Auto'), default='Auto',
-                            help="Specify which introspection interface to load. \
-                            The default ('Auto') uses ldd to try and detect which \
-                            interface to load.")
-    parser_launch.add_argument('-v', '--verbose', required=False, default=False,
-                            action='count', help="Show autopilot log messages. \
-                            Set twice to also log data useful for debugging \
-                            autopilot itself.")
-    parser_launch.add_argument('application', nargs=1, type=str,
-                            help="The application to launch. Can be a full path, \
-                            or just an application name (in which case Autopilot \
-                                will search for it in $PATH).")
-    args = parser.parse_args()
-
-    return args
-
-
 def list_tests(args):
     """Print a list of tests we find inside autopilot.tests."""
     num_tests = 0
@@ -341,21 +265,12 @@
         exit(1)
 
     try:
-        launch_application(launcher, app_name, capture_output=False)
+        launch_application(launcher, *args.application, capture_output=False)
     except RuntimeError as e:
         print "Error: " + e.message
         exit(1)
 
 
-def have_vis():
-    """Return true if the vis package is installed."""
-    try:
-        from autopilot.vis import vis_main
-        return True
-    except ImportError:
-        return False
-
-
 def run_vis(args):
     setup_logging(args.verbose)
     # importing this requires that DISPLAY is set. Since we don't always want
@@ -374,6 +289,7 @@
 
 
 def main():
+    from autopilot import parse_arguments
     args = parse_arguments()
     if args.mode == 'list':
         list_tests(args)

=== modified file 'debian/changelog'
--- debian/changelog	2013-05-03 00:01:17 +0000
+++ debian/changelog	2013-05-06 23:30:33 +0000
@@ -1,3 +1,9 @@
+autopilot (1.3daily13.05.06ubuntu.unity.next-0ubuntu1) raring; urgency=low
+
+  * Automatic snapshot from revision 194 (ubuntu-unity/next)
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 06 May 2013 00:01:03 +0000
+
 autopilot (1.3daily13.05.03ubuntu.unity.next-0ubuntu1) raring; urgency=low
 
   [ Thomi Richards ]

=== modified file 'debian/control'
--- debian/control	2013-05-05 21:22:50 +0000
+++ debian/control	2013-05-06 23:30:33 +0000
@@ -60,6 +60,7 @@
          gir1.2-ibus-1.0,
          python-autopilot,
          python-xlib,
+Recommends: python-autopilot-vis,
 Description: Autopilot support for the ubuntu Desktop platform
  This metapackage exists to depend on the packages needed to install and use
  autopilot on the Ubuntu Desktop platform.