memfs 0.0.2 → 0.1.0

data/lib/memfs/file_system.rb

@@ -43,10 +43,6 @@ module MemFs
       entry.gid = gid if gid && gid != -1
     end
 
-    def directory?(path)
-      find(path).is_a?(Fake::Directory)
-    end
-
     def dirname(path)
       File.dirname(path)
     end
@@ -128,10 +124,6 @@ module MemFs
       find_parent!(new_name).add_entry Fake::Symlink.new(new_name, old_name)
     end
 
-    def symlink?(path)
-      find(path).is_a?(Fake::Symlink)
-    end
-
     def touch(*paths)
       paths.each do |path|
         entry = find(path)

data/lib/memfs/version.rb

@@ -1,3 +1,3 @@
 module MemFs
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
 end

data/spec/memfs/fake/directory_spec.rb

@@ -110,6 +110,12 @@ module MemFs
           expect(directory.entries).not_to have_value(file)
         end
       end
+
+      describe "#type" do
+        it "returns 'directory'" do
+          expect(directory.type).to eq('directory')
+        end
+      end
     end
   end
 end

data/spec/memfs/fake/entry_spec.rb

@@ -29,6 +29,18 @@ module MemFs
         let(:value) { time }
       end
 
+      it_behaves_like 'it has accessors for', :block_device do
+        let(:value) { true }
+      end
+
+      it_behaves_like 'it has accessors for', :character_device do
+        let(:value) { true }
+      end
+
+      it_behaves_like 'it has accessors for', :ctime do
+        let(:value) { time }
+      end
+
       it_behaves_like 'it has accessors for', :mtime do
         let(:value) { time }
       end
@@ -50,32 +62,13 @@ module MemFs
         let(:value) { parent }
       end
 
-      describe ".delete" do
-        it "removes the entry from its parent" do
-          entry.delete
-          expect(parent.entries).not_to have_value(entry)
-        end
-      end
-
-      describe '.dereferenced' do
-        it "returns the entry itself" do
-          expect(entry.dereferenced).to be(entry)
-        end
-      end
-
-      describe '.find' do
-        it "raises an error" do
-          expect { entry.find('test') }.to raise_error(Errno::ENOTDIR)
-        end
-      end
-
       describe ".new" do
         it "sets its default uid to the current user's uid" do
-          expect(entry.uid).to eq(Etc.getpwuid.uid)
+          expect(entry.uid).to eq(Process.euid)
         end
 
         it "sets its default gid to the current user's gid" do
-          expect(entry.gid).to eq(Etc.getpwuid.gid)
+          expect(entry.gid).to eq(Process.egid)
         end
 
         it "extract its name from the path passed as argument" do
@@ -99,9 +92,34 @@ module MemFs
         end
       end
 
-      describe ".path" do
-        it "returns the complete path of the entry" do
-          expect(entry.path).to eq('/parent/test')
+      describe "#delete" do
+        it "removes the entry from its parent" do
+          entry.delete
+          expect(parent.entries).not_to have_value(entry)
+        end
+      end
+
+      describe '#dereferenced' do
+        it "returns the entry itself" do
+          expect(entry.dereferenced).to be(entry)
+        end
+      end
+
+      describe "#dereferenced_name" do
+        it "returns the entry name" do
+          expect(entry.dereferenced_name).to eq('test')
+        end
+      end
+
+      describe "#dereferenced_path" do
+        it "returns the entry path" do
+          expect(entry.dereferenced_path).to eq('/parent/test')
+        end
+      end
+
+      describe '#find' do
+        it "raises an error" do
+          expect { entry.find('test') }.to raise_error(Errno::ENOTDIR)
         end
       end
 
@@ -117,6 +135,12 @@ module MemFs
         end
       end
 
+      describe "#path" do
+        it "returns the complete path of the entry" do
+          expect(entry.path).to eq('/parent/test')
+        end
+      end
+
       describe "#touch" do
         let(:time) { Time.now - 5000 }
 
