Add an assert to ensure UTF-8 locale when handling file paths.

appengine/swarming/local_smoke_test.py

 #!/usr/bin/env python
 # Copyright 2014 The Swarming 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.
 
 """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 json
 import glob
 import logging
 import os
-import shutil
 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')
 CLIENT_DIR = os.path.join(APP_DIR, '..', '..', 'client')
 
 from tools import start_bot
 from tools import start_servers
 
 sys.path.insert(0, CLIENT_DIR)
+from third_party.depot_tools import fix_encoding
+from utils import file_path
 from utils import subprocess42
 sys.path.pop(0)
 
 sys.path.insert(0, BOT_DIR)
 
 # This is only needed on Windows.
 import test_env_bot
 test_env_bot.init_symlinks(BOT_DIR)
 
 from api import os_utilities
@@ skipping 117 matching lines @@
           raise
         outputs = {}
         for root, _, files in os.walk(tmpdir):
           for i in files:
             p = os.path.join(root, i)
             name = p[len(tmpdir)+1:]
             with open(p, 'rb') as f:
               outputs[name] = f.read()
         return summary, outputs
       finally:
-        shutil.rmtree(tmpdir)
+        file_path.rmtree(tmpdir)
     finally:
       os.remove(tmp)
 
   def terminate(self, bot_id):
     return self._run('terminate', ['--wait', bot_id])
 
   def cleanup(self):
     if self._tmpdir:
-      shutil.rmtree(self._tmpdir)
+      file_path.rmtree(self._tmpdir)
       self._tmpdir = None
 
   def dump_log(self):
     print >> sys.stderr, '-' * 60
     print >> sys.stderr, 'Client calls'
     print >> sys.stderr, '-' * 60
     for i in xrange(self._index):
       with open(os.path.join(self._tmpdir, 'client_%d.log' % i), 'rb') as f:
         log = f.read().strip('\n')
       for l in log.splitlines():
@@ skipping 273 matching lines @@
       with open(os.path.join(tmpdir, 'hello_world.py'), 'wb') as f:
         f.write(hello_world)
       isolated_hash = self.client.isolate(isolate_path, isolated_path)
       task_id = self.client.task_trigger_isolated(
           name, isolated_hash, extra=args)
       actual_summary, actual_files = self.client.task_collect(task_id)
       self.assertResults(expected_summary, actual_summary)
       actual_files.pop('summary.json')
       self.assertEqual(expected_files, actual_files)
     finally:
-      shutil.rmtree(tmpdir)
+      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()
     # These are not deterministic (or I'm too lazy to calculate the value).
     bot_version = result.pop('bot_version')
     self.assertTrue(bot_version)
     self.assertTrue(result.pop('costs_usd'))
@@ skipping 33 matching lines @@
         if servers:
           servers.dump_log()
         if client:
           client.dump_log()
   finally:
     if client and not leak:
       client.cleanup()
 
 
 def main():
+  fix_encoding.fix_encoding()
   verbose = '-v' in sys.argv
   leak = bool('--leak' in sys.argv)
   if leak:
     sys.argv.remove('--leak')
   if verbose:
     logging.basicConfig(level=logging.INFO)
     unittest.TestCase.maxDiff = None
   else:
     logging.basicConfig(level=logging.ERROR)
 
@@ skipping 37 matching lines @@
     if bot:
       bot.kill()
       bot.wait()
   finally:
     cleanup(bot, client, servers, failed or verbose, leak)
   return int(failed)
 
 
 if __name__ == '__main__':
   sys.exit(main())