fakefs 0.4.3 → 0.5.0

data/lib/fakefs/file_system.rb

@@ -3,7 +3,7 @@ module FakeFS
     extend self
 
     def dir_levels
-      @dir_levels ||= []
+      @dir_levels ||= ['/']
     end
 
     def fs
@@ -36,9 +36,11 @@ module FakeFS
       parts = path_parts(normalize_path(path))
 
       d = parts[0...-1].inject(fs) do |dir, part|
+        assert_dir dir[part] if dir[part]
         dir[part] ||= FakeDir.new(part, dir)
       end
 
+      assert_dir d
       object.name = parts.last
       object.parent = d
       d[parts.last] ||= object
@@ -47,21 +49,21 @@ module FakeFS
     # copies directories and files from the real filesystem
     # into our fake one
     def clone(path, target = nil)
-      path    = File.expand_path(path)
+      path    = RealFile.expand_path(path)
       pattern = File.join(path, '**', '*')
       files   = RealFile.file?(path) ? [path] : [path] + RealDir.glob(pattern, RealFile::FNM_DOTMATCH)
 
       files.each do |f|
         target_path = target ? f.gsub(path, target) : f
-        if RealFile.file?(f)
+        if RealFile.symlink?(f)
+          FileUtils.ln_s(RealFile.readlink(f), f)
+        elsif RealFile.file?(f)
           FileUtils.mkdir_p(File.dirname(f))
           File.open(target_path, File::WRITE_ONLY) do |g|
             g.print RealFile.open(f){|h| h.read }
           end
         elsif RealFile.directory?(f)
           FileUtils.mkdir_p(target_path)
-        elsif RealFile.symlink?(f)
-          FileUtils.ln_s()
         end
       end
     end
@@ -91,15 +93,15 @@ module FakeFS
 
     def normalize_path(path)
       if Pathname.new(path).absolute?
-        File.expand_path(path)
+        RealFile.expand_path(path)
       else
         parts = dir_levels + [path]
-        File.expand_path(File.join(*parts))
+        RealFile.expand_path(parts.inject {|base, part| Pathname(base) + part }.to_s)
       end
     end
 
     def current_dir
-      find(normalize_path('.'))
+      find('.')
     end
 
     private
@@ -107,7 +109,7 @@ module FakeFS
     def drop_root(path_parts)
       # we need to remove parts from root dir at least for windows and jruby
       return path_parts if path_parts.nil? || path_parts.empty?
-      root = File.expand_path('/').split(File::SEPARATOR).first
+      root = RealFile.expand_path('/').split(File::SEPARATOR).first
       path_parts.shift if path_parts.first == root
       path_parts
     end
@@ -145,5 +147,9 @@ module FakeFS
       children = dir.entries.select{|f| f.is_a? FakeDir}
       ([dir] + children + children.map{|c| directories_under(c)}).flatten.uniq
     end
+
+    def assert_dir(dir)
+      raise Errno::EEXIST, dir.name unless dir.is_a?(FakeDir)
+    end
   end
 end

data/lib/fakefs/file_test.rb

@@ -1,15 +1,21 @@
 module FakeFS
-  class FileTest
-    def self.exist?(file_name)
+  module FileTest
+    extend self
+
+    def exist?(file_name)
       File.exist?(file_name)
     end
 
-    def self.directory?(file_name)
+    def directory?(file_name)
       File.directory?(file_name)
     end
 
-    def self.file?(file_name)
+    def file?(file_name)
       File.file?(file_name)
     end
+
+    def writable?(file_name)
+      File.writable?(file_name)
+    end
   end
 end

data/lib/fakefs/fileutils.rb

@@ -16,8 +16,8 @@ module FakeFS
       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)
+        raise Errno::ENOENT, path unless parent.join == "" || parent.join == "." || FileSystem.find(parent.join('/'))
+        raise Errno::EEXIST, path if FileSystem.find(path)
         FileSystem.add(path, FakeDir.new)
       end
     end
@@ -27,7 +27,7 @@ module FakeFS
       list.each do |l|
         parent = l.split('/')
         parent.pop
-        raise Errno::ENOENT, "No such file or directory - #{l}" unless parent.join == "" || FileSystem.find(parent.join('/'))
+        raise Errno::ENOENT, l unless parent.join == "" || FileSystem.find(parent.join('/'))
         raise Errno::ENOENT, l unless FileSystem.find(l)
         raise Errno::ENOTEMPTY, l unless FileSystem.find(l).empty?
         rm(l)
@@ -67,11 +67,17 @@ module FakeFS
 
     alias_method :symlink, :ln_s
 
-    def cp(src, dest)
+    def cp(src, dest, options={})
       if src.is_a?(Array) && !File.directory?(dest)
         raise Errno::ENOTDIR, dest
       end
 
+      # handle `verbose' flag
+      RealFileUtils.cp src, dest, options.merge(:noop => true)
+
+      # handle `noop' flag
+      return if options[:noop]
+
       Array(src).each do |src|
         dst_file = FileSystem.find(dest)
         src_file = FileSystem.find(src)
@@ -91,6 +97,8 @@ module FakeFS
           FileSystem.add(dest, src_file.entry.clone)
         end
       end
+
+      return nil
     end
 
     alias_method :copy, :cp
@@ -101,6 +109,12 @@ module FakeFS
     end
 
     def cp_r(src, dest, options={})
+      # handle `verbose' flag
+      RealFileUtils.cp_r src, dest, options.merge(:noop => true)
+
+      # handle `noop' flag
+      return if options[:noop]
+
       Array(src).each do |src|
         # This error sucks, but it conforms to the original Ruby
         # method.
@@ -128,19 +142,35 @@ module FakeFS
           FileSystem.add(dest, dir.entry.clone)
         end
       end
+
+      return nil
     end
 
     def mv(src, dest, options={})
+      # handle `verbose' flag
+      RealFileUtils.mv src, dest, options.merge(:noop => true)
+
+      # handle `noop' flag
+      return if options[:noop]
+
       Array(src).each do |path|
         if target = FileSystem.find(path)
           dest_path = File.directory?(dest) ? File.join(dest, File.basename(path)) : dest
-          FileSystem.delete(dest_path)
-          FileSystem.add(dest_path, target.entry.clone)
-          FileSystem.delete(path)
+          if File.directory?(dest_path)
+            raise Errno::EEXIST, dest_path unless options[:force]
+          elsif File.directory?(File.dirname(dest_path))
+            FileSystem.delete(dest_path)
+            FileSystem.add(dest_path, target.entry.clone)
+            FileSystem.delete(path)
+          else
+            raise Errno::ENOENT, dest_path unless options[:force]
+          end
         else
           raise Errno::ENOENT, path
         end
       end
+
+      return nil
     end
 
     alias_method :move, :mv

data/lib/fakefs/version.rb

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

data/spec/fakefs/fakefs_bug_ruby_2.1.0-preview2_spec.rb

@@ -0,0 +1,17 @@
+require 'find'
+require 'fakefs/spec_helpers'
+
+RSpec.configure do |c|
+  c.mock_with(:rspec)
+  c.include(FakeFS::SpecHelpers, :fakefs => true)
+end
+
+if RUBY_VERSION >= '2.1'
+  describe 'Find.find', :fakefs => true do
+    it 'does not give an ArgumentError' do
+      FileUtils.mkdir_p('/tmp/foo')
+      found = Find.find('/tmp').to_a
+      expect(found).to eq(%w(/tmp /tmp/foo))
+    end
+  end
+end

data/test/fakefs_test.rb

@@ -68,6 +68,21 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
+  def test_raises_error_when_creating_a_new_dir_over_existing_file
+    File.open("file", "w") {|f| f << "This is a file, not a directory." }
+
+    assert_raise Errno::EEXIST do
+      FileUtils.mkdir_p("file/subdir")
+    end
+
+    FileUtils.mkdir("dir")
+    File.open("dir/subfile", "w") {|f| f << "This is a file inside a directory." }
+
+    assert_raise Errno::EEXIST do
+      FileUtils.mkdir_p("dir/subfile/subdir")
+    end
+  end
+
   def test_can_create_directories_with_mkpath
     FileUtils.mkpath("/path/to/dir")
     assert_kind_of FakeDir, FileSystem.fs['path']['to']['dir']
@@ -520,6 +535,14 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 9, File.size(path)
   end
 
+  def test_can_get_correct_size_for_files_with_multibyte_characters
+    path = 'file.txt'
+    File.open(path, 'wb') do |f|
+      f << "Y\xC3\xA1da" # Yáda
+    end
+    assert_equal 5, File.size(path)
+  end
+
   def test_can_check_if_file_has_size?
     path = 'file.txt'
     File.open(path, 'w') do |f|
@@ -564,20 +587,22 @@ class FakeFSTest < Test::Unit::TestCase
     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)
+  if RUBY_VERSION >= "1.9"
+    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
+      assert_equal File.mtime("foo.txt"), time
+    end
 
-  def test_can_set_mtime_on_existing_file_touch_with_param
-    FileUtils.touch("foo.txt")
+    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)
+      time = Time.new(2002, 10, 31, 2, 2, 2, "+02:00")
+      FileUtils.touch("foo.txt", :mtime => time)
 
-    assert_equal File.mtime("foo.txt"), time
+      assert_equal File.mtime("foo.txt"), time
+    end
   end
 
   def test_can_return_mtime_on_existing_file
@@ -981,11 +1006,32 @@ class FakeFSTest < Test::Unit::TestCase
     end
   end
 
-  def test_file_utils_cp_r_takes_ignored_options
+  def test_file_utils_cp_allows_verbose_option
+    File.open('foo', 'w') {|f| f << 'TEST' }
+    assert_equal "cp foo bar\n", capture_stderr { FileUtils.cp 'foo', 'bar', :verbose => true }
+  end
+
+  def test_file_utils_cp_allows_noop_option
+    File.open('foo', 'w') {|f| f << 'TEST' }
+    FileUtils.cp 'foo', 'bar', :noop => true
+    assert !File.exist?('bar'), 'does not actually copy'
+  end
+
+  def test_file_utils_cp_raises_on_invalid_option
+    assert_raises ArgumentError do
+      FileUtils.cp 'foo', 'bar', :whatisthis => "I don't know"
+    end
+  end
+
+  def test_file_utils_cp_r_allows_verbose_option
     FileUtils.touch "/foo"
+    assert_equal "cp -r /foo /bar\n", capture_stderr { FileUtils.cp_r '/foo', '/bar', :verbose => true }
+  end
 
-    FileUtils.cp_r '/foo', '/bar', :verbose => true
-    assert_equal Dir.glob("/*").sort, ["/bar", "/foo"]
+  def test_file_utils_cp_r_allows_noop_option
+    FileUtils.touch "/foo"
+    FileUtils.cp_r '/foo', '/bar', :noop => true
+    assert !File.exist?('/bar'), 'does not actually copy'
   end
 
   def test_dir_glob_handles_root
@@ -1085,8 +1131,17 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal 1, fp.pos
   end
 
+  OMITTED_FILE_METHODS = [
+    # omit methods from io/console
+    :raw, :raw!, :cooked, :cooked!,
+    :echo?, :echo=, :noecho,
+    :winsize, :winsize=,
+    :getch,
+    :iflush, :ioflush, :oflush
+  ]
+
   def test_every_method_in_file_is_in_fake_fs_file
-    RealFile.instance_methods.each do |method_name|
+    (RealFile.instance_methods - OMITTED_FILE_METHODS).each do |method_name|
       assert File.instance_methods.include?(method_name), "#{method_name} method is not available in File :("
     end
   end
@@ -1156,6 +1211,19 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal ['/path/me/foobar'], Dir.glob('/path/me/*').sort
   end
 
+  def test_chdir_should_be_nestable_with_absolute_paths
+    FileUtils.mkdir_p '/path/me'
+    Dir.chdir '/path' do
+      File.open('foo', 'w') { |f| f.write 'foo'}
+      Dir.chdir '/path/me' do
+        File.open('foobar', 'w') { |f| f.write 'foo'}
+      end
+    end
+
+    assert_equal ['/path/foo','/path/me'], Dir.glob('/path/*').sort
+    assert_equal ['/path/me/foobar'], Dir.glob('/path/me/*').sort
+  end
+
   def test_chdir_should_flop_over_and_die_if_the_dir_doesnt_exist
     assert_raise(Errno::ENOENT) do
       Dir.chdir('/nope') do
@@ -1185,7 +1253,7 @@ class FakeFSTest < Test::Unit::TestCase
       rescue Errno::ENOENT
       end
 
-      assert_equal ['/path'], FileSystem.dir_levels
+      assert_equal ['/', '/path'], FileSystem.dir_levels
     end
 
     assert_equal(['/path/foo', '/path/foobar'], Dir.glob('/path/*').sort)
@@ -1221,6 +1289,20 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal '/path/subdir', Dir.getwd
   end
 
+  def test_current_dir_reflected_by_expand_path
+    FileUtils.mkdir_p '/path'
+    Dir.chdir '/path'
+
+    assert_equal '/path', File.expand_path('.')
+    assert_equal '/path/foo', File.expand_path('foo')
+
+    FileUtils.mkdir_p 'subdir'
+    Dir.chdir 'subdir'
+
+    assert_equal '/path/subdir', File.expand_path('.')
+    assert_equal '/path/subdir/foo', File.expand_path('foo')
+  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 }
@@ -1277,6 +1359,46 @@ class FakeFSTest < Test::Unit::TestCase
     assert_equal('binky', File.open('destdir/baz') {|f| f.read })
   end
 
+  def test_mv_accepts_verbose_option
+    FileUtils.touch 'foo'
+    assert_equal "mv foo bar\n", capture_stderr { FileUtils.mv 'foo', 'bar', :verbose => true }
+  end
+
+  def test_mv_accepts_noop_option
+    FileUtils.touch 'foo'
+    FileUtils.mv 'foo', 'bar', :noop => true
+    assert File.exist?('foo'), 'does not remove src'
+    assert !File.exist?('bar'), 'does not create target'
+  end
+
+  def test_mv_raises_when_moving_file_onto_directory
+    FileUtils.mkdir_p 'dir/stuff'
+    FileUtils.touch 'stuff'
+    assert_raises Errno::EEXIST do
+      FileUtils.mv 'stuff', 'dir'
+    end
+  end
+
+  def test_mv_raises_when_moving_to_non_existent_directory
+    FileUtils.touch 'stuff'
+    assert_raises Errno::ENOENT do
+      FileUtils.mv 'stuff', '/this/path/is/not/here'
+    end
+  end
+
+  def test_mv_ignores_failures_when_using_force
+    FileUtils.mkdir_p 'dir/stuff'
+    FileUtils.touch %w[stuff other]
+    FileUtils.mv %w[stuff other], 'dir', :force => true
+    assert File.exist?('stuff'), 'failed move remains where it was'
+    assert File.exist?('dir/other'), 'successful one is moved'
+    assert !File.exist?('other'), 'successful one is moved'
+
+    FileUtils.mv 'stuff', '/this/path/is/not/here', :force => true
+    assert File.exist?('stuff'), 'failed move remains where it was'
+    assert !File.exist?('/this/path/is/not/here'), 'nothing is created for a failed move'
+  end
+
   def test_cp_actually_works
     File.open('foo', 'w') {|f| f.write 'bar' }
     FileUtils.cp('foo', 'baz')
@@ -1477,6 +1599,48 @@ class FakeFSTest < Test::Unit::TestCase
     act_on_real_fs { RealFileUtils.rm_rf(here('subdir')) }
   end
 
+  def test_clone_with_file_symlinks
+    original = here('subdir/test-file')
+    symlink  = here('subdir/test-file.txt')
+
+    act_on_real_fs do
+      RealDir.mkdir(RealFile.dirname(original))
+      RealFile.open(original, 'w') {|f| f << 'stuff' }
+      RealFileUtils.ln_s original, symlink
+      assert RealFile.symlink?(symlink), 'real symlink is in place'
+    end
+
+    assert !File.exists?(original), 'file does not already exist'
+
+    FileSystem.clone(File.dirname(original))
+    assert File.symlink?(symlink), 'symlinks are cloned as symlinks'
+    assert_equal 'stuff', File.read(symlink)
+  ensure
+    act_on_real_fs { RealFileUtils.rm_rf File.dirname(original) }
+  end
+
+  def test_clone_with_dir_symlinks
+    original = here('subdir/dir')
+    symlink  = here('subdir/dir.link')
+    original_file = File.join(original, 'test-file')
+    symlink_file  = File.join(symlink, 'test-file')
+
+    act_on_real_fs do
+      RealFileUtils.mkdir_p(original)
+      RealFile.open(original_file, 'w') {|f| f << 'stuff' }
+      RealFileUtils.ln_s original, symlink
+      assert RealFile.symlink?(symlink), 'real symlink is in place'
+    end
+
+    assert !File.exists?(original_file), 'file does not already exist'
+
+    FileSystem.clone(File.dirname(original))
+    assert File.symlink?(symlink), 'symlinks are cloned as symlinks'
+    assert_equal 'stuff', File.read(symlink_file)
+  ensure
+    act_on_real_fs { RealFileUtils.rm_rf File.dirname(original) }
+  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' } }
@@ -1774,6 +1938,26 @@ class FakeFSTest < Test::Unit::TestCase
     test.each { |t| assert yielded.include?(t) }
   end
 
+  def test_directory_foreach_relative_paths
+    test = ['.', '..', 'file_1', 'file_2', 'file_3', 'file_4', 'file_5' ]
+
+    FileUtils.mkdir_p('/this/path/should/be/here')
+
+    test.each do |f|
+      FileUtils.touch("/this/path/should/be/here/#{f}")
+    end
+
+    yielded = []
+    Dir.chdir '/this/path/should/be' do
+      Dir.foreach('here') do |dir|
+        yielded << dir
+      end
+    end
+
+    assert yielded.size == test.size, 'wrong number of files yielded'
+    test.each { |t| assert yielded.include?(t), "#{t} was not included in #{yielded.inspect}" }
+  end
+
   def test_directory_mkdir
     Dir.mkdir('/path')
     assert File.exists?('/path')
@@ -2129,6 +2313,16 @@ class FakeFSTest < Test::Unit::TestCase
     assert !FileTest.file?('/path/to/somedir')
   end
 
+  def test_filetest_writable_returns_correct_values
+    assert !FileTest.writable?('not-here.txt'), 'missing files are not writable'
+
+    FileUtils.touch 'here.txt'
+    assert FileTest.writable?('here.txt'), 'existing files are writable'
+
+    FileUtils.mkdir 'dir'
+    assert FileTest.writable?('dir'), 'directories are writable'
+  end
+
   def test_pathname_exists_returns_correct_value
     FileUtils.touch "foo"
     assert Pathname.new("foo").exist?
@@ -2256,10 +2450,10 @@ class FakeFSTest < Test::Unit::TestCase
 
   def test_file_umask
     assert_equal File.umask, RealFile.umask
-    File.umask(1234)
+    File.umask(0740)
 
     assert_equal File.umask, RealFile.umask
-    assert_equal File.umask, 1234
+    assert_equal File.umask, 0740
   end
 
   def test_file_stat_comparable
@@ -2388,5 +2582,15 @@ class FakeFSTest < Test::Unit::TestCase
       File.write('foo', 'bar', 3)
       assert_equal File.read('foo'), 'foobar'
     end
+
+    def test_can_read_binary_data_in_binary_mode
+      File.open('foo', 'wb') { |f| f << "\u0000\u0000\u0000\u0003\u0000\u0003\u0000\xA3\u0000\u0000\u0000y\u0000\u0000\u0000\u0000\u0000" }
+      assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00", File.open("foo", "rb").read
+    end
+
+    def test_can_read_binary_data_in_non_binary_mode
+      File.open('foo_non_bin', 'wb') { |f| f << "\u0000\u0000\u0000\u0003\u0000\u0003\u0000\xA3\u0000\u0000\u0000y\u0000\u0000\u0000\u0000\u0000" }
+      assert_equal "\x00\x00\x00\x03\x00\x03\x00\xA3\x00\x00\x00y\x00\x00\x00\x00\x00".force_encoding('UTF-8'), File.open("foo_non_bin", "r").read
+    end
   end
 end