Return specific files, not just those in $(ISOLATED_OUTDIR)

client/tests/run_isolated_test.py

 #!/usr/bin/env python
 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 # pylint: disable=R0201
 
 import StringIO
 import base64
 import functools
@@ skipping 194 matching lines @@
       make_tree_call.append(i)
     for i in ('make_tree_read_only', 'make_tree_files_read_only',
               'make_tree_deleteable', 'make_tree_writeable'):
       self.mock(file_path, i, functools.partial(add, i))
 
     ret = run_isolated.run_tha_test(
         command,
         isolated_hash,
         StorageFake(files),
         isolateserver.MemoryCache(),
+        None,
         lambda run_dir: None,
         False,
         None,
         None,
         None,
         None,
         None,
         None,
         lambda run_dir: None,
         False)
@@ skipping 309 matching lines @@
       server.add_content('default-store', script)
       server.add_content('default-store', isolated_data)
       store = isolateserver.get_storage(server.url, 'default-store')
 
       self.mock(sys, 'stdout', StringIO.StringIO())
       ret = run_isolated.run_tha_test(
           None,
           isolated_hash,
           store,
           isolateserver.MemoryCache(),
+          None,
           lambda run_dir: None,
           False,
           None,
           None,
           None,
           None,
           None,
           None,
           lambda run_dir: None,
           False)
@@ skipping 26 matching lines @@
         '[run_isolated_out_hack]',
         '{"hash":"%s","namespace":"default-store","storage":%s}' % (
             uploaded_hash, json.dumps(server.url)),
         '[/run_isolated_out_hack]'
       ]) + '\n'
       self.assertEqual(expected, sys.stdout.getvalue())
     finally:
       server.close()
 
 
+# Like RunIsolatedTestRun, but ensures that specific output files
+# (as opposed to anything in $(ISOLATED_OUTDIR)) are returned.
+class RunIsolatedTestOutputFiles(RunIsolatedTestBase):
+  def test_output(self):
+    # Starts a full isolate server mock and have run_tha_test() uploads results
+    # back after the task completed.
+    server = isolateserver_mock.MockIsolateServer()
+    try:
+      script = (
+        'import sys\n'
+        'open(sys.argv[1], "w").write("bar")\n'
+        'open(sys.argv[2], "w").write("baz")\n')
+      script_hash = isolateserver_mock.hash_content(script)
+      isolated = {
+        'algo': 'sha-1',
+        'command': ['cmd.py', 'foo', 'foodir/foo2'],
+        'files': {
+          'cmd.py': {
+            'h': script_hash,
+            'm': 0700,
+            's': len(script),
+          },
+        },
+        'version': isolated_format.ISOLATED_FILE_VERSION,
+      }
+      if sys.platform == 'win32':
+        isolated['files']['cmd.py'].pop('m')
+      isolated_data = json_dumps(isolated)
+      isolated_hash = isolateserver_mock.hash_content(isolated_data)
+      server.add_content('default-store', script)
+      server.add_content('default-store', isolated_data)
+      store = isolateserver.get_storage(server.url, 'default-store')
+
+      self.mock(sys, 'stdout', StringIO.StringIO())
+      ret = run_isolated.run_tha_test(
+          None,
+          isolated_hash,
+          store,
+          isolateserver.MemoryCache(),
+          ['foo', 'foodir/foo2'],
+          lambda run_dir: None,
+          False,
+          None,
+          None,
+          None,
+          None,
+          None,
+          None,
+          lambda run_dir: None,
+          False)
+      self.assertEqual(0, ret)
+
+      # It uploaded back. Assert the store has a new item containing foo.
+      hashes = {isolated_hash, script_hash}
+      foo_output_hash = isolateserver_mock.hash_content('bar')
+      foo2_output_hash = isolateserver_mock.hash_content('baz')
+      hashes.add(foo_output_hash)
+      hashes.add(foo2_output_hash)
+      isolated =  {
+        'algo': 'sha-1',
+        'files': {
+          'foo': {
+            'h': foo_output_hash,
+            # TODO(maruel): Handle umask.
+            'm': 0640,
+            's': 3,
+          },
+          'foodir/foo2': {
+            'h': foo2_output_hash,
+            # TODO(maruel): Handle umask.
+            'm': 0640,
+            's': 3,
+          },
+        },
+        'version': isolated_format.ISOLATED_FILE_VERSION,
+      }
+      if sys.platform == 'win32':
+        isolated['files']['foo'].pop('m')
+        isolated['files']['foodir/foo2'].pop('m')
+      uploaded = json_dumps(isolated)
+      uploaded_hash = isolateserver_mock.hash_content(uploaded)
+      hashes.add(uploaded_hash)
+      self.assertEqual(hashes, set(server.contents['default-store']))
+
+      expected = ''.join([
+        '[run_isolated_out_hack]',
+        '{"hash":"%s","namespace":"default-store","storage":%s}' % (
+            uploaded_hash, json.dumps(server.url)),
+        '[/run_isolated_out_hack]'
+      ]) + '\n'
+      self.assertEqual(expected, sys.stdout.getvalue())
+    finally:
+      server.close()
+
+
 class RunIsolatedJsonTest(RunIsolatedTestBase):
   # Similar to RunIsolatedTest but adds the hacks to process ISOLATED_OUTDIR to
   # generate a json result file.
   def setUp(self):
     super(RunIsolatedJsonTest, self).setUp()
     self.popen_calls = []
 
     # pylint: disable=no-self-argument
     class Popen(object):
       def __init__(self2, args, **kwargs):
@@ skipping 98 matching lines @@
     self.assertEqual(expected, actual)
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   if '-v' in sys.argv:
     unittest.TestCase.maxDiff = None
   logging.basicConfig(
       level=logging.DEBUG if '-v' in sys.argv else logging.ERROR)
   unittest.main()