Fetch contents of DerivedData after each test

ios/build/bots/scripts/test_runner.py

 # Copyright 2016 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.
 
 """Test runners for iOS."""
 
 import argparse
 import collections
 import errno
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import time
 
 import find_xcode
 import gtest_utils
 import xctest_utils
 
 
+DERIVED_DATA = os.path.expanduser('~/Library/Developer/Xcode/DerivedData')
+
+
 XCTEST_PROJECT = os.path.abspath(os.path.join(
   os.path.dirname(__file__),
   'TestProject',
   'TestProject.xcodeproj',
 ))
 
 XCTEST_SCHEME = 'TestProject'
 
 
 class Error(Exception):
@@ skipping 191 matching lines @@
     """Performs cleanup actions which must occur after every test launch."""
     raise NotImplementedError
 
   def screenshot_desktop(self):
     """Saves a screenshot of the desktop in the output directory."""
     subprocess.check_call([
         'screencapture',
         os.path.join(self.out_dir, 'desktop_%s.png' % time.time()),
     ])
 
+  def retrieve_derived_data(self):
+    """Retrieves the contents of DerivedData"""
+    # DerivedData contains some logs inside workspace-specific directories.
+    # Since we don't control the name of the workspace or project, most of
+    # the directories are just called "temporary", making it hard to tell
+    # which directory we need to retrieve. Instead we just delete the
+    # entire contents of this directory before starting and return the
+    # entire contents after the test is over.
+    if os.path.exists(DERIVED_DATA):
+      os.mkdir(os.path.join(self.out_dir, 'DerivedData'))
+      derived_data = os.path.join(self.out_dir, 'DerivedData')
+      for directory in os.listdir(DERIVED_DATA):
+        shutil.move(os.path.join(DERIVED_DATA, directory), derived_data)
+
+  def wipe_derived_data(self):
+    """Removes the contents of Xcode's DerivedData directory."""
+    if os.path.exists(DERIVED_DATA):
+      shutil.rmtree(DERIVED_DATA)
+      os.mkdir(DERIVED_DATA)
+
   def _run(self, cmd):
     """Runs the specified command, parsing GTest output.
 
     Args:
       cmd: List of strings forming the command to run.
 
     Returns:
       GTestResult instance.
     """
     print ' '.join(cmd)
@@ skipping 186 matching lines @@
         self.iossim_path,
         '-d', self.platform,
         '-p',
         '-s', self.version,
     ]).rstrip()
 
   def set_up(self):
     """Performs setup actions which must occur prior to every test launch."""
     self.kill_simulators()
     self.wipe_simulator()
+    self.wipe_derived_data()
     self.homedir = self.get_home_directory()
     # Crash reports have a timestamp in their file name, formatted as
     # YYYY-MM-DD-HHMMSS. Save the current time in the same format so
     # we can compare and fetch crash reports from this run later on.
     self.start_time = time.strftime('%Y-%m-%d-%H%M%S', time.localtime())
 
   def extract_test_data(self):
     """Extracts data emitted by the test."""
     # Find the Documents directory of the test app. The app directory names
     # don't correspond with any known information, so we have to examine them
@@ skipping 37 matching lines @@
         # a staight string comparison works.
         if report_time > self.start_time:
           with open(os.path.join(crash_reports_dir, crash_report)) as f:
             self.logs['crash report (%s)' % report_time] = (
                 f.read().splitlines())
 
   def tear_down(self):
     """Performs cleanup actions which must occur after every test launch."""
     self.extract_test_data()
     self.retrieve_crash_reports()
+    self.retrieve_derived_data()
     self.screenshot_desktop()
     self.kill_simulators()
     self.wipe_simulator()
     if os.path.exists(self.homedir):
       shutil.rmtree(self.homedir, ignore_errors=True)
       self.homedir = ''
 
   def get_launch_command(self, test_filter=None, invert=False):
     """Returns the command that can be used to launch the test app.
 
@@ skipping 90 matching lines @@
         ['ideviceinstaller', '--udid', self.udid, '--uninstall', app])
 
   def install_app(self):
     """Installs the app."""
     subprocess.check_call(
       ['ideviceinstaller', '--udid', self.udid, '--install', self.app_path])
 
   def set_up(self):
     """Performs setup actions which must occur prior to every test launch."""
     self.uninstall_apps()
+    self.wipe_derived_data()
     self.install_app()
 
   def extract_test_data(self):
     """Extracts data emitted by the test."""
     try:
       subprocess.check_call([
         'idevicefs',
         '--udid', self.udid,
         'pull',
         '@%s/Documents' % self.cfbundleid,
@@ skipping 12 matching lines @@
         '--extract',
         '--udid', self.udid,
         logs_dir,
       ])
     except subprocess.CalledProcessError:
       raise TestDataExtractionError()
 
   def tear_down(self):
     """Performs cleanup actions which must occur after every test launch."""
     self.screenshot_desktop()
+    self.retrieve_derived_data()
     self.extract_test_data()
     self.retrieve_crash_reports()
     self.uninstall_apps()
 
   def get_launch_command(self, test_filter=None, invert=False):
     """Returns the command that can be used to launch the test app.
 
     Args:
       test_filter: List of test cases to filter.
       invert: Whether to invert the filter or not. Inverted, the filter will
@@ skipping 43 matching lines @@
     """
     env = super(DeviceTestRunner, self).get_launch_env()
     if self.xctest_path:
       env['NSUnbufferedIO'] = 'YES'
       # e.g. ios_web_shell_egtests
       env['APP_TARGET_NAME'] = os.path.splitext(
           os.path.basename(self.app_path))[0]
       # e.g. ios_web_shell_egtests_module
       env['TEST_TARGET_NAME'] = env['APP_TARGET_NAME'] + '_module'
     return env