memfs 0.0.2 → 0.1.0

data/spec/memfs/file_spec.rb

@@ -14,6 +14,31 @@ module MemFs
       subject.symlink '/no-file', '/no-link'
     end
 
+    describe '.absolute_path' do
+      before :each do
+        MemFs::Dir.chdir('/test-dir')
+      end
+
+      it "converts a pathname to an absolute pathname" do
+        path = subject.absolute_path('./test-file')
+        expect(path).to eq('/test-dir/test-file')
+      end
+
+      context "when +dir_string+ is given" do
+        it "uses it as the starting point" do
+          path = subject.absolute_path('./test-file', '/no-dir')
+          expect(path).to eq('/no-dir/test-file')
+        end
+      end
+
+      context "when the given pathname starts with a '~'" do
+        it "does not expanded" do
+          path = subject.absolute_path('~/test-file')
+          expect(path).to eq('/test-dir/~/test-file')
+        end
+      end
+    end
+
     describe '.atime' do
       it "returns the last access time for the named file as a Time object" do
         expect(subject.atime('/test-file')).to be_a(Time)
@@ -34,6 +59,34 @@ module MemFs
       end
     end
 
+    describe ".blockdev?" do
+      context "when the name file exists" do
+        context "and it is a block device" do
+          it "returns true" do
+            fs.touch('/block-file')
+            file = fs.find('/block-file')
+            file.block_device = true
+            blockdev = subject.blockdev?('/block-file')
+            expect(blockdev).to be_true
+          end
+        end
+
+        context "and it is not a block device" do
+          it "returns false" do
+            blockdev = subject.blockdev?('/test-file')
+            expect(blockdev).to be_false
+          end
+        end
+      end
+
+      context "when the name file does not exist" do
+        it "returns false" do
+          blockdev = subject.blockdev?('/no-file')
+          expect(blockdev).to be_false
+        end
+      end
+    end
+
     describe ".basename" do
       it "returns the last component of the filename given in +file_name+" do
         expect(subject.basename('/path/to/file.txt')).to eq('file.txt')
@@ -48,6 +101,34 @@ module MemFs
       end
     end
 
+    describe ".chardev?" do
+      context "when the name file exists" do
+        context "and it is a character device" do
+          it "returns true" do
+            fs.touch('/character-file')
+            file = fs.find('/character-file')
+            file.character_device = true
+            chardev = subject.chardev?('/character-file')
+            expect(chardev).to be_true
+          end
+        end
+
+        context "and it is not a character device" do
+          it "returns false" do
+            chardev = subject.chardev?('/test-file')
+            expect(chardev).to be_false
+          end
+        end
+      end
+
+      context "when the name file does not exist" do
+        it "returns false" do
+          chardev = subject.chardev?('/no-file')
+          expect(chardev).to be_false
+        end
+      end
+    end
+
     describe '.chmod' do
       it "changes permission bits on the named file" do
         subject.chmod(0777, '/test-file')
@@ -131,6 +212,26 @@ module MemFs
       end
     end
 
+    describe ".ctime" do
+      it "returns the change time for the named file as a Time object" do
+        expect(subject.ctime('/test-file')).to be_a(Time)
+      end
+
+      it "raises an error if the entry does not exist" do
+        expect { subject.ctime('/no-file') }.to raise_error(Errno::ENOENT)
+      end
+
+      context "when the entry is a symlink" do
+        let(:time) { Time.now - 500000 }
+
+        it "returns the last access time of the last target of the link chain" do
+          fs.find!('/test-file').ctime = time
+          subject.symlink('/test-link', '/test-link2')
+          expect(subject.ctime('/test-link2')).to eq(time)
+        end
+      end
+    end
+
     describe ".delete" do
       it_behaves_like 'aliased method', :delete, :unlink
     end
@@ -159,6 +260,132 @@ module MemFs
       end
     end
 
