src/build/android/pylib/base/base_test_runner.py

   1 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Base class for running tests on a single device."""
   6
   7 # TODO(jbudorick) Deprecate and remove this class and all subclasses after
   8 # any relevant parts have been ported to the new environment + test instance
   9 # model.
  10
  11 import logging
  12 import time
  13
  14 from pylib import ports
  15 from pylib.chrome_test_server_spawner import SpawningServer
  16 from pylib.device import device_utils
  17 from pylib.forwarder import Forwarder
  18 from pylib.valgrind_tools import CreateTool
  19 # TODO(frankf): Move this to pylib/utils
  20 import lighttpd_server
  21
  22
  23 # A file on device to store ports of net test server. The format of the file is
  24 # test-spawner-server-port:test-server-port
  25 NET_TEST_SERVER_PORT_INFO_FILE = 'net-test-server-ports'
  26
  27
  28 class BaseTestRunner(object):
  29   """Base class for running tests on a single device."""
  30
  31   def __init__(self, device_serial, tool, cleanup_test_files=False):
  32     """
  33       Args:
  34         device: Tests will run on the device of this ID.
  35         tool: Name of the Valgrind tool.
  36         cleanup_test_files: Whether or not to cleanup test files on device.
  37     """
  38     self.device_serial = device_serial
  39     self.device = device_utils.DeviceUtils(device_serial)
  40     self.tool = CreateTool(tool, self.device)
  41     self._http_server = None
  42     self._forwarder_device_port = 8000
  43     self.forwarder_base_url = ('http://localhost:%d' %
  44         self._forwarder_device_port)
  45     self._spawning_server = None
  46     # We will allocate port for test server spawner when calling method
  47     # LaunchChromeTestServerSpawner and allocate port for test server when
  48     # starting it in TestServerThread.
  49     self.test_server_spawner_port = 0
  50     self.test_server_port = 0
  51     self._cleanup_test_files = cleanup_test_files
  52
  53   def _PushTestServerPortInfoToDevice(self):
  54     """Pushes the latest port information to device."""
  55     self.device.WriteFile(
  56         self.device.GetExternalStoragePath() + '/' +
  57             NET_TEST_SERVER_PORT_INFO_FILE,
  58         '%d:%d' % (self.test_server_spawner_port, self.test_server_port))
  59
  60   def RunTest(self, test):
  61     """Runs a test. Needs to be overridden.
  62
  63     Args:
  64       test: A test to run.
  65
  66     Returns:
  67       Tuple containing:
  68         (base_test_result.TestRunResults, tests to rerun or None)
  69     """
  70     raise NotImplementedError
  71
  72   def InstallTestPackage(self):
  73     """Installs the test package once before all tests are run."""
  74     pass
  75
  76   def PushDataDeps(self):
  77     """Push all data deps to device once before all tests are run."""
  78     pass
  79
  80   def SetUp(self):
  81     """Run once before all tests are run."""
  82     self.InstallTestPackage()
  83     self.PushDataDeps()
  84
  85   def TearDown(self):
  86     """Run once after all tests are run."""
  87     self.ShutdownHelperToolsForTestSuite()
  88     if self._cleanup_test_files:
  89       self.device.old_interface.RemovePushedFiles()
  90
  91   def LaunchTestHttpServer(self, document_root, port=None,
  92                            extra_config_contents=None):
  93     """Launches an HTTP server to serve HTTP tests.
  94
  95     Args:
  96       document_root: Document root of the HTTP server.
  97       port: port on which we want to the http server bind.
  98       extra_config_contents: Extra config contents for the HTTP server.
  99     """
 100     self._http_server = lighttpd_server.LighttpdServer(
 101         document_root, port=port, extra_config_contents=extra_config_contents)
 102     if self._http_server.StartupHttpServer():
 103       logging.info('http server started: http://localhost:%s',
 104                    self._http_server.port)
 105     else:
 106       logging.critical('Failed to start http server')
 107     self._ForwardPortsForHttpServer()
 108     return (self._forwarder_device_port, self._http_server.port)
 109
 110   def _ForwardPorts(self, port_pairs):
 111     """Forwards a port."""
 112     Forwarder.Map(port_pairs, self.device, self.tool)
 113
 114   def _UnmapPorts(self, port_pairs):
 115     """Unmap previously forwarded ports."""
 116     for (device_port, _) in port_pairs:
 117       Forwarder.UnmapDevicePort(device_port, self.device)
 118
 119   # Deprecated: Use ForwardPorts instead.
 120   def StartForwarder(self, port_pairs):
 121     """Starts TCP traffic forwarding for the given |port_pairs|.
 122
 123     Args:
 124       host_port_pairs: A list of (device_port, local_port) tuples to forward.
 125     """
 126     self._ForwardPorts(port_pairs)
 127
 128   def _ForwardPortsForHttpServer(self):
 129     """Starts a forwarder for the HTTP server.
 130
 131     The forwarder forwards HTTP requests and responses between host and device.
 132     """
 133     self._ForwardPorts([(self._forwarder_device_port, self._http_server.port)])
 134
 135   def _RestartHttpServerForwarderIfNecessary(self):
 136     """Restarts the forwarder if it's not open."""
 137     # Checks to see if the http server port is being used.  If not forwards the
 138     # request.
 139     # TODO(dtrainor): This is not always reliable because sometimes the port
 140     # will be left open even after the forwarder has been killed.
 141     if not ports.IsDevicePortUsed(self.device, self._forwarder_device_port):
 142       self._ForwardPortsForHttpServer()
 143
 144   def ShutdownHelperToolsForTestSuite(self):
 145     """Shuts down the server and the forwarder."""
 146     if self._http_server:
 147       self._UnmapPorts([(self._forwarder_device_port, self._http_server.port)])
 148       self._http_server.ShutdownHttpServer()
 149     if self._spawning_server:
 150       self._spawning_server.Stop()
 151
 152   def CleanupSpawningServerState(self):
 153     """Tells the spawning server to clean up any state.
 154
 155     If the spawning server is reused for multiple tests, this should be called
 156     after each test to prevent tests affecting each other.
 157     """
 158     if self._spawning_server:
 159       self._spawning_server.CleanupState()
 160
 161   def LaunchChromeTestServerSpawner(self):
 162     """Launches test server spawner."""
 163     server_ready = False
 164     error_msgs = []
 165     # TODO(pliard): deflake this function. The for loop should be removed as
 166     # well as IsHttpServerConnectable(). spawning_server.Start() should also
 167     # block until the server is ready.
 168     # Try 3 times to launch test spawner server.
 169     for _ in xrange(0, 3):
 170       self.test_server_spawner_port = ports.AllocateTestServerPort()
 171       self._ForwardPorts(
 172           [(self.test_server_spawner_port, self.test_server_spawner_port)])
 173       self._spawning_server = SpawningServer(self.test_server_spawner_port,
 174                                              self.device,
 175                                              self.tool)
 176       self._spawning_server.Start()
 177       server_ready, error_msg = ports.IsHttpServerConnectable(
 178           '127.0.0.1', self.test_server_spawner_port, path='/ping',
 179           expected_read='ready')
 180       if server_ready:
 181         break
 182       else:
 183         error_msgs.append(error_msg)
 184       self._spawning_server.Stop()
 185       # Wait for 2 seconds then restart.
 186       time.sleep(2)
 187     if not server_ready:
 188       logging.error(';'.join(error_msgs))
 189       raise Exception('Can not start the test spawner server.')
 190     self._PushTestServerPortInfoToDevice()