Add everything from src/tools/isolate r159537.

tests/isolate_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 hashlib
+import json
+import logging
+import os
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, ROOT_DIR)
+
+import isolate
+
+
+VERBOSE = False
+SHA_1_NULL = hashlib.sha1().hexdigest()
+
+
+# Keep the list hard coded.
+EXPECTED_MODES = (
+  'check',
+  'hashtable',
+  'help',
+  'noop',
+  'merge',
+  'read',
+  'remap',
+  'run',
+  'trace',
+)
+
+# These are per test case, not per mode.
+RELATIVE_CWD = {
+  'fail': '.',
+  'missing_trailing_slash': '.',
+  'no_run': '.',
+  'non_existent': '.',
+  'symlink_full': '.',
+  'symlink_partial': '.',
+  'touch_only': '.',
+  'touch_root': os.path.join('tests', 'isolate'),
+  'with_flag': '.',
+}
+
+DEPENDENCIES = {
+  'fail': ['fail.py'],
+  'missing_trailing_slash': [],
+  'no_run': [
+    'no_run.isolate',
+    os.path.join('files1', 'subdir', '42.txt'),
+    os.path.join('files1', 'test_file1.txt'),
+    os.path.join('files1', 'test_file2.txt'),
+  ],
+  'non_existent': [],
+  'symlink_full': [
+    os.path.join('files1', 'subdir', '42.txt'),
+    os.path.join('files1', 'test_file1.txt'),
+    os.path.join('files1', 'test_file2.txt'),
+    # files2 is a symlink to files1.
+    'files2',
+    'symlink_full.py',
+  ],
+  'symlink_partial': [
+    os.path.join('files1', 'test_file2.txt'),
+    # files2 is a symlink to files1.
+    'files2',
+    'symlink_partial.py',
+  ],
+  'touch_only': [
+    'touch_only.py',
+    os.path.join('files1', 'test_file1.txt'),
+  ],
+  'touch_root': [
+    os.path.join('tests', 'isolate', 'touch_root.py'),
+    'isolate.py',
+  ],
+  'with_flag': [
+    'with_flag.py',
+    os.path.join('files1', 'subdir', '42.txt'),
+    os.path.join('files1', 'test_file1.txt'),
+    os.path.join('files1', 'test_file2.txt'),
+  ],
+}
+
+
+class CalledProcessError(subprocess.CalledProcessError):
+  """Makes 2.6 version act like 2.7"""
+  def __init__(self, returncode, cmd, output, stderr, cwd):
+    super(CalledProcessError, self).__init__(returncode, cmd)
+    self.output = output
+    self.stderr = stderr
+    self.cwd = cwd
+
+  def __str__(self):
+    return super(CalledProcessError, self).__str__() + (
+        '\n'
+        'cwd=%s\n%s\n%s\n%s') % (
+            self.cwd,
+            self.output,
+            self.stderr,
+            ' '.join(self.cmd))
+
+
+def list_files_tree(directory):
+  """Returns the list of all the files in a tree."""
+  actual = []
+  for root, dirnames, filenames in os.walk(directory):
+    actual.extend(os.path.join(root, f)[len(directory)+1:] for f in filenames)
+    for dirname in dirnames:
+      full = os.path.join(root, dirname)
+      # Manually include symlinks.
+      if os.path.islink(full):
+        actual.append(full[len(directory)+1:])
+  return sorted(actual)
+
+
+def calc_sha1(filepath):
+  """Calculates the SHA-1 hash for a file."""
+  return hashlib.sha1(open(filepath, 'rb').read()).hexdigest()
+
+
+class IsolateBase(unittest.TestCase):
+  # To be defined by the subclass, it defines the amount of meta data saved by
+  # isolate.py for each file. Should be one of (NO_INFO, STATS_ONLY, WITH_HASH).
+  LEVEL = None
+
+  def setUp(self):
+    # The tests assume the current directory is the file's directory.
+    os.chdir(ROOT_DIR)
+    self.tempdir = tempfile.mkdtemp()
+    self.result = os.path.join(self.tempdir, 'isolate_smoke_test.results')
+    self.outdir = os.path.join(self.tempdir, 'isolated')
+
+  def tearDown(self):
+    logging.debug(self.tempdir)
+    shutil.rmtree(self.tempdir)
+
+  @staticmethod
+  def _isolate_dict_to_string(values):
+    buf = cStringIO.StringIO()
+    isolate.pretty_print(values, buf)
+    return buf.getvalue()
+
+  @classmethod
+  def _wrap_in_condition(cls, variables):
+    """Wraps a variables dict inside the current OS condition.
+
+    Returns the equivalent string.
+    """
+    return cls._isolate_dict_to_string(
+        {
+          'conditions': [
+            ['OS=="%s"' % isolate.get_flavor(), {
+              'variables': variables
+            }],
+          ],
+        })
+
+
+class IsolateModeBase(IsolateBase):
+  def _expect_no_tree(self):
+    self.assertFalse(os.path.exists(self.outdir))
+
+  def _result_tree(self):
+    return list_files_tree(self.outdir)
+
+  def _expected_tree(self):
+    """Verifies the files written in the temporary directory."""
+    self.assertEquals(sorted(DEPENDENCIES[self.case()]), self._result_tree())
+
+  @staticmethod
+  def _fix_file_mode(filename, read_only):
+    """4 modes are supported, 0750 (rwx), 0640 (rw), 0550 (rx), 0440 (r)."""
+    min_mode = 0440
+    if not read_only:
+      min_mode |= 0200
+    return (min_mode | 0110) if filename.endswith('.py') else min_mode
+
+  def _gen_files(self, read_only, empty_file):
+    """Returns a dict of files like calling isolate.process_input() on each
+    file.
+    """
+    root_dir = ROOT_DIR
+    if RELATIVE_CWD[self.case()] == '.':
+      root_dir = os.path.join(root_dir, 'tests', 'isolate')
+
+    files = dict((unicode(f), {}) for f in DEPENDENCIES[self.case()])
+
+    for relfile, v in files.iteritems():
+      filepath = os.path.join(root_dir, relfile)
+      if self.LEVEL >= isolate.STATS_ONLY:
+        filestats = os.lstat(filepath)
+        is_link = stat.S_ISLNK(filestats.st_mode)
+        if not is_link:
+          v[u'size'] = filestats.st_size
+          if isolate.get_flavor() != 'win':
+            v[u'mode'] = self._fix_file_mode(relfile, read_only)
+        else:
+          v[u'mode'] = 488
+        # Used the skip recalculating the hash. Use the most recent update
+        # time.
+        v[u'timestamp'] = int(round(filestats.st_mtime))
+        if is_link:
+          v['link'] = os.readlink(filepath)
+
+      if self.LEVEL >= isolate.WITH_HASH:
+        if not is_link:
+          # Upgrade the value to unicode so diffing the structure in case of
+          # test failure is easier, since the basestring type must match,
+          # str!=unicode.
+          v[u'sha-1'] = unicode(calc_sha1(filepath))
+
+    if empty_file:
+      item = files[empty_file]
+      item['sha-1'] = unicode(SHA_1_NULL)
+      if sys.platform != 'win32':
+        item['mode'] = 288
+      item['size'] = 0
+      item['touched_only'] = True
+      item.pop('timestamp', None)
+    return files
+
+  def _expected_result(self, args, read_only, empty_file):
+    """Verifies self.result contains the expected data."""
+    expected = {
+      u'files': self._gen_files(read_only, empty_file),
+      u'os': isolate.get_flavor(),
+      u'relative_cwd': unicode(RELATIVE_CWD[self.case()]),
+    }
+    if read_only is not None:
+      expected[u'read_only'] = read_only
+    if args:
+      expected[u'command'] = [u'python'] + [unicode(x) for x in args]
+    else:
+      expected[u'command'] = []
+    self.assertEquals(expected, json.load(open(self.result, 'r')))
+
+  def _expected_saved_state(self, extra_vars):
+    flavor = isolate.get_flavor()
+    expected = {
+      u'isolate_file': unicode(self.filename()),
+      u'variables': {
+        u'EXECUTABLE_SUFFIX': '.exe' if flavor == 'win' else '',
+        u'OS': unicode(flavor),
+      },
+    }
+    expected['variables'].update(extra_vars or {})
+    self.assertEquals(expected, json.load(open(self.saved_state(), 'r')))
+
+  def _expect_results(self, args, read_only, extra_vars, empty_file):
+    self._expected_result(args, read_only, empty_file)
+    self._expected_saved_state(extra_vars)
+    # Also verifies run_swarm_step.py will be able to read it.
+    isolate.run_swarm_step.load_manifest(open(self.result, 'r').read())
+
+  def _expect_no_result(self):
+    self.assertFalse(os.path.exists(self.result))
+
+  def _execute(self, mode, case, args, need_output):
+    """Executes isolate.py."""
+    self.assertEquals(
+        case,
+        self.case() + '.isolate',
+        'Rename the test case to test_%s()' % case)
+    cmd = [
+      sys.executable, os.path.join(ROOT_DIR, 'isolate.py'),
+      mode,
+      '--result', self.result,
+      '--outdir', self.outdir,
+      '--isolate', self.filename(),
+    ]
+    cmd.extend(args)
+
+    env = os.environ.copy()
+    if 'ISOLATE_DEBUG' in env:
+      del env['ISOLATE_DEBUG']
+
+    if need_output or not VERBOSE:
+      stdout = subprocess.PIPE
+      stderr = subprocess.PIPE
+    else:
+      cmd.extend(['-v'] * 3)
+      stdout = None
+      stderr = None
+
+    logging.debug(cmd)
+    cwd = ROOT_DIR
+    p = subprocess.Popen(
+        cmd,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        universal_newlines=True)
+    out, err = p.communicate()
+    if p.returncode:
+      raise CalledProcessError(p.returncode, cmd, out, err, cwd)
+
+    # Do not check on Windows since a lot of spew is generated there.
+    if sys.platform != 'win32':
+      self.assertTrue(err in (None, ''), err)
+    return out
+
+  def case(self):
+    """Returns the filename corresponding to this test case."""
+    test_id = self.id().split('.')
+    return re.match('^test_([a-z_]+)$', test_id[2]).group(1)
+
+  def filename(self):
+    """Returns the filename corresponding to this test case."""
+    filename = os.path.join(
+        ROOT_DIR, 'tests', 'isolate', self.case() + '.isolate')
+    self.assertTrue(os.path.isfile(filename), filename)
+    return filename
+
+  def saved_state(self):
+    return isolate.result_to_state(self.result)
+
+
+class Isolate(unittest.TestCase):
+  # Does not inherit from the other *Base classes.
+  def test_help_modes(self):
+    # Check coherency in the help and implemented modes.
+    p = subprocess.Popen(
+        [sys.executable, os.path.join(ROOT_DIR, 'isolate.py'), '--help'],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        cwd=ROOT_DIR)
+    out = p.communicate()[0].splitlines()
+    self.assertEquals(0, p.returncode)
+    out = out[out.index('') + 1:]
+    out = out[:out.index('')]
+    modes = [re.match(r'^  (\w+) .+', l) for l in out]
+    modes = tuple(m.group(1) for m in modes if m)
+    # noop doesn't do anything so no point in testing it.
+    self.assertEquals(sorted(EXPECTED_MODES), sorted(modes))
+
+  def test_modes(self):
+    # This is a bit redundant but make sure all combinations are tested.
+    files = sorted(
+      i[:-len('.isolate')]
+      for i in os.listdir(os.path.join(ROOT_DIR, 'tests', 'isolate'))
+      if i.endswith('.isolate')
+    )
+    self.assertEquals(sorted(RELATIVE_CWD), files)
+    self.assertEquals(sorted(DEPENDENCIES), files)
+
+    if sys.platform == 'win32':
+      # Symlink stuff is unsupported there, remove them from the list.
+      files = [f for f in files if not f.startswith('symlink_')]
+
+    # TODO(csharp): touched_only is disabled until crbug.com/150823 is fixed.
+    files.remove('touch_only')
+
+    # modes read and trace are tested together.
+    modes_to_check = list(EXPECTED_MODES)
+    modes_to_check.remove('help')
+    modes_to_check.remove('merge')
+    modes_to_check.remove('noop')
+    modes_to_check.remove('read')
+    modes_to_check.remove('trace')
+    modes_to_check.append('trace_read_merge')
+    for mode in modes_to_check:
+      expected_cases = set('test_%s' % f for f in files)
+      fixture_name = 'Isolate_%s' % mode
+      fixture = getattr(sys.modules[__name__], fixture_name)
+      actual_cases = set(i for i in dir(fixture) if i.startswith('test_'))
+      missing = expected_cases - actual_cases
+      self.assertFalse(missing, '%s.%s' % (fixture_name, missing))
+
+
+class Isolate_check(IsolateModeBase):
+  LEVEL = isolate.NO_INFO
+
+  def test_fail(self):
+    self._execute('check', 'fail.isolate', [], False)
+    self._expect_no_tree()
+    self._expect_results(['fail.py'], None, None, None)
+
+  def test_missing_trailing_slash(self):
+    try:
+      self._execute('check', 'missing_trailing_slash.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_non_existent(self):
+    try:
+      self._execute('check', 'non_existent.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_no_run(self):
+    self._execute('check', 'no_run.isolate', [], False)
+    self._expect_no_tree()
+    self._expect_results([], None, None, None)
+
+  # TODO(csharp): Disabled until crbug.com/150823 is fixed.
+  def do_not_test_touch_only(self):
+    self._execute('check', 'touch_only.isolate', ['-V', 'FLAG', 'gyp'], False)
+    self._expect_no_tree()
+    empty = os.path.join('files1', 'test_file1.txt')
+    self._expected_result(['touch_only.py', 'gyp'], None, empty)
+
+  def test_touch_root(self):
+    self._execute('check', 'touch_root.isolate', [], False)
+    self._expect_no_tree()
+    self._expect_results(['touch_root.py'], None, None, None)
+
+  def test_with_flag(self):
+    self._execute('check', 'with_flag.isolate', ['-V', 'FLAG', 'gyp'], False)
+    self._expect_no_tree()
+    self._expect_results(
+        ['with_flag.py', 'gyp'], None, {u'FLAG': u'gyp'}, None)
+
+  if sys.platform != 'win32':
+    def test_symlink_full(self):
+      self._execute('check', 'symlink_full.isolate', [], False)
+      self._expect_no_tree()
+      self._expect_results(['symlink_full.py'], None, None, None)
+
+    def test_symlink_partial(self):
+      self._execute('check', 'symlink_partial.isolate', [], False)
+      self._expect_no_tree()
+      self._expect_results(['symlink_partial.py'], None, None, None)
+
+
+class Isolate_hashtable(IsolateModeBase):
+  LEVEL = isolate.WITH_HASH
+
+  def _gen_expected_tree(self, empty_file):
+    expected = [
+      v['sha-1'] for v in self._gen_files(False, empty_file).itervalues()
+    ]
+    expected.append(calc_sha1(self.result))
+    return expected
+
+  def _expected_hash_tree(self, empty_file):
+    """Verifies the files written in the temporary directory."""
+    self.assertEquals(
+        sorted(self._gen_expected_tree(empty_file)), self._result_tree())
+
+  def test_fail(self):
+    self._execute('hashtable', 'fail.isolate', [], False)
+    self._expected_hash_tree(None)
+    self._expect_results(['fail.py'], None, None, None)
+
+  def test_missing_trailing_slash(self):
+    try:
+      self._execute('hashtable', 'missing_trailing_slash.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_non_existent(self):
+    try:
+      self._execute('hashtable', 'non_existent.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_no_run(self):
+    self._execute('hashtable', 'no_run.isolate', [], False)
+    self._expected_hash_tree(None)
+    self._expect_results([], None, None, None)
+
+  # TODO(csharp): Disabled until crbug.com/150823 is fixed.
+  def do_not_test_touch_only(self):
+    self._execute(
+        'hashtable', 'touch_only.isolate', ['-V', 'FLAG', 'gyp'], False)
+    empty = os.path.join('files1', 'test_file1.txt')
+    self._expected_hash_tree(empty)
+    self._expected_result(['touch_only.py', 'gyp'], None, empty)
+
+  def test_touch_root(self):
+    self._execute('hashtable', 'touch_root.isolate', [], False)
+    self._expected_hash_tree(None)
+    self._expect_results(['touch_root.py'], None, None, None)
+
+  def test_with_flag(self):
+    self._execute(
+        'hashtable', 'with_flag.isolate', ['-V', 'FLAG', 'gyp'], False)
+    self._expected_hash_tree(None)
+    self._expect_results(
+        ['with_flag.py', 'gyp'], None, {u'FLAG': u'gyp'}, None)
+
+  if sys.platform != 'win32':
+    def test_symlink_full(self):
+      self._execute('hashtable', 'symlink_full.isolate', [], False)
+      # Construct our own tree.
+      expected = [
+        str(v['sha-1'])
+        for v in self._gen_files(False, None).itervalues() if 'sha-1' in v
+      ]
+      expected.append(calc_sha1(self.result))
+      self.assertEquals(sorted(expected), self._result_tree())
+      self._expect_results(['symlink_full.py'], None, None, None)
+
+    def test_symlink_partial(self):
+      self._execute('hashtable', 'symlink_partial.isolate', [], False)
+      # Construct our own tree.
+      expected = [
+        str(v['sha-1'])
+        for v in self._gen_files(False, None).itervalues() if 'sha-1' in v
+      ]
+      expected.append(calc_sha1(self.result))
+      self.assertEquals(sorted(expected), self._result_tree())
+      self._expect_results(['symlink_partial.py'], None, None, None)
+
+
+
+class Isolate_remap(IsolateModeBase):
+  LEVEL = isolate.STATS_ONLY
+
+  def test_fail(self):
+    self._execute('remap', 'fail.isolate', [], False)
+    self._expected_tree()
+    self._expect_results(['fail.py'], None, None, None)
+
+  def test_missing_trailing_slash(self):
+    try:
+      self._execute('remap', 'missing_trailing_slash.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_non_existent(self):
+    try:
+      self._execute('remap', 'non_existent.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_no_run(self):
+    self._execute('remap', 'no_run.isolate', [], False)
+    self._expected_tree()
+    self._expect_results([], None, None, None)
+
+  # TODO(csharp): Disabled until crbug.com/150823 is fixed.
+  def do_not_test_touch_only(self):
+    self._execute('remap', 'touch_only.isolate', ['-V', 'FLAG', 'gyp'], False)
+    self._expected_tree()
+    empty = os.path.join('files1', 'test_file1.txt')
+    self._expect_results(
+        ['touch_only.py', 'gyp'], None, {u'FLAG': u'gyp'}, empty)
+
+  def test_touch_root(self):
+    self._execute('remap', 'touch_root.isolate', [], False)
+    self._expected_tree()
+    self._expect_results(['touch_root.py'], None, None, None)
+
+  def test_with_flag(self):
+    self._execute('remap', 'with_flag.isolate', ['-V', 'FLAG', 'gyp'], False)
+    self._expected_tree()
+    self._expect_results(
+        ['with_flag.py', 'gyp'], None, {u'FLAG': u'gyp'}, None)
+
+  if sys.platform != 'win32':
+    def test_symlink_full(self):
+      self._execute('remap', 'symlink_full.isolate', [], False)
+      self._expected_tree()
+      self._expect_results(['symlink_full.py'], None, None, None)
+
+    def test_symlink_partial(self):
+      self._execute('remap', 'symlink_partial.isolate', [], False)
+      self._expected_tree()
+      self._expect_results(['symlink_partial.py'], None, None, None)
+
+
+class Isolate_run(IsolateModeBase):
+  LEVEL = isolate.STATS_ONLY
+
+  def _expect_empty_tree(self):
+    self.assertEquals([], self._result_tree())
+
+  def test_fail(self):
+    try:
+      self._execute('run', 'fail.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_empty_tree()
+    self._expect_results(['fail.py'], None, None, None)
+
+  def test_missing_trailing_slash(self):
+    try:
+      self._execute('run', 'missing_trailing_slash.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_non_existent(self):
+    try:
+      self._execute('run', 'non_existent.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_no_tree()
+    self._expect_no_result()
+
+  def test_no_run(self):
+    try:
+      self._execute('run', 'no_run.isolate', [], False)
+      self.fail()
+    except subprocess.CalledProcessError:
+      pass
+    self._expect_empty_tree()
+    self._expect_no_result()
+
+  # TODO(csharp): Disabled until crbug.com/150823 is fixed.
+  def do_not_test_touch_only(self):
+    self._execute('run', 'touch_only.isolate', ['-V', 'FLAG', 'run'], False)
+    self._expect_empty_tree()
+    empty = os.path.join('files1', 'test_file1.txt')
+    self._expect_results(
+        ['touch_only.py', 'run'], None, {u'FLAG': u'run'}, empty)
+
+  def test_touch_root(self):
+    self._execute('run', 'touch_root.isolate', [], False)
+    self._expect_empty_tree()
+    self._expect_results(['touch_root.py'], None, None, None)
+
+  def test_with_flag(self):
+    self._execute('run', 'with_flag.isolate', ['-V', 'FLAG', 'run'], False)
+    # Not sure about the empty tree, should be deleted.
+    self._expect_empty_tree()
+    self._expect_results(
+        ['with_flag.py', 'run'], None, {u'FLAG': u'run'}, None)
+
+  if sys.platform != 'win32':
+    def test_symlink_full(self):
+      self._execute('run', 'symlink_full.isolate', [], False)
+      self._expect_empty_tree()
+      self._expect_results(['symlink_full.py'], None, None, None)
+
+    def test_symlink_partial(self):
+      self._execute('run', 'symlink_partial.isolate', [], False)
+      self._expect_empty_tree()
+      self._expect_results(['symlink_partial.py'], None, None, None)
+
+
+class Isolate_trace_read_merge(IsolateModeBase):
+  # Tests both trace, read and merge.
+  # Warning: merge updates .isolate files. But they are currently in their
+  # canonical format so they shouldn't be changed.
+  LEVEL = isolate.STATS_ONLY
+
+  def _check_merge(self, filename):
+    filepath = isolate.trace_inputs.get_native_path_case(
+        os.path.join(ROOT_DIR, 'tests', 'isolate', filename))
+    expected = 'Updating %s\n' % filepath
+    with open(filepath, 'rb') as f:
+      old_content = f.read()
+    out = self._execute('merge', filename, [], True) or ''
+    self.assertEquals(expected, out)
+    with open(filepath, 'rb') as f:
+      new_content = f.read()
+    self.assertEquals(old_content, new_content)
+
+  def test_fail(self):
+    # Even if the process returns non-zero, the trace will still be good.
+    try:
+      self._execute('trace', 'fail.isolate', ['-v'], True)
+      self.fail()
+    except subprocess.CalledProcessError, e:
+      self.assertEquals('', e.output)
+    self._expect_no_tree()
+    self._expect_results(['fail.py'], None, None, None)
+    expected = self._wrap_in_condition(
+        {
+          isolate.KEY_TRACKED: [
+            'fail.py',
+          ],
+        })
+    out = self._execute('read', 'fail.isolate', [], True) or ''
+    self.assertEquals(expected.splitlines(), out.splitlines())
+    self._check_merge('fail.isolate')
+
+  def test_missing_trailing_slash(self):
+    try:
+      self._execute('trace', 'missing_trailing_slash.isolate', [], True)
+      self.fail()
+    except subprocess.CalledProcessError, e:
+      self.assertEquals('', e.output)
+      out = e.stderr
+    self._expect_no_tree()
+    self._expect_no_result()
+    expected = (
+      '\n'
+      'Error: Input directory %s must have a trailing slash\n' %
+          os.path.join(ROOT_DIR, 'tests', 'isolate', 'files1')
+    )
+    self.assertEquals(expected, out)
+
+  def test_non_existent(self):
+    try:
+      self._execute('trace', 'non_existent.isolate', [], True)
+      self.fail()
+    except subprocess.CalledProcessError, e:
+      self.assertEquals('', e.output)
+      out = e.stderr
+    self._expect_no_tree()
+    self._expect_no_result()
+    expected = (
+      '\n'
+      'Error: Input file %s doesn\'t exist\n' %
+          os.path.join(ROOT_DIR, 'tests', 'isolate', 'A_file_that_do_not_exist')
+    )
+    self.assertEquals(expected, out)
+
+  def test_no_run(self):
+    try:
+      self._execute('trace', 'no_run.isolate', [], True)
+      self.fail()
+    except subprocess.CalledProcessError, e:
+      out = e.output
+      err = e.stderr
+    self._expect_no_tree()
+    self._expect_no_result()
+    expected = '\nError: No command to run\n'
+    self.assertEquals('', out)
+    self.assertEquals(expected, err)
+
+  # TODO(csharp): Disabled until crbug.com/150823 is fixed.
+  def do_not_test_touch_only(self):
+    out = self._execute(
+        'trace', 'touch_only.isolate', ['-V', 'FLAG', 'trace'], True)
+    self.assertEquals('', out)
+    self._expect_no_tree()
+    empty = os.path.join('files1', 'test_file1.txt')
+    self._expect_results(
+        ['touch_only.py', 'trace'], None, {u'FLAG': u'trace'}, empty)
+    expected = {
+      isolate.KEY_TRACKED: [
+        'touch_only.py',
+      ],
+      isolate.KEY_TOUCHED: [
+        # Note that .isolate format mandates / and not os.path.sep.
+        'files1/test_file1.txt',
+      ],
+    }
+    if sys.platform != 'linux2':
+      # TODO(maruel): Implement touch-only tracing on non-linux.
+      del expected[isolate.KEY_TOUCHED]
+
+    out = self._execute('read', 'touch_only.isolate', [], True)
+    self.assertEquals(self._wrap_in_condition(expected), out)
+    self._check_merge('touch_only.isolate')
+
+  def test_touch_root(self):
+    out = self._execute('trace', 'touch_root.isolate', [], True)
+    self.assertEquals('', out)
+    self._expect_no_tree()
+    self._expect_results(['touch_root.py'], None, None, None)
+    expected = self._wrap_in_condition(
+        {
+          isolate.KEY_TRACKED: [
+            '../../isolate.py',
+            'touch_root.py',
+          ],
+        })
+    out = self._execute('read', 'touch_root.isolate', [], True)
+    self.assertEquals(expected, out)
+    self._check_merge('touch_root.isolate')
+
+  def test_with_flag(self):
+    out = self._execute(
+        'trace', 'with_flag.isolate', ['-V', 'FLAG', 'trace'], True)
+    self.assertEquals('', out)
+    self._expect_no_tree()
+    self._expect_results(
+        ['with_flag.py', 'trace'], None, {u'FLAG': u'trace'}, None)
+    expected = {
+      isolate.KEY_TRACKED: [
+        'with_flag.py',
+      ],
+      isolate.KEY_UNTRACKED: [
+        # Note that .isolate format mandates / and not os.path.sep.
+        'files1/',
+      ],
+    }
+    out = self._execute('read', 'with_flag.isolate', [], True)
+    self.assertEquals(self._wrap_in_condition(expected), out)
+    self._check_merge('with_flag.isolate')
+
+  if sys.platform != 'win32':
+    def test_symlink_full(self):
+      out = self._execute(
+          'trace', 'symlink_full.isolate', [], True)
+      self.assertEquals('', out)
+      self._expect_no_tree()
+      self._expect_results(['symlink_full.py'], None, None, None)
+      expected = {
+        isolate.KEY_TRACKED: [
+          'symlink_full.py',
+        ],
+        isolate.KEY_UNTRACKED: [
+          # Note that .isolate format mandates / and not os.path.sep.
+          'files2/',
+        ],
+      }
+      out = self._execute('read', 'symlink_full.isolate', [], True)
+      self.assertEquals(self._wrap_in_condition(expected), out)
+      self._check_merge('symlink_full.isolate')
+
+    def test_symlink_partial(self):
+      out = self._execute(
+          'trace', 'symlink_partial.isolate', [], True)
+      self.assertEquals('', out)
+      self._expect_no_tree()
+      self._expect_results(['symlink_partial.py'], None, None, None)
+      expected = {
+        isolate.KEY_TRACKED: [
+          'symlink_partial.py',
+        ],
+        isolate.KEY_UNTRACKED: [
+          'files2/test_file2.txt',
+        ],
+      }
+      out = self._execute('read', 'symlink_partial.isolate', [], True)
+      self.assertEquals(self._wrap_in_condition(expected), out)
+      self._check_merge('symlink_partial.isolate')
+
+
+class IsolateNoOutdir(IsolateBase):
+  # Test without the --outdir flag.
+  # So all the files are first copied in the tempdir and the test is run from
+  # there.
+  def setUp(self):
+    super(IsolateNoOutdir, self).setUp()
+    self.root = os.path.join(self.tempdir, 'root')
+    os.makedirs(os.path.join(self.root, 'tests', 'isolate'))
+    for i in ('touch_root.isolate', 'touch_root.py'):
+      shutil.copy(
+          os.path.join(ROOT_DIR, 'tests', 'isolate', i),
+          os.path.join(self.root, 'tests', 'isolate', i))
+      shutil.copy(
+          os.path.join(ROOT_DIR, 'isolate.py'),
+          os.path.join(self.root, 'isolate.py'))
+
+  def _execute(self, mode, args, need_output):
+    """Executes isolate.py."""
+    cmd = [
+      sys.executable, os.path.join(ROOT_DIR, 'isolate.py'),
+      mode,
+      '--result', self.result,
+    ]
+    cmd.extend(args)
+
+    env = os.environ.copy()
+    if 'ISOLATE_DEBUG' in env:
+      del env['ISOLATE_DEBUG']
+
+    if need_output or not VERBOSE:
+      stdout = subprocess.PIPE
+      stderr = subprocess.STDOUT
+    else:
+      cmd.extend(['-v'] * 3)
+      stdout = None
+      stderr = None
+
+    logging.debug(cmd)
+    cwd = self.tempdir
+    p = subprocess.Popen(
+        cmd,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        universal_newlines=True)
+    out, err = p.communicate()
+    if p.returncode:
+      raise CalledProcessError(p.returncode, cmd, out, err, cwd)
+    return out
+
+  def mode(self):
+    """Returns the execution mode corresponding to this test case."""
+    test_id = self.id().split('.')
+    self.assertEquals(3, len(test_id))
+    self.assertEquals('__main__', test_id[0])
+    return re.match('^test_([a-z]+)$', test_id[2]).group(1)
+
+  def filename(self):
+    """Returns the filename corresponding to this test case."""
+    filename = os.path.join(self.root, 'tests', 'isolate', 'touch_root.isolate')
+    self.assertTrue(os.path.isfile(filename), filename)
+    return filename
+
+  def test_check(self):
+    self._execute('check', ['--isolate', self.filename()], False)
+    files = sorted([
+      'isolate_smoke_test.results',
+      'isolate_smoke_test.state',
+      os.path.join('root', 'tests', 'isolate', 'touch_root.isolate'),
+      os.path.join('root', 'tests', 'isolate', 'touch_root.py'),
+      os.path.join('root', 'isolate.py'),
+    ])
+    self.assertEquals(files, list_files_tree(self.tempdir))
+
+  def test_hashtable(self):
+    self._execute('hashtable', ['--isolate', self.filename()], False)
+    files = sorted([
+      os.path.join(
+          'hashtable', calc_sha1(os.path.join(ROOT_DIR, 'isolate.py'))),
+      os.path.join(
+          'hashtable',
+          calc_sha1(
+              os.path.join(ROOT_DIR, 'tests', 'isolate', 'touch_root.py'))),
+      os.path.join('hashtable', calc_sha1(os.path.join(self.result))),
+      'isolate_smoke_test.results',
+      'isolate_smoke_test.state',
+      os.path.join('root', 'tests', 'isolate', 'touch_root.isolate'),
+      os.path.join('root', 'tests', 'isolate', 'touch_root.py'),
+      os.path.join('root', 'isolate.py'),
+    ])
+    self.assertEquals(files, list_files_tree(self.tempdir))
+
+  def test_remap(self):
+    self._execute('remap', ['--isolate', self.filename()], False)
+    files = sorted([
+      'isolate_smoke_test.results',
+      'isolate_smoke_test.state',
+      os.path.join('root', 'tests', 'isolate', 'touch_root.isolate'),
+      os.path.join('root', 'tests', 'isolate', 'touch_root.py'),
+      os.path.join('root', 'isolate.py'),
+    ])
+    self.assertEquals(files, list_files_tree(self.tempdir))
+
+  def test_run(self):
+    self._execute('run', ['--isolate', self.filename()], False)
+    files = sorted([
+      'isolate_smoke_test.results',
+      'isolate_smoke_test.state',
+      os.path.join('root', 'tests', 'isolate', 'touch_root.isolate'),
+      os.path.join('root', 'tests', 'isolate', 'touch_root.py'),
+      os.path.join('root', 'isolate.py'),
+    ])
+    self.assertEquals(files, list_files_tree(self.tempdir))
+
+  def test_trace_read_merge(self):
+    self._execute('trace', ['--isolate', self.filename()], False)
+    # Read the trace before cleaning up. No need to specify self.filename()
+    # because add the needed information is in the .state file.
+    output = self._execute('read', [], True)
+    expected = {
+      isolate.KEY_TRACKED: [
+        '../../isolate.py',
+        'touch_root.py',
+      ],
+    }
+    self.assertEquals(self._wrap_in_condition(expected), output)
+
+    output = self._execute('merge', [], True)
+    expected = 'Updating %s\n' % isolate.trace_inputs.get_native_path_case(
+        os.path.join(self.root, 'tests', 'isolate', 'touch_root.isolate'))
+    self.assertEquals(expected, output)
+    # In theory the file is going to be updated but in practice its content
+    # won't change.
+
+    # Clean the directory from the logs, which are OS-specific.
+    isolate.trace_inputs.get_api().clean_trace(
+        os.path.join(self.tempdir, 'isolate_smoke_test.results.log'))
+    files = sorted([
+      'isolate_smoke_test.results',
+      'isolate_smoke_test.state',
+      os.path.join('root', 'tests', 'isolate', 'touch_root.isolate'),
+      os.path.join('root', 'tests', 'isolate', 'touch_root.py'),
+      os.path.join('root', 'isolate.py'),
+    ])
+    self.assertEquals(files, list_files_tree(self.tempdir))
+
+
+if __name__ == '__main__':
+  VERBOSE = '-v' in sys.argv
+  logging.basicConfig(level=logging.DEBUG if VERBOSE else logging.ERROR)
+  unittest.main()