@@ -135,6 +159,12 @@ module MemFs
           expect(entry.mtime).not_to eq(time)
         end
       end
+
+      describe "#type" do
+        it "returns 'unknown" do
+          expect(entry.type).to eq('unknown')
+        end
+      end
     end
   end
 end

data/spec/memfs/fake/file/content_spec.rb

@@ -79,6 +79,15 @@ module MemFs
         end
       end
 
+      describe "#truncate" do
+        subject { File::Content.new('x'*50) }
+
+        it "truncates the content to length characters" do
+          subject.truncate(5)
+          expect(subject.length).to eq(5)
+        end
+      end
+
       describe "#write" do
         it "writes the given string in content" do
           subject.write 'test'

data/spec/memfs/fake/file_spec.rb

@@ -32,6 +32,28 @@ module MemFs
           end
         end
       end
+
+      describe "#type" do
+        context "when the file is a regular file" do
+          it "returns 'file'" do
+            expect(file.type).to eq('file')
+          end
+        end
+
+        context "when the file is a block device" do
+          it "returns 'blockSpecial'" do
+            file.block_device = true
+            expect(file.type).to eq('blockSpecial')
+          end
+        end
+
+        context "when the file is a character device" do
+          it "returns 'characterSpecial'" do
+            file.character_device = true
+            expect(file.type).to eq('characterSpecial')
+          end
+        end
+      end
     end
   end
 end

data/spec/memfs/fake/symlink_spec.rb

@@ -32,12 +32,82 @@ module MemFs
         end
       end
 
+      describe "#dereferenced_name" do
+        context "when the symlink's target exists" do
+          it "returns its target name" do
+            fs.touch('/test-file')
+            symlink = Symlink.new('/test-link', '/test-file')
+            expect(symlink.dereferenced_name).to eq('test-file')
+          end
+        end
+
+        context "when the symlink's target does not exist" do
+          it "returns its target name" do
+            symlink = Symlink.new('/test-link', '/no-file')
+            expect(symlink.dereferenced_name).to eq('no-file')
+          end
+        end
+      end
+
+      describe "#dereferenced_path" do
+        context "when the symlink's target exists" do
+          it "returns its target path" do
+            fs.touch('/test-file')
+            symlink = Symlink.new('/test-link', '/test-file')
+            expect(symlink.dereferenced_path).to eq('/test-file')
+          end
+        end
+
+        context "when the symlink's target does not exist" do
+          it "raises an exception" do
+            symlink = Symlink.new('/test-link', '/no-file')
+            expect {
+              symlink.dereferenced_path
+            }.to raise_exception
+          end
+        end
+      end
+
+      describe '#find' do
+        let(:file) { fs.find!('/test-dir/test-file') }
+
+        before :each do
+          fs.mkdir '/test-dir'
+          fs.touch '/test-dir/test-file'
+        end
+
+        context "when the symlink's target exists" do
+          subject { Symlink.new('/test-dir-link', '/test-dir') }
+
+          it "forwards the search to it" do
+            entry = subject.find('test-file')
+            expect(entry).to eq(file)
+          end
+        end
+
+        context "when the symlink's target does not exist" do
+          subject { Symlink.new('/test-no-link', '/no-dir') }
+
+          it "returns nil" do
+            entry = subject.find('test-file')
+            expect(entry).to be_nil
+          end
+        end
+      end
+
       describe '#target' do
         it "returns the target of the symlink" do
           s = Symlink.new('/test-link', '/test-file')
           expect(s.target).to eq('/test-file')
         end
       end
+
+      describe "#type" do
+        it "returns 'link'" do
+          s = Symlink.new('/test-link', '/test-file')
+          expect(s.type).to eq('link')
+        end
+      end
     end
   end
 end

data/spec/memfs/file/stat_spec.rb

@@ -2,11 +2,36 @@ require 'spec_helper'
 
 module MemFs
   describe File::Stat do
