run_isolated: support non-isolated commands

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 by the Apache v2.0 license that can be
 # found in the LICENSE file.
 
 # pylint: disable=R0201
 
 import StringIO
 import base64
 import functools
@@ skipping 158 matching lines @@
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
     self.assertEqual(
         [
           ([self.temp_join(u'foo.exe'), u'cmd w/ space', '--extraargs', 'bar'],
             {'detached': True}),
           ],
         self.popen_calls)
 
-  def _run_tha_test(self, isolated_hash, files):
+  def _run_tha_test(self, isolated_hash=None, files=None, args=None):
+    files = files or {}
+    args = args or []
     make_tree_call = []
     def add(i, _):
       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(
         isolated_hash,
+        args,
         StorageFake(files),
         isolateserver.MemoryCache(),
         False,
         None,
         None,
         None,
-        None,
-        [])
+        None)
     self.assertEqual(0, ret)
     return make_tree_call
 
   def test_run_tha_test_naked(self):
     isolated = json_dumps({'command': ['invalid', 'command']})
     isolated_hash = isolateserver_mock.hash_content(isolated)
     files = {isolated_hash:isolated}
     make_tree_call = self._run_tha_test(isolated_hash, files)
     self.assertEqual(
         [
@@ skipping 59 matching lines @@
         [
           'make_tree_read_only', 'make_tree_deleteable', 'make_tree_deleteable',
           'make_tree_deleteable',
         ],
         make_tree_call)
     self.assertEqual(1, len(self.popen_calls))
     self.assertEqual(
         [([self.temp_join(u'invalid'), u'command'], {'detached': True})],
         self.popen_calls)
 
+  def mock_popen_with_oserr(self):
+    def r(self, args, **kwargs):
+      old_init(self, args, **kwargs)
+      raise OSError('Unknown')
+    old_init = self.mock(subprocess42.Popen, '__init__', r)
+
   def test_main_naked(self):
+    self.mock_popen_with_oserr()
     self.mock(on_error, 'report', lambda _: None)
     # The most naked .isolated file that can exist.
     self.mock(tools, 'disable_buffering', lambda: None)
     isolated = json_dumps({'command': ['invalid', 'command']})
     isolated_hash = isolateserver_mock.hash_content(isolated)
     def get_storage(_isolate_server, _namespace):
       return StorageFake({isolated_hash:isolated})
     self.mock(isolateserver, 'get_storage', get_storage)
 
-    def r(self, args, **kwargs):
-      old_init(self, args, **kwargs)
-      raise OSError('Unknown')
-    old_init = self.mock(subprocess42.Popen, '__init__', r)
-
     cmd = [
         '--no-log',
         '--isolated', isolated_hash,
         '--cache', self.tempdir,
         '--isolate-server', 'https://localhost',
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(1, ret)
     self.assertEqual(1, len(self.popen_calls))
     self.assertEqual(
         [([self.temp_join(u'invalid'), u'command'], {'detached': True})],
         self.popen_calls)
 
+  def test_main_naked_without_isolated(self):
+    self.mock_popen_with_oserr()
+    cmd = [
+      '--no-log',
+      '/bin/echo',
+      'hello',
+      'world',
+    ]
+    ret = run_isolated.main(cmd)
+    self.assertEqual(1, ret)
+    self.assertEqual(1, len(self.popen_calls))
+    self.assertEqual(
+        [([u'/bin/echo', u'hello', u'world'], {'detached': True})],
+        self.popen_calls)
+
   def test_modified_cwd(self):
     isolated = json_dumps({
         'command': ['../out/some.exe', 'arg'],
         'relative_cwd': 'some',
     })
     isolated_hash = isolateserver_mock.hash_content(isolated)
     files = {isolated_hash:isolated}
     _ = self._run_tha_test(isolated_hash, files)
     self.assertEqual(1, len(self.popen_calls))
     self.assertEqual(
@@ skipping 10 matching lines @@
     _ = self._run_tha_test(isolated_hash, files)
     self.assertEqual(1, len(self.popen_calls))
     # Injects sys.executable.
     self.assertEqual(
         [
           ([sys.executable, os.path.join(u'..', 'out', 'cmd.py'), u'arg'],
             {'detached': True}),
         ],
         self.popen_calls)
 
+  def test_run_tha_test_non_isolated(self):
+    _ = self._run_tha_test(args=['/bin/echo', 'hello', 'world'])
+    self.assertEqual(
+        [([u'/bin/echo', u'hello', u'world'], {'detached': True})],
+        self.popen_calls)
+
 
 class RunIsolatedTestRun(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')
@@ skipping 14 matching lines @@
         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(
           isolated_hash,
+          [],
           store,
           isolateserver.MemoryCache(),
           False,
           None,
           None,
           None,
-          None,
-          [])
+          None)
       self.assertEqual(0, ret)
 
       # It uploaded back. Assert the store has a new item containing foo.
       hashes = {isolated_hash, script_hash}
       output_hash = isolateserver_mock.hash_content('bar')
       hashes.add(output_hash)
       isolated =  {
         'algo': 'sha-1',
         'files': {
           'foo': {
@@ skipping 130 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()