bmabey-fakefs 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,68 @@
+FakeFS
+======
+
+Mocha is great. But when your library is all about manipulating the
+filesystem, you really want to test the behavior and not the implementation.
+
+If you're mocking and stubbing every call to FileUtils or File, you're 
+tightly coupling your tests with the implementation.
+
+    def test_creates_directory
+      FileUtils.expects(:mkdir).with("directory").once
+      Library.add "directory"
+    end
+
+The above test will break if we decide to use `mkdir_p` in our code. Refactoring
+code shouldn't necessitate refactoring tests.
+
+With FakeFS:
+
+    def test_creates_directory
+      Library.add "directory"
+      assert File.directory?("directory")
+    end
+
+Woot.
+
+
+Usage
+-----
+
+    require 'fakefs'
+
+    # That's it.
+
+
+Don't Fake the FS Immediately
+-----------------------------
+
+    require 'fakefs/safe'
+    
+    FakeFS.activate!
+    # your code
+    FakeFS.deactivate!
+    
+    # or
+    FakeFS do
+      # your code
+    end
+
+
+How is this different than MockFS?
+----------------------------------
+
+FakeFS provides a test suite and works with symlinks. It's also strictly a 
+test-time dependency: your actual library does not need to use or know about
+FakeFS.
+
+
+Speed?
+------
+http://gist.github.com/156091
+
+
+Authors
+-------
+
+* Chris Wanstrath [chris@ozmm.org]
+* Pat Nakajima [http://github.com/nakajima]

data/Rakefile

@@ -0,0 +1,20 @@
+task :default do
+  Dir['test/*_test.rb'].each { |file| require file }
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fakefs"
+    gem.summary = %Q{A fake filesystem. Use it in your tests.}
+    gem.email = "chris@ozmm.org"
+    gem.homepage = "http://ozmm.org/posts/fakefs.html"
+    gem.authors = ["Chris Wanstrath", "Pat Nakajima"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/fakefs.gemspec

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fakefs}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chris Wanstrath", "Pat Nakajima"]
+  s.date = %q{2009-08-07}
+  s.email = %q{chris@ozmm.org}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "fakefs.gemspec",
+     "lib/fakefs.rb",
+     "lib/fakefs/base.rb",
+     "lib/fakefs/dir.rb",
+     "lib/fakefs/fake/dir.rb",
+     "lib/fakefs/fake/file.rb",
+     "lib/fakefs/fake/symlink.rb",
+     "lib/fakefs/file.rb",
+     "lib/fakefs/file_system.rb",
+     "lib/fakefs/fileutils.rb",
+     "lib/fakefs/safe.rb",
+     "test/fakefs_test.rb",
+     "test/safe_test.rb",
+     "test/verify.rb"
+  ]
+  s.homepage = %q{http://ozmm.org/posts/fakefs.html}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{A fake filesystem. Use it in your tests.}
+  s.test_files = [
+    "test/fakefs_test.rb",
+     "test/safe_test.rb",
+     "test/verify.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/fakefs.rb

@@ -0,0 +1,3 @@
+require 'fakefs/safe'
+
+FakeFS.activate!

data/lib/fakefs/base.rb

@@ -0,0 +1,39 @@
+
+
+RealFile = File
+RealFileUtils = FileUtils
+RealDir = Dir
+RealFileUtils::Dir = RealDir
+RealFileUtils::File = RealFile
+
+module FakeFS
+  def self.activate!
+    Object.class_eval do
+      remove_const(:Dir)
+      remove_const(:File)
+      remove_const(:FileUtils)
+      const_set(:Dir, FakeFS::Dir)
+      const_set(:File, FakeFS::File)
+      const_set(:FileUtils, FakeFS::FileUtils)
+    end
+  end
+
+  def self.deactivate!
+    Object.class_eval do
+      remove_const(:Dir)
+      remove_const(:File)
+      remove_const(:FileUtils)
+      const_set(:Dir, RealDir)
+      const_set(:File, RealFile)
+      const_set(:FileUtils, RealFileUtils)
+    end
+  end
+end
+
+def FakeFS
+  return ::FakeFS unless block_given?
+  ::FakeFS.activate!
+  yield
+  ::FakeFS.deactivate!
+end
+

data/lib/fakefs/dir.rb

@@ -0,0 +1,23 @@
+module FakeFS
+  class Dir
+    def self.glob(pattern)
+      [FileSystem.find(pattern) || []].flatten.map{|e| e.to_s}.sort
+    end
+
+    def self.[](pattern)
+      glob(pattern)
+    end
+
+    def self.chdir(dir, &blk)
+      FileSystem.chdir(dir, &blk)
+    end
+
+    def self.pwd
+      FileSystem.current_dir.to_s
+    end
+
+    class << self
+      alias_method :getwd, :pwd
+    end
+  end
+end

data/lib/fakefs/fake/dir.rb

@@ -0,0 +1,37 @@
+module FakeFS
+  class FakeDir < Hash
+    attr_accessor :name, :parent
+
+    def initialize(name = nil, parent = nil)
+      @name = name
+      @parent = parent
+    end
+
+    def entry
+      self
+    end
+
+    def inspect
+      "(FakeDir name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{size})"
+    end
+
+    def clone(parent = nil)
+      clone = Marshal.load(Marshal.dump(self))
+      clone.each do |key, value|
+        value.parent = clone
+      end
+      clone.parent = parent if parent
+      clone
+    end
+
+    def to_s
+      if parent && parent.to_s != '.'
+        File.join(parent.to_s, name)
+      elsif parent && parent.to_s == '.'
+        "#{File::PATH_SEPARATOR}#{name}"
+      else
+        name
+      end
+    end
+  end
+end

data/lib/fakefs/fake/file.rb

@@ -0,0 +1,29 @@
+module FakeFS
+  class FakeFile
+    attr_accessor :name, :parent, :content
+
+    def initialize(name = nil, parent = nil)
+      @name = name
+      @parent = parent
+      @content = ''
+    end
+
+    def clone(parent = nil)
+      clone = super()
+      clone.parent = parent if parent
+      clone
+    end
+
+    def entry
+      self
+    end
+
+    def inspect
+      "(FakeFile name:#{name.inspect} parent:#{parent.to_s.inspect} size:#{content.size})"
+    end
+
+    def to_s
+      File.join(parent.to_s, name)
+    end
+  end
+end

data/lib/fakefs/fake/symlink.rb

@@ -0,0 +1,26 @@
+module FakeFS
+  class FakeSymlink
+    attr_accessor :name, :target
+    alias_method  :to_s, :name
+
+    def initialize(target)
+      @target = target
+    end
+
+    def inspect
+      "symlink(#{target.split('/').last})"
+    end
+
+    def entry
+      FileSystem.find(target)
+    end
+
+    def method_missing(*args, &block)
+      entry.send(*args, &block)
+    end
+
+    def respond_to?(method)
+      entry.respond_to?(method)
+    end
+  end
+end

data/lib/fakefs/file.rb

@@ -0,0 +1,124 @@
+module FakeFS
+  class File
+    PATH_SEPARATOR = '/'
+
+    def self.join(*parts)
+      parts * PATH_SEPARATOR
+    end
+
+    def self.exist?(path)
+      !!FileSystem.find(path)
+    end
+
+    class << self
+      alias_method :exists?, :exist?
+    end
+
+    def self.const_missing(name)
+      RealFile.const_get(name)
+    end
+
+    def self.directory?(path)
+      if path.respond_to? :entry
+        path.entry.is_a? FakeDir
+      else
+        result = FileSystem.find(path)
+        result ? result.entry.is_a?(FakeDir) : false
+      end
+    end
+
+    def self.symlink?(path)
+      if path.respond_to? :entry
+        path.is_a? FakeSymlink
+      else
+        FileSystem.find(path).is_a? FakeSymlink
+      end
+    end
+
+    def self.file?(path)
+      if path.respond_to? :entry
+        path.entry.is_a? FakeFile
+      else
+        result = FileSystem.find(path)
+        result ? result.entry.is_a?(FakeFile) : false
+      end
+    end
+
+    def self.expand_path(*args)
+      RealFile.expand_path(*args)
+    end
+
+    def self.basename(*args)
+      RealFile.basename(*args)
+    end
+
+    def self.dirname(path)
+      RealFile.dirname(path)
+    end
+
+    def self.readlink(path)
+      symlink = FileSystem.find(path)
+      FileSystem.find(symlink.target).to_s
+    end
+
+    def self.open(path, mode='r')
+      if block_given?
+        yield new(path, mode)
+      else
+        new(path, mode)
+      end
+    end
+
+    def self.read(path)
+      file = new(path)
+      if file.exists?
+        file.read
+      else
+        raise Errno::ENOENT
+      end
+    end
+
+    def self.readlines(path)
+      read(path).split("\n")
+    end
+
+    attr_reader :path
+    def initialize(path, mode = nil)
+      @path = path
+      @mode = mode
+      @file = FileSystem.find(path)
+      @open = true
+    end
+
+    def close
+      @open = false
+    end
+
+    def read
+      raise IOError.new('closed stream') unless @open
+      @file.content
+    end
+
+    def exists?
+      @file
+    end
+
+    def puts(content)
+      write(content + "\n")
+    end
+
+    def write(content)
+      raise IOError.new('closed stream') unless @open
+
+      if !File.exists?(@path)
+        @file = FileSystem.add(path, FakeFile.new)
+      end
+
+      @file.content += content
+    end
+    alias_method :print, :write
+    alias_method :<<, :write
+
+    def flush; self; end
+  end
+end

data/lib/fakefs/file_system.rb

@@ -0,0 +1,118 @@
+module FakeFS
+  module FileSystem
+    extend self
+
+    def dir_levels
+      @dir_levels ||= []
+    end
+
+    def fs
+      @fs ||= FakeDir.new('.')
+    end
+
+    def clear
+      @dir_levels = nil
+      @fs = nil
+    end
+
+    def files
+      fs.values
+    end
+
+    def find(path)
+      parts = path_parts(normalize_path(path))
+      return fs if parts.empty? # '/'
+      
+      entries = find_recurser(fs, parts).flatten
+      
+      case entries.length
+      when 0 then nil
+      when 1 then entries.first
+      else entries
+      end
+    end
+
+    def add(path, object=FakeDir.new)
+      parts = path_parts(normalize_path(path))
+
+      d = parts[0...-1].inject(fs) do |dir, part|
+        dir[part] ||= FakeDir.new(part, dir)
+      end
+
+      object.name = parts.last
+      object.parent = d
+      d[parts.last] ||= object
+    end
+
+    # copies directories and files from the real filesystem
+    # into our fake one
+    def clone(path)
+      path    = File.expand_path(path)
+      pattern = File.join(path, '**', '*')
+      files   = RealFile.file?(path) ? [path] : [path] + RealDir.glob(pattern, RealFile::FNM_DOTMATCH)
+
+      files.each do |f|
+        if RealFile.file?(f)
+          FileUtils.mkdir_p(File.dirname(f))
+          File.open(f, 'w') do |g|
+            g.print RealFile.open(f){|h| h.read }
+          end
+        elsif RealFile.directory?(f)
+          FileUtils.mkdir_p(f)
+        elsif RealFile.symlink?(f)
+          FileUtils.ln_s()
+        end
+      end
+    end
+
+    def delete(path)
+      if dir = FileSystem.find(path)
+        dir.parent.delete(dir.name)
+      end
+    end
+
+    def chdir(dir, &blk)
+      new_dir = find(dir)
+      dir_levels.push dir if blk
+
+      raise Errno::ENOENT, dir unless new_dir
+
+      dir_levels.push dir if !blk
+      blk.call if blk
+    ensure
+      dir_levels.pop if blk
+    end
+
+    def path_parts(path)
+      path.split(File::PATH_SEPARATOR).reject { |part| part.empty? }
+    end
+
+    def normalize_path(path)
+      if Pathname.new(path).absolute?
+        File.expand_path(path)
+      else
+        parts = dir_levels + [path]
+        File.expand_path(File.join(*parts))
+      end
+    end
+
+    def current_dir
+      find(normalize_path('.'))
+    end
+
+    private
+
+    def find_recurser(dir, parts)
+      return [] unless dir.respond_to? :[]
+
+      pattern , *parts = parts
+      matches = dir.reject {|k,v| /\A#{pattern.gsub('?','.').gsub('*', '.*')}\Z/ !~ k }.values
+
+      if parts.empty? # we're done recursing
+        matches
+      else
+        matches.map{|entry| find_recurser(entry, parts) }
+      end
+    end    
+  end
+end

data/lib/fakefs/fileutils.rb

@@ -0,0 +1,108 @@
+module FakeFS
+  module FileUtils
+    extend self
+
+    def mkdir_p(path)
+      FileSystem.add(path, FakeDir.new)
+    end
+
+    def rm(path)
+      FileSystem.delete(path)
+    end
+    alias_method :rm_rf, :rm
+    alias_method :rm_r, :rm
+
+    def ln_s(target, path)
+      raise Errno::EEXIST, path if FileSystem.find(path)
+      FileSystem.add(path, FakeSymlink.new(target))
+    end
+
+    def cp(src, dest)
+      dst_file = FileSystem.find(dest)
+      src_file = FileSystem.find(src)
+
+      if !src_file
+        raise Errno::ENOENT, src
+      end
+
+      if File.directory? src_file
+        raise Errno::EISDIR, src
+      end
+
+      if dst_file && File.directory?(dst_file)
+        FileSystem.add(File.join(dest, src), src_file.entry.clone(dst_file))
+      else
+        FileSystem.delete(dest)
+        FileSystem.add(dest, src_file.entry.clone)
+      end
+    end
+
+    def cp_r(src, dest)
+      # This error sucks, but it conforms to the original Ruby
+      # method.
+      raise "unknown file type: #{src}" unless dir = FileSystem.find(src)
+
+      new_dir = FileSystem.find(dest)
+
+      if new_dir && !File.directory?(dest)
+        raise Errno::EEXIST, dest
+      end
+
+      if !new_dir && !FileSystem.find(dest+'/../')
+        raise Errno::ENOENT, dest
+      end
+
+      # This last bit is a total abuse and should be thought hard
+      # about and cleaned up.
+      if new_dir
+        if src[-2..-1] == '/.'
+          dir.values.each{|f| new_dir[f.name] = f.clone(new_dir) }
+        else
+          new_dir[dir.name] = dir.entry.clone(new_dir)
+        end
+      else
+        FileSystem.add(dest, dir.entry.clone)
+      end
+    end
+
+    def mv(src, dest)
+      if target = FileSystem.find(src)
+        FileSystem.add(dest, target.entry.clone)
+        FileSystem.delete(src)
+      else
+        raise Errno::ENOENT, src
+      end
+    end
+
+    def chown(user, group, list, options={})
+      list = Array(list)
+      list.each do |f|
+        unless File.exists?(f)
+          raise Errno::ENOENT, f
+        end
+      end
+      list
+    end
+
+    def chown_R(user, group, list, options={})
+      chown(user, group, list, options={})
+    end
+
+    def touch(list, options={})
+      Array(list).each do |f|
+        directory = File.dirname(f)
+        # FIXME this explicit check for '.' shouldn't need to happen
+        if File.exists?(directory) || directory == '.'
+          FileSystem.add(f, FakeFile.new)
+        else
+          raise Errno::ENOENT, f
+        end
+      end
+    end
+
+    def cd(dir)
+      FileSystem.chdir(dir)
+    end
+    alias_method :chdir, :cd
+  end
+end

data/lib/fakefs/safe.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+require 'pathname'
+require 'fakefs/base'
+require 'fakefs/fake/file'
+require 'fakefs/fake/dir'
+require 'fakefs/fake/symlink'
+require 'fakefs/file_system'
+require 'fakefs/fileutils'
+require 'fakefs/file'
+require 'fakefs/dir'
+

data/test/fakefs_test.rb

@@ -0,0 +1,538 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'fakefs'
+require 'test/unit'
+
+class FakeFSTest < Test::Unit::TestCase
+  include FakeFS
+
+  def setup
+    FileSystem.clear
+  end
+
+  def test_can_be_initialized_empty
+    fs = FileSystem
+    assert_equal 0, fs.files.size
+  end
+
+  def xtest_can_be_initialized_with_an_existing_directory
+    fs = FileSystem
+    fs.clone(File.expand_path(File.dirname(__FILE__))).inspect
+    puts fs.files.inspect
+    assert_equal 1, fs.files.size
+  end
+
+  def test_can_create_directories
+    FileUtils.mkdir_p("/path/to/dir")
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+  end
+
+  def test_knows_directories_exist
+    FileUtils.mkdir_p(path = "/path/to/dir")
+    assert File.exists?(path)
+  end
+
+  def test_knows_directories_are_directories
+    FileUtils.mkdir_p(path = "/path/to/dir")
+    assert File.directory?(path)
+  end
+
+  def test_knows_symlink_directories_are_directories
+    FileUtils.mkdir_p(path = "/path/to/dir")
+    FileUtils.ln_s path, sympath = '/sympath'
+    assert File.directory?(sympath)
+  end
+
+  def test_knows_non_existent_directories_arent_directories
+    path = 'does/not/exist/'
+    assert_equal RealFile.directory?(path), File.directory?(path)
+  end
+
+  def test_doesnt_overwrite_existing_directories
+    FileUtils.mkdir_p(path = "/path/to/dir")
+    assert File.exists?(path)
+    FileUtils.mkdir_p("/path/to")
+    assert File.exists?(path)
+  end
+
+  def test_can_create_symlinks
+    FileUtils.mkdir_p(target = "/path/to/target")
+    FileUtils.ln_s(target, "/path/to/link")
+    assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
+
+    assert_raises(Errno::EEXIST) {
+      FileUtils.ln_s(target, '/path/to/link')
+    }
+  end
+
+  def test_can_follow_symlinks
+    FileUtils.mkdir_p(target = "/path/to/target")
+    FileUtils.ln_s(target, link = "/path/to/symlink")
+    assert_equal target, File.readlink(link)
+  end
+
+  def test_knows_symlinks_are_symlinks
+    FileUtils.mkdir_p(target = "/path/to/target")
+    FileUtils.ln_s(target, link = "/path/to/symlink")
+    assert File.symlink?(link)
+  end
+
+  def test_can_create_files
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f.write "Yatta!"
+    end
+
+    assert File.exists?(path)
+  end
+
+  def test_can_read_files_once_written
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f.write "Yatta!"
+    end
+
+    assert_equal "Yatta!", File.read(path)
+  end
+
+  def test_can_write_to_files
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f << 'Yada Yada'
+    end
+    assert_equal 'Yada Yada', File.read(path)
+  end
+
+  def test_can_read_with_File_readlines
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f.puts "Yatta!"
+      f.puts "woot"
+    end
+
+    assert_equal ["Yatta!", "woot"], File.readlines(path)
+  end
+
+  def test_File_close_disallows_further_access
+    path = '/path/to/file.txt'
+    file = File.open(path, 'w')
+    file.write 'Yada'
+    file.close
+    assert_raise IOError do
+      file.read
+    end
+  end
+
+  def test_can_read_from_file_objects
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f.write "Yatta!"
+    end
+
+    assert_equal "Yatta!", File.new(path).read
+  end
+
+  def test_file_read_errors_appropriately
+    assert_raise Errno::ENOENT do
+      File.read('anything')
+    end
+  end
+
+  def test_knows_files_are_files
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f.write "Yatta!"
+    end
+
+    assert File.file?(path)
+  end
+
+  def test_knows_symlink_files_are_files
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f.write "Yatta!"
+    end
+    FileUtils.ln_s path, sympath='/sympath'
+
+    assert File.file?(sympath)
+  end
+
+  def test_knows_non_existent_files_arent_files
+    assert_equal RealFile.file?('does/not/exist.txt'), File.file?('does/not/exist.txt')
+  end
+
+  def test_can_chown_files
+    good = 'file.txt'
+    bad = 'nofile.txt'
+    File.open(good,'w'){|f| f.write "foo" }
+
+    assert_equal [good], FileUtils.chown('noone', 'nogroup', good, :verbose => true)
+    assert_raises(Errno::ENOENT) do
+      FileUtils.chown('noone', 'nogroup', bad, :verbose => true)
+    end
+
+    assert_equal [good], FileUtils.chown('noone', 'nogroup', good)
+    assert_raises(Errno::ENOENT) do
+      FileUtils.chown('noone', 'nogroup', bad)
+    end
+
+    assert_equal [good], FileUtils.chown('noone', 'nogroup', [good])
+    assert_raises(Errno::ENOENT) do
+      FileUtils.chown('noone', 'nogroup', [good, bad])
+    end
+  end
+
+  def test_can_chown_R_files
+    FileUtils.mkdir_p '/path/'
+    File.open('/path/foo', 'w'){|f| f.write 'foo' }
+    File.open('/path/foobar', 'w'){|f| f.write 'foo' }
+    resp = FileUtils.chown_R('no', 'no', '/path')
+    assert_equal ['/path'], resp
+  end
+
+  def test_dir_globs_paths
+    FileUtils.mkdir_p '/path'
+    File.open('/path/foo', 'w'){|f| f.write 'foo' }
+    File.open('/path/foobar', 'w'){|f| f.write 'foo' }
+
+    FileUtils.mkdir_p '/path/bar'
+    File.open('/path/bar/baz', 'w'){|f| f.write 'foo' }
+
+    FileUtils.cp_r '/path/bar', '/path/bar2'
+
+    assert_equal  ['/path'], Dir['/path']
+    assert_equal %w( /path/bar /path/bar2 /path/foo /path/foobar ), Dir['/path/*']
+
+    assert_equal ['/path/bar/baz'], Dir['/path/bar/*']
+    assert_equal ['/path/foo'], Dir['/path/foo']
+
+    assert_equal ['/path'], Dir['/path*']
+    assert_equal ['/path/foo', '/path/foobar'], Dir['/p*h/foo*']
+    assert_equal ['/path/foo', '/path/foobar'], Dir['/p??h/foo*']
+
+    FileUtils.cp_r '/path', '/otherpath'
+
+    assert_equal %w( /otherpath/foo /otherpath/foobar /path/foo /path/foobar ), Dir['/*/foo*']
+  end
+
+  def test_dir_glob_handles_root
+    FileUtils.mkdir_p '/path'
+
+    # this fails. the root dir should be named '/' but it is '.'
+    #assert_equal ['/'], Dir['/']
+  end
+
+  def test_chdir_changes_directories_like_a_boss
+    # I know memes!
+    FileUtils.mkdir_p '/path'
+    assert_equal '.', FileSystem.fs.name
+    assert_equal({}, FileSystem.fs['path'])
+    Dir.chdir '/path' do
+      File.open('foo', 'w'){|f| f.write 'foo'}
+      File.open('foobar', 'w'){|f| f.write 'foo'}
+    end
+
+    assert_equal '.', FileSystem.fs.name
+    assert_equal(['foo', 'foobar'], FileSystem.fs['path'].keys.sort)
+
+    c = nil
+    Dir.chdir '/path' do
+      c = File.open('foo', 'r'){|f| f.read }
+    end
+
+    assert_equal 'foo', c
+  end
+
+  def test_chdir_shouldnt_keep_us_from_absolute_paths
+    FileUtils.mkdir_p '/path'
+
+    Dir.chdir '/path' do
+      File.open('foo', 'w'){|f| f.write 'foo'}
+      File.open('/foobar', 'w'){|f| f.write 'foo'}
+    end
+    assert_equal ['foo'], FileSystem.fs['path'].keys.sort
+    assert_equal ['foobar', 'path'], FileSystem.fs.keys.sort
+
+    Dir.chdir '/path' do
+      FileUtils.rm('foo')
+      FileUtils.rm('/foobar')
+    end
+
+    assert_equal [], FileSystem.fs['path'].keys.sort
+    assert_equal ['path'], FileSystem.fs.keys.sort
+  end
+
+  def test_chdir_should_be_nestable
+    FileUtils.mkdir_p '/path/me'
+    Dir.chdir '/path' do
+      File.open('foo', 'w'){|f| f.write 'foo'}
+      Dir.chdir 'me' do
+        File.open('foobar', 'w'){|f| f.write 'foo'}
+      end
+    end
+
+    assert_equal ['foo','me'], FileSystem.fs['path'].keys.sort
+    assert_equal ['foobar'], FileSystem.fs['path']['me'].keys.sort
+  end
+
+  def test_chdir_should_flop_over_and_die_if_the_dir_doesnt_exist
+    assert_raise(Errno::ENOENT) do
+      Dir.chdir('/nope') do
+        1
+      end
+    end
+  end
+
+  def test_chdir_shouldnt_lose_state_because_of_errors
+    FileUtils.mkdir_p '/path'
+
+    Dir.chdir '/path' do
+      File.open('foo', 'w'){|f| f.write 'foo'}
+      File.open('foobar', 'w'){|f| f.write 'foo'}
+    end
+
+    begin
+      Dir.chdir('/path') do
+        raise Exception
+      end
+    rescue Exception # hardcore
+    end
+
+    Dir.chdir('/path') do
+      begin
+        Dir.chdir('nope'){ }
+      rescue Errno::ENOENT
+      end
+
+      assert_equal ['/path'], FileSystem.dir_levels
+    end
+
+    assert_equal(['foo', 'foobar'], FileSystem.fs['path'].keys.sort)
+  end
+
+  def test_chdir_with_no_block_is_awesome
+    FileUtils.mkdir_p '/path'
+    Dir.chdir('/path')
+    FileUtils.mkdir_p 'subdir'
+    assert_equal ['subdir'], FileSystem.current_dir.keys
+    Dir.chdir('subdir')
+    File.open('foo', 'w'){|f| f.write 'foo'}
+    assert_equal ['foo'], FileSystem.current_dir.keys
+
+    assert_raises(Errno::ENOENT) do
+      Dir.chdir('subsubdir')
+    end
+
+    assert_equal ['foo'], FileSystem.current_dir.keys
+  end
+
+  def test_current_dir_reflected_by_pwd
+    FileUtils.mkdir_p '/path'
+    Dir.chdir('/path')
+
+    assert_equal '/path', Dir.pwd
+    assert_equal '/path', Dir.getwd
+
+    FileUtils.mkdir_p 'subdir'
+    Dir.chdir('subdir')
+
+    assert_equal '/path/subdir', Dir.pwd
+    assert_equal '/path/subdir', Dir.getwd
+  end
+
+  def test_file_open_defaults_to_read
+    File.open('foo','w'){|f| f.write 'bar' }
+    assert_equal 'bar', File.open('foo'){|f| f.read }
+  end
+
+  def test_flush_exists_on_file
+    r = File.open('foo','w'){|f| f.write 'bar';  f.flush }
+    assert_equal 'foo', r.path
+  end
+
+  def test_mv_should_raise_error_on_missing_file
+    assert_raise(Errno::ENOENT) do
+      FileUtils.mv 'blafgag', 'foo'
+    end
+  end
+
+  def test_mv_actually_works
+    File.open('foo', 'w') {|f| f.write 'bar' }
+    FileUtils.mv 'foo', 'baz'
+    assert_equal 'bar', File.open('baz'){|f| f.read }
+  end
+
+  def test_cp_actually_works
+    File.open('foo', 'w') {|f| f.write 'bar' }
+    FileUtils.cp('foo', 'baz')
+    assert_equal 'bar', File.read('baz')
+  end
+
+  def test_cp_file_into_dir
+    File.open('foo', 'w') {|f| f.write 'bar' }
+    FileUtils.mkdir_p 'baz'
+
+    FileUtils.cp('foo', 'baz')
+    assert_equal 'bar', File.read('baz/foo')
+  end
+
+  def test_cp_overwrites_dest_file
+    File.open('foo', 'w') {|f| f.write 'FOO' }
+    File.open('bar', 'w') {|f| f.write 'BAR' }
+
+    FileUtils.cp('foo', 'bar')
+    assert_equal 'FOO', File.read('bar')
+  end
+
+  def test_cp_fails_on_no_source
+    assert_raise Errno::ENOENT do
+      FileUtils.cp('foo', 'baz')
+    end
+  end
+
+  def test_cp_fails_on_directory_copy
+    FileUtils.mkdir_p 'baz'
+
+    assert_raise Errno::EISDIR do
+      FileUtils.cp('baz', 'bar')
+    end
+  end
+
+  def test_cp_r_doesnt_tangle_files_together
+    File.open('foo', 'w') {|f| f.write 'bar' }
+    FileUtils.cp_r('foo', 'baz')
+    File.open('baz', 'w') {|f| f.write 'quux' }
+    assert_equal 'bar', File.open('foo'){|f| f.read }
+  end
+
+  def test_cp_r_should_raise_error_on_missing_file
+    # Yes, this error sucks, but it conforms to the original Ruby
+    # method.
+    assert_raise(RuntimeError) do
+      FileUtils.cp_r 'blafgag', 'foo'
+    end
+  end
+
+  def test_cp_r_handles_copying_directories
+    FileUtils.mkdir_p 'subdir'
+    Dir.chdir('subdir'){ File.open('foo', 'w'){|f| f.write 'footext' } }
+
+    FileUtils.mkdir_p 'baz'
+
+    # To a previously uncreated directory
+    FileUtils.cp_r('subdir', 'quux')
+    assert_equal 'footext', File.open('quux/foo'){|f| f.read }
+
+    # To a directory that already exists
+    FileUtils.cp_r('subdir', 'baz')
+    assert_equal 'footext', File.open('baz/subdir/foo'){|f| f.read }
+
+    # To a subdirectory of a directory that does not exist
+    assert_raises(Errno::ENOENT) {
+      FileUtils.cp_r('subdir', 'nope/something')
+    }
+  end
+
+  def test_cp_r_only_copies_into_directories
+    FileUtils.mkdir_p 'subdir'
+    Dir.chdir('subdir'){ File.open('foo', 'w'){|f| f.write 'footext' } }
+
+    File.open('bar', 'w') {|f| f.write 'bartext' }
+
+    assert_raises(Errno::EEXIST) do
+      FileUtils.cp_r 'subdir', 'bar'
+    end
+
+    FileUtils.mkdir_p 'otherdir'
+    FileUtils.ln_s 'otherdir', 'symdir'
+
+    FileUtils.cp_r 'subdir', 'symdir'
+    assert_equal 'footext', File.open('symdir/subdir/foo'){|f| f.read }
+  end
+
+  def test_cp_r_sets_parent_correctly
+    FileUtils.mkdir_p '/path/foo'
+    File.open('/path/foo/bar', 'w'){|f| f.write 'foo' }
+    File.open('/path/foo/baz', 'w'){|f| f.write 'foo' }
+
+    FileUtils.cp_r '/path/foo', '/path/bar'
+
+    assert File.exists?('/path/bar/baz')
+    FileUtils.rm_rf '/path/bar/baz'
+    assert_equal %w( /path/bar/bar ), Dir['/path/bar/*']
+  end
+
+  def test_clone_clones_normal_files
+    RealFile.open(here('foo'), 'w'){|f| f.write 'bar' }
+    assert !File.exists?(here('foo'))
+    FileSystem.clone(here('foo'))
+    assert_equal 'bar', File.open(here('foo')){|f| f.read }
+  ensure
+    RealFile.unlink(here('foo')) if RealFile.exists?(here('foo'))
+  end
+
+  def test_clone_clones_directories
+    RealFileUtils.mkdir_p(here('subdir'))
+
+    FileSystem.clone(here('subdir'))
+
+    assert File.exists?(here('subdir')), 'subdir was cloned'
+    assert File.directory?(here('subdir')), 'subdir is a directory'
+  ensure
+    RealFileUtils.rm_rf(here('subdir')) if RealFile.exists?(here('subdir'))
+  end
+
+  def test_clone_clones_dot_files_even_hard_to_find_ones
+    RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo'))
+    assert !File.exists?(here('subdir'))
+
+    FileSystem.clone(here('subdir'))
+    assert_equal ['.bar'], FileSystem.find(here('subdir')).keys
+    assert_equal ['foo'], FileSystem.find(here('subdir/.bar/baz/.quux')).keys
+  ensure
+    RealFileUtils.rm_rf(here('subdir')) if RealFile.exists?(here('subdir'))
+  end
+
+  def test_putting_a_dot_at_end_copies_the_contents
+    FileUtils.mkdir_p 'subdir'
+    Dir.chdir('subdir'){ File.open('foo', 'w'){|f| f.write 'footext' } }
+
+    FileUtils.mkdir_p 'newdir'
+    FileUtils.cp_r 'subdir/.', 'newdir'
+    assert_equal 'footext', File.open('newdir/foo'){|f| f.read }
+  end
+
+  def test_file_can_read_from_symlinks
+    File.open('first', 'w'){|f| f.write '1'}
+    FileUtils.ln_s 'first', 'one'
+    assert_equal '1', File.open('one'){|f| f.read }
+
+    FileUtils.mkdir_p 'subdir'
+    File.open('subdir/nother','w'){|f| f.write 'works' }
+    FileUtils.ln_s 'subdir', 'new'
+    assert_equal 'works', File.open('new/nother'){|f| f.read }
+  end
+
+  def test_files_can_be_touched
+    FileUtils.touch('touched_file')
+    assert File.exists?('touched_file')
+    list = ['newfile', 'another']
+    FileUtils.touch(list)
+    list.each { |fp| assert(File.exists?(fp)) }
+  end
+
+  def test_touch_does_not_work_if_the_dir_path_cannot_be_found
+    assert_raises(Errno::ENOENT) {
+      FileUtils.touch('this/path/should/not/be/here')
+    }
+    FileUtils.mkdir_p('subdir')
+    list = ['subdir/foo', 'nosubdir/bar']
+
+    assert_raises(Errno::ENOENT) {
+      FileUtils.touch(list)
+    }
+  end
+
+  def here(fname)
+    RealFile.expand_path(RealFile.dirname(__FILE__)+'/'+fname)
+  end
+end

data/test/safe_test.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'fakefs/safe'
+require 'test/unit'
+
+class FakeFSSafeTest < Test::Unit::TestCase
+  def setup
+    FakeFS.deactivate!
+  end
+
+  def test_FakeFS_method_does_not_intrude_on_global_namespace
+    path = '/path/to/file.txt'
+
+    FakeFS do
+      File.open(path, 'w') { |f| f.write "Yatta!" }
+      assert File.exists?(path)
+    end
+
+    assert ! File.exists?(path)
+  end
+end

data/test/verify.rb

@@ -0,0 +1,27 @@
+# Figure out what's missing from fakefs
+#
+# USAGE
+#
+#   $ ruby test/verify.rb | grep "not implemented"
+require 'fakefs'
+require 'test/unit'
+ 
+class FakeFSVerifierTest < Test::Unit::TestCase
+  (RealFile.methods - Class.new.methods).each do |name|
+    define_method("test #{name} class method") do
+      assert File.respond_to?(name), "File.#{name} not implemented"
+    end
+  end
+ 
+  (RealFile.instance_methods - Enumerable.instance_methods).each do |name|
+    define_method("test #{name} instance method") do
+      assert File.instance_methods.include?(name), "File##{name} not implemented"
+    end
+  end
+ 
+  (RealFileUtils.methods - Class.new.methods).each do |name|
+    define_method("test #{name} module method") do
+      assert FileUtils.respond_to?(name), "FileUtils.#{name} not implemented"
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: bmabey-fakefs
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Chris Wanstrath
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: chris@ozmm.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- fakefs.gemspec
+- lib/fakefs.rb
+- lib/fakefs/base.rb
+- lib/fakefs/dir.rb
+- lib/fakefs/fake/dir.rb
+- lib/fakefs/fake/file.rb
+- lib/fakefs/fake/symlink.rb
+- lib/fakefs/file.rb
+- lib/fakefs/file_system.rb
+- lib/fakefs/fileutils.rb
+- lib/fakefs/safe.rb
+- test/fakefs_test.rb
+- test/safe_test.rb
+- test/verify.rb
+has_rdoc: false
+homepage: http://ozmm.org/posts/fakefs.html
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A fake filesystem. Use it in your tests.
+test_files: 
+- test/fakefs_test.rb
+- test/safe_test.rb
+- test/verify.rb