+    let(:file_stat) { File::Stat.new('/test-file') }
+    let(:dereferenced_file_stat) { File::Stat.new('/test-file', true) }
+
+    let(:dir_link_stat) { File::Stat.new('/test-dir-link') }
+    let(:dereferenced_dir_link_stat) { File::Stat.new('/test-dir-link', true) }
+
+    let(:link_stat) { File::Stat.new('/test-link') }
+    let(:dereferenced_link_stat) { File::Stat.new('/test-link', true) }
+
+    let(:dir_stat) { File::Stat.new('/test-dir') }
+    let(:dereferenced_dir_stat) { File::Stat.new('/test-dir', true) }
+
+    let(:entry) { fs.find!('/test-file') }
+
+    before :each do
+      fs.mkdir('/test-dir')
+      fs.touch('/test-file')
+      fs.symlink('/test-file', '/test-link')
+      fs.symlink('/test-dir', '/test-dir-link')
+      fs.symlink('/no-file', '/test-no-file-link')
+    end
+
     describe '.new' do
-      context "when optional follow_symlink argument is set to true" do
-        it "raises an error if the end-of-links-chain target doesn't exist" do
-          fs.symlink('/test-file', '/test-link')
-          expect { File::Stat.new('/test-link', true) }.to raise_error(Errno::ENOENT)
+      context "when optional dereference argument is set to true" do
+        context "when the last target of the link chain does not exist" do
+          it "raises an exception" do
+            expect {
+              File::Stat.new('/test-no-file-link', true)
+            }.to raise_error(Errno::ENOENT)
+          end
         end
       end
     end
@@ -15,30 +40,23 @@ module MemFs
       let(:time) { Time.now - 500000 }
 
       it "returns the access time of the entry" do
-        fs.touch('/test-file')
         entry = fs.find!('/test-file')
         entry.atime = time
-        expect(File::Stat.new('/test-file').atime).to eq(time)
+        expect(file_stat.atime).to eq(time)
       end
 
       context "when the entry is a symlink" do
-        context "and the optional follow_symlink argument is true" do
+        context "and the optional dereference argument is true" do
           it "returns the access time of the last target of the link chain" do
-            fs.touch('/test-file')
-            entry = fs.find!('/test-file')
             entry.atime = time
-            fs.symlink('/test-file', '/test-link')
-            expect(File::Stat.new('/test-link', true).atime).to eq(time)
+            expect(dereferenced_link_stat.atime).to eq(time)
           end
         end
 
-        context "and the optional follow_symlink argument is false" do
+        context "and the optional dereference argument is false" do
           it "returns the access time of the symlink itself" do
-            fs.touch('/test-file')
-            entry = fs.find!('/test-file')
             entry.atime = time
-            fs.symlink('/test-file', '/test-link')
-            expect(File::Stat.new('/test-link').atime).not_to eq(time)
+            expect(link_stat.atime).not_to eq(time)
           end
         end
       end
@@ -46,52 +64,130 @@ module MemFs
 
     describe "#blksize" do
       it "returns the block size of the file" do
-        fs.touch('/test-file')
-        expect(File::Stat.new('/test-file').blksize).to be(4096)
+        expect(file_stat.blksize).to be(4096)
       end
     end
 
-    describe "#dev" do
-      it "returns an integer representing the device on which stat resides" do
-        fs.touch('/test-file')
-        expect(File::Stat.new('/test-file').dev).to be_a(Fixnum)
+    describe "#blockdev?" do
+      context "when the file is a block device" do
+        it "returns true" do
+          fs.touch('/block-file')
+          file = fs.find('/block-file')
+          file.block_device = true
+          block_stat = File::Stat.new('/block-file')
+          expect(block_stat.blockdev?).to be_true
+        end
+      end
+
+      context "when the file is not a block device" do
+        it "returns false" do
+          expect(file_stat.blockdev?).to be_false
+        end
       end
     end
 
