task_runner: always use run_isolated

appengine/swarming/local_smoke_test.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """Integration test for the Swarming server, Swarming bot and Swarming client.
 
 It starts both a Swarming server and a Swarming bot and triggers tasks with the
 Swarming client to ensure the system works end to end.
 """
 
 import base64
 import json
 import glob
 import logging
 import os
+import re
 import signal
 import socket
 import sys
 import tempfile
 import time
 import unittest
 import urllib
 
 APP_DIR = os.path.dirname(os.path.abspath(__file__))
 BOT_DIR = os.path.join(APP_DIR, 'swarming_bot')
@@ skipping 240 matching lines @@
       'python', '-u', '-c', 'print(\'' + invalid_bytes + '\')',
     ]
     summary = self.gen_expected(
         name=u'non_utf8',
         # The string is mostly converted to 'Replacement Character'.
         outputs=[u'A\ufeff\ufffd\ufffd\ufffdsfs\ufffd(B\n'])
     self.assertOneTask(args, summary, {})
 
   def test_invalid_command(self):
     args = ['-T', 'invalid', '--', 'unknown_invalid_command']
-    err = (
-      '[Error 2] The system cannot find the file specified'
-      if sys.platform == 'win32' else '[Errno 2] No such file or directory')
     summary = self.gen_expected(
         name=u'invalid',
         exit_codes=[1],
         failure=True,
-        outputs=[
-          u'Command "unknown_invalid_command" failed to start.\n'
-          u'Error: %s' % err,
-        ])
+        outputs=re.compile(
+            u'^<The executable does not exist or a dependent library is '
+            u'missing>'))
     self.assertOneTask(args, summary, {})
 
   def test_hard_timeout(self):
     args = [
       # Need to flush to ensure it will be sent to the server.
       '-T', 'hard_timeout', '--hard-timeout', '1', '--',
       'python', '-u', '-c',
       'import time,sys; sys.stdout.write(\'hi\\n\'); '
         'sys.stdout.flush(); time.sleep(120)',
     ]
@@ skipping 212 matching lines @@
       actual_files.pop('summary.json')
       self.assertEqual(expected_files, actual_files)
     finally:
       file_path.rmtree(tmpdir)
 
   def assertResults(self, expected, result):
     self.assertEqual(['shards'], result.keys())
     self.assertEqual(1, len(result['shards']))
     self.assertTrue(result['shards'][0])
     result = result['shards'][0].copy()
+    self.assertFalse(result.get('abandoned_ts'))
     # These are not deterministic (or I'm too lazy to calculate the value).
     if expected.get('performance_stats'):
       self.assertLess(
           0, result['performance_stats'].pop('bot_overhead'))
       self.assertLess(
           0, result['performance_stats']['isolated_download'].pop('duration'))
       self.assertLess(
           0, result['performance_stats']['isolated_upload'].pop('duration'))
       for k in ('isolated_download', 'isolated_upload'):
         for j in ('items_cold', 'items_hot'):
           result['performance_stats'][k][j] = large.unpack(
               base64.b64decode(result['performance_stats'][k].get(j, '')))
     else:
-      perf_stats = result.get('performance_stats')
+      perf_stats = result.pop('performance_stats', None)
       if perf_stats:
         # Ignore bot_overhead, everything else should be empty.
         perf_stats.pop('bot_overhead', None)
         self.assertFalse(perf_stats)
 
     bot_version = result.pop('bot_version')
     self.assertTrue(bot_version)
     self.assertLess(0, result.pop('costs_usd'))
     self.assertTrue(result.pop('created_ts'))
     self.assertTrue(result.pop('completed_ts'))
     self.assertLess(0, result.pop('durations'))
     self.assertTrue(result.pop('id'))
     self.assertTrue(result.pop('modified_ts'))
     self.assertTrue(result.pop('started_ts'))
+
+    if getattr(expected.get('outputs'), 'match', None):
+      expected_outputs = expected.pop('outputs')
+      outputs = '\n'.join(result.pop('outputs'))
+      self.assertTrue(
+          expected_outputs.match(outputs),
+          '%s does not match %s' % (outputs, expected_outputs.pattern))
+
     self.assertEqual(expected, result)
     return bot_version
 
   def assertOneTask(self, args, expected_summary, expected_files):
     """Runs a single task at a time."""
     task_id = self.client.task_trigger_raw(args)
     actual_summary, actual_files = self.client.task_collect(task_id)
     bot_version = self.assertResults(expected_summary, actual_summary)
     actual_files.pop('summary.json')
     self.assertEqual(expected_files, actual_files)
@@ skipping 75 matching lines @@
     if bot.poll() is None:
       bot.kill()
       bot.wait()
   finally:
     cleanup(bot, client, servers, failed or verbose, leak)
   return int(failed)
 
 
 if __name__ == '__main__':
   sys.exit(main())