[Android] Add sharding for AMP instrumentation tests.

build/android/pylib/remote/device/remote_device_uirobot_test_run.py

 # Copyright 2014 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.
 
 """Run specific test on specific environment."""
 
 import logging
 
+from devil.utils import reraiser_thread
 from pylib.base import base_test_result
 from pylib.remote.device import appurify_sanitized
 from pylib.remote.device import remote_device_test_run
 from pylib.remote.device import remote_device_helper
 
 
 class RemoteDeviceUirobotTestRun(remote_device_test_run.RemoteDeviceTestRun):
   """Run uirobot tests on a remote device."""
 
 
   def __init__(self, env, test_instance):
     """Constructor.
 
     Args:
       env: Environment the tests will run in.
       test_instance: The test that will be run.
     """
     super(RemoteDeviceUirobotTestRun, self).__init__(env, test_instance)
 
   #override
+  def _GetAppPath(self):
+    return self._test_instance.app_under_test
+
+  #override
+  def _GetTestFramework(self):
+    if self._env.test_framework:
+      return self._env.test_framework
+    elif self._env.device_type == 'Android':
+      return 'android_robot'
+    elif self._env.device_type == 'iOS':
+      return 'ios_robot'
+    else:
+      raise remote_device_helper.RemoteDeviceError(
+          'Unknown device type: %s' % self._env.device_type)
+
+  #override
+  def _ShouldShard(self):
+    return False
+
+  #override
+  def _SetupTestShards(self, num_shards):
+    test_ids = []
+    framework_configs = {'duration': self._test_instance.minutes}
+
+    def upload_test_shards():
+      test_id = self._UploadTestToDevice(None)
+      self._UploadTestConfigToDevice(
+          test_id, framework_configs, self._appurify_configs)
+      test_ids.append(test_id)
+
+    workers = reraiser_thread.ReraiserThreadGroup(

[rnephew (Wrong account), 2015/11/04 22:22:03]

Since _ShouldShard() returns False, is it necessary to do this?
Another thought, there seems to be a lot of boilerplate code around the reraiser
threads in all the test runs; is there a way to extract into into a function and
move it up to 'remote_device_test_run.py'? That might make less sense than the
current way its being done, just a thought.

[mikecase (-- gone --), 2015/11/05 23:17:41]

Yeah, I'll add a RunThreadsSync function to reraiser_threads.py that takes a
list of reraiser threads and just creates a ThreadGroup, calls StartAll and then
calls JoinAll. This will remove lots of the boilerplate.

And since ShouldShard is False, no this is not neccessary. This is also not
necessary for the gtest_test_run. Removing the thread nonsense for those.

+        [reraiser_thread.ReraiserThread(
+            upload_test_shards,
+            name='upload test shard %d' % i)
+         for i in xrange(num_shards)])
+    workers.StartAll()
+    workers.JoinAll()
+    return test_ids
+
+  #override
   def TestPackage(self):
     return self._test_instance.package_name
 
-  #override
-  def _TriggerSetUp(self):
-    """Set up the triggering of a test run."""
-    logging.info('Triggering test run.')
-
-    if self._env.device_type == 'Android':
-      default_runner_type = 'android_robot'
-    elif self._env.device_type == 'iOS':
-      default_runner_type = 'ios_robot'
-    else:
-      raise remote_device_helper.RemoteDeviceError(
-          'Unknown device type: %s' % self._env.device_type)
-
-    self._app_id = self._UploadAppToDevice(self._test_instance.app_under_test)
-    if not self._env.runner_type:
-      runner_type = default_runner_type
-      logging.info('Using default runner type: %s', default_runner_type)
-    else:
-      runner_type = self._env.runner_type
-
-    self._test_id = self._UploadTestToDevice(
-        'android_robot', None, app_id=self._app_id)
-    config_body = {'duration': self._test_instance.minutes}
-    self._SetTestConfig(runner_type, config_body)
-
-
   # TODO(rnephew): Switch to base class implementation when supported.
   #override
-  def _UploadTestToDevice(self, test_type, test_path, app_id=None):
-    if test_path:
-      logging.info("Ignoring test path.")
+  def _UploadTestToDevice(self, test_path):
     data = {
-        'access_token':self._env.token,
-        'test_type':test_type,
-        'app_id':app_id,
+        'access_token': self._env.token,
+        'test_type': self._GetTestFramework(),
+        'app_id': self._app_id,
     }
     with appurify_sanitized.SanitizeLogging(self._env.verbose_count,
                                             logging.WARNING):
-      test_upload_res = appurify_sanitized.utils.post('tests/upload',
-                                                      data, None)
-    remote_device_helper.TestHttpResponse(
-        test_upload_res, 'Unable to get UiRobot test id.')
-    return test_upload_res.json()['response']['test_id']
+      test_upload_response = appurify_sanitized.utils.post(
+          resource='tests/upload', data=data, files=None)
+    remote_device_helper.TestHttpResponse(test_upload_response,
+                                          'Unable to get UiRobot test id.')
+    return test_upload_response.json()['response']['test_id']
 
   #override
-  def _ParseTestResults(self):
+  def _ParseTestResults(self, test_output, results_zip):
     logging.info('Parsing results from remote service.')
     results = base_test_result.TestRunResults()
-    if self._results['results']['pass']:
+    if test_output['results']['pass']:
       result_type = base_test_result.ResultType.PASS
     else:
       result_type = base_test_result.ResultType.FAIL
     results.AddResult(base_test_result.BaseTestResult('uirobot', result_type))
+    remote_device_test_run.DetectPlatformErrors(
+        results, test_output, results_zip)
     return results