[Android] Converts host driven tests to common test_dispatcher

build/android/pylib/host_driven/instrumentation_test_base.py

-# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Copyright (c) 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.
 
-"""Base class for Android Python-driven tests.
+"""Base class for Android Python-driven instrumentation tests.
 
-This test case is intended to serve as the base class for any Python-driven
-tests. It is similar to the Python unitttest module in that the user's tests
-inherit from this case and add their tests in that case.
-
-When a PythonTestBase object is instantiated, its purpose is to run only one of
-its tests. The test runner gives it the name of the test the instance will
-run. The test runner calls SetUp with the Android device ID which the test will
-run against. The runner runs the test method itself, collecting the result,
-and calls TearDown.
-
-Tests can basically do whatever they want in the test methods, such as call
-Java tests using _RunJavaTests. Those methods have the advantage of massaging
-the Java test results into Python test results.
+This test case serves as the base class for any test cases which intend
+to run instrumentation tests. It provides a constructor which accepts
+the relevant options and stores them in object variables.
 """
 
-import logging
 import os
 import time
 
-from pylib import android_commands
 from pylib.base import base_test_result
 from pylib.instrumentation import test_package
 from pylib.instrumentation import test_result
 from pylib.instrumentation import test_runner
 
+import python_test_base
 
 # aka the parent of com.google.android
 BASE_ROOT = 'src' + os.sep
 
 
-class PythonTestBase(object):
-  """Base class for Python-driven tests."""
+class InstrumentationPythonTestBase(python_test_base.PythonTestBase):

[bulach, 2013/07/23 17:27:52]

hehe, everytime I look into "host-driven" or "python-test" my head hurts big
time. :)
in that spirit, a request, since we're renaming it anyways:

1) this class is Instrumentation"Python"TestBase and the file is just
instrumentation_test_base.py...

2) if we're going to split this so that the host-driven tests will aggregate
rather then being one, then this should probably be called
"HostDrivenInstrumentationHelper", or something..


I guess my question is: what is a PythonTestBase and what is a
InstrumentationPythonTestBase?

can we get away with just PythonTestBase, and if the test needs to run
instrumentation, it'll create a "HostDrivenInstrumentationHelper"? having two
base-classes seem a bit confusing, and also "instrumentationpython" doesn't make
much sense..

[gkanwar1, 2013/07/23 18:38:55]

So the reason we need a new class to derive from is that somehow these tests
need to get the extra instrumentation args, either though __init__ or Setup.
I've chosen to pass them in through __init__ here, since they don't change based
on the device/shard_index. This new class doesn't need to be called a "base
class" though, so...

What I'm going to do in terms of cleaning this up is:
* Rename InstrumentationPythonTestBase --> HostDrivenInstrumentationTest,
instrumentation_test_base.py --> instrumentation_test.py, python_test_base.py
--> test_base.py to match.
* Since searching directories for host-driven tests is specific to host-driven
instrumentation tests only, I will change the functions in setup.py to be a
little more specific to this.

[frankf, 2013/07/24 01:04:55]

I think we should follow the accepted python unittest terminology. So the
inhertance would be:

unittest.TestCase < hostDrivenTestCase < xxxHostDrivenTestCase

On 2013/07/23 18:38:55, gkanwar1 wrote:

[gkanwar1, 2013/07/24 17:38:04]

Done.

+  """Base class for Python-driven instrumentation tests.
 
-  def __init__(self, test_name):
-    # test_name must match one of the test methods defined on a subclass which
-    # inherits from this class.
-    # It's stored so we can do the attr lookup on demand, allowing this class
-    # to be pickled, a requirement for the multiprocessing module.
-    self.test_name = test_name
-    class_name = self.__class__.__name__
-    self.qualified_name = class_name + '.' + self.test_name
+  Args:
+    test_name: The name of the method to run as the test.
+    test_apk_path: Path to the test apk file.
+    test_apk_jar_path: Path to the accompanying jar file.
+    other args: All passed through to the instrumentation test runner. See the
+        test runner docs for details.
+  """
 
-  def SetUp(self, options):
-    self.options = options
-    self.shard_index = self.options.shard_index
-    self.device_id = self.options.device_id
-    self.adb = android_commands.AndroidCommands(self.device_id)
-    self.ports_to_forward = []
-
-  def TearDown(self):
-    pass
-
-  def GetOutDir(self):
-    return os.path.join(os.environ['CHROME_SRC'], 'out',
-        self.options.build_type)
-
-  def Run(self):
-    logging.warning('Running Python-driven test: %s', self.test_name)
-    return getattr(self, self.test_name)()
+  def __init__(self, test_name, test_apk_path, test_apk_jar_path,
+               test_data, install_apk, save_perf_json, screenshot_failures,
+               tool, wait_for_debugger, disable_assertions):
+    super(InstrumentationPythonTestBase, self).__init__(test_name)
+    self.test_apk_path = test_apk_path
+    self.test_apk_jar_path = test_apk_jar_path
+    self.test_data = test_data
+    self.install_apk = install_apk
+    self.save_perf_json = save_perf_json
+    self.screenshot_failures = screenshot_failures
+    self.wait_for_debugger = wait_for_debugger
+    self.tool = tool
+    self.disable_assertions = disable_assertions
 
   def _RunJavaTest(self, fname, suite, test):
     """Runs a single Java test with a Java TestRunner.
 
     Args:
       fname: filename for the test (e.g. foo/bar/baz/tests/FooTest.py)
       suite: name of the Java test suite (e.g. FooTest)
       test: name of the test method to run (e.g. testFooBar)
 
     Returns:
       TestRunResults object with a single test result.
     """
     test = self._ComposeFullTestName(fname, suite, test)
     test_pkg = test_package.TestPackage(
-        self.options.test_apk_path, self.options.test_apk_jar_path)
-    java_test_runner = test_runner.TestRunner(self.options.build_type,
-                                              self.options.test_data,
-                                              self.options.install_apk,
-                                              self.options.save_perf_json,
-                                              self.options.screenshot_failures,
-                                              self.options.tool,
-                                              self.options.wait_for_debugger,
-                                              self.options.disable_assertions,
-                                              self.options.push_deps,
-                                              self.options.cleanup_test_files,
+        self.test_apk_path, self.test_apk_jar_path)
+    java_test_runner = test_runner.TestRunner(self.build_type,
+                                              self.test_data,
+                                              self.install_apk,
+                                              self.save_perf_json,
+                                              self.screenshot_failures,
+                                              self.tool,
+                                              self.wait_for_debugger,
+                                              self.disable_assertions,
+                                              self.push_deps,
+                                              self.cleanup_test_files,
                                               self.device_id,
-                                              self.shard_index, test_pkg,
-                                              self.ports_to_forward)
+                                              self.shard_index, test_pkg, [])
     try:
       java_test_runner.SetUp()
       return java_test_runner.RunTest(test)[0]
     finally:
       java_test_runner.TearDown()
 
   def _RunJavaTests(self, fname, tests):
     """Calls a list of tests and stops at the first test failure.
 
     This method iterates until either it encounters a non-passing test or it
@@ skipping 31 matching lines @@
 
   def _ComposeFullTestName(self, fname, suite, test):
     package_name = self._GetPackageName(fname)
     return package_name + '.' + suite + '#' + test
 
   def _GetPackageName(self, fname):
     """Extracts the package name from the test file path."""
     dirname = os.path.dirname(fname)
     package = dirname[dirname.rfind(BASE_ROOT) + len(BASE_ROOT):]
     return package.replace(os.sep, '.')