depot_tools/testing_support/filesystem_mock.py

# Copyright (c) 2011 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 errno
import fnmatch
import os
import re
import sys

if sys.version_info.major == 2:
  from StringIO import StringIO
else:
  from io import StringIO


def _RaiseNotFound(path):
  raise IOError(errno.ENOENT, path, os.strerror(errno.ENOENT))


class MockFileSystem(object):
  """Stripped-down version of WebKit's webkitpy.common.system.filesystem_mock

  Implements a filesystem-like interface on top of a dict of filenames ->
  file contents. A file content value of None indicates that the file should
  not exist (IOError will be raised if it is opened;
  reading from a missing key raises a KeyError, not an IOError."""

  def __init__(self, files=None):
    self.files = files or {}
    self.written_files = {}
    self._sep = '/'

  @property
  def sep(self):
    return self._sep

  def abspath(self, path):
    if path.endswith(self.sep):
      return path[:-1]
    return path

  def basename(self, path):
    if self.sep not in path:
      return ''
    return self.split(path)[-1] or self.sep

  def dirname(self, path):
    if self.sep not in path:
      return ''
    return self.split(path)[0] or self.sep

  def exists(self, path):
    return self.isfile(path) or self.isdir(path)

  def isabs(self, path):
    return path.startswith(self.sep)

  def isfile(self, path):
    return path in self.files and self.files[path] is not None

  def isdir(self, path):
    if path in self.files:
      return False
    if not path.endswith(self.sep):
      path += self.sep

    # We need to use a copy of the keys here in order to avoid switching
    # to a different thread and potentially modifying the dict in
    # mid-iteration.
    files = list(self.files.keys())[:]
    return any(f.startswith(path) for f in files)

  def join(self, *comps):
    # TODO: Might want tests for this and/or a better comment about how
    # it works.
    return re.sub(re.escape(os.path.sep), self.sep, os.path.join(*comps))

  def glob(self, path):
    return fnmatch.filter(self.files.keys(), path)

  def open_for_reading(self, path):
    return StringIO(self.read_binary_file(path))

  def normpath(self, path):
    # This is not a complete implementation of normpath. Only covers what we
    # use in tests.
    result = []
    for part in path.split(self.sep):
      if part == '..':
        result.pop()
      elif part == '.':
        continue
      else:
        result.append(part)
    return self.sep.join(result)

  def read_binary_file(self, path):
    # Intentionally raises KeyError if we don't recognize the path.
    if self.files[path] is None:
      _RaiseNotFound(path)
    return self.files[path]

  def relpath(self, path, base):
    # This implementation is wrong in many ways; assert to check them for now.
    if not base.endswith(self.sep):
      base += self.sep
    assert path.startswith(base)
    return path[len(base):]

  def split(self, path):
    return path.rsplit(self.sep, 1)