rfusefs 1.0.2 → 1.0.3

data/spec/mount_unmount_spec.rb

@@ -10,8 +10,8 @@ describe "a mounted FuseFS" do
 
     it "should get mounted and unmounted callbacks" do
         mock_fs = FuseFS::FuseDir.new()
-        mock_fs.should_receive(:mounted)
-        mock_fs.should_receive(:unmounted)
+        expect(mock_fs).to receive(:mounted)
+        expect(mock_fs).to receive(:unmounted)
 
         t = Thread.new { sleep 0.5 ; puts "exiting" ; FuseFS.exit }
         FuseFS.start(mock_fs,mountpoint)

data/spec/pathmapper_spec.rb

@@ -72,41 +72,41 @@ describe FuseFS::PathMapperFS do
     context "fusefs api" do
 
         it "maps files and directories" do
-            pathmap_fs.directory?("/").should be_true
-            pathmap_fs.directory?("/textfiles").should be_true
-            pathmap_fs.directory?("/pictures/201103").should be_true
-            pathmap_fs.file?("/textfiles/hello").should be_true
-            pathmap_fs.directory?("/textfiles/hello").should be_false
-            pathmap_fs.file?("/artist/album/mysong.mp3").should be_true
-            pathmap_fs.directory?("/artist/album/mysong.mp3").should be_false
-            pathmap_fs.file?("/some/unknown/path").should be_false
-            pathmap_fs.directory?("/some/unknown/path").should be_false
+            expect(pathmap_fs.directory?("/")).to be_truthy
+            expect(pathmap_fs.directory?("/textfiles")).to be_truthy
+            expect(pathmap_fs.directory?("/pictures/201103")).to be_truthy
+            expect(pathmap_fs.file?("/textfiles/hello")).to be_truthy
+            expect(pathmap_fs.directory?("/textfiles/hello")).to be_falsey
+            expect(pathmap_fs.file?("/artist/album/mysong.mp3")).to be_truthy
+            expect(pathmap_fs.directory?("/artist/album/mysong.mp3")).to be_falsey
+            expect(pathmap_fs.file?("/some/unknown/path")).to be_falsey
+            expect(pathmap_fs.directory?("/some/unknown/path")).to be_falsey
         end
 
         it "lists the mapped contents of directories" do
-            pathmap_fs.contents("/").should =~ [ "textfiles","artist","pictures" ]
-            pathmap_fs.contents("/artist").should =~ [ "album" ]
-            pathmap_fs.contents("/textfiles").should =~ [ "hello" ]
+            expect(pathmap_fs.contents("/")).to match_array([ "textfiles","artist","pictures" ])
+            expect(pathmap_fs.contents("/artist")).to match_array([ "album" ])
+            expect(pathmap_fs.contents("/textfiles")).to match_array([ "hello" ])
         end
 
         it "reports the size of a file" do
-            pathmap_fs.size("/textfiles/hello").should == 16
+            expect(pathmap_fs.size("/textfiles/hello")).to eq(16)
         end
 
         it "reads the contents of a file" do
-            pathmap_fs.read_file("/textfiles/hello").should == "/textfiles/hello"
+            expect(pathmap_fs.read_file("/textfiles/hello")).to eq("/textfiles/hello")
         end
 
         it "does not allow writes" do
-            pathmap_fs.can_write?("/textfiles/hello").should be_false
+            expect(pathmap_fs.can_write?("/textfiles/hello")).to be_falsey
         end
 
         it "reports the atime,mtime and ctime of the mapped file" do
             atime,mtime,ctime = pathmap_fs.times("/pictures/201103/apicture.jpg")
             picture = tmpdir + "apicture.jpeg"
-            atime.should == picture.atime()
-            mtime.should == picture.mtime()
-            ctime.should == picture.ctime()
+            expect(atime).to eq(picture.atime())
+            expect(mtime).to eq(picture.mtime())
+            expect(ctime).to eq(picture.ctime())
         end
 
         context "with extended attributes" do
@@ -130,62 +130,62 @@ describe FuseFS::PathMapperFS do
             end
 
             it "should list extended attributes" do
-                pm_file_xattr.keys.should include("user.file_attr")
-                pm_file_xattr.keys.should include("user.add_attr")
-                pm_file_xattr.keys.size.should == 2
+                expect(pm_file_xattr.keys).to include("user.file_attr")
+                expect(pm_file_xattr.keys).to include("user.add_attr")
+                expect(pm_file_xattr.keys.size).to eq(2)
             end
 
             it "should read extended attributes from underlying file" do
-                pm_file_xattr["user.file_attr"].should == "fileValue"
+                expect(pm_file_xattr["user.file_attr"]).to eq("fileValue")
             end
 
             it "should read additional attributes" do
                 # make sure additional attributes are not on the real file
-                hello_xattr.list.should_not include("user.add_attr")
+                expect(hello_xattr.list).not_to include("user.add_attr")
 
-                pm_file_xattr["user.add_attr"].should == "addValue"
+                expect(pm_file_xattr["user.add_attr"]).to eq("addValue")
             end
 
             it "should write extended attributes to the underlying file" do
                 pm_file_xattr["user.file_attr"] = "written"
-                hello_xattr["user.file_attr"].should == "written"
+                expect(hello_xattr["user.file_attr"]).to eq("written")
             end
 
             it "should remove extended attributes from the underlying file" do
                 pm_file_xattr.delete("user.file_attr")
-                hello_xattr.list.should_not include("user.file_attr")
+                expect(hello_xattr.list).not_to include("user.file_attr")
             end
 
             it "raise EACCES when writing to additional attributes" do
