fakefs 0.4.2 → 0.4.3

data/README.markdown

@@ -128,10 +128,6 @@ Installation
 
     $ gem install fakefs
 
-### [Rip](http://hellorip.com)
-
-    $ rip install git://github.com/defunkt/fakefs.git
-
 
 Contributing
 ------------
@@ -151,7 +147,6 @@ Meta
 * Home: <http://github.com/defunkt/fakefs>
 * Docs: <http://defunkt.github.com/fakefs>
 * Bugs: <http://github.com/defunkt/fakefs/issues>
-* List: <http://groups.google.com/group/fakefs>
 * Test: <http://travisci.org/#!/defunkt/fakefs>
 * Gems: <http://rubygems.org/gems/fakefs>
 

data/fakefs.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "fakefs"
-  s.version = "0.4.2"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Chris Wanstrath", "Scott Taylor", "Jeff Hodges", "Pat Nakajima"]
-  s.date = "2012-11-24"
+  s.date = "2013-09-07"
   s.description = "A fake filesystem. Use it in your tests."
   s.email = "chris@ozmm.org"
   s.extra_rdoc_files = [

data/lib/fakefs/dir.rb

@@ -90,7 +90,7 @@ module FakeFS
       Dir.open(dirname) { |file| yield file }
     end
 
-    def self.glob(pattern, &block)
+    def self.glob(pattern, flags = 0, &block)
       matches_for_pattern = lambda do |matcher|
         [FileSystem.find(matcher) || []].flatten.map{|e|
           Dir.pwd.match(%r[\A/?\z]) || !e.to_s.match(%r[\A#{Dir.pwd}/?]) ? e.to_s : e.to_s.match(%r[\A#{Dir.pwd}/?]).post_match}.sort
@@ -180,6 +180,7 @@ module FakeFS
       alias_method :getwd, :pwd
       alias_method :rmdir, :delete
       alias_method :unlink, :delete
+      alias_method :exist?, :exists?
     end
   end
 end

data/lib/fakefs/file.rb

@@ -94,12 +94,16 @@ module FakeFS
 
     def self.size?(path)
       if exists?(path) && !size(path).zero?
-        true
+        size(path)
       else
         nil
       end
     end
 
+    def self.zero?(path)
+      exists?(path) && size(path) == 0
+    end
+
     def self.const_missing(name)
       RealFile.const_get(name)
     end
@@ -149,18 +153,24 @@ module FakeFS
 
     def self.read(path, *args)
       file = new(path)
+
+      raise Errno::ENOENT if !file.exists?
+      raise Errno::EISDIR, "Is a directory - #{path}" if directory?(path)
+
+      FileSystem.find(path).atime = Time.now
+      file.read
+    end
+
+    def self.readlines(path)
+      file = new(path)
       if file.exists?
         FileSystem.find(path).atime = Time.now
-        file.read
+        file.readlines
       else
         raise Errno::ENOENT
       end
     end
 
-    def self.readlines(path)
-      read(path).split("\n")
-    end
-
     def self.rename(source, dest)
       if directory?(source) && file?(dest)
         raise Errno::ENOTDIR, "Not a directory - #{source} or #{dest}"
@@ -236,6 +246,14 @@ module FakeFS
       FileSystem.find(filename).mode = 0100000 + mode_int
     end
 
+    # Not exactly right, returns true if the file is chmod +x for owner. In the
+    # context of when you would use fakefs, this is usually what you want.
+    def self.executable?(filename)
+      file = FileSystem.find(filename)
+      return false unless file
+      (file.mode - 0100000) & 0100 != 0
+    end
+
     def self.chown(owner_int, group_int, filename)
       file = FileSystem.find(filename)
       if owner_int && owner_int != -1
@@ -248,8 +266,18 @@ module FakeFS
       end
     end
 
-    def self.umask
-      RealFile.umask
+    def self.umask(*args)
+      RealFile.umask(*args)
+    end
+
+    def self.binread(file, length = nil, offset = 0)
+      contents = File.read(file)
+
+      if length
+        contents.slice(offset, length)
+      else
+        contents
+      end
     end
 
     class Stat
@@ -279,6 +307,12 @@ module FakeFS
         File.directory?(@file)
       end
 
+      def ftype
+        return 'link' if symlink?
+        return 'directory' if directory?
+        return 'file'
+      end
+
       # assumes, like above, that all files are readable and writable
       def readable?
         true
@@ -418,6 +452,10 @@ module FakeFS
     end
 
     if RUBY_VERSION >= "1.9"
+      def self.realpath(*args)
+        RealFile.realpath(*args)
+      end
+
       def binmode?
         raise NotImplementedError
       end
@@ -460,6 +498,21 @@ module FakeFS
     if RUBY_VERSION >= "1.9.3"
       def advise(advice, offset=0, len=0)
       end
+
+      def self.write(filename, contents, offset = nil)
+        if offset
+          open(filename, 'a') do |f|
+            f.seek(offset)
+            f.write(contents)
+          end
+        else
+          open(filename, 'w') do |f|
+            f << contents
+          end
+        end
+
+        contents.length
+      end
     end
 
   private

data/lib/fakefs/fileutils.rb

@@ -2,18 +2,24 @@ module FakeFS
   module FileUtils
     extend self
 
-    def mkdir_p(path, options = {})
-      FileSystem.add(path, FakeDir.new)
+    def mkdir_p(list, options = {})
+      list = [ list ] unless list.is_a?(Array)
+      list.each do |path|
+        FileSystem.add(path, FakeDir.new)
+      end
     end
     alias_method :mkpath, :mkdir_p
     alias_method :makedirs, :mkdir_p
 
-    def mkdir(path)
-      parent = path.split('/')
-      parent.pop
-      raise Errno::ENOENT, "No such file or directory - #{path}" unless parent.join == "" || parent.join == "." || FileSystem.find(parent.join('/'))
-      raise Errno::EEXIST, "File exists - #{path}" if FileSystem.find(path)
-      FileSystem.add(path, FakeDir.new)
+    def mkdir(list, ignored_options={})
+      list = [ list ] unless list.is_a?(Array)
+      list.each do |path|
+        parent = path.split('/')
+        parent.pop
+        raise Errno::ENOENT, "No such file or directory - #{path}" unless parent.join == "" || parent.join == "." || FileSystem.find(parent.join('/'))
+        raise Errno::EEXIST, "File exists - #{path}" if FileSystem.find(path)
+        FileSystem.add(path, FakeDir.new)
+      end
     end
 
     def rmdir(list, options = {})
@@ -37,6 +43,10 @@ module FakeFS
     alias_method :rm_rf, :rm
     alias_method :rm_r, :rm
     alias_method :rm_f, :rm
+    alias_method :remove, :rm
+    alias_method :rmtree, :rm_rf
+    alias_method :safe_unlink, :rm_f
+    alias_method :remove_entry_secure, :rm_rf
 
     def ln_s(target, path, options = {})
       options = { :force => false }.merge(options)
@@ -55,6 +65,8 @@ module FakeFS
       ln_s(target, path, { :force => true })
     end
 
+    alias_method :symlink, :ln_s
+
     def cp(src, dest)
       if src.is_a?(Array) && !File.directory?(dest)
         raise Errno::ENOTDIR, dest
@@ -73,7 +85,7 @@ module FakeFS
         end
 
         if dst_file && File.directory?(dst_file)
-          FileSystem.add(File.join(dest, src), src_file.entry.clone(dst_file))
+          FileSystem.add(File.join(dest, File.basename(src)), src_file.entry.clone(dst_file))
         else
           FileSystem.delete(dest)
           FileSystem.add(dest, src_file.entry.clone)
@@ -81,7 +93,14 @@ module FakeFS
       end
     end
 
-    def cp_r(src, dest)
+    alias_method :copy, :cp
+
+    def copy_file(src, dest, preserve = false, dereference = true)
+      # Not a perfect match, but similar to what regular FileUtils does.
+      cp(src, dest)
+    end
+
+    def cp_r(src, dest, options={})
       Array(src).each do |src|
         # This error sucks, but it conforms to the original Ruby
         # method.
@@ -124,6 +143,8 @@ module FakeFS
       end
     end
 
+    alias_method :move, :mv
+
     def chown(user, group, list, options={})
       list = Array(list)
       list.each do |f|
@@ -184,18 +205,30 @@ module FakeFS
       Array(list).each do |f|
         if fs = FileSystem.find(f)
           now = Time.now
-          fs.mtime = now
+          fs.mtime = options[:mtime] || now
           fs.atime = now
         else
-          f = File.open(f, 'w')
-          f.close
+          file = File.open(f, 'w')
+          file.close
+
+          if mtime = options[:mtime]
+            fs = FileSystem.find(f)
+            fs.mtime = mtime
+          end
         end
       end
     end
 
-    def cd(dir)
-      FileSystem.chdir(dir)
+    def cd(dir, &block)
+      FileSystem.chdir(dir, &block)
     end
     alias_method :chdir, :cd
+
+    def compare_file(file1, file2)
+      # we do a strict comparison of both files content
+      File.readlines(file1) == File.readlines(file2)
+    end
+    alias_method :cmp, :compare_file
+    alias_method :identical?, :compare_file
   end
 end

data/lib/fakefs/spec_helpers.rb

@@ -9,6 +9,10 @@
 #     ...
 #   end
 #
+# By default, including FakeFS::SpecHelpers will run for each example inside a describe block.
+# If you want to turn on FakeFS one time only for all your examples, you will need to
+# include FakeFS::SpecHelpers::All.
+#
 # Alternatively, you can include FakeFS::SpecHelpers in all your example groups using RSpec's
 # configuration block in your spec helper:
 #
@@ -23,23 +27,37 @@
 require 'fakefs/safe'
 
 module FakeFS
+  def use_fakefs(describe_block, opts)
+    describe_block.before opts[:with] do
+      FakeFS.activate!
+    end
+
+    describe_block.after opts[:with] do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear if opts[:with] == :each
+    end
+  end
+
   module SpecHelpers
+    include ::FakeFS
+
     def self.extended(example_group)
-      example_group.use_fakefs(example_group)
+      example_group.use_fakefs(example_group, :with => :each)
     end
 
     def self.included(example_group)
       example_group.extend self
     end
 
-    def use_fakefs(describe_block)
-      describe_block.before :each do
-        FakeFS.activate!
+    module All
+      include ::FakeFS
+
+      def self.extended(example_group)
+        example_group.use_fakefs(example_group, :with => :all)
       end
 
-      describe_block.after :each do
-        FakeFS.deactivate!
-        FakeFS::FileSystem.clear
+      def self.included(example_group)
+        example_group.extend self
       end
     end
   end

data/lib/fakefs/version.rb

@@ -1,6 +1,6 @@
 module FakeFS
   module Version
-    VERSION = "0.4.2"
+    VERSION = "0.4.3"
 
     def self.to_s
       VERSION

data/spec/fakefs/spec_helpers_spec.rb

@@ -53,5 +53,49 @@ module FakeFS
         end
       end
     end
+
+    describe SpecHelpers::All do
+      describe "when extending" do
+        context "before :all" do
+          it "should call it" do
+            @rspec_example_group.should_receive(:before).with(:all)
+            @rspec_example_group.extend FakeFS::SpecHelpers::All
+          end
+
+          it "should call FakeFS.activate!" do
+            FakeFS.should_receive(:activate!)
+            @rspec_example_group.extend FakeFS::SpecHelpers::All
+          end
+        end
+
+        context "after :all" do
+          it "should call it" do
+            @rspec_example_group.should_receive(:after).with(:all)
+            @rspec_example_group.extend FakeFS::SpecHelpers::All
+          end
+
+          it "should call FakeFS.deactivate!" do
+            FakeFS.should_receive(:deactivate!)
+            @rspec_example_group.extend FakeFS::SpecHelpers::All
+          end
+
+          it "should not call FakeFS::FileSystem.clear" do
+            FakeFS::FileSystem.should_not_receive(:clear)
+            @rspec_example_group.extend FakeFS::SpecHelpers::All
+          end
+        end
+      end
+
+      describe "when including" do
+        context "before :all" do
+          it "should call it" do
+            @rspec_example_group.should_receive(:before)
+            @rspec_example_group.class_eval do
+              include FakeFS::SpecHelpers::All
+            end
+          end
+        end
+      end
+    end
   end
 end

data/test/fakefs_test.rb

@@ -28,6 +28,22 @@ class FakeFSTest < Test::Unit::TestCase
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
+  def test_can_cd_to_directory_with_block
+    FileUtils.mkdir_p("/path/to/dir")
+    new_path = nil
+    FileUtils.cd("/path/to") do
+      new_path = Dir.getwd
+    end
+
+    assert_equal new_path, "/path/to"
+  end
+
+  def test_can_create_a_list_of_directories_with_file_utils_mkdir_p
+    FileUtils.mkdir_p(["/path/to/dir1", "/path/to/dir2"])
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir1']
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir2']
+  end
+
   def test_can_create_directories_with_options
     FileUtils.mkdir_p("/path/to/dir", :mode => 0755)
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
@@ -39,6 +55,13 @@ class FakeFSTest < Test::Unit::TestCase
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir']
   end
 
+  def test_can_create_a_list_of_directories_with_file_utils_mkdir
+    FileUtils.mkdir_p("/path/to/dir")
+    FileUtils.mkdir(["/path/to/dir/subdir1", "/path/to/dir/subdir2"])
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir1']
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir2']
+  end
+
   def test_raises_error_when_creating_a_new_dir_with_mkdir_in_non_existent_path
     assert_raises Errno::ENOENT do
       FileUtils.mkdir("/this/path/does/not/exists/newdir")
@@ -91,6 +114,23 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?("bar") == false
   end
 
+  def test_aliases_exist
+    assert File.respond_to?(:unlink)
+    assert FileUtils.respond_to?(:rm_f)
+    assert FileUtils.respond_to?(:rm_r)
+    assert FileUtils.respond_to?(:rm)
+    assert FileUtils.respond_to?(:rm_rf)
+    assert FileUtils.respond_to?(:symlink)
+    assert FileUtils.respond_to?(:move)
+    assert FileUtils.respond_to?(:copy)
+    assert FileUtils.respond_to?(:remove)
+    assert FileUtils.respond_to?(:rmtree)
+    assert FileUtils.respond_to?(:safe_unlink)
+    assert FileUtils.respond_to?(:remove_entry_secure)
+    assert FileUtils.respond_to?(:cmp)
+    assert FileUtils.respond_to?(:identical?)
+  end
+
   def test_knows_directories_exist
     FileUtils.mkdir_p(path = "/path/to/dir")
     assert File.exists?(path)
@@ -130,6 +170,11 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?(path)
   end
 
+  def test_file_utils_mkdir_takes_options
+    FileUtils.mkdir("/foo", :some => :option)
+    assert File.exists?("/foo")
+  end
+
   def test_symlink_with_missing_refferent_does_not_exist
     File.symlink('/foo', '/bar')
     assert !File.exists?('/bar')
@@ -480,7 +525,7 @@ class FakeFSTest < Test::Unit::TestCase
     File.open(path, 'w') do |f|
       f << 'Yada Yada'
     end
-    assert File.size?(path)
+    assert_equal 9, File.size?(path)
     assert_nil File.size?("other.txt")
   end
 
@@ -492,12 +537,49 @@ class FakeFSTest < Test::Unit::TestCase
     assert_nil File.size?("file.txt")
   end
 
+  def test_zero_on_empty_file
+    path = 'file.txt'
+    File.open(path, 'w') do |f|
+      f << ''
+    end
+    assert_equal true, File.zero?(path)
+  end
+
+  def test_zero_on_non_empty_file
+    path = 'file.txt'
+    File.open(path, 'w') do |f|
+      f << 'Not empty'
+    end
+    assert_equal false, File.zero?(path)
+  end
+
+  def test_zero_on_non_existent_file
+    path = 'file_does_not_exist.txt'
+    assert_equal false, File.zero?(path)
+  end
+
   def test_raises_error_on_mtime_if_file_does_not_exist
     assert_raise Errno::ENOENT do
       File.mtime('/path/to/file.txt')
     end
   end
 
+  def test_can_set_mtime_on_new_file_touch_with_param
+    time = Time.new(2002, 10, 31, 2, 2, 2, "+02:00")
+    FileUtils.touch("foo.txt", :mtime => time)
+
+    assert_equal File.mtime("foo.txt"), time
+  end
+
+  def test_can_set_mtime_on_existing_file_touch_with_param
+    FileUtils.touch("foo.txt")
+
+    time = Time.new(2002, 10, 31, 2, 2, 2, "+02:00")
+    FileUtils.touch("foo.txt", :mtime => time)
+
+    assert_equal File.mtime("foo.txt"), time
+  end
+
   def test_can_return_mtime_on_existing_file
     path = 'file.txt'
     File.open(path, 'w') do |f|
@@ -638,7 +720,25 @@ class FakeFSTest < Test::Unit::TestCase
       f.puts ["woot","toot"]
     end
 
-    assert_equal %w(Yatta! Gatta! woot toot), File.readlines(path)
+    assert_equal ["Yatta!\n", "Gatta!\n", "woot\n", "toot\n"], File.readlines(path)
+  end
+
+  def test_can_read_with_File_readlines_and_only_empty_lines
+    path = 'file.txt'
+    File.open(path, 'w') do |f|
+      f.write "\n"
+    end
+
+    assert_equal ["\n"], File.readlines(path)
+  end
+
+  def test_can_read_with_File_readlines_and_new_lines
+    path = 'file.txt'
+    File.open(path, 'w') do |f|
+      f.write "this\nis\na\ntest\n"
+    end
+
+    assert_equal ["this\n", "is\n", "a\n", "test\n"], File.readlines(path)
   end
 
   def test_File_close_disallows_further_access
@@ -691,6 +791,14 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_file_read_errors_on_directory
+    FileUtils.mkdir_p("a_directory")
+
+    assert_raise Errno::EISDIR do
+      File.read("a_directory")
+    end
+  end
+
   def test_knows_files_are_files
     path = 'file.txt'
     File.open(path, 'w') do |f|
@@ -724,6 +832,10 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal RealFile.file?('does/not/exist.txt'), File.file?('does/not/exist.txt')
   end
 
+  def test_executable_returns_false_for_non_existent_files
+    assert !File.executable?('/does/not/exist')
+  end
+
   def test_can_chown_files
     good = 'file.txt'
     bad = 'nofile.txt'
@@ -785,6 +897,7 @@ class FakeFSTest < Test::Unit::TestCase
 
     assert_equal [good], FileUtils.chmod(0600, good, :verbose => true)
     assert_equal File.stat(good).mode, 0100600
+    assert_equal File.executable?(good), false
     assert_raises(Errno::ENOENT) do
       FileUtils.chmod(0600, bad)
     end
@@ -800,6 +913,14 @@ class FakeFSTest < Test::Unit::TestCase
     assert_raises(Errno::ENOENT) do
       FileUtils.chmod(0644, bad)
     end
+
+    assert_equal [good], FileUtils.chmod(0744, [good])
+    assert_equal File.executable?(good), true
+
+    # This behaviour is unimplemented, the spec below is only to show that it
+    # is a deliberate YAGNI omission.
+    assert_equal [good], FileUtils.chmod(0477, [good])
+    assert_equal File.executable?(good), false
   end
 
   def test_can_chmod_R_files
@@ -860,6 +981,13 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_file_utils_cp_r_takes_ignored_options
+    FileUtils.touch "/foo"
+
+    FileUtils.cp_r '/foo', '/bar', :verbose => true
+    assert_equal Dir.glob("/*").sort, ["/bar", "/foo"]
+  end
+
   def test_dir_glob_handles_root
     FileUtils.mkdir_p '/path'
 
@@ -867,6 +995,11 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/'], Dir['/']
   end
 
+  def test_dir_glob_takes_optional_flags
+    FileUtils.touch "/foo"
+    assert_equal Dir.glob("/*", 0), ["/foo"]
+  end
+
   def test_dir_glob_handles_recursive_globs
     FileUtils.mkdir_p "/one/two/three"
     File.open('/one/two/three/four.rb', 'w')
@@ -894,6 +1027,16 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 2, yielded.size
   end
 
+  def test_copy_with_subdirectory
+    FileUtils.mkdir_p "/one/two/three/"
+    FileUtils.mkdir_p "/onebis/two/three/"
+    FileUtils.touch "/one/two/three/foo"
+    Dir.glob("/one/two/three/*") do |hook|
+      FileUtils.cp(hook, "/onebis/two/three/")
+    end
+    assert_equal ['/onebis/two/three/foo'], Dir['/onebis/two/three/*']
+  end
+
   if RUBY_VERSION >= "1.9"
     def test_dir_home
       assert_equal RealDir.home, Dir.home
@@ -1189,6 +1332,12 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_copy_file_works
+    File.open('foo', 'w') {|f| f.write 'bar' }
+    FileUtils.copy_file('foo', 'baz', :ignore_param_1, :ignore_param_2)
+    assert_equal 'bar', File.read('baz')
+  end
+
   def test_cp_r_doesnt_tangle_files_together
     File.open('foo', 'w') { |f| f.write 'bar' }
     FileUtils.cp_r('foo', 'baz')
@@ -1705,6 +1854,14 @@ class FakeFSTest < Test::Unit::TestCase
     test.each { |t| assert yielded.include?(t) }
   end
 
+  def test_directory_exists
+    assert Dir.exists?('/this/path/should/be/here') == false
+    assert Dir.exist?('/this/path/should/be/here') == false
+    FileUtils.mkdir_p('/this/path/should/be/here')
+    assert Dir.exists?('/this/path/should/be/here') == true
+    assert Dir.exist?('/this/path/should/be/here') == true
+  end
+
   def test_tmpdir
     assert Dir.tmpdir == "/tmp"
   end
@@ -1854,10 +2011,6 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
-  def test_unlink_is_alias_for_delete
-    assert_equal File.method(:unlink), File.method(:delete)
-  end
-
   def test_unlink_removes_only_one_file_content
     File.open("/foo", "w") { |f| f << "some_content" }
     File.link("/foo", "/bar")
@@ -2103,6 +2256,10 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_file_umask
     assert_equal File.umask, RealFile.umask
+    File.umask(1234)
+
+    assert_equal File.umask, RealFile.umask
+    assert_equal File.umask, 1234
   end
 
   def test_file_stat_comparable
@@ -2129,10 +2286,41 @@ class FakeFSTest < Test::Unit::TestCase
     assert (different1.stat <=> different2.stat) == -1
   end
 
+  def test_file_binread_works
+    File.open("testfile", 'w') do |f|
+      f << "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
+    end
+
+    assert_equal File.binread("testfile"), "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
+    assert_equal File.binread("testfile", 20), "This is line one\nThi"
+    assert_equal File.binread("testfile", 20, 10), "ne one\nThis is line "
+  end
+
   def here(fname)
     RealFile.expand_path(File.join(RealFile.dirname(__FILE__), fname))
   end
 
+  def test_file_utils_compare_file
+    file1 = 'file1.txt'
+    file2 = 'file2.txt'
+    file3 = 'file3.txt'
+    content = "This is my \n file\content\n"
+    File.open(file1, 'w') do |f|
+      f.write content
+    end
+    File.open(file3, 'w') do |f|
+      f.write "#{content} with additional content"
+    end
+
+    FileUtils.cp file1, file2
+
+    assert_equal FileUtils.compare_file(file1, file2), true
+    assert_equal FileUtils.compare_file(file1, file3), false
+    assert_raises Errno::ENOENT do
+      FileUtils.compare_file(file1, "file4.txt")
+    end
+  end
+
   if RUBY_VERSION >= "1.9.2"
     def test_file_size
       File.open("foo", 'w') do |f|
@@ -2173,5 +2361,32 @@ class FakeFSTest < Test::Unit::TestCase
         end
       end
     end
+
+    def test_file_write_can_write_a_file
+      File.write("testfile", "0123456789")
+      assert_equal File.read("testfile"), "0123456789"
+    end
+
+    def test_file_write_returns_the_length_written
+      assert_equal File.write("testfile", "0123456789"), 10
+    end
+
+    def test_file_write_truncates_file_if_offset_not_given
+      File.open("foo", 'w') do |f|
+        f << "foo"
+      end
+
+      File.write('foo', 'bar')
+      assert_equal File.read('foo'), 'bar'
+    end
+
+    def test_file_write_writes_at_offset_and_does_not_truncate
+      File.open("foo", 'w') do |f|
+        f << "foo"
+      end
+
+      File.write('foo', 'bar', 3)
+      assert_equal File.read('foo'), 'foobar'
+    end
   end
 end

data/test/file/stat_test.rb

@@ -34,24 +34,28 @@ class FileStatTest < Test::Unit::TestCase
     ln_s("/foo", "/bar")
 
     assert File::Stat.new("/bar").symlink?
+    assert File::Stat.new("/bar").ftype == "link"
   end
 
   def test_symlink_should_be_false_when_not_a_symlink
     FileUtils.touch("/foo")
 
     assert !File::Stat.new("/foo").symlink?
+    assert File::Stat.new("/foo").ftype == "file"
   end
 
   def test_should_return_false_for_directory_when_not_a_directory
     FileUtils.touch("/foo")
 
     assert !File::Stat.new("/foo").directory?
+    assert File::Stat.new("/foo").ftype == "file"
   end
 
   def test_should_return_true_for_directory_when_a_directory
     mkdir "/foo"
 
     assert File::Stat.new("/foo").directory?
+    assert File::Stat.new("/foo").ftype == "directory"
   end
 
   def test_writable_is_true
@@ -106,4 +110,12 @@ class FileStatTest < Test::Unit::TestCase
     File.open('/foo', 'w') { |f| f << 'test' }
     assert File.mtime("/foo") > mtime
   end
+
+  def test_responds_to_realpath_only_on_1_9
+    if RUBY_VERSION > '1.9'
+      assert File.respond_to?(:realpath)
+    else
+      assert !File.respond_to?(:realpath)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakefs
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-24 00:00:00.000000000 Z
+date: 2013-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -123,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4092255673165272959
+      hash: -790320842587735539
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: