fakefs 0.2.1 → 0.3.2

data/test/fakefs_test.rb

@@ -1,14 +1,17 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'fakefs'
-require 'test/unit'
+require "test_helper"
 
 class FakeFSTest < Test::Unit::TestCase
   include FakeFS
 
   def setup
+    FakeFS.activate!
     FileSystem.clear
   end
 
+  def teardown
+    FakeFS.deactivate!
+  end
+
   def test_can_be_initialized_empty
     fs = FileSystem
     assert_equal 0, fs.files.size
@@ -20,16 +23,48 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 1, fs.files.size
   end
 
-  def test_can_create_directories
+  def test_can_create_directories_with_file_utils_mkdir_p
     FileUtils.mkdir_p("/path/to/dir")
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   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']
+  end
+
+  def test_can_create_directories_with_file_utils_mkdir
+    FileUtils.mkdir_p("/path/to/dir")
+    FileUtils.mkdir("/path/to/dir/subdir")
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']['subdir']
+  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")
+    end
+  end
+
   def test_can_create_directories_with_mkpath
     FileUtils.mkpath("/path/to/dir")
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
   end
 
+  def test_can_create_directories_with_mkpath_and_options
+    FileUtils.mkpath("/path/to/dir", :mode => 0755)
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+  end
+
+  def test_can_create_directories_with_mkpath
+    FileUtils.makedirs("/path/to/dir")
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+  end
+
+  def test_can_create_directories_with_mkpath_and_options
+    FileUtils.makedirs("/path/to/dir", :mode => 0755)
+    assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
+  end
+
   def test_can_delete_directories
     FileUtils.mkdir_p("/path/to/dir")
     FileUtils.rmdir("/path/to/dir")
@@ -37,6 +72,13 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?("/path/to/dir") == false
   end
 
+  def test_can_delete_multiple_files
+    FileUtils.touch(["foo", "bar"])
+    FileUtils.rm(["foo", "bar"])
+    assert File.exists?("foo") == false
+    assert File.exists?("bar") == false
+  end
+
   def test_knows_directories_exist
     FileUtils.mkdir_p(path = "/path/to/dir")
     assert File.exists?(path)
@@ -63,6 +105,10 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.exists?(path)
     FileUtils.mkdir_p("/path/to")
     assert File.exists?(path)
+    assert_raises Errno::EEXIST do
+      FileUtils.mkdir("/path/to")
+    end
+    assert File.exists?(path)
   end
 
   def test_can_create_symlinks
@@ -74,14 +120,14 @@ class FakeFSTest < Test::Unit::TestCase
       FileUtils.ln_s(target, '/path/to/link')
     end
   end
-  
+
   def test_can_force_creation_of_symlinks
     FileUtils.mkdir_p(target = "/path/to/first/target")
     FileUtils.ln_s(target, "/path/to/link")
     assert_kind_of FakeSymlink, FileSystem.fs['path']['to']['link']
     FileUtils.ln_s(target, '/path/to/link', :force => true)
   end
-  
+
   def test_create_symlink_using_ln_sf
     FileUtils.mkdir_p(target = "/path/to/first/target")
     FileUtils.ln_s(target, "/path/to/link")
@@ -288,7 +334,7 @@ class FakeFSTest < Test::Unit::TestCase
     assert_nil File.size?("/path/to/other.txt")
   end
 
-  def test_can_check_size?_of_empty_file
+  def test_can_check_size_of_empty_file
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
       f << ''
@@ -310,6 +356,86 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.mtime('/path/to/file.txt').is_a?(Time)
   end
 
+  def test_raises_error_on_ctime_if_file_does_not_exist
+    assert_raise Errno::ENOENT do
+      File.ctime('/path/to/file.txt')
+    end
+  end
+
+  def test_can_return_ctime_on_existing_file
+    File.open("foo", "w") { |f| f << "some content" }
+    assert File.ctime('foo').is_a?(Time)
+  end
+
+  def test_ctime_and_mtime_are_equal_for_new_files
+    File.open("foo", "w") { |f| f << "some content" }
+    ctime = File.ctime("foo")
+    mtime = File.mtime("foo")
+    assert ctime.is_a?(Time)
+    assert mtime.is_a?(Time)
+    assert_equal ctime, mtime
+
+    File.open("foo", "r") do |f|
+      assert_equal ctime, f.ctime
+      assert_equal mtime, f.mtime
+    end
+  end
+
+  def test_ctime_and_mtime_are_equal_for_new_directories
+    FileUtils.mkdir_p("foo")
+    ctime = File.ctime("foo")
+    mtime = File.mtime("foo")
+    assert ctime.is_a?(Time)
+    assert mtime.is_a?(Time)
+    assert_equal ctime, mtime
+  end
+
+  def test_file_ctime_is_equal_to_file_stat_ctime
+    File.open("foo", "w") { |f| f << "some content" }
+    assert_equal File.stat("foo").ctime, File.ctime("foo")
+  end
+
+  def test_directory_ctime_is_equal_to_directory_stat_ctime
+    FileUtils.mkdir_p("foo")
+    assert_equal File.stat("foo").ctime, File.ctime("foo")
+  end
+
+  def test_file_mtime_is_equal_to_file_stat_mtime
+    File.open("foo", "w") { |f| f << "some content" }
+    assert_equal File.stat("foo").mtime, File.mtime("foo")
+  end
+
+  def test_directory_mtime_is_equal_to_directory_stat_mtime
+    FileUtils.mkdir_p("foo")
+    assert_equal File.stat("foo").mtime, File.mtime("foo")
+  end
+
+  def test_utime_raises_error_if_path_does_not_exist
+    assert_raise Errno::ENOENT do
+      File.utime(Time.now, Time.now, '/path/to/file.txt')
+    end
+  end
+
+  def test_can_call_utime_on_an_existing_file
+    time = Time.now - 300 # Not now
+    path = '/path/to/file.txt'
+    File.open(path, 'w') do |f|
+      f << ''
+    end
+    File.utime(time, time, path)
+    assert_equal time, File.mtime('/path/to/file.txt')
+  end
+
+  def test_utime_returns_number_of_paths
+    path1, path2 = '/path/to/file.txt', '/path/to/another_file.txt'
+    [path1, path2].each do |path|
+      File.open(path, 'w') do |f|
+        f << ''
+      end
+    end
+    assert_equal 2, File.utime(Time.now, Time.now, path1, path2)
+  end
+
   def test_can_read_with_File_readlines
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -330,6 +456,16 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_File_close_disallows_further_writes
+    path = '/path/to/file.txt'
+    file = File.open(path, 'w')
+    file.write 'Yada'
+    file.close
+    assert_raise IOError do
+      file << "foo"
+    end
+  end
+
   def test_can_read_from_file_objects
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -354,6 +490,16 @@ class FakeFSTest < Test::Unit::TestCase
     assert File.file?(path)
   end
 
+  def test_File_io_returns_self
+    f = File.open("/foo", "w")
+    assert_equal f, f.to_io
+  end
+
+  def test_File_to_i_is_alias_for_filno
+    f = File.open("/foo", "w")
+    assert_equal f.method(:to_i), f.method(:fileno)
+  end
+
   def test_knows_symlink_files_are_files
     path = '/path/to/file.txt'
     File.open(path, 'w') do |f|
@@ -418,6 +564,12 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/path/foo', '/path/foobar'], Dir['/p*h/foo*']
     assert_equal ['/path/foo', '/path/foobar'], Dir['/p??h/foo*']
 
+    assert_equal ['/path/bar', '/path/bar/baz', '/path/bar2', '/path/bar2/baz', '/path/foo', '/path/foobar'], Dir['/path/**/*']
+    assert_equal ['/path', '/path/bar', '/path/bar/baz', '/path/bar2', '/path/bar2/baz', '/path/foo', '/path/foobar'], Dir['/**/*']
+
+    assert_equal ['/path/bar', '/path/bar/baz', '/path/bar2', '/path/bar2/baz', '/path/foo', '/path/foobar'], Dir['/path/**/*']
+    assert_equal ['/path/bar/baz'], Dir['/path/bar/**/*']
+
     FileUtils.cp_r '/path', '/otherpath'
 
     assert_equal %w( /otherpath/foo /otherpath/foobar /path/foo /path/foobar ), Dir['/*/foo*']
@@ -438,11 +590,84 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/one/two/three'], Dir['/one/**/three']
   end
 
-  def test_dir_recursive_glob_ending_in_wildcards_only_returns_files
+  def test_dir_recursive_glob_ending_in_wildcards_returns_both_files_and_dirs
     File.open('/one/two/three/four.rb', 'w')
     File.open('/one/five.rb', 'w')
-    assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**/*']
-    assert_equal ['/one/five.rb', '/one/two/three/four.rb'], Dir['/one/**']
+    assert_equal ['/one/five.rb', '/one/two', '/one/two/three', '/one/two/three/four.rb'], Dir['/one/**/*']
+    assert_equal ['/one/five.rb', '/one/two'], Dir['/one/**']
+  end
+
+  def test_dir_glob_with_block
+    FileUtils.touch('foo')
+    FileUtils.touch('bar')
+
+    yielded = []
+    Dir.glob('*') { |file| yielded << file }
+
+    assert_equal 2, yielded.size
+  end
+
+  def test_should_report_pos_as_0_when_opening
+    File.open("/foo", "w") do |f|
+      f << "foobar"
+      f.rewind
+
+      assert_equal 0, f.pos
+    end
+  end
+
+  def test_should_report_pos_as_1_when_seeking_one_char
+    File.open("/foo", "w") do |f|
+      f << "foobar"
+
+      f.rewind
+      f.seek(1)
+
+      assert_equal 1, f.pos
+    end
+  end
+
+  def test_should_set_pos
+    File.open("/foo", "w") do |f|
+      f << "foo"
+    end
+
+    fp = File.open("/foo", "r")
+    fp.pos = 1
+
+    assert_equal 1, fp.pos
+  end
+
+  def test_should_set_pos_with_tell_method
+    File.open("/foo", "w") do |f|
+      f << "foo"
+    end
+
+    fp = File.open("/foo", "r")
+    fp.tell = 1
+
+    assert_equal 1, fp.pos
+  end
+
+  # Every method in File is in FakeFS::File
+  RealFile.instance_methods.each do |method_name|
+    define_method "test_should_have_method_#{method_name}_from_real_file_class" do
+      assert File.instance_methods.include?(method_name)
+    end
+  end
+
+  # No methods which are in StringIO that aren't in File are included into
+  # FakeFS::File (because of inheritence)
+  uniq_string_io_methods = StringIO.instance_methods - RealFile.instance_methods
+  uniq_string_io_methods.each do |method_name|
+    define_method "test_file_should_not_respond_to_#{method_name}" do
+      assert !File.instance_methods.include?(method_name)
+    end
+  end
+
+  def test_does_not_remove_methods_from_stringio
+    stringio = StringIO.new("foo")
+    assert stringio.respond_to?(:size)
   end
 
   def test_chdir_changes_directories_like_a_boss
@@ -577,6 +802,10 @@ class FakeFSTest < Test::Unit::TestCase
     assert_raise(Errno::ENOENT) do
       FileUtils.mv 'blafgag', 'foo'
     end
+    exception = assert_raise(Errno::ENOENT) do
+      FileUtils.mv ['foo', 'bar'], 'destdir'
+    end
+    assert_equal "No such file or directory - foo", exception.message
   end
 
   def test_mv_actually_works
@@ -585,6 +814,29 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 'bar', File.open('baz') { |f| f.read }
   end
 
+  def test_mv_works_with_options
+    File.open('foo', 'w') {|f| f.write 'bar'}
+    FileUtils.mv 'foo', 'baz', :force => true
+    assert_equal('bar', File.open('baz') { |f| f.read })
+  end
+
+  def test_mv_to_directory
+    File.open('foo', 'w') {|f| f.write 'bar'}
+    FileUtils.mkdir_p 'destdir'
+    FileUtils.mv 'foo', 'destdir'
+    assert_equal('bar', File.open('destdir/foo') {|f| f.read })
+    assert File.directory?('destdir')
+  end
+
+  def test_mv_array
+    File.open('foo', 'w') {|f| f.write 'bar' }
+    File.open('baz', 'w') {|f| f.write 'binky' }
+    FileUtils.mkdir_p 'destdir'
+    FileUtils.mv %w(foo baz), 'destdir'
+    assert_equal('bar', File.open('destdir/foo') {|f| f.read })
+    assert_equal('binky', File.open('destdir/baz') {|f| f.read })
+  end
+
   def test_cp_actually_works
     File.open('foo', 'w') {|f| f.write 'bar' }
     FileUtils.cp('foo', 'baz')
@@ -695,25 +947,34 @@ class FakeFSTest < Test::Unit::TestCase
   end
 
   def test_clone_clones_directories
+    FakeFS.deactivate!
     RealFileUtils.mkdir_p(here('subdir'))
+    FakeFS.activate!
 
     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'))
+    FakeFS.deactivate!
+    RealFileUtils.rm_rf(here('subdir'))
+    FakeFS.activate!
   end
 
   def test_clone_clones_dot_files_even_hard_to_find_ones
+    FakeFS.deactivate!
     RealFileUtils.mkdir_p(here('subdir/.bar/baz/.quux/foo'))
+    FakeFS.activate!
+
     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'))
+    FakeFS.deactivate!
+    RealFileUtils.rm_rf(here('subdir'))
+    FakeFS.activate!
   end
 
   def test_putting_a_dot_at_end_copies_the_contents
@@ -1019,6 +1280,14 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_mkdir_raises_error_if_already_created
+    Dir.mkdir "foo"
+
+    assert_raises(Errno::EEXIST) do
+      Dir.mkdir "foo"
+    end
+  end
+
   def test_directory_open
     test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
 
@@ -1053,38 +1322,92 @@ class FakeFSTest < Test::Unit::TestCase
   def test_tmpdir
     assert Dir.tmpdir == "/tmp"
   end
-  
+
+  def test_rename_renames_a_file
+    FileUtils.touch("/foo")
+    File.rename("/foo", "/bar")
+    assert File.file?("/bar")
+  end
+
+  def test_rename_returns
+    FileUtils.touch("/foo")
+    assert_equal 0, File.rename("/foo", "/bar")
+  end
+
+  def test_rename_renames_two_files
+    FileUtils.touch("/foo")
+    FileUtils.touch("/bar")
+    File.rename("/foo", "/bar")
+    assert File.file?("/bar")
+  end
+
+  def test_rename_renames_a_directories
+    Dir.mkdir("/foo")
+    File.rename("/foo", "/bar")
+    assert File.directory?("/bar")
+  end
+
+  def test_rename_renames_two_directories
+    Dir.mkdir("/foo")
+    Dir.mkdir("/bar")
+    File.rename("/foo", "/bar")
+    assert File.directory?("/bar")
+  end
+
+  def test_rename_file_to_directory_raises_error
+    FileUtils.touch("/foo")
+    Dir.mkdir("/bar")
+    assert_raises(Errno::EISDIR) do
+      File.rename("/foo", "/bar")
+    end
+  end
+
+  def test_rename_directory_to_file_raises_error
+    Dir.mkdir("/foo")
+    FileUtils.touch("/bar")
+    assert_raises(Errno::ENOTDIR) do
+      File.rename("/foo", "/bar")
+    end
+  end
+
+
+  def test_rename_with_missing_source_raises_error
+    assert_raises(Errno::ENOENT) do
+      File.rename("/no_such_file", "/bar")
+    end
+  end
+
   def test_hard_link_creates_file
     FileUtils.touch("/foo")
-    
+
     File.link("/foo", "/bar")
     assert File.exists?("/bar")
   end
-  
+
   def test_hard_link_with_missing_file_raises_error
     assert_raises(Errno::ENOENT) do
       File.link("/foo", "/bar")
     end
   end
-  
+
   def test_hard_link_with_existing_destination_file
     FileUtils.touch("/foo")
     FileUtils.touch("/bar")
-    
+
     assert_raises(Errno::EEXIST) do
       File.link("/foo", "/bar")
     end
   end
-  
+
   def test_hard_link_returns_0_when_successful
     FileUtils.touch("/foo")
-    
+
     assert_equal 0, File.link("/foo", "/bar")
   end
-  
+
   def test_hard_link_returns_duplicate_file
     File.open("/foo", "w") { |x| x << "some content" }
-    
+
     File.link("/foo", "/bar")
     assert_equal "some content", File.read("/bar")
   end
@@ -1245,7 +1568,88 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal IO::SEEK_SET, File::SEEK_SET
   end
 