-    describe '#directory?' do
-      before :each do
-        fs.mkdir('/test')
-        fs.touch('/test-file')
-        fs.symlink('/test', '/link-to-dir')
-        fs.symlink('/test-file', '/link-to-file')
+    describe "#chardev?" do
+      context "when the file is a character device" do
+        it "returns true" do
+          fs.touch('/character-file')
+          file = fs.find('/character-file')
+          file.character_device = true
+          character_stat = File::Stat.new('/character-file')
+          expect(character_stat.chardev?).to be_true
+        end
       end
 
-      it "returns true if the entry is a directory" do
-        expect(File::Stat.new('/test')).to be_directory
+      context "when the file is not a character device" do
+        it "returns false" do
+          expect(file_stat.chardev?).to be_false
+        end
       end
+    end
+
+    describe '#ctime' do
+      let(:time) { Time.now - 500000 }
 
-      it "returns false if the entry is not a directory" do
-        expect(File::Stat.new('/test-file')).not_to be_directory
+      it "returns the access time of the entry" do
+        entry.ctime = time
+        expect(file_stat.ctime).to eq(time)
       end
 
       context "when the entry is a symlink" do
-        context "and the optional follow_symlink argument is true" do
-          it "returns true if the last target of the link chain is a directory" do
-            expect(File::Stat.new('/link-to-dir', true)).to be_directory
+        context "and the optional dereference argument is true" do
+          it "returns the access time of the last target of the link chain" do
+            entry.ctime = time
+            expect(dereferenced_link_stat.ctime).to eq(time)
+          end
+        end
+
+        context "and the optional dereference argument is false" do
+          it "returns the access time of the symlink itself" do
+            entry.ctime = time
+            expect(link_stat.ctime).not_to eq(time)
+          end
+        end
+      end
+    end
+
+    describe "#dev" do
+      it "returns an integer representing the device on which stat resides" do
+        expect(file_stat.dev).to be_a(Fixnum)
+      end
+    end
+
+    describe '#directory?' do
+      context 'when dereference is true' do
+        context "when the entry is a directory" do
+          it "returns true" do
+            expect(dereferenced_dir_stat.directory?).to be_true
+          end
+        end
+
+        context "when the entry is not a directory" do
+          it "returns false" do
+            expect(dereferenced_file_stat.directory?).to be_false
+          end
+        end
+
+        context "when the entry is a symlink" do
+          context "and the last target of the link chain is a directory" do
+            it "returns true" do
+              expect(dereferenced_dir_link_stat.directory?).to be_true
+            end
+          end
+
+          context "and the last target of the link chain is not a directory" do
+            it "returns false" do
+              expect(dereferenced_link_stat.directory?).to be_false
+            end
+          end
+        end
+      end
+
+      context 'when dereference is false' do
+        context "when the entry is a directory" do
+          it "returns true" do
+            expect(dir_stat.directory?).to be_true
           end
+        end
 
-          it "returns false if the last target of the link chain is not a directory" do
-            expect(File::Stat.new('/link-to-file', true)).not_to be_directory
+        context "when the entry is not a directory" do
+          it "returns false" do
+            expect(file_stat.directory?).to be_false
           end
         end
 
-        context "and the optional follow_symlink argument is false" do
-          it "returns false if the last target of the link chain is a directory" do
-            expect(File::Stat.new('/link-to-dir', false)).not_to be_directory
+        context "when the entry is a symlink" do
+          context "and the last target of the link chain is a directory" do
+            it "returns false" do
+              expect(dir_link_stat.directory?).to be_false
+            end
           end
 
-          it "returns false if the last target of the link chain is not a directory" do
-            expect(File::Stat.new('/link-to-file', false)).not_to be_directory
+          context "and the last target of the link chain is not a directory" do
+            it "returns false" do
+              expect(link_stat.directory?).to be_false
+            end
           end
         end
       end