+    describe ".executable?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        subject.chmod(access, '/test-file')
+        subject.chown(uid, gid, '/test-file')
+      end
+
+      context "when the file is not executable by anyone" do
+        it "return false" do
+          executable = subject.executable?('/test-file')
+          expect(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
+          before(:each) { subject.chown(uid, 0, '/test-file') }
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            executable = subject.executable?('/test-file')
+            expect(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
+            executable = subject.executable?('/test-file')
+            expect(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
+            executable = subject.executable?('/test-file')
+            expect(executable).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          executable = subject.executable?('/no-file')
+          expect(executable).to be_false
+        end
+      end
+    end
+
+    describe ".executable_real?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        subject.chmod(access, '/test-file')
+        subject.chown(uid, gid, '/test-file')
+      end
+
+      context "when the file is not executable by anyone" do
+        it "return false" do
+          executable = subject.executable_real?('/test-file')
+          expect(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
+          before(:each) { subject.chown(uid, 0, '/test-file') }
+          let(:uid) { Process.uid }
+
+          it "returns true" do
+            executable = subject.executable_real?('/test-file')
+            expect(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.gid }
+
+          it "returns true" do
+            executable = subject.executable_real?('/test-file')
+            expect(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
+            executable = subject.executable_real?('/test-file')
+            expect(executable).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          executable = subject.executable_real?('/no-file')
+          expect(executable).to be_false
+        end
+      end
+    end
+
     describe ".exists?" do
       it "returns true if the file exists" do
         expect(subject.exists?('/test-file')).to be_true
@@ -191,6 +418,32 @@ module MemFs
       end
     end
 
+    describe ".extname" do
+      it "returns the extension of the given path" do
+        expect(subject.extname('test-file.txt')).to eq('.txt')
+      end
+
+      context "when the given path starts with a period" do
+        context "and the path has no extension" do
+          it "returns an empty string" do
+            expect(subject.extname('.test-file')).to eq('')
+          end
+        end
+
+        context "and the path has an extension" do
+          it "returns the extension" do
+            expect(subject.extname('.test-file.txt')).to eq('.txt')
+          end
+        end
+      end
+
+      context "when the period is the last character in path" do
+        it "returns an empty string" do
+          expect(subject.extname('test-file.')).to eq('')
+        end
+      end
+    end
+
     describe ".file?" do
       context "when the named file exists" do
         context "and it is a regular file" do
@@ -213,6 +466,96 @@ module MemFs
       end
     end
 
+    describe ".fnmatch" do
+      context "when the given path matches against the given pattern" do
+        it "returns true" do
+          expect(File.fnmatch('c?t', 'cat')).to be_true
+        end
+      end
+
+      context "when the given path does not match against the given pattern" do
+        it "returns false" do
+          expect(File.fnmatch('c?t', 'tac')).to be_false
+        end
+      end
+    end
+
+    describe ".fnmatch?" do
+      it_behaves_like 'aliased method', :fnmatch?, :fnmatch
+    end
+
+    describe ".ftype" do
+      context "when the named entry is a regular file" do
+        it "returns 'file'" do
+          expect(subject.ftype('/test-file')).to eq('file')
+        end
+      end
+
+      context "when the named entry is a directory" do
+        it "returns 'directory'" do
+          expect(subject.ftype('/test-dir')).to eq('directory')
+        end
+      end
+
+      context "when the named entry is a block device" do
+        it "returns 'blockSpecial'" do
+          fs.touch('/block-file')
+          file = fs.find('/block-file')
+          file.block_device = true
+          expect(subject.ftype('/block-file')).to eq('blockSpecial')
+        end
+      end
+
+      context "when the named entry is a character device" do
+        it "returns 'characterSpecial'" do
+          fs.touch('/character-file')
+          file = fs.find('/character-file')
+          file.character_device = true
+          expect(subject.ftype('/character-file')).to eq('characterSpecial')
+        end
+      end
+
+      context "when the named entry is a symlink" do
+        it "returns 'link'" do
+          expect(subject.ftype('/test-link')).to eq('link')
+        end
+      end
+
+      # fifo and socket not handled for now
+
+      context "when the named entry has no specific type" do
+        it "returns 'unknown'" do
+          root = fs.find('/')
+          root.add_entry Fake::Entry.new('test-entry')
+          expect(subject.ftype('/test-entry')).to eq('unknown')
+        end
+      end
+    end
+
+    describe ".grpowned?" do
+      context "when the named file exists" do
+        context "and the effective user group owns of the file" do
+          it "returns true" do
+            subject.chown(0, Process.egid, '/test-file')
+            expect(File.grpowned?('/test-file')).to be_true
+          end
+        end
+
+        context "and the effective user group does not own of the file" do
+          it "returns false" do
+            subject.chown(0, 0, '/test-file')
+            expect(File.grpowned?('/test-file')).to be_false
+          end
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          expect(File.grpowned?('/no-file')).to be_false
+        end
+      end
+    end
+
     describe ".identical?" do
       before :each do
         subject.open('/test-file', 'w') { |f| f.puts 'test' }
@@ -394,6 +737,30 @@ module MemFs
       end
     end
 
+    describe ".owned?" do
+      context "when the named file exists" do
+        context "and the effective user owns of the file" do
+          it "returns true" do
+            subject.chown(Process.euid, 0, '/test-file')
+            expect(File.owned?('/test-file')).to be_true
+          end
+        end
+
+        context "and the effective user does not own of the file" do
+          it "returns false" do
+            subject.chown(0, 0, '/test-file')
+            expect(File.owned?('/test-file')).to be_false
+          end
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          expect(File.owned?('/no-file')).to be_false
+        end
+      end
+    end
+
     describe '.path' do
       context "when the path is a string" do
         let(:path) { '/some/path' }
@@ -412,6 +779,17 @@ module MemFs
       end
     end
 
+    describe ".pipe?" do
+      # Pipes are not handled for now
+
+      context "when the named file is not a pipe" do
+        it "returns false" do
+          pipe = File.pipe?('/test-file')
+          expect(pipe).to be_false
+        end
+      end
+    end
+
     describe ".read" do
       before :each do
         subject.open('/test-file', 'w') { |f| f.puts "test" }
@@ -464,65 +842,445 @@ module MemFs
       end
     end
 
-    describe ".readlink" do
-      it "returns the name of the file referenced by the given link" do
-        expect(subject.readlink('/test-link')).to eq('/test-file')
-      end
-    end
+    describe ".readable?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
 
-    describe ".rename" do
-      it "renames the given file to the new name" do
-        subject.rename('/test-file', '/test-file2')
-        expect(subject.exists?('/test-file2')).to be_true
+      before :each do
+        subject.chmod(access, '/test-file')
+        subject.chown(uid, gid, '/test-file')
       end
 
-      it "returns zero" do
-        expect(subject.rename('/test-file', '/test-file2')).to eq(0)
+      context "when the file is not readable by anyone" do
+        it "return false" do
+          readable = subject.readable?('/test-file')
+          expect(readable).to be_false
+        end
       end
-    end
 
-    describe ".size" do
-      it "returns the size of the file" do
-        subject.open('/test-file', 'w') { |f| f.puts random_string }
-        expect(subject.size('/test-file')).to eq(random_string.size + 1)
-      end
-    end
+      context "when the file is user readable" do
+        let(:access) { MemFs::Fake::Entry::UREAD }
 
-    describe '.stat' do
-      it "returns a File::Stat object for the named file" do
-        expect(subject.stat('/test-file')).to be_a(File::Stat)
-      end
+        context "and the current user owns the file" do
+          before(:each) { subject.chown(uid, 0, '/test-file') }
+          let(:uid) { Process.euid }
 
-      it "follows the last symbolic link" do
-        expect(subject.stat('/test-link').symlink?).to be_false
+          it "returns true" do
+            readable = subject.readable?('/test-file')
+            expect(readable).to be_true
+          end
+        end
       end
 
-      context "when the named file does not exist" do
-        it "raises an exception" do
-          expect { subject.stat('/no-file') }.to raise_error(Errno::ENOENT)
+      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
+            readable = subject.readable?('/test-file')
+            expect(readable).to be_true
+          end
         end
       end
 
-      context "when the named file is a symlink" do
-        context "and its target does not exist" do
-          it "raises an exception" do
-            expect { subject.stat('/no-link') }.to raise_error(Errno::ENOENT)
+      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
+            readable = subject.readable?('/test-file')
+            expect(readable).to be_true
           end
         end
       end
 
-      it "always returns a new object" do
-        stat = subject.stat('/test-file')
-        expect(subject.stat('/test-file')).not_to be(stat)
+      context "when the file does not exist" do
+        it "returns false" do
+          readable = subject.readable?('/no-file')
+          expect(readable).to be_false
+        end
       end
     end
 
-    describe '.symlink' do
-      it "creates a symbolic link named new_name" do
-        expect(subject.symlink?('/test-link')).to be_true
+    describe ".readable_real?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        subject.chmod(access, '/test-file')
+        subject.chown(uid, gid, '/test-file')
       end
 
-      it "creates a symbolic link that points to an entry named old_name" do
+      context "when the file is not readable by anyone" do
+        it "return false" do
+          readable = subject.readable_real?('/test-file')
+          expect(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
+          before(:each) { subject.chown(uid, 0, '/test-file') }
+          let(:uid) { Process.uid }
+
+          it "returns true" do
+            readable = subject.readable_real?('/test-file')
+            expect(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.gid }
+
+          it "returns true" do
+            readable = subject.readable_real?('/test-file')
+            expect(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
+            readable = subject.readable_real?('/test-file')
+            expect(readable).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          readable = subject.readable_real?('/no-file')
+          expect(readable).to be_false
+        end
+      end
+    end
+
+    describe ".readlink" do
+      it "returns the name of the file referenced by the given link" do
+        expect(subject.readlink('/test-link')).to eq('/test-file')
+      end
+    end
+
+    describe ".realdirpath" do
+      before :each do
+        fs.mkdir('/test-dir/sub-dir')
+        fs.symlink('/test-dir/sub-dir', '/test-dir/sub-dir-link')
+        fs.touch('/test-dir/sub-dir/test-file')
+      end
+
+      context "when the path does not contain any symlink or useless dots" do
+        it "returns the path itself" do
+          path = subject.realdirpath('/test-file')
+          expect(path).to eq('/test-file')
+        end
+      end
+
+      context "when the path contains a symlink" do
+        context "and the symlink is a middle part" do
+          it "returns the path with the symlink dereferrenced" do
+            path = subject.realdirpath('/test-dir/sub-dir-link/test-file')
+            expect(path).to eq('/test-dir/sub-dir/test-file')
+          end
+        end
+
+        context "and the symlink is the last part" do
+          it "returns the path with the symlink dereferrenced" do
+            path = subject.realdirpath('/test-dir/sub-dir-link')
+            expect(path).to eq('/test-dir/sub-dir')
+          end
+        end
+      end
+
+      context "when the path contains useless dots" do
+        it "returns the path with the useless dots interpolated" do
+          path = subject.realdirpath('/test-dir/../test-dir/./sub-dir/test-file')
+          expect(path).to eq('/test-dir/sub-dir/test-file')
+        end
+      end
+
+      context 'when the given path is relative' do
+        context "and +dir_string+ is not provided" do
+          it "uses the current working directory has base directory" do
+            fs.chdir('/test-dir')
+            path = subject.realdirpath('../test-dir/./sub-dir/test-file')
+            expect(path).to eq('/test-dir/sub-dir/test-file')
+          end
+        end
+
+        context "and +dir_string+ is provided" do
+          it "uses the given directory has base directory" do
+            path = subject.realdirpath('../test-dir/./sub-dir/test-file', '/test-dir')
+            expect(path).to eq('/test-dir/sub-dir/test-file')
+          end
+        end
+      end
+
+      context "when the last part of the given path is a symlink" do
+        context "and its target does not exist" do
+          before :each do
+            fs.symlink('/test-dir/sub-dir/test', '/test-dir/sub-dir/test-link')
+          end
+
+          it "uses the name of the target in the resulting path" do
+            path = subject.realdirpath('/test-dir/sub-dir/test-link')
+            expect(path).to eq('/test-dir/sub-dir/test')
+          end
+        end
+      end
+
+      context "when the last part of the given path does not exist" do
+        it "uses its name in the resulting path" do
+          path = subject.realdirpath('/test-dir/sub-dir/test')
+          expect(path).to eq('/test-dir/sub-dir/test')
+        end
+      end
+
+      context "when a middle part of the given path does not exist" do
+        it "raises an exception" do
+          expect {
+            subject.realdirpath('/no-dir/test-file')
+          }.to raise_error
+        end
+      end
+    end
+
+    describe ".realpath" do
+      before :each do
+        fs.mkdir('/test-dir/sub-dir')
+        fs.symlink('/test-dir/sub-dir', '/test-dir/sub-dir-link')
+        fs.touch('/test-dir/sub-dir/test-file')
+      end
+
+      context "when the path does not contain any symlink or useless dots" do
+        it "returns the path itself" do
+          path = subject.realpath('/test-file')
+          expect(path).to eq('/test-file')
+        end
+      end
+
+      context "when the path contains a symlink" do
+        context "and the symlink is a middle part" do
+          it "returns the path with the symlink dereferrenced" do
+            path = subject.realpath('/test-dir/sub-dir-link/test-file')
+            expect(path).to eq('/test-dir/sub-dir/test-file')
+          end
+        end
+
+        context "and the symlink is the last part" do
+          it "returns the path with the symlink dereferrenced" do
+            path = subject.realpath('/test-dir/sub-dir-link')
+            expect(path).to eq('/test-dir/sub-dir')
+          end
+        end
+      end
+
+      context "when the path contains useless dots" do
+        it "returns the path with the useless dots interpolated" do
+          path = subject.realpath('/test-dir/../test-dir/./sub-dir/test-file')
+          expect(path).to eq('/test-dir/sub-dir/test-file')
+        end
+      end
+
+      context 'when the given path is relative' do
+        context "and +dir_string+ is not provided" do
+          it "uses the current working directory has base directory" do
+            fs.chdir('/test-dir')
+            path = subject.realpath('../test-dir/./sub-dir/test-file')
+            expect(path).to eq('/test-dir/sub-dir/test-file')
+          end
+        end
+
+        context "and +dir_string+ is provided" do
+          it "uses the given directory has base directory" do
+            path = subject.realpath('../test-dir/./sub-dir/test-file', '/test-dir')
+            expect(path).to eq('/test-dir/sub-dir/test-file')
+          end
+        end
+      end
+
+      context "when a part of the given path does not exist" do
+        it "raises an exception" do
+          expect {
+            subject.realpath('/no-dir/test-file')
+          }.to raise_error
+        end
+      end
+    end
+
+    describe ".rename" do
+      it "renames the given file to the new name" do
+        subject.rename('/test-file', '/test-file2')
+        expect(subject.exists?('/test-file2')).to be_true
+      end
+
+      it "returns zero" do
+        expect(subject.rename('/test-file', '/test-file2')).to eq(0)
+      end
+    end
+
+    describe ".setgid?" do
+      context "when the named file exists" do
+        context "and the named file has the setgid bit set" do
+          it "returns true" do
+            fs.chmod(02000, '/test-file')
+            expect(File.setgid?('/test-file')).to be_true
+          end
+        end
+
+        context "and the named file does not have the setgid bit set" do
+          it "returns false" do
+            expect(File.setgid?('/test-file')).not_to be_true
+          end
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          expect(File.setgid?('/no-file')).to be_false
+        end
+      end
+    end
+
+    describe ".setuid?" do
+      context "when the named file exists" do
+        context "and the named file has the setuid bit set" do
+          it "returns true" do
+            fs.chmod(04000, '/test-file')
+            expect(File.setuid?('/test-file')).to be_true
+          end
+        end
+
+        context "and the named file does not have the setuid bit set" do
+          it "returns false" do
+            expect(File.setuid?('/test-file')).not_to be_true
+          end
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          expect(File.setuid?('/no-file')).to be_false
+        end
+      end
+    end
+
+    describe ".size" do
+      it "returns the size of the file" do
+        subject.open('/test-file', 'w') { |f| f.puts random_string }
+        expect(subject.size('/test-file')).to eq(random_string.size + 1)
+      end
+    end
+
+    describe ".size?" do
+      context "when the named file exists" do
+        context "and it is empty" do
+          it "returns false" do
+            expect(File.size?('/empty-file')).to be_false
+          end
+        end
+
+        context "and it is not empty" do
+          it "returns the size of the file" do
+            File.open('/content-file', 'w') { |f| f.write 'test' }
+            expect(File.size?('/content-file')).to eq(4)
+          end
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          expect(File.size?('/no-file')).to be_false
+        end
+      end
+    end
+
+    describe ".socket?" do
+      # Sockets are not handled for now
+
+      context "when the named file is not a socket" do
+        it "returns false" do
+          socket = File.socket?('/test-file')
+          expect(socket).to be_false
+        end
+      end
+    end
+
+    describe '.split' do
+      it "splits the given string into a directory and a file component" do
+        result = subject.split('/path/to/some-file')
+        expect(result).to eq(['/path/to', 'some-file'])
+      end
+    end
+
+    describe '.stat' do
+      it "returns a File::Stat object for the named file" do
+        expect(subject.stat('/test-file')).to be_a(File::Stat)
+      end
+
+      it "follows the last symbolic link" do
+        expect(subject.stat('/test-link').symlink?).to be_false
+      end
+
+      context "when the named file does not exist" do
+        it "raises an exception" do
+          expect { subject.stat('/no-file') }.to raise_error(Errno::ENOENT)
+        end
+      end
+
+      context "when the named file is a symlink" do
+        context "and its target does not exist" do
+          it "raises an exception" do
+            expect { subject.stat('/no-link') }.to raise_error(Errno::ENOENT)
+          end
+        end
+      end
+
+      it "always returns a new object" do
+        stat = subject.stat('/test-file')
+        expect(subject.stat('/test-file')).not_to be(stat)
+      end
+    end
+
+    describe ".sticky?" do
+      context "when the named file exists" 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.sticky?('/test-file')).to be_true
+        end
+
+        it "returns false if the named file hasn't' the sticky bit set" do
+          fs.touch('/test-file')
+          expect(File.sticky?('/test-file')).not_to be_true
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          expect(File.sticky?('/no-file')).to be_false
+        end
+      end
+    end
+
+    describe '.symlink' do
+      it "creates a symbolic link named new_name" do
+        expect(subject.symlink?('/test-link')).to be_true
+      end
+
+      it "creates a symbolic link that points to an entry named old_name" do
         expect(fs.find!('/test-link').target).to eq('/test-file')
       end
 
@@ -557,6 +1315,34 @@ module MemFs
       end
     end
 
+    describe '.truncate' do
+      before :each do
+        subject.open('/test-file', 'w') { |f| f.write 'x' * 50 }
+      end
+
+      it "truncates the named file to the given size" do
+        subject.truncate('/test-file', 5)
+        expect(subject.size('/test-file')).to eq(5)
+      end
+
+      it "returns zero" do
+        return_value = subject.truncate('/test-file', 5)
+        expect(return_value).to eq(0)
+      end
+
+      context "when the named file does not exist" do
+        it "raises an exception" do
+          expect { subject.truncate('/no-file', 5) }.to raise_error
+        end
+      end
+
+      context "when the given size is negative" do
+        it "it raises an exception" do
+          expect { subject.truncate('/test-file', -1) }.to raise_error
+        end
+      end
+    end
+
     describe '.umask' do
       before :each do
         subject.umask(0022)
@@ -626,6 +1412,209 @@ module MemFs
       end
     end
 
+    describe '.world_readable?' do
+      before :each do
+        subject.chmod(access, '/test-file')
+      end
+
+      context 'when file_name is readable by others' do
+        let(:access) { MemFs::Fake::Entry::OREAD }
+
+        it 'returns an integer representing the file permission bits' do
+          readable = subject.world_readable?('/test-file')
+          expect(readable).to eq(MemFs::Fake::Entry::OREAD)
+        end
+      end
+
+      context 'when file_name is not readable by others' do
+        let(:access) { MemFs::Fake::Entry::UREAD }
+
+        it 'returns nil' do
+          readable = subject.world_readable?('/test-file')
+          expect(readable).to be_nil
+        end
+      end
+    end
+
+    describe '.world_writable?' do
+      before :each do
+        subject.chmod(access, '/test-file')
+      end
+
+      context 'when file_name is writable by others' do
+        let(:access) { MemFs::Fake::Entry::OWRITE }
+
+        it 'returns an integer representing the file permission bits' do
+          writable = subject.world_writable?('/test-file')
+          expect(writable).to eq(MemFs::Fake::Entry::OWRITE)
+        end
+      end
+
+      context 'when file_name is not writable by others' do
+        let(:access) { MemFs::Fake::Entry::UWRITE }
+
+        it 'returns nil' do
+          writable = subject.world_writable?('/test-file')
+          expect(writable).to be_nil
+        end
+      end
+    end
+
+    describe ".writable?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        subject.chmod(access, '/test-file')
+        subject.chown(uid, gid, '/test-file')
+      end
+
+      context "when the file is not writable by anyone" do
+        it "return false" do
+          writable = subject.writable?('/test-file')
+          expect(writable).to be_false
+        end
+      end
+
+      context "when the file is user writable" do
+        let(:access) { MemFs::Fake::Entry::UWRITE }
+
+        context "and the current user owns the file" do
+          before(:each) { subject.chown(uid, 0, '/test-file') }
+          let(:uid) { Process.euid }
+
+          it "returns true" do
+            writable = subject.writable?('/test-file')
+            expect(writable).to be_true
+          end
+        end
+      end
+
+      context "when the file is group writable" 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
+            writable = subject.writable?('/test-file')
+            expect(writable).to be_true
+          end
+        end
+      end
+
+      context "when the file is writable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OWRITE }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            writable = subject.writable?('/test-file')
+            expect(writable).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          writable = subject.writable?('/no-file')
+          expect(writable).to be_false
+        end
+      end
+    end
+
+    describe ".writable_real?" do
+      let(:access) { 0 }
+      let(:gid) { 0 }
+      let(:uid) { 0 }
+
+      before :each do
+        subject.chmod(access, '/test-file')
+        subject.chown(uid, gid, '/test-file')
+      end
+
+      context "when the file is not writable by anyone" do
+        it "return false" do
+          writable = subject.writable_real?('/test-file')
+          expect(writable).to be_false
+        end
+      end
+
+      context "when the file is user writable" do
+        let(:access) { MemFs::Fake::Entry::UWRITE }
+
+        context "and the current user owns the file" do
+          before(:each) { subject.chown(uid, 0, '/test-file') }
+          let(:uid) { Process.uid }
+
+          it "returns true" do
+            writable = subject.writable_real?('/test-file')
+            expect(writable).to be_true
+          end
+        end
+      end
+
+      context "when the file is group writable" do
+        let(:access) { MemFs::Fake::Entry::GWRITE }
+
+        context "and the current user is part of the owner group" do
+          let(:gid) { Process.gid }
+
+          it "returns true" do
+            writable = subject.writable_real?('/test-file')
+            expect(writable).to be_true
+          end
+        end
+      end
+
+      context "when the file is writable by anyone" do
+        let(:access) { MemFs::Fake::Entry::OWRITE }
+
+        context "and the user has no specific right on it" do
+          it "returns true" do
+            writable = subject.writable_real?('/test-file')
+            expect(writable).to be_true
+          end
+        end
+      end
+
+      context "when the file does not exist" do
+        it "returns false" do
+          writable = subject.writable_real?('/no-file')
+          expect(writable).to be_false
+        end
+      end
+    end
+
+    describe ".zero?" do
+      context "when the named file exists" do
+        context "and has a zero size" do
+          it "returns true" do
+            zero = subject.zero?('/test-file')
+            expect(zero).to be_true
+          end
+        end
+
+        context "and does not have a zero size" do
+          before :each do
+            File.open('/test-file', 'w') { |f| f.puts 'test' }
+          end
+
+          it "returns false" do
+            zero = subject.zero?('/test-file')
+            expect(zero).to be_false
+          end
+        end
+      end
+
+      context "when the named file does not exist" do
+        it "returns false" do
+          zero = subject.zero?('/no-file')
+          expect(zero).to be_false
+        end
+      end
+    end
+
     describe '#chmod' do
       it "changes permission bits on the file" do
         file.chmod(0777)
@@ -739,7 +1728,7 @@ module MemFs
 
       it "does not follow the last symbolic link" do
         file = subject.new('/test-link')
-        expect(file.lstat).to be_symlink
+        expect(file.lstat.symlink?).to be_true
       end
 
       context "when the named file is a symlink" do