+  def test_filetest_exists_return_correct_values
+    FileUtils.mkdir_p("/path/to/dir")
+    assert FileTest.exist?("/path/to/")
+
+    FileUtils.rmdir("/path/to/dir")
+    assert !FileTest.exist?("/path/to/dir")
+  end
+
+  def test_filetest_directory_returns_correct_values
+    FileUtils.mkdir_p '/path/to/somedir'
+    assert FileTest.directory?('/path/to/somedir')
+
+    FileUtils.rm_r '/path/to/somedir'
+    assert !FileTest.directory?('/path/to/somedir')
+  end
+
+  def test_pathname_exists_returns_correct_value
+    FileUtils.touch "foo"
+    assert Pathname.new("foo").exist?
+
+    assert !Pathname.new("bar").exist?
+  end
+
+  def test_dir_mktmpdir
+    FileUtils.mkdir '/tmp'
+
+    tmpdir = Dir.mktmpdir
+    assert File.directory?(tmpdir)
+    FileUtils.rm_r tmpdir
+
+    Dir.mktmpdir do |t|
+      tmpdir = t
+      assert File.directory?(t)
+    end
+    assert !File.directory?(tmpdir)
+  end
+
+  def test_activating_returns_true
+    FakeFS.deactivate!
+    assert_equal true, FakeFS.activate!
+  end
+
+  def test_deactivating_returns_true
+    assert_equal true, FakeFS.deactivate!
+  end
+
+  def test_split
+    assert File.respond_to? :split
+    filename = "/this/is/what/we/expect.txt"
+    path,filename = File.split(filename)
+    assert_equal path, "/this/is/what/we"
+    assert_equal filename, "expect.txt"
+  end
+
+
   def here(fname)
-    RealFile.expand_path(RealFile.dirname(__FILE__)+'/'+fname)
+    RealFile.expand_path(File.join(RealFile.dirname(__FILE__), fname))
+  end
+
+  if RUBY_VERSION >= "1.9.2"
+    def test_file_size
+      File.open("foo", 'w') do |f|
+        f << 'Yada Yada'
+        assert_equal 9, f.size
+      end
+    end
+
+    def test_fdatasync
+      File.open("foo", 'w') do |f|
+        f << 'Yada Yada'
+        assert_nothing_raised do
+          f.fdatasync
+        end
+      end
+    end
+
+    def test_autoclose
+      File.open("foo", 'w') do |f|
+        assert_equal true, f.autoclose?
+        f.autoclose = false
+        assert_equal false, f.autoclose?
+      end
+    end
   end
 end

data/test/file/stat_test.rb

@@ -1,6 +1,4 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
-require 'fakefs/safe'
-require 'test/unit'
+require "test_helper"
 
 class FileStatTest < Test::Unit::TestCase
   include FakeFS
@@ -67,4 +65,9 @@ class FileStatTest < Test::Unit::TestCase
 
     assert_equal 2, File.stat("testfile").nlink
   end
+
+  def test_file_size
+    File.open('testfile', 'w') { |f| f << 'test' }
+    assert_equal 4, File.stat('testfile').size
+  end
 end

data/test/safe_test.rb

@@ -1,12 +1,14 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'fakefs/safe'
-require 'test/unit'
+require "test_helper"
 
 class FakeFSSafeTest < Test::Unit::TestCase
   def setup
     FakeFS.deactivate!
   end
 
+  def teardown
+    FakeFS.activate!
+  end
+
   def test_FakeFS_method_does_not_intrude_on_global_namespace
     path = '/path/to/file.txt'
 
@@ -26,7 +28,7 @@ class FakeFSSafeTest < Test::Unit::TestCase
 
     assert_equal result, "Yatta!"
   end
-  
+
   def test_FakeFS_method_deactivates_FakeFS_when_block_raises_exception
     begin
       FakeFS do
@@ -34,9 +36,9 @@ class FakeFSSafeTest < Test::Unit::TestCase
       end
     rescue
     end
-    
+
     assert_equal RealFile, File, "File is #{File} (should be #{RealFile})"
-    assert_equal RealFileUtils, FileUtils, "FileUtils is #{FileUtils} (should be #{RealFileUtils})"    
+    assert_equal RealFileUtils, FileUtils, "FileUtils is #{FileUtils} (should be #{RealFileUtils})"
     assert_equal RealDir, Dir, "Dir is #{Dir} (should be #{RealDir})"
-  end  
+  end
 end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'fakefs/safe'
+require 'test/unit'
+
+begin
+  require 'redgreen'
+rescue LoadError
+end