Add Results.Process.executable and command.

tools/isolate/trace_inputs_smoke_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 import cStringIO
 import logging
 import os
 import shutil
 import subprocess
@@ skipping 118 matching lines @@
       '--cwd', 'data',
       '--product', '.',  # Not tested.
     ] + self.command(True)
     actual = self._execute(cmd)
     self.assertEquals(expected_buffer.getvalue(), actual)
 
 
 class TraceInputsImport(TraceInputsBase):
   def setUp(self):
     super(TraceInputsImport, self).setUp()
+    import trace_inputs
+    self.trace_inputs = trace_inputs
     self.cwd = os.path.join(ROOT_DIR, u'data')
     self.initial_cwd = self.cwd
     if sys.platform == 'win32':
       # Still not supported on Windows.
       self.initial_cwd = None
+    self.executable = sys.executable
+    if sys.platform == 'darwin':
+      # /usr/bin/python is a thunk executable that decides which version of
+      # python gets executed.
+      suffix = '.'.join(map(str, sys.version_info[0:2]))
+      if os.access(self.executable + suffix, os.X_OK):
+        self.executable += suffix
+    self.real_executable = self.trace_inputs.get_native_path_case(
+        self.executable)
+    if sys.platform == 'darwin':
+      # Interestingly, only OSX does resolve the symlink manually before
+      # starting the executable.
+      if os.path.islink(self.real_executable):
+        self.real_executable = os.path.normpath(
+            os.path.join(
+                os.path.dirname(self.real_executable),
+                os.readlink(self.real_executable)))
+    self.naked_executable = sys.executable
+    if sys.platform == 'win32':
+      self.naked_executable = os.path.basename(sys.executable)
+
+  def tearDown(self):
+    del self.trace_inputs
+    super(TraceInputsImport, self).tearDown()
 
   # Similar to TraceInputs test fixture except that it calls the function
   # directly, so the Results instance can be inspected.
   # Roughly, make sure the API is stable.
   def _execute(self, command):
     # Similar to what trace_test_cases.py does.
-    import trace_inputs
-    api = trace_inputs.get_api()
-    _, _ = trace_inputs.trace(
+    api = self.trace_inputs.get_api()
+    _, _ = self.trace_inputs.trace(
           self.log, command, self.cwd, api, True)
     # TODO(maruel): Check
     #self.assertEquals(0, returncode)
     #self.assertEquals('', output)
-    return trace_inputs.load_trace(self.log, ROOT_DIR, api)
+    return self.trace_inputs.load_trace(self.log, ROOT_DIR, api)
 
   def test_trace_wrong_path(self):
     # Deliberately start the trace from the wrong path. Starts it from the
     # directory 'data' so 'data/data/trace_inputs/child1.py' is not accessible,
     # so child2.py process is not started.
     results, simplified = self._execute(self.command(False))
     expected = {
       'root': {
         'children': [],
-        'command': None,
-        'executable': None,
+        'command': [
+          self.executable,
+          os.path.join('data', 'trace_inputs', 'child1.py'),
+          '--child',
+        ],
+        'executable': self.real_executable,
         'files': [],
         'initial_cwd': self.initial_cwd,
       },
     }
     actual = results.flatten()
     self.assertTrue(actual['root'].pop('pid'))
     self.assertEquals(expected, actual)
     self.assertEquals([], simplified)
 
   def test_trace(self):
     size_t_i_s = os.stat(FULLNAME).st_size
     size_t_i = os.stat(os.path.join(ROOT_DIR, 'trace_inputs.py')).st_size
     expected = {
       'root': {
         'children': [
           {
             'children': [],
-            'command': None,
-            'executable': None,
+            'command': ['python', 'child2.py'],
+            'executable': self.naked_executable,
             'files': [
               {
                 'path': os.path.join(u'data', 'trace_inputs', 'child2.py'),
                 'size': 776,
               },
               {
                 'path': os.path.join(u'data', 'trace_inputs', 'test_file.txt'),
                 'size': 4,
               },
             ],
             'initial_cwd': self.initial_cwd,
           },
         ],
-        'command': None,
-        'executable': None,
+        'command': [
+          self.executable,
+          os.path.join('trace_inputs', 'child1.py'),
+          '--child-gyp',
+        ],
+        'executable': self.real_executable,
         'files': [
           {
             'path': os.path.join(u'data', 'trace_inputs', 'child1.py'),
             'size': 1364,
           },
           {
             'path': u'trace_inputs.py',
             'size': size_t_i,
           },
           {
@@ skipping 15 matching lines @@
       u'trace_inputs_smoke_test.py',
     ]
     self.assertEquals(files, [f.path for f in simplified])
 
 
 
 if __name__ == '__main__':
   VERBOSE = '-v' in sys.argv
   logging.basicConfig(level=logging.DEBUG if VERBOSE else logging.ERROR)
   unittest.main()