-                lambda {pm_file_xattr["user.add_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+                expect {pm_file_xattr["user.add_attr"] = "newValue"}.to raise_error(Errno::EACCES)
             end
 
             it "raise EACCES when removing additional attributes" do
-                lambda {pm_file_xattr.delete("user.add_attr")}.should raise_error(Errno::EACCES)
+                expect {pm_file_xattr.delete("user.add_attr")}.to raise_error(Errno::EACCES)
             end
 
             it "should list additional attributes from virtual directories" do
-                pm_dir_xattr.keys.should include("user.dir_attr")
-                pm_dir_xattr.keys.size.should == 1
+                expect(pm_dir_xattr.keys).to include("user.dir_attr")
+                expect(pm_dir_xattr.keys.size).to eq(1)
             end
 
             it "should read additional attributes from virtual directories" do
-                pm_dir_xattr["user.dir_attr"].should == "dirValue"
+                expect(pm_dir_xattr["user.dir_attr"]).to eq("dirValue")
 
             end
 
             it "should raise EACCES when writing additional attributes on virtual directories" do
-                lambda {pm_dir_xattr["user.dir_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+                expect {pm_dir_xattr["user.dir_attr"] = "newValue"}.to raise_error(Errno::EACCES)
             end
 
             it "should raise EACCES when deleting additional attributes on virtual directories" do
-                lambda {pm_dir_xattr.delete("user.dir_attr")}.should raise_error(Errno::EACCES)
+                expect {pm_dir_xattr.delete("user.dir_attr")}.to raise_error(Errno::EACCES)
             end
 
             it "should accept xattr as option to #map_file" do
                 fixture.pathmap("mapped_xattr.txt","/textfiles/mapped_xattr","content",
                                  :xattr => { "user.xattr" => "map_file" })
-                pathmap_fs.xattr("/textfiles/mapped_xattr")["user.xattr"].should == "map_file"
+                expect(pathmap_fs.xattr("/textfiles/mapped_xattr")["user.xattr"]).to eq("map_file")
             end
         end
 
@@ -193,10 +193,10 @@ describe FuseFS::PathMapperFS do
 
             it "reports accumulated stats about mapped files" do
                 used_space, used_nodes, max_space, max_nodes = pathmap_fs.statistics("/pictures/201103/apicture.jpg")
-                used_space.should == 69
-                used_nodes.should == 9
-                max_space.should be_nil
-                max_nodes.should be_nil
+                expect(used_space).to eq(69)
+                expect(used_nodes).to eq(9)
+                expect(max_space).to be_nil
+                expect(max_nodes).to be_nil
             end
         end
 
@@ -208,20 +208,20 @@ describe FuseFS::PathMapperFS do
 
             it "updates the contents of the real file" do
                 hello_path = tmpdir + "hello.txt"
-                hello_path.read.should == "updated content"
+                expect(hello_path.read).to eq("updated content")
             end
 
             it "updates the contents of the mapped file" do
-                pathmap_fs.read_file("textfiles/hello").should == "updated content"
+                expect(pathmap_fs.read_file("textfiles/hello")).to eq("updated content")
             end
 
             it "changes the reported file size" do
-                pathmap_fs.size("textfiles/hello").should == 15
+                expect(pathmap_fs.size("textfiles/hello")).to eq(15)
             end
 
             it "changes the filesystem statistics" do
                 used_space, used_nodes, max_space, max_nodes = pathmap_fs.statistics("/pictures/201103/apicture.jpg")
-                used_space.should == 68
+                expect(used_space).to eq(68)
             end
         end
 
@@ -233,12 +233,12 @@ describe FuseFS::PathMapperFS do
         end
 
         it "maps files and directories" do
-            (mountpoint + "textfiles").directory?.should be_true
-            (mountpoint + "textfiles/hello").file?.should be_true
+            expect((mountpoint + "textfiles").directory?).to be_truthy
+            expect((mountpoint + "textfiles/hello").file?).to be_truthy
         end
 
         it "lists the mapped contents of directories" do
-            (mountpoint + "textfiles").entries.should =~ pathnames(".","..","hello")
+            expect((mountpoint + "textfiles").entries).to match_array(pathnames(".","..","hello"))
         end
 
         it "represents the stat information of the underlying files" do
@@ -246,15 +246,15 @@ describe FuseFS::PathMapperFS do
             realpath=(tmpdir + "hello.txt")
             mappedstat = hellopath.stat
             realstat = realpath.stat
-            mappedstat.size.should == realstat.size
-            mappedstat.atime.should == realstat.atime
-            mappedstat.mtime.should == realstat.mtime
-            mappedstat.ctime.should == realstat.ctime
+            expect(mappedstat.size).to eq(realstat.size)
+            expect(mappedstat.atime).to eq(realstat.atime)
+            expect(mappedstat.mtime).to eq(realstat.mtime)
+            expect(mappedstat.ctime).to eq(realstat.ctime)
         end
 
         it "reads the files" do
             hellopath= mountpoint + "textfiles/hello"
-            hellopath.read.should == "/textfiles/hello"
+            expect(hellopath.read).to eq("/textfiles/hello")
         end
 
         it "writes the files" do
@@ -263,8 +263,8 @@ describe FuseFS::PathMapperFS do
             hellopath.open("w") do |f|
                 f.print "updated content"
             end
-            hellopath.read.should == "updated content"
-            real_path.read.should == "updated content"
+            expect(hellopath.read).to eq("updated content")
+            expect(real_path.read).to eq("updated content")
         end
 
         context "extended attributes" do
@@ -288,52 +288,52 @@ describe FuseFS::PathMapperFS do
             end
 
             it "should list extended attributes" do
-                file_xattr.list.should include("user.file_attr")
-                file_xattr.list.should include("user.add_attr")
-                file_xattr.list.size.should == 2
+                expect(file_xattr.list).to include("user.file_attr")
+                expect(file_xattr.list).to include("user.add_attr")
+                expect(file_xattr.list.size).to eq(2)
             end
 
             it "should read extended attributes from underlying file" do
-                file_xattr["user.file_attr"].should == "fileValue"
+                expect(file_xattr["user.file_attr"]).to eq("fileValue")
             end
 
             it "should read additional attributes" do
-                file_xattr["user.add_attr"].should == "addValue"
+                expect(file_xattr["user.add_attr"]).to eq("addValue")
             end
 
             it "should write extended attributes to the underlying file" do
                 file_xattr["user.file_attr"] = "written"
-                hello_xattr["user.file_attr"].should == "written"
+                expect(hello_xattr["user.file_attr"]).to eq("written")
             end
 
             it "should remove extended attributes from the underlying file" do
                 file_xattr.remove("user.file_attr")
-                hello_xattr.list.should_not include("user.file_attr")
+                expect(hello_xattr.list).not_to include("user.file_attr")
             end
 
             it "raise EACCES when writing to additional attributes" do
-                lambda {file_xattr["user.add_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+                expect {file_xattr["user.add_attr"] = "newValue"}.to raise_error(Errno::EACCES)
             end
 
             it "raise EACCES when removing additional attributes" do
-                lambda {file_xattr.remove("user.add_attr")}.should raise_error(Errno::EACCES)
+                expect {file_xattr.remove("user.add_attr")}.to raise_error(Errno::EACCES)
             end
 
             it "should list additional attributes from virtual directories" do
-                dir_xattr.list.should include("user.dir_attr")
-                dir_xattr.list.size.should == 1
+                expect(dir_xattr.list).to include("user.dir_attr")
+                expect(dir_xattr.list.size).to eq(1)
             end
 
             it "should read additional attributes from virtual directories" do
-                dir_xattr["user.dir_attr"].should == "dirValue"
+                expect(dir_xattr["user.dir_attr"]).to eq("dirValue")
             end
 
             it "should raise EACCES when writing additional attributes on virtual directories" do
-                lambda {dir_xattr["user.dir_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+                expect {dir_xattr["user.dir_attr"] = "newValue"}.to raise_error(Errno::EACCES)
             end
 
             it "should raise EACCES when deleting additional attributes on virtual directories" do
-                lambda {dir_xattr.remove("user.dir_attr")}.should raise_error(Errno::EACCES)
+                expect {dir_xattr.remove("user.dir_attr")}.to raise_error(Errno::EACCES)
             end
 
         end
@@ -346,25 +346,25 @@ describe FuseFS::PathMapperFS do
             it "reports stats for files" do
                 statfs = Sys::Filesystem.stat(mountpoint.to_path)
                 # These are fixed
-                statfs.block_size.should == 1024
-                statfs.fragment_size.should == 1024
+                expect(statfs.block_size).to eq(1024)
+                expect(statfs.fragment_size).to eq(1024)
 
                 # These are dependant on the tests above creating files/directories
-                statfs.files.should == 10
+                expect(statfs.files).to eq(10)
                 statfs.files_available == 10
 
                 # assume test are less than 1 block, so dependant on bigfile above
-                statfs.blocks.should == 2
-                statfs.blocks_available.should == 0
-                statfs.blocks_free.should == 0
+                expect(statfs.blocks).to eq(2)
+                expect(statfs.blocks_available).to eq(0)
+                expect(statfs.blocks_free).to eq(0)
             end
 
             it "reports stats for files after writing" do
 
                 (mountpoint + "textfiles/bigfile").open("w") { |f| f.print("y" * 4096) }
                 statfs = Sys::Filesystem.stat(mountpoint.to_path)
-                statfs.files.should == 10
-                statfs.blocks.should == 4
+                expect(statfs.files).to eq(10)
+                expect(statfs.blocks).to eq(4)
 
             end
 
@@ -382,12 +382,12 @@ describe FuseFS::PathMapperFS do
             hello_path = (mountpoint + "textfiles/hello")
             hello_path.open do |f|
                 f.seek(2)
-                f.read(3).should == "ext"
+                expect(f.read(3)).to eq("ext")
             end
 
             hello_path.sysopen do |f|
                 f.sysseek(1)
-                f.sysread(3).should == "tex"
+                expect(f.sysread(3)).to eq("tex")
             end
         end
 
@@ -398,10 +398,10 @@ describe FuseFS::PathMapperFS do
                 f.sysseek(2)
                 f.syswrite("zzz")
                 f.sysseek(0)
-                f.sysread(6).should == "/tzzzf"
+                expect(f.sysread(6)).to eq("/tzzzf")
             end
 
-            real_path.read.should == "/tzzzfiles/hello"
+            expect(real_path.read).to eq("/tzzzfiles/hello")
         end
 
         it "reports filesystem statistics after raw write" do
@@ -411,7 +411,7 @@ describe FuseFS::PathMapperFS do
             end
 
             statfs = Sys::Filesystem.stat(mountpoint.to_path)
-            statfs.blocks.should == 2
+            expect(statfs.blocks).to eq(2)
         end
     end
 end

data/spec/rfusefs_spec.rb

@@ -1,497 +1,505 @@
-require 'spec_helper'
-
-describe FuseFS do
-
-  TEST_FILE = "/aPath/aFile"
-  TEST_DIR = "/aPath"
-  ROOT_PATH = "/"
-  Struct.new("FuseFileInfo",:flags,:fh)
-
-  describe "an empty FuseFS object" do
-    before(:each) do
-      @fuse = FuseFS::RFuseFS.new(Object.new())
-    end
-
-    it "should return an appropriate Stat for the root directory" do
-      stat = @fuse.getattr(nil,ROOT_PATH)
-      stat.should respond_to(:dev)
-      (stat.mode & RFuse::Stat::S_IFDIR).should_not == 0
-      (stat.mode & RFuse::Stat::S_IFREG).should == 0
-      permissions(stat.mode).should == 0555
-    end
-
-    it "should have an empty root directory" do
-      filler = mock("entries_filler")
-      filler.should_receive(:push).with(".",nil,0)
-      filler.should_receive(:push).with("..",nil,0)
-      @fuse.readdir(nil,"/",filler,nil,nil)
-    end
-
-    it "should raise ENOENT for other paths" do
-      lambda { @fuse.getattr(nil,"/somepath") }.should raise_error(Errno::ENOENT)
-    end
-
-    it "should not allow new files or directories" do
-      lambda { @fuse.mknod(nil,"/afile",0100644,0,0) }.should raise_error(Errno::EACCES)
-      lambda { @fuse.mkdir(nil,"/adir",0040555) }.should raise_error(Errno::EACCES)
-    end
-  end
-
-  describe "a FuseFS filesystem" do
-    before(:each) do
-      @mock_fuse = FuseFS::FuseDir.new()
-      @fuse = FuseFS::RFuseFS.new(@mock_fuse)
-    end
-
-    describe :readdir do
-      before(:each) do
-        @mock_fuse.should_receive(:contents).with("/apath").and_return(["afile"])
-      end
-
-      it "should add  . and .. to the results of :contents when listing a directory" do
-        filler = mock("entries_filler")
-        filler.should_receive(:push).with(".",nil,0)
-        filler.should_receive(:push).with("..",nil,0)
-        filler.should_receive(:push).with("afile",nil,0)
-        @fuse.readdir(nil,"/apath",filler,nil,nil)
-      end
-
-    end
-
-    describe :getattr do
-
-      #Root directory is special (ish) so we need to run these specs twice.
-      [ROOT_PATH,TEST_DIR].each do |dir|
-
-        context "of a directory #{ dir }" do
-
-          before(:each) do
-            @mock_fuse.stub!(:file?).and_return(false)
-            @mock_fuse.should_receive(:directory?).with(dir).at_most(:once).and_return(true)
-            @checkfile =  (dir == "/" ? "" : dir ) + FuseFS::RFuseFS::CHECK_FILE
-          end
-
-          it "should return a Stat like object representing a directory" do
-            @mock_fuse.should_receive(:can_write?).with(@checkfile).at_most(:once).and_return(false)
-            @mock_fuse.should_receive(:can_mkdir?).with(@checkfile).at_most(:once).and_return(false)
-            stat = @fuse.getattr(nil,dir)
-            #Apparently find relies on nlink accurately listing the number of files/directories or nlink being 1
-            stat.nlink.should == 1
-            filetype(stat.mode).should == RFuse::Stat::S_IFDIR
-            permissions(stat.mode).should == 0555
-          end
-
-
-          it "should return writable mode if can_mkdir?" do
-            @mock_fuse.should_receive(:can_mkdir?).with(@checkfile).at_most(:once).and_return(true)
-
-            stat = @fuse.getattr(nil,dir)
-            permissions(stat.mode).should == 0777
-          end
-
-          it "should return writable mode if can_write?" do
-            @mock_fuse.should_receive(:can_write?).with(@checkfile).at_most(:once).and_return(true)
-
-            stat = @fuse.getattr(nil,dir)
-            permissions(stat.mode).should == 0777
-
-          end
-
-          it "should return times in the result if available" do
-            @mock_fuse.should_receive(:times).with(dir).and_return([10,20,30])
-            stat = @fuse.getattr(nil,dir)
-            stat.atime.should == 10
-            stat.mtime.should == 20
-            stat.ctime.should == 30
-          end
-        end
-      end
-
-      describe "a file" do
-
-        before(:each) do
-          @file="/aPath/aFile"
-          @mock_fuse.stub!(:directory?).and_return(false)
-          @mock_fuse.should_receive(:file?).with(@file).at_most(:once).and_return(true)
-        end
-
-
-        it "should return a Stat like object representing a file" do
-          stat = @fuse.getattr(nil,@file)
-          (stat.mode & RFuse::Stat::S_IFDIR).should == 0
-          (stat.mode & RFuse::Stat::S_IFREG).should_not == 0
-          permissions(stat.mode).should == 0444
-        end
-
-        it "should indicate executable mode if executable?" do
-          @mock_fuse.should_receive(:executable?).with(@file).and_return(true)
-          stat = @fuse.getattr(nil,@file)
-          permissions(stat.mode).should == 0555
-        end
-
-        it "should indicate writable mode if can_write?" do
-          @mock_fuse.should_receive(:can_write?).with(@file).and_return(true)
-          stat = @fuse.getattr(nil,@file)
-          permissions(stat.mode).should == 0666
-        end
-
-        it "should by 777 mode if can_write? and exectuable?" do
-          @mock_fuse.should_receive(:can_write?).with(@file).and_return(true)
-          @mock_fuse.should_receive(:executable?).with(@file).and_return(true)
-          stat = @fuse.getattr(nil,@file)
-          permissions(stat.mode).should == 0777
-        end
-
-        it "should include size in the result if available" do
-          @mock_fuse.should_receive(:size).with(@file).and_return(234)
-          stat = @fuse.getattr(nil,@file)
-          stat.size.should == 234
-        end
-
-        it "should include times in the result if available" do
-          @mock_fuse.should_receive(:times).with(@file).and_return([22,33,44])
-          stat = @fuse.getattr(nil,@file)
-          stat.atime.should == 22
-          stat.mtime.should == 33
-          stat.ctime.should == 44
-        end
-      end
-
-      it "should raise ENOENT for a path that does not exist" do
-        @mock_fuse.should_receive(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.should_receive(:directory?).with(TEST_FILE).and_return(false)
-        lambda{stat = @fuse.getattr(nil,TEST_FILE) }.should raise_error(Errno::ENOENT)
-      end
-    end
-
-    context "creating files and directories" do
-
-      it ":mknod should raise EACCES unless :can_write?" do
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
-        @mock_fuse.should_receive(:can_write?).with(TEST_FILE).and_return(false)
-        lambda{@fuse.mknod(nil,TEST_FILE,0100644,0,0)}.should raise_error(Errno::EACCES)
-      end
-
-      it ":mkdir should raise EACCES unless :can_mkdir?" do
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
-        @mock_fuse.should_receive(:can_mkdir?).with(TEST_FILE).and_return(false)
-        lambda{@fuse.mkdir(nil,TEST_FILE,004555)}.should raise_error(Errno::EACCES)
-      end
-
-      it ":mknod should raise EACCES unless mode requests a regular file" do
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        lambda{@fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFLNK | 0644,0,0)}.should raise_error(Errno::EACCES)
-      end
-
-      it ":mknod should result in getattr returning a Stat like object representing an empty file" do
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
-
-        stat = @fuse.getattr(nil,TEST_FILE)
-        filetype(stat.mode).should == RFuse::Stat::S_IFREG
-        stat.size.should == 0
-      end
-
-      it "should create zero length files" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_WRONLY
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.should_receive(:write_to).once.with(TEST_FILE,"")
-        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
-        @fuse.open(nil,TEST_FILE,ffi)
-        @fuse.flush(nil,TEST_FILE,ffi)
-        @fuse.release(nil,TEST_FILE,ffi)
-      end
-
-      it ":mkdir should not raise error if can_mkdir?" do
-        @mock_fuse.should_receive(:can_mkdir?).with(TEST_FILE).and_return(true)
-        @fuse.mkdir(nil,TEST_FILE,004555)
-      end
-
-    end
-
-    context "reading files" do
-      it "should read the contents of a file" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_RDONLY
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(true)
-        @mock_fuse.stub!(:read_file).with(TEST_FILE).and_return("Hello World\n")
-        @fuse.open(nil,TEST_FILE,ffi)
-        #to me fuse is backwards -- size, offset!
-        @fuse.read(nil,TEST_FILE,5,0,ffi).should == "Hello"
-        @fuse.read(nil,TEST_FILE,4,6,ffi).should == "Worl"
-        @fuse.read(nil,TEST_FILE,10,8,ffi).should == "rld\n"
-        @fuse.flush(nil,TEST_FILE,ffi)
-        @fuse.release(nil,TEST_FILE,ffi)
-      end
-    end
-
-    context "writing files" do
-      it "should overwrite a file opened WR_ONLY" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_WRONLY
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.stub!(:read_file).with(TEST_FILE).and_return("I'm writing a file\n")
-        @mock_fuse.should_receive(:write_to).once().with(TEST_FILE,"My new contents\n")
-        @fuse.open(nil,TEST_FILE,ffi)
-        @fuse.ftruncate(nil,TEST_FILE,0,ffi)
-        @fuse.write(nil,TEST_FILE,"My new c",0,ffi)
-        @fuse.write(nil,TEST_FILE,"ontents\n",8,ffi)
-        @fuse.flush(nil,TEST_FILE,ffi)
-        #that's right flush can be called more than once.
-        @fuse.flush(nil,TEST_FILE,ffi)
-        #but then we can write some more and flush again
-        @fuse.release(nil,TEST_FILE,ffi)
-      end
-
-      it "should append to a file opened WR_ONLY | APPEND" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_WRONLY | Fcntl::O_APPEND
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.stub!(:read_file).with(TEST_FILE).and_return("I'm writing a file\n")
-        @mock_fuse.should_receive(:write_to).once().with(TEST_FILE,"I'm writing a file\nMy new contents\n")
-        @fuse.open(nil,TEST_FILE,ffi)
-        @fuse.write(nil,TEST_FILE,"My new c",0,ffi)
-        @fuse.write(nil,TEST_FILE,"ontents\n",8,ffi)
-        @fuse.flush(nil,TEST_FILE,ffi)
-        #that's right flush can be called more than once. But we should only write-to the first time
-        @fuse.flush(nil,TEST_FILE,ffi)
-        @fuse.release(nil,TEST_FILE,ffi)
-
-      end
-
-      it "should do sensible things for files opened RDWR"
-
-      it "should pass on buffered data when requested (fsync)"
-
-    end
-
-    context "raw reading" do
-
-      it "should call the raw_read/raw_close if raw_open returns true" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_RDONLY
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.should_receive(:raw_open).with(TEST_FILE,"r",true).and_return("raw")
-        @mock_fuse.should_receive(:raw_read).with(TEST_FILE,5,0,"raw").and_return("12345")
-        @mock_fuse.should_receive(:raw_read).with(TEST_FILE,5,5,"raw").and_return("67890")
-        @mock_fuse.should_receive(:raw_close).with(TEST_FILE,"raw")
-        @fuse.open(nil,TEST_FILE,ffi)
-        @fuse.read(nil,TEST_FILE,0,5,ffi).should == "12345"
-        @fuse.read(nil,TEST_FILE,5,5,ffi).should == "67890"
-        @fuse.flush(nil,TEST_FILE,ffi)
-        @fuse.release(nil,TEST_FILE,ffi)
-      end
-
-    end
-
-    context "raw writing" do
-      it "should call other raw_* methods if raw_open returns true" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_WRONLY
-        raw = Object.new()
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.should_receive(:raw_open).with(TEST_FILE,"w",true).and_return(raw)
-        @mock_fuse.should_receive(:raw_truncate).with(TEST_FILE,0,raw)
-        @mock_fuse.should_receive(:raw_write).with(TEST_FILE,0,5,"12345",raw).once().and_return(5)
-        @mock_fuse.should_receive(:raw_write).with(TEST_FILE,5,5,"67890",raw).once().and_return(5)
-        @mock_fuse.should_receive(:raw_sync).with(TEST_FILE, false, raw)
-        @mock_fuse.should_receive(:raw_close).with(TEST_FILE,raw)
-        @fuse.open(nil,TEST_FILE,ffi)
-        @fuse.ftruncate(nil,TEST_FILE,0,ffi)
-        @fuse.write(nil,TEST_FILE,"12345",0,ffi).should == 5
-        @fuse.fsync(nil,TEST_FILE,0,ffi)
-        @fuse.write(nil,TEST_FILE,"67890",5,ffi).should == 5
-        @fuse.flush(nil,TEST_FILE,ffi)
-        @fuse.release(nil,TEST_FILE,ffi)
-      end
-
-      it "should clean up created files" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_WRONLY
-        raw = Object.new()
-        @mock_fuse.stub!(:directory?).and_return(false)
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false,true)
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.should_receive(:raw_open).with(TEST_FILE,"w",true).and_return(raw)
-        @mock_fuse.should_receive(:raw_close).with(TEST_FILE,raw)
-        @mock_fuse.should_receive(:size).with(TEST_FILE).and_return(25)
-
-        lambda { @fuse.getattr(nil,TEST_FILE) }.should raise_error(Errno::ENOENT)
-        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
-        @fuse.open(nil,TEST_FILE,ffi)
-        @fuse.flush(nil,TEST_FILE,ffi)
-        @fuse.release(nil,TEST_FILE,ffi)
-        stat = @fuse.getattr(nil,TEST_FILE)
-        stat.size = 25
-      end
-
-      it "should pass 'wa' to raw_open if fuse sends WRONLY | APPEND" do
-        ffi = Struct::FuseFileInfo.new()
-        ffi.flags = Fcntl::O_WRONLY | Fcntl::O_APPEND
-        raw = Object.new()
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @mock_fuse.should_receive(:raw_open).with(TEST_FILE,"wa",true).and_return(raw)
-        @fuse.open(nil,TEST_FILE,ffi)
-      end
-    end
-
-    context "deleting files" do
-      it "should raise EACCES unless :can_delete?" do
-        @mock_fuse.should_receive(:can_delete?).with(TEST_FILE).and_return(false)
-        lambda {@fuse.unlink(nil,TEST_FILE)}.should raise_error(Errno::EACCES)
-      end
-
-      it "should :delete without error if :can_delete?" do
-        @mock_fuse.stub!(:can_delete?).with(TEST_FILE).and_return(true)
-        @mock_fuse.should_receive(:delete).with(TEST_FILE)
-        @fuse.unlink(nil,TEST_FILE)
-      end
-
-      it "should remove entries created with mknod that have never been opened" do
-        @mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
-        @mock_fuse.stub!(:can_delete?).with(TEST_FILE).and_return(true)
-        @mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
-        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
-
-        @fuse.unlink(nil,TEST_FILE)
-        lambda {@fuse.getattr(nil,TEST_FILE)}.should raise_error(Errno::ENOENT)
-      end
-    end
-
-    context "deleting directories" do
-      it "should raise EACCES unless :can_rmdir?" do
-        @mock_fuse.should_receive(:can_rmdir?).with(TEST_DIR).and_return(false)
-        lambda{@fuse.rmdir(nil,TEST_DIR)}.should raise_error(Errno::EACCES)
-      end
-
-      it "should :rmdir without error if :can_rmdir?" do
-        @mock_fuse.stub!(:can_rmdir?).with(TEST_DIR).and_return(true)
-        @fuse.rmdir(nil,TEST_DIR)
-      end
-    end
-
-    context "touching files" do
-      it "should call :touch in response to utime" do
-        @mock_fuse.should_receive(:touch).with(TEST_FILE,220)
-        @fuse.utime(nil,TEST_FILE,100,220)
-      end
-    end
-
-    context "renaming files" do
-      before(:each) do
-        @oldfile = "/aPath/oldFile"
-        @newfile = "/aNewFile"
-        @mock_fuse.stub!(:file?).with(@oldfile).and_return(true)
-        @mock_fuse.stub!(:directory?).with(@oldfile).and_return(false)
-      end
-      it "should raise EACCES unless :can_write? the new file" do
-        @mock_fuse.stub!(:can_delete?).with(@oldfile).and_return(true)
-        @mock_fuse.should_receive(:can_write?).with(@newfile).and_return(false)
-        lambda {@fuse.rename(nil,@oldfile,@newfile)}.should raise_error(Errno::EACCES)
-      end
-
-      it "should raise EACCES unless :can_delete the old file" do
-        @mock_fuse.stub!(:can_write?).with(@newfile).and_return(true)
-        @mock_fuse.should_receive(:can_delete?).with(@oldfile).and_return(false)
-        lambda {@fuse.rename(nil,@oldfile,@newfile)}.should raise_error(Errno::EACCES)
-      end
-
-      it "should copy and delete files" do
-        @mock_fuse.stub!(:can_write?).with(@newfile).and_return(true)
-        @mock_fuse.stub!(:can_delete?).with(@oldfile).and_return(true)
-        @mock_fuse.should_receive(:read_file).with(@oldfile).and_return("some contents\n")
-        @mock_fuse.should_receive(:write_to).with(@newfile,"some contents\n")
-        @mock_fuse.should_receive(:delete).with(@oldfile)
-        @fuse.rename(nil,@oldfile,@newfile)
-      end
-
-      it "should not copy and delete files if fs responds_to? :rename" do
-        @mock_fuse.should_receive(:rename).with(@oldfile,@newfile).and_return(true)
-        @fuse.rename(nil,@oldfile,@newfile)
-      end
-
-      it "should raise EACCES if moving a directory and rename not supported" do
-        @mock_fuse.stub!(:file?).with(@oldfile).and_return(false)
-        @mock_fuse.stub!(:directory?).with(@oldfile).and_return(true)
-        @mock_fuse.stub!(:can_write?).with(@newfile).and_return(true)
-        @mock_fuse.stub!(:can_delete?).with(@oldfile).and_return(true)
-        lambda{@fuse.rename(nil,@oldfile,@newfile)}.should raise_error(Errno::EACCES)
-      end
-
-    end
-    context "extended attributes" do
-
-      let(:xattr) { mock(:xattr) }
-      before(:each) { @mock_fuse.stub!(:xattr).with(TEST_FILE).and_return(xattr) }
-
-      it "should list attributes via #keys on result of #xattr" do
-        xattr.should_receive(:keys).and_return(["one","two"])
-        @fuse.listxattr(nil,TEST_FILE).should == [ "one","two" ]
-      end
-
-      it "should get attributes via #xattr.[]" do
-        xattr.should_receive(:[]).with("user.one").and_return("one")
-
-        @fuse.getxattr(nil,TEST_FILE,"user.one").should == "one"
-      end
-
-      it "should set attributes via #xattr.[]=" do
-        xattr.should_receive(:[]=).with("user.two","two")
-
-        @fuse.setxattr(nil,TEST_FILE,"user.two","two",0)
-      end
-
-      it "should remove attributes via #xattr.delete" do
-        xattr.should_receive(:delete).with("user.three")
-
-        @fuse.removexattr(nil,TEST_FILE,"user.three")
-      end
-
-      it "should raise ENODATA when #xattr.[] returns nil" do
-
-        xattr.should_receive(:[]).with("user.xxxx").and_return(nil)
-        lambda{@fuse.getxattr(nil,TEST_FILE,"user.xxxx") }.should raise_error(Errno::ENODATA)
-      end
-    end
-
-    context "#statfs" do
-      # used space, used files, total_space, total_files
-      let(:stats) { [ 1000 * 1024, 5, 1200 * 1024, 12 ] }
-      it "should convert simple array into StatVfs" do
-
-        @mock_fuse.should_receive(:statistics).with(TEST_FILE).and_return(stats)
-
-        result = @fuse.statfs(nil,TEST_FILE)
-        result.should be_kind_of(RFuse::StatVfs)
-        result.f_bsize.should == 1024
-        result.f_blocks.should == 1200
-        result.f_bavail.should == 200
-        result.f_files.should == 12
-        result.f_ffree.should == 7
-      end
-
-      it "passes on raw statistics" do
-        statvfs = Object.new()
-        @mock_fuse.should_receive(:statistics).with(TEST_FILE).and_return(statvfs)
-
-        @fuse.statfs(nil,TEST_FILE).should equal(statvfs)
-      end
-
-    end
-  end
-
-  describe "a FuseFS filesystem with gid/uid specific behaviour" do
-    it "should provide context uid and gid for all API methods"
-  end
-
-end
+require 'spec_helper'
+
+describe FuseFS do
+
+  TEST_FILE = "/aPath/aFile"
+  TEST_DIR = "/aPath"
+  ROOT_PATH = "/"
+  Struct.new("FuseFileInfo",:flags,:fh)
+
+  describe "an empty Root object" do
+    before(:each) do
+      @fuse = FuseFS::Fuse::Root.new(Object.new())
+    end
+
+    it "should return an appropriate Stat for the root directory" do
+      stat = @fuse.getattr(nil,ROOT_PATH)
+      expect(stat).to respond_to(:dev)
+      expect(stat.mode & RFuse::Stat::S_IFDIR).not_to eq(0)
+      expect(stat.mode & RFuse::Stat::S_IFREG).to eq(0)
+      expect(permissions(stat.mode)).to eq(0555)
+    end
+
+    it "should have an empty root directory" do
+      filler = double("entries_filler")
+      expect(filler).to receive(:push).with(".",nil,0)
+      expect(filler).to receive(:push).with("..",nil,0)
+      @fuse.readdir(nil,"/",filler,nil,nil)
+    end
+
+    it "should raise ENOENT for other paths" do
+      expect { @fuse.getattr(nil,"/somepath") }.to raise_error(Errno::ENOENT)
+    end
+
+    it "should not allow new files or directories" do
+      expect { @fuse.mknod(nil,"/afile",0100644,0,0) }.to raise_error(Errno::EACCES)
+      expect { @fuse.mkdir(nil,"/adir",0040555) }.to raise_error(Errno::EACCES)
+    end
+  end
+
+  describe "a FuseFS filesystem" do
+    before(:each) do
+      @mock_fuse = FuseFS::FuseDir.new()
+      @fuse = FuseFS::Fuse::Root.new(@mock_fuse)
+    end
+
+    context("handling signals") do
+      it "should pass on signals" do
+        expect(@mock_fuse).to receive(:sighup) { }
+        fuse = FuseFS::Fuse::Root.new(@mock_fuse)
+        fuse.sighup
+      end
+    end
+
+    describe :readdir do
+      before(:each) do
+        expect(@mock_fuse).to receive(:contents).with("/apath").and_return(["afile"])
+      end
+
+      it "should add  . and .. to the results of :contents when listing a directory" do
+        filler = double("entries_filler")
+        expect(filler).to receive(:push).with(".",nil,0)
+        expect(filler).to receive(:push).with("..",nil,0)
+        expect(filler).to receive(:push).with("afile",nil,0)
+        @fuse.readdir(nil,"/apath",filler,nil,nil)
+      end
+
+    end
+
+    describe :getattr do
+
+      #Root directory is special (ish) so we need to run these specs twice.
+      [ROOT_PATH,TEST_DIR].each do |dir|
+
+        context "of a directory #{ dir }" do
+
+          before(:each) do
+            allow(@mock_fuse).to receive(:file?).and_return(false)
+            expect(@mock_fuse).to receive(:directory?).with(dir).at_most(:once).and_return(true)
+            @checkfile =  (dir == "/" ? "" : dir ) + FuseFS::Fuse::Root::CHECK_FILE
+          end
+
+          it "should return a Stat like object representing a directory" do
+            expect(@mock_fuse).to receive(:can_write?).with(@checkfile).at_most(:once).and_return(false)
+            expect(@mock_fuse).to receive(:can_mkdir?).with(@checkfile).at_most(:once).and_return(false)
+            stat = @fuse.getattr(nil,dir)
+            #Apparently find relies on nlink accurately listing the number of files/directories or nlink being 1
+            expect(stat.nlink).to eq(1)
+            expect(filetype(stat.mode)).to eq(RFuse::Stat::S_IFDIR)
+            expect(permissions(stat.mode)).to eq(0555)
+          end
+
+
+          it "should return writable mode if can_mkdir?" do
+            expect(@mock_fuse).to receive(:can_mkdir?).with(@checkfile).at_most(:once).and_return(true)
+
+            stat = @fuse.getattr(nil,dir)
+            expect(permissions(stat.mode)).to eq(0777)
+          end
+
+          it "should return writable mode if can_write?" do
+            expect(@mock_fuse).to receive(:can_write?).with(@checkfile).at_most(:once).and_return(true)
+
+            stat = @fuse.getattr(nil,dir)
+            expect(permissions(stat.mode)).to eq(0777)
+
+          end
+
+          it "should return times in the result if available" do
+            expect(@mock_fuse).to receive(:times).with(dir).and_return([10,20,30])
+            stat = @fuse.getattr(nil,dir)
+            expect(stat.atime).to eq(10)
+            expect(stat.mtime).to eq(20)
+            expect(stat.ctime).to eq(30)
+          end
+        end
+      end
+
+      describe "a file" do
+
+        before(:each) do
+          @file="/aPath/aFile"
+          allow(@mock_fuse).to receive(:directory?).and_return(false)
+          expect(@mock_fuse).to receive(:file?).with(@file).at_most(:once).and_return(true)
+        end
+
+
+        it "should return a Stat like object representing a file" do
+          stat = @fuse.getattr(nil,@file)
+          expect(stat.mode & RFuse::Stat::S_IFDIR).to eq(0)
+          expect(stat.mode & RFuse::Stat::S_IFREG).not_to eq(0)
+          expect(permissions(stat.mode)).to eq(0444)
+        end
+
+        it "should indicate executable mode if executable?" do
+          expect(@mock_fuse).to receive(:executable?).with(@file).and_return(true)
+          stat = @fuse.getattr(nil,@file)
+          expect(permissions(stat.mode)).to eq(0555)
+        end
+
+        it "should indicate writable mode if can_write?" do
+          expect(@mock_fuse).to receive(:can_write?).with(@file).and_return(true)
+          stat = @fuse.getattr(nil,@file)
+          expect(permissions(stat.mode)).to eq(0666)
+        end
+
+        it "should by 777 mode if can_write? and exectuable?" do
+          expect(@mock_fuse).to receive(:can_write?).with(@file).and_return(true)
+          expect(@mock_fuse).to receive(:executable?).with(@file).and_return(true)
+          stat = @fuse.getattr(nil,@file)
+          expect(permissions(stat.mode)).to eq(0777)
+        end
+
+        it "should include size in the result if available" do
+          expect(@mock_fuse).to receive(:size).with(@file).and_return(234)
+          stat = @fuse.getattr(nil,@file)
+          expect(stat.size).to eq(234)
+        end
+
+        it "should include times in the result if available" do
+          expect(@mock_fuse).to receive(:times).with(@file).and_return([22,33,44])
+          stat = @fuse.getattr(nil,@file)
+          expect(stat.atime).to eq(22)
+          expect(stat.mtime).to eq(33)
+          expect(stat.ctime).to eq(44)
+        end
+      end
+
+      it "should raise ENOENT for a path that does not exist" do
+        expect(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        expect(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        expect{stat = @fuse.getattr(nil,TEST_FILE) }.to raise_error(Errno::ENOENT)
+      end
+    end
+
+    context "creating files and directories" do
+
+      it ":mknod should raise EACCES unless :can_write?" do
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        expect(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(false)
+        expect{@fuse.mknod(nil,TEST_FILE,0100644,0,0)}.to raise_error(Errno::EACCES)
+      end
+
+      it ":mkdir should raise EACCES unless :can_mkdir?" do
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        expect(@mock_fuse).to receive(:can_mkdir?).with(TEST_FILE).and_return(false)
+        expect{@fuse.mkdir(nil,TEST_FILE,004555)}.to raise_error(Errno::EACCES)
+      end
+
+      it ":mknod should raise EACCES unless mode requests a regular file" do
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        expect{@fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFLNK | 0644,0,0)}.to raise_error(Errno::EACCES)
+      end
+
+      it ":mknod should result in getattr returning a Stat like object representing an empty file" do
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
+
+        stat = @fuse.getattr(nil,TEST_FILE)
+        expect(filetype(stat.mode)).to eq(RFuse::Stat::S_IFREG)
+        expect(stat.size).to eq(0)
+      end
+
+      it "should create zero length files" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_WRONLY
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        expect(@mock_fuse).to receive(:write_to).once.with(TEST_FILE,"")
+        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
+        @fuse.open(nil,TEST_FILE,ffi)
+        @fuse.flush(nil,TEST_FILE,ffi)
+        @fuse.release(nil,TEST_FILE,ffi)
+      end
+
+      it ":mkdir should not raise error if can_mkdir?" do
+        expect(@mock_fuse).to receive(:can_mkdir?).with(TEST_FILE).and_return(true)
+        @fuse.mkdir(nil,TEST_FILE,004555)
+      end
+
+    end
+
+    context "reading files" do
+      it "should read the contents of a file" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_RDONLY
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(true)
+        allow(@mock_fuse).to receive(:read_file).with(TEST_FILE).and_return("Hello World\n")
+        @fuse.open(nil,TEST_FILE,ffi)
+        #to me fuse is backwards -- size, offset!
+        expect(@fuse.read(nil,TEST_FILE,5,0,ffi)).to eq("Hello")
+        expect(@fuse.read(nil,TEST_FILE,4,6,ffi)).to eq("Worl")
+        expect(@fuse.read(nil,TEST_FILE,10,8,ffi)).to eq("rld\n")
+        @fuse.flush(nil,TEST_FILE,ffi)
+        @fuse.release(nil,TEST_FILE,ffi)
+      end
+    end
+
+    context "writing files" do
+      it "should overwrite a file opened WR_ONLY" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_WRONLY
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        allow(@mock_fuse).to receive(:read_file).with(TEST_FILE).and_return("I'm writing a file\n")
+        expect(@mock_fuse).to receive(:write_to).once().with(TEST_FILE,"My new contents\n")
+        @fuse.open(nil,TEST_FILE,ffi)
+        @fuse.ftruncate(nil,TEST_FILE,0,ffi)
+        @fuse.write(nil,TEST_FILE,"My new c",0,ffi)
+        @fuse.write(nil,TEST_FILE,"ontents\n",8,ffi)
+        @fuse.flush(nil,TEST_FILE,ffi)
+        #that's right flush can be called more than once.
+        @fuse.flush(nil,TEST_FILE,ffi)
+        #but then we can write some more and flush again
+        @fuse.release(nil,TEST_FILE,ffi)
+      end
+
+      it "should append to a file opened WR_ONLY | APPEND" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_WRONLY | Fcntl::O_APPEND
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        allow(@mock_fuse).to receive(:read_file).with(TEST_FILE).and_return("I'm writing a file\n")
+        expect(@mock_fuse).to receive(:write_to).once().with(TEST_FILE,"I'm writing a file\nMy new contents\n")
+        @fuse.open(nil,TEST_FILE,ffi)
+        @fuse.write(nil,TEST_FILE,"My new c",0,ffi)
+        @fuse.write(nil,TEST_FILE,"ontents\n",8,ffi)
+        @fuse.flush(nil,TEST_FILE,ffi)
+        #that's right flush can be called more than once. But we should only write-to the first time
+        @fuse.flush(nil,TEST_FILE,ffi)
+        @fuse.release(nil,TEST_FILE,ffi)
+
+      end
+
+      it "should do sensible things for files opened RDWR"
+
+      it "should pass on buffered data when requested (fsync)"
+
+    end
+
+    context "raw reading" do
+
+      it "should call the raw_read/raw_close if raw_open returns true" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_RDONLY
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        expect(@mock_fuse).to receive(:raw_open).with(TEST_FILE,"r",true).and_return("raw")
+        expect(@mock_fuse).to receive(:raw_read).with(TEST_FILE,5,0,"raw").and_return("12345")
+        expect(@mock_fuse).to receive(:raw_read).with(TEST_FILE,5,5,"raw").and_return("67890")
+        expect(@mock_fuse).to receive(:raw_close).with(TEST_FILE,"raw")
+        @fuse.open(nil,TEST_FILE,ffi)
+        expect(@fuse.read(nil,TEST_FILE,0,5,ffi)).to eq("12345")
+        expect(@fuse.read(nil,TEST_FILE,5,5,ffi)).to eq("67890")
+        @fuse.flush(nil,TEST_FILE,ffi)
+        @fuse.release(nil,TEST_FILE,ffi)
+      end
+
+    end
+
+    context "raw writing" do
+      it "should call other raw_* methods if raw_open returns true" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_WRONLY
+        raw = Object.new()
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        expect(@mock_fuse).to receive(:raw_open).with(TEST_FILE,"w",true).and_return(raw)
+        expect(@mock_fuse).to receive(:raw_truncate).with(TEST_FILE,0,raw)
+        expect(@mock_fuse).to receive(:raw_write).with(TEST_FILE,0,5,"12345",raw).once().and_return(5)
+        expect(@mock_fuse).to receive(:raw_write).with(TEST_FILE,5,5,"67890",raw).once().and_return(5)
+        expect(@mock_fuse).to receive(:raw_sync).with(TEST_FILE, false, raw)
+        expect(@mock_fuse).to receive(:raw_close).with(TEST_FILE,raw)
+        @fuse.open(nil,TEST_FILE,ffi)
+        @fuse.ftruncate(nil,TEST_FILE,0,ffi)
+        expect(@fuse.write(nil,TEST_FILE,"12345",0,ffi)).to eq(5)
+        @fuse.fsync(nil,TEST_FILE,0,ffi)
+        expect(@fuse.write(nil,TEST_FILE,"67890",5,ffi)).to eq(5)
+        @fuse.flush(nil,TEST_FILE,ffi)
+        @fuse.release(nil,TEST_FILE,ffi)
+      end
+
+      it "should clean up created files" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_WRONLY
+        raw = Object.new()
+        allow(@mock_fuse).to receive(:directory?).and_return(false)
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false,true)
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        expect(@mock_fuse).to receive(:raw_open).with(TEST_FILE,"w",true).and_return(raw)
+        expect(@mock_fuse).to receive(:raw_close).with(TEST_FILE,raw)
+        expect(@mock_fuse).to receive(:size).with(TEST_FILE).and_return(25)
+
+        expect { @fuse.getattr(nil,TEST_FILE) }.to raise_error(Errno::ENOENT)
+        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
+        @fuse.open(nil,TEST_FILE,ffi)
+        @fuse.flush(nil,TEST_FILE,ffi)
+        @fuse.release(nil,TEST_FILE,ffi)
+        stat = @fuse.getattr(nil,TEST_FILE)
+        stat.size = 25
+      end
+
+      it "should pass 'wa' to raw_open if fuse sends WRONLY | APPEND" do
+        ffi = Struct::FuseFileInfo.new()
+        ffi.flags = Fcntl::O_WRONLY | Fcntl::O_APPEND
+        raw = Object.new()
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        expect(@mock_fuse).to receive(:raw_open).with(TEST_FILE,"wa",true).and_return(raw)
+        @fuse.open(nil,TEST_FILE,ffi)
+      end
+    end
+
+    context "deleting files" do
+      it "should raise EACCES unless :can_delete?" do
+        expect(@mock_fuse).to receive(:can_delete?).with(TEST_FILE).and_return(false)
+        expect {@fuse.unlink(nil,TEST_FILE)}.to raise_error(Errno::EACCES)
+      end
+
+      it "should :delete without error if :can_delete?" do
+        allow(@mock_fuse).to receive(:can_delete?).with(TEST_FILE).and_return(true)
+        expect(@mock_fuse).to receive(:delete).with(TEST_FILE)
+        @fuse.unlink(nil,TEST_FILE)
+      end
+
+      it "should remove entries created with mknod that have never been opened" do
+        allow(@mock_fuse).to receive(:file?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(TEST_FILE).and_return(false)
+        allow(@mock_fuse).to receive(:can_delete?).with(TEST_FILE).and_return(true)
+        allow(@mock_fuse).to receive(:can_write?).with(TEST_FILE).and_return(true)
+        @fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
+
+        @fuse.unlink(nil,TEST_FILE)
+        expect {@fuse.getattr(nil,TEST_FILE)}.to raise_error(Errno::ENOENT)
+      end
+    end
+
+    context "deleting directories" do
+      it "should raise EACCES unless :can_rmdir?" do
+        expect(@mock_fuse).to receive(:can_rmdir?).with(TEST_DIR).and_return(false)
+        expect{@fuse.rmdir(nil,TEST_DIR)}.to raise_error(Errno::EACCES)
+      end
+
+      it "should :rmdir without error if :can_rmdir?" do
+        allow(@mock_fuse).to receive(:can_rmdir?).with(TEST_DIR).and_return(true)
+        @fuse.rmdir(nil,TEST_DIR)
+      end
+    end
+
+    context "touching files" do
+      it "should call :touch in response to utime" do
+        expect(@mock_fuse).to receive(:touch).with(TEST_FILE,220)
+        @fuse.utime(nil,TEST_FILE,100,220)
+      end
+    end
+
+    context "renaming files" do
+      before(:each) do
+        @oldfile = "/aPath/oldFile"
+        @newfile = "/aNewFile"
+        allow(@mock_fuse).to receive(:file?).with(@oldfile).and_return(true)
+        allow(@mock_fuse).to receive(:directory?).with(@oldfile).and_return(false)
+      end
+      it "should raise EACCES unless :can_write? the new file" do
+        allow(@mock_fuse).to receive(:can_delete?).with(@oldfile).and_return(true)
+        expect(@mock_fuse).to receive(:can_write?).with(@newfile).and_return(false)
+        expect {@fuse.rename(nil,@oldfile,@newfile)}.to raise_error(Errno::EACCES)
+      end
+
+      it "should raise EACCES unless :can_delete the old file" do
+        allow(@mock_fuse).to receive(:can_write?).with(@newfile).and_return(true)
+        expect(@mock_fuse).to receive(:can_delete?).with(@oldfile).and_return(false)
+        expect {@fuse.rename(nil,@oldfile,@newfile)}.to raise_error(Errno::EACCES)
+      end
+
+      it "should copy and delete files" do
+        allow(@mock_fuse).to receive(:can_write?).with(@newfile).and_return(true)
+        allow(@mock_fuse).to receive(:can_delete?).with(@oldfile).and_return(true)
+        expect(@mock_fuse).to receive(:read_file).with(@oldfile).and_return("some contents\n")
+        expect(@mock_fuse).to receive(:write_to).with(@newfile,"some contents\n")
+        expect(@mock_fuse).to receive(:delete).with(@oldfile)
+        @fuse.rename(nil,@oldfile,@newfile)
+      end
+
+      it "should not copy and delete files if fs responds_to? :rename" do
+        expect(@mock_fuse).to receive(:rename).with(@oldfile,@newfile).and_return(true)
+        @fuse.rename(nil,@oldfile,@newfile)
+      end
+
+      it "should raise EACCES if moving a directory and rename not supported" do
+        allow(@mock_fuse).to receive(:file?).with(@oldfile).and_return(false)
+        allow(@mock_fuse).to receive(:directory?).with(@oldfile).and_return(true)
+        allow(@mock_fuse).to receive(:can_write?).with(@newfile).and_return(true)
+        allow(@mock_fuse).to receive(:can_delete?).with(@oldfile).and_return(true)
+        expect{@fuse.rename(nil,@oldfile,@newfile)}.to raise_error(Errno::EACCES)
+      end
+
+    end
+    context "extended attributes" do
+
+      let(:xattr) { double(:xattr) }
+      before(:each) { allow(@mock_fuse).to receive(:xattr).with(TEST_FILE).and_return(xattr) }
+
+      it "should list attributes via #keys on result of #xattr" do
+        expect(xattr).to receive(:keys).and_return(["one","two"])
+        expect(@fuse.listxattr(nil,TEST_FILE)).to eq([ "one","two" ])
+      end
+
+      it "should get attributes via #xattr.[]" do
+        expect(xattr).to receive(:[]).with("user.one").and_return("one")
+
+        expect(@fuse.getxattr(nil,TEST_FILE,"user.one")).to eq("one")
+      end
+
+      it "should set attributes via #xattr.[]=" do
+        expect(xattr).to receive(:[]=).with("user.two","two")
+
+        @fuse.setxattr(nil,TEST_FILE,"user.two","two",0)
+      end
+
+      it "should remove attributes via #xattr.delete" do
+        expect(xattr).to receive(:delete).with("user.three")
+
+        @fuse.removexattr(nil,TEST_FILE,"user.three")
+      end
+
+      it "should raise ENODATA when #xattr.[] returns nil" do
+
+        expect(xattr).to receive(:[]).with("user.xxxx").and_return(nil)
+        expect{@fuse.getxattr(nil,TEST_FILE,"user.xxxx") }.to raise_error(Errno::ENODATA)
+      end
+    end
+
+    context "#statfs" do
+      # used space, used files, total_space, total_files
+      let(:stats) { [ 1000 * 1024, 5, 1200 * 1024, 12 ] }
+      it "should convert simple array into StatVfs" do
+
+        expect(@mock_fuse).to receive(:statistics).with(TEST_FILE).and_return(stats)
+
+        result = @fuse.statfs(nil,TEST_FILE)
+        expect(result).to be_kind_of(RFuse::StatVfs)
+        expect(result.f_bsize).to eq(1024)
+        expect(result.f_blocks).to eq(1200)
+        expect(result.f_bavail).to eq(200)
+        expect(result.f_files).to eq(12)
+        expect(result.f_ffree).to eq(7)
+      end
+
+      it "passes on raw statistics" do
+        statvfs = Object.new()
+        expect(@mock_fuse).to receive(:statistics).with(TEST_FILE).and_return(statvfs)
+
+        expect(@fuse.statfs(nil,TEST_FILE)).to equal(statvfs)
+      end
+
+    end
+  end
+
+  describe "a FuseFS filesystem with gid/uid specific behaviour" do
+    it "should provide context uid and gid for all API methods"
+  end
+
+end