Add AMP support to test runner.

build/android/test_runner.py

 #!/usr/bin/env python
 #
 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs all types of tests from one unified interface."""
 
 import argparse
 import collections
@@ skipping 101 matching lines @@
   if args.output_directory:
     constants.SetOutputDirectort(args.output_directory)
   if args.adb_path:
     constants.SetAdbPath(args.adb_path)
   # Some things such as Forwarder require ADB to be in the environment path.
   adb_dir = os.path.dirname(constants.GetAdbPath())
   if adb_dir and adb_dir not in os.environ['PATH'].split(os.pathsep):
     os.environ['PATH'] = adb_dir + os.pathsep + os.environ['PATH']
 
 
+def AddRemoteDeviceOptions(parser):
+  group = parser.add_argument_group('Remote Device Options')
+
+  group.add_argument('--trigger', default='',
+                   help=('Only triggers the test if set. Stores test_run_id '
+                         'in given file path. '))
+  group.add_argument('--collect', default='',
+                   help=('Only collects the test results if set. '
+                         'Gets test_run_id from given file path.'))
+  group.add_argument('--remote-device', default='Nexus 5',
+                   help=('Device type to run test on.'))
+  group.add_argument('--remote-device-os', default='4.4.2',
+                   help=('OS to have on the device.'))
+  group.add_argument('--results-path', default='',
+                   help=('File path to download results to.'))
+  group.add_argument('--api-protocol', default='http',
+                   help=('HTTP protocol to use. (http or https)'))
+  group.add_argument('--api-address', default='172.22.21.180',
+                   help=('Address to send HTTP requests.'))
+  group.add_argument('--api-port', default='80',
+                   help=('Port to send HTTP requests to.'))
+  group.add_argument('--runner-type', default='',
+                   help=('Type of test to run as.'))
+  group.add_argument('--runner-package', default='',
+                   help=('Package name of test.'))
+  group.add_argument('--apk-under-test', default='apks/Chrome.apk',
+                   help=('APK to run tests on.'))
+
+  api_secret_group = group.add_mutually_exclusive_group()
+  api_secret_group.add_argument('--api-secret', default='',
+                   help=('API secret for remote devices.'))
+  api_secret_group.add_argument('--api-secret-file', default='',
+                   help=('Path to file that contains API secret.'))
+
+  api_key_group = group.add_mutually_exclusive_group()
+  api_key_group.add_argument('--api-key', default='',
+                   help=('API key for remote devices.'))
+  api_key_group.add_argument('--api-key-file', default='',
+                   help=('Path to file that contains API key.'))
+
+
 def AddDeviceOptions(parser):
   """Adds device options to |parser|."""
   group = parser.add_argument_group(title='Device Options')
   group.add_argument('-c', dest='cleanup_test_files',
                      help='Cleanup test files on the device after run',
                      action='store_true')
   group.add_argument('--tool',
                      dest='tool',
                      help=('Run the test under a tool '
                            '(use --tool help to list them)'))
@@ skipping 27 matching lines @@
   group.add_argument('-t', dest='timeout', type=int, default=60,
                      help='Timeout to wait for each test '
                           '(default: %(default)s).')
   group.add_argument('--isolate_file_path',
                      '--isolate-file-path',
                      dest='isolate_file_path',
                      help='.isolate file path to override the default '
                           'path')
   AddDeviceOptions(parser)
   AddCommonOptions(parser)
+  AddRemoteDeviceOptions(parser)
 
 
 def AddLinkerTestOptions(parser):
   group = parser.add_argument_group('Linker Test Options')
   group.add_argument('-f', '--gtest-filter', dest='test_filter',
                      help='googletest-style filter string.')
   AddCommonOptions(parser)
   AddDeviceOptions(parser)
 
 
@@ skipping 240 matching lines @@
       '--seed', type=int,
       help=('Seed value for pseudo-random generator. Same seed value generates '
             'the same sequence of events. Seed is randomized by default.'))
   group.add_argument(
       '--extra-args', default='',
       help=('String of other args to pass to the command verbatim.'))
 
   AddCommonOptions(parser)
   AddDeviceOptions(parser)
 
-
 def ProcessMonkeyTestOptions(args):
   """Processes all monkey test options.
 
   Args:
     args: argparse.Namespace object.
 
   Returns:
     A MonkeyOptions named tuple which contains all options relevant to
     monkey tests.
   """
   # TODO(jbudorick): Handle this directly in argparse with nargs='+'
   category = args.category
   if category:
     category = args.category.split(',')
 
   # TODO(jbudorick): Get rid of MonkeyOptions.
   return monkey_test_options.MonkeyOptions(
       args.verbose_count,
       args.package,
       args.event_count,
       category,
       args.throttle,
       args.seed,
       args.extra_args)
 
+def AddUirobotTestOptions(parser):
+  """Adds uirobot test options to |option_parser|."""
+  group = parser.add_argument_group('Uirobot Test Options')
+
+  group.add_argument(
+      '--minutes', default=5, type=int,
+      help='Number of minutes to run uirobot test [default: %default].')
+
+  AddCommonOptions(parser)
+  AddDeviceOptions(parser)
+  AddRemoteDeviceOptions(parser)
 
 def AddPerfTestOptions(parser):
   """Adds perf test options to |parser|."""
 
   group = parser.add_argument_group('Perf Test Options')
 
   class SingleStepAction(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
       if values and not namespace.single_step:
         parser.error('single step command provided, '
@@ skipping 340 matching lines @@
 
   Raises:
     Exception: Unknown command name passed in, or an exception from an
         individual test runner.
   """
   command = args.command
 
   ProcessCommonOptions(args)
 
   if args.enable_platform_mode:
-    return RunTestsInPlatformMode(args, parser.error)
+    return RunTestsInPlatformMode(args, parser)
 
   if command in constants.LOCAL_MACHINE_TESTS:
     devices = []
   else:
     devices = _GetAttachedDevices(args.test_device)
 
   forwarder.Forwarder.RemoveHostLog()
   if not ports.ResetTestServerPortAllocation():
     raise Exception('Failed to reset test server port.')
 
@@ skipping 12 matching lines @@
   elif command == 'perf':
     return _RunPerfTests(args)
   elif command == 'python':
     return _RunPythonTests(args)
   else:
     raise Exception('Unknown test type.')
 
 
 _SUPPORTED_IN_PLATFORM_MODE = [
   # TODO(jbudorick): Add support for more test types.
-  'gtest',
+  'gtest', 'uirobot',
 ]
 
 
 def RunTestsInPlatformMode(args, parser):
 
   if args.command not in _SUPPORTED_IN_PLATFORM_MODE:
     parser.error('%s is not yet supported in platform mode' % args.command)
 
   with environment_factory.CreateEnvironment(args, parser.error) as env:
     with test_instance_factory.CreateTestInstance(args, parser.error) as test:
       with test_run_factory.CreateTestRun(
           args, env, test, parser.error) as test_run:
         results = test_run.RunTests()
 
+        if args.trigger:
+          return 0 # Not returning results, only triggering.
+
         report_results.LogFull(
             results=results,
             test_type=test.TestType(),
             test_package=test_run.TestPackage(),
             annotation=getattr(args, 'annotations', None),
             flakiness_server=getattr(args, 'flakiness_dashboard_server', None))
 
         if args.json_results_file:
           json_results.GenerateJsonResultsFile(
               results, args.json_results_file)
 
-  return results
+  return 0 if results.DidRunPass() else 1
 
 
 CommandConfigTuple = collections.namedtuple(
     'CommandConfigTuple',
     ['add_options_func', 'help_txt'])
 VALID_COMMANDS = {
     'gtest': CommandConfigTuple(
         AddGTestOptions,
         'googletest-based C++ tests'),
     'instrumentation': CommandConfigTuple(
@@ skipping 10 matching lines @@
         "Tests based on Android's monkey"),
     'perf': CommandConfigTuple(
         AddPerfTestOptions,
         'Performance tests'),
     'python': CommandConfigTuple(
         AddPythonTestOptions,
         'Python tests based on unittest.TestCase'),
     'linker': CommandConfigTuple(
         AddLinkerTestOptions,
         'Linker tests'),
+    'uirobot': CommandConfigTuple(
+        AddUirobotTestOptions,
+        'Uirobot test'),
 }
 
 
 def DumpThreadStacks(_signal, _frame):
   for thread in threading.enumerate():
     reraiser_thread.LogThreadStack(thread)
 
 
 def main():
   signal.signal(signal.SIGUSR1, DumpThreadStacks)
 
   parser = argparse.ArgumentParser()
   command_parsers = parser.add_subparsers(title='test types',
                                           dest='command')
 
   for test_type, config in sorted(VALID_COMMANDS.iteritems(),
                                   key=lambda x: x[0]):
     subparser = command_parsers.add_parser(
         test_type, usage='%(prog)s [options]', help=config.help_txt)
     config.add_options_func(subparser)
 
   args = parser.parse_args()
   return RunTestsCommand(args, parser)
 
 
 if __name__ == '__main__':
   sys.exit(main())