@@ -99,109 +195,657 @@ module MemFs
 
     describe '#entry' do
       it "returns the comcerned entry" do
-        entry = fs.touch('/test-file')
-        stat = File::Stat.new('/test-file')
-        expect(stat.entry).to be_a(Fake::File)
+        expect(file_stat.entry).to be_a(Fake::File)
+      end
+    end
+
+    describe "#executable?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        entry.mode = access
+        entry.uid = uid
+        entry.gid = gid
+      end
+
+      context "when the file is not executable by anyone" do
+        it "return false" do
+          expect(file_stat.executable?).to be_false
+        end
+      end
+
+      context "when the file is user executable" do
+        let(:access) { MemFs::Fake::Entry::UEXEC }
+
+        context "and the current user owns the file" do
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            expect(file_stat.executable?).to be_true
+          end
+        end
+      end
+
+      context "when the file is group executable" do
+        let(:access) { MemFs::Fake::Entry::GEXEC }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.egid }
+
+          it "returns true" do
+            expect(file_stat.executable?).to be_true
+          end
+        end
+      end
+
+      context "when the file is executable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OEXEC }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            expect(file_stat.executable?).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          expect(file_stat.executable?).to be_false
+        end
+      end
+    end
+
+    describe "#executable_real?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        entry.mode = access
+        entry.uid = uid
+        entry.gid = gid
+      end
+
+      context "when the file is not executable by anyone" do
+        it "return false" do
+          expect(file_stat.executable_real?).to be_false
+        end
+      end
+
+      context "when the file is user executable" do
+        let(:access) { MemFs::Fake::Entry::UEXEC }
+
+        context "and the current user owns the file" do
+          let(:uid) { Process.uid }
+
+          it "returns true" do
+            expect(file_stat.executable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file is group executable" do
+        let(:access) { MemFs::Fake::Entry::GEXEC }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.gid }
+
+          it "returns true" do
+            expect(file_stat.executable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file is executable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OEXEC }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            expect(file_stat.executable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          expect(file_stat.executable_real?).to be_false
+        end
       end
     end
 
     describe "#file?" do
-      it "returns true if the entry is a regular file" do
-        fs.touch('/test-file')
-        expect(File.stat('/test-file')).to be_file
+      context 'when dereference is true' do
+        context "when the entry is a regular file" do
+          it "returns true" do
+            expect(dereferenced_file_stat.file?).to be_true
+          end
+        end
+
+        context "when the entry is not a regular file" do
+          it "returns false" do
+            expect(dereferenced_dir_stat.file?).to be_false
+          end
+        end
+
+        context "when the entry is a symlink" do
+          context "and the last target of the link chain is a regular file" do
+            it "returns true" do
+              expect(dereferenced_link_stat.file?).to be_true
+            end
+          end
+
+          context "and the last target of the link chain is not a regular file" do
+            it "returns false" do
+              expect(dereferenced_dir_link_stat.file?).to be_false
+            end
+          end
+        end
       end
 
-      it "returns false if the entry is not a regular file" do
-        fs.mkdir('/test-dir')
-        expect(File.stat('/test-dir')).not_to be_file
+      context 'when dereference is false' do
+        context "when the entry is a regular file" do
+          it "returns true" do
+            expect(file_stat.file?).to be_true
+          end
+        end
+
+        context "when the entry is not a regular file" do
+          it "returns false" do
+            expect(dir_stat.file?).to be_false
+          end
+        end
+
+        context "when the entry is a symlink" do
+          context "and the last target of the link chain is a regular file" do
+            it "returns false" do
+              expect(link_stat.file?).to be_false
+            end
+          end
+
+          context "and the last target of the link chain is not a regular file" do
+            it "returns false" do
+              expect(dir_link_stat.file?).to be_false
+            end
+          end
+        end
+      end
+    end
+
+    describe "#ftype" do
+      context "when the entry is a regular file" do
+        it "returns 'file'" do
+          expect(file_stat.ftype).to eq('file')
+        end
+      end
+
+      context "when the entry is a directory" do
+        it "returns 'directory'" do
+          expect(dir_stat.ftype).to eq('directory')
+        end
+      end
+
+      context "when the entry is a block device" do
+        it "returns 'blockSpecial'" do
+          fs.touch('/block-file')
+          file = fs.find('/block-file')
+          file.block_device = true
+          block_stat = File::Stat.new('/block-file')
+          expect(block_stat.ftype).to eq('blockSpecial')
+        end
+      end
+
+      context "when the entry is a character device" do
+        it "returns 'characterSpecial'" do
+          fs.touch('/character-file')
+          file = fs.find('/character-file')
+          file.character_device = true
+          character_stat = File::Stat.new('/character-file')
+          expect(character_stat.ftype).to eq('characterSpecial')
+        end
       end
 
       context "when the entry is a symlink" do
-        it "returns true if its target is a regular file" do
-          fs.touch('/test-file')
-          fs.symlink('/test-file', '/test-link')
-          expect(File.stat('/test-link')).to be_file
+        it "returns 'link'" do
+          expect(link_stat.ftype).to eq('link')
         end
+      end
+
+      # fifo and socket not handled for now
 
-        it "returns false if its target is not a regular file" do
-          fs.mkdir('/test-dir')
-          fs.symlink('/test-dir', '/test-link')
-          expect(File.stat('/test-link')).not_to be_file
+      context "when the entry has no specific type" do
+        it "returns 'unknown'" do
+          root = fs.find('/')
+          root.add_entry Fake::Entry.new('test-entry')
+          entry_stat = File::Stat.new('/test-entry')
+          expect(entry_stat.ftype).to eq('unknown')
         end
       end
     end
 
     describe "#gid" do
       it "returns the group id of the named entry" do
-        fs.touch('/test-file')
         fs.chown(nil, 42, '/test-file')
-        expect(File::Stat.new('/test-file').gid).to be(42)
+        expect(file_stat.gid).to be(42)
+      end
+    end
+
+    describe "#grpowned?" do
+      context "when the effective user group owns of the file" do
+        it "returns true" do
+          fs.chown(0, Process.egid, '/test-file')
+          expect(file_stat.grpowned?).to be_true
+        end
+      end
+
+      context "when the effective user group does not own of the file" do
+        it "returns false" do
+          fs.chown(0, 0, '/test-file')
+          expect(file_stat.grpowned?).to be_false
+        end
       end
     end
 
     describe "#ino" do
       it "returns the inode number for stat." do
-        fs.touch('/test-file')
-        expect(File::Stat.new('/test-file').ino).to be_a(Fixnum)
+        expect(file_stat.ino).to be_a(Fixnum)
       end
     end
 
     describe '#mode' do
       it "returns an integer representing the permission bits of stat" do
-        fs.touch('/test-file')
         fs.chmod(0777, '/test-file')
-        expect(File::Stat.new('/test-file').mode).to be(0100777)
+        expect(file_stat.mode).to be(0100777)
+      end
+    end
+
+    describe "#owned?" do
+      context "when the effective user owns of the file" do
+        it "returns true" do
+          fs.chown(Process.euid, 0, '/test-file')
+          expect(file_stat.owned?).to be_true
+        end
+      end
+
+      context "when the effective user does not own of the file" do
+        it "returns false" do
+          fs.chown(0, 0, '/test-file')
+          expect(file_stat.owned?).to be_false
+        end
+      end
+    end
+
+    describe "#pipe?" do
+      # Pipes are not handled for now
+
+      context "when the file is not a pipe" do
+        it "returns false" do
+          expect(file_stat.pipe?).to be_false
+        end
+      end
+    end
+
+    describe "#readable?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        entry.mode = access
+        entry.uid = uid
+        entry.gid = gid
+      end
+
+      context "when the file is not readable by anyone" do
+        it "return false" do
+          expect(file_stat.readable?).to be_false
+        end
+      end
+
+      context "when the file is user readable" do
+        let(:access) { MemFs::Fake::Entry::UREAD }
+
+        context "and the current user owns the file" do
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            expect(file_stat.readable?).to be_true
+          end
+        end
+      end
+
+      context "when the file is group readable" do
+        let(:access) { MemFs::Fake::Entry::GREAD }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.egid }
+
+          it "returns true" do
+            expect(file_stat.readable?).to be_true
+          end
+        end
+      end
+
+      context "when the file is readable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OREAD }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            expect(file_stat.readable?).to be_true
+          end
+        end
+      end
+    end
+
+    describe "#readable_real?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        entry.mode = access
+        entry.uid = uid
+        entry.gid = gid
+      end
+
+      context "when the file is not readable by anyone" do
+        it "return false" do
+          expect(file_stat.readable_real?).to be_false
+        end
+      end
+
+      context "when the file is user readable" do
+        let(:access) { MemFs::Fake::Entry::UREAD }
+
+        context "and the current user owns the file" do
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            expect(file_stat.readable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file is group readable" do
+        let(:access) { MemFs::Fake::Entry::GREAD }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.egid }
+
+          it "returns true" do
+            expect(file_stat.readable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file is readable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OREAD }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            expect(file_stat.readable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          expect(file_stat.readable_real?).to be_false
+        end
+      end
+    end
+
+    describe "#setgid?" do
+      context "when the file has the setgid bit set" do
+        it "returns true" do
+          fs.chmod(02000, '/test-file')
+          expect(file_stat.setgid?).to be_true
+        end
+      end
+
+      context "when the file does not have the setgid bit set" do
+        it "returns false" do
+          expect(file_stat.setgid?).to be_false
+        end
+      end
+    end
+
+    describe "#setuid?" do
+      context "when the file has the setuid bit set" do
+        it "returns true" do
+          fs.chmod(04000, '/test-file')
+          expect(file_stat.setuid?).to be_true
+        end
+      end
+
+      context "when the file does not have the setuid bit set" do
+        it "returns false" do
+          expect(file_stat.setuid?).to be_false
+        end
+      end
+    end
+
+    describe "#socket?" do
+      # Sockets are not handled for now
+
+      context "when the file is not a socket" do
+        it "returns false" do
+          expect(file_stat.socket?).to be_false
+        end
       end
     end
 
     describe "#sticky?" do
       it "returns true if the named file has the sticky bit set" do
-        fs.touch('/test-file')
         fs.chmod(01777, '/test-file')
-        expect(File::Stat.new('/test-file')).to be_sticky
+        expect(file_stat.sticky?).to be_true
       end
 
       it "returns false if the named file hasn't' the sticky bit set" do
-        fs.touch('/test-file')
-        expect(File::Stat.new('/test-file')).not_to be_sticky
+        expect(file_stat.sticky?).to be_false
       end
     end
 
     describe '#symlink?' do
-      it "returns true if the entry is a symlink" do
-        fs.touch('/test-file')
-        fs.symlink('/test-file', '/test-link')
-        expect(File::Stat.new('/test-link').symlink?).to be_true
+      context 'when dereference is true' do
+        context "when the entry is a symlink" do
+          it "returns false" do
+            expect(dereferenced_link_stat.symlink?).to be_false
+          end
+        end
+
+        context "when the entry is not a symlink" do
+          it "returns false" do
+            expect(dereferenced_file_stat.symlink?).to be_false
+          end
+        end
       end
 
-      it "returns false if the entry is not a symlink" do
-        fs.touch('/test-file')
-        expect(File::Stat.new('/test-file').symlink?).to be_false
+      context 'when dereference is false' do
+        context "when the entry is a symlink" do
+          it "returns true" do
+            expect(link_stat.symlink?).to be_true
+          end
+        end
+
+        context "when the entry is not a symlink" do
+          it "returns false" do
+            expect(file_stat.symlink?).to be_false
+          end
+        end
       end
     end
 
     describe "#uid" do
       it "returns the user id of the named entry" do
-        fs.touch('/test-file')
         fs.chown(42, nil, '/test-file')
-        expect(File::Stat.new('/test-file').uid).to be(42)
+        expect(file_stat.uid).to be(42)
+      end
+    end
+
+    describe "#world_reable?" do
+      context "when +file_name+ is readable by others" do
+        it "returns an integer representing the file permission bits of +file_name+" do
+          fs.chmod(MemFs::Fake::Entry::OREAD, '/test-file')
+          expect(file_stat.world_readable?).to eq(MemFs::Fake::Entry::OREAD)
+        end
+      end
+
+      context "when +file_name+ is not readable by others" do
+        it "returns nil" do
+          fs.chmod(MemFs::Fake::Entry::UREAD, '/test-file')
+          expect(file_stat.world_readable?).to be_nil
+        end
       end
     end
 
     describe "#world_writable?" do
       context "when +file_name+ is writable by others" do
         it "returns an integer representing the file permission bits of +file_name+" do
-          fs.touch('/test-file')
-          fs.chmod(0777, '/test-file')
-          expect(File::Stat.new('/test-file')).to be_world_writable
+          fs.chmod(MemFs::Fake::Entry::OWRITE, '/test-file')
+          expect(file_stat.world_writable?).to eq(MemFs::Fake::Entry::OWRITE)
         end
       end
 
       context "when +file_name+ is not writable by others" do
         it "returns nil" do
-          fs.touch('/test-file')
-          fs.chmod(0644, '/test-file')
-          expect(File::Stat.new('/test-file')).not_to be_world_writable
+          fs.chmod(MemFs::Fake::Entry::UWRITE, '/test-file')
+          expect(file_stat.world_writable?).to be_nil
+        end
+      end
+    end
+
+    describe "#writable?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        entry.mode = access
+        entry.uid = uid
+        entry.gid = gid
+      end
+
+      context "when the file is not executable by anyone" do
+        it "return false" do
+          expect(file_stat.writable?).to be_false
+        end
+      end
+
+      context "when the file is user executable" do
+        let(:access) { MemFs::Fake::Entry::UWRITE }
+
+        context "and the current user owns the file" do
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            expect(file_stat.writable?).to be_true
+          end
+        end
+      end
+
+      context "when the file is group executable" do
+        let(:access) { MemFs::Fake::Entry::GWRITE }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.egid }
+
+          it "returns true" do
+            expect(file_stat.writable?).to be_true
+          end
+        end
+      end
+
+      context "when the file is executable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OWRITE }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            expect(file_stat.writable?).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          expect(file_stat.writable?).to be_false
+        end
+      end
+    end
+
+    describe "#writable_real?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        entry.mode = access
+        entry.uid = uid
+        entry.gid = gid
+      end
+
+      context "when the file is not executable by anyone" do
+        it "return false" do
+          expect(file_stat.writable_real?).to be_false
+        end
+      end
+
+      context "when the file is user executable" do
+        let(:access) { MemFs::Fake::Entry::UWRITE }
+
+        context "and the current user owns the file" do
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            expect(file_stat.writable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file is group executable" do
+        let(:access) { MemFs::Fake::Entry::GWRITE }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.egid }
+
+          it "returns true" do
+            expect(file_stat.writable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file is executable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OWRITE }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            expect(file_stat.writable_real?).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          expect(file_stat.writable_real?).to be_false
+        end
+      end
+    end
+
+    describe "#zero?" do
+      context "when the file has a zero size" do
+        it "returns true" do
+          expect(file_stat.zero?).to be_true
+        end
+      end
+
+      context "when the file does not have a zero size" do
+        before :each do
+          fs.find!('/test-file').content << 'test'
+        end
+
+        it "returns false" do
+          expect(file_stat.zero?).to be_false
         end
       end
     end