rfusefs 1.0.3 → 1.1.0.rc202009.34

data/spec/mount_unmount_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'rfusefs'
-require 'tmpdir'
-require 'pathname'
-
-describe "a mounted FuseFS" do
-    let(:mountpoint) { Pathname.new(Dir.mktmpdir("rfusefs_mount_unmount")) }
-
-    after(:each) { FileUtils.rmdir mountpoint }
-
-    it "should get mounted and unmounted callbacks" do
-        mock_fs = FuseFS::FuseDir.new()
-        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)
-        t.join
-    end
-end
-

data/spec/pathmapper_spec.rb

@@ -1,417 +0,0 @@
-#Pathmapper is hard to test because it is difficult to mock Dir/Pathname/File etc...
-require "spec_helper"
-require "fusefs/pathmapper"
-require 'tmpdir'
-require 'pathname'
-require 'sys/filesystem'
-require 'ffi-xattr/extensions'
-
-class PMFixture
-    attr_reader :tmpdir
-
-    def initialize()
-        #Note - these names define the filesystem stats so if you change them those tests will break
-    end
-
-    def tmpdir
-        @tmpdir ||= Pathname.new(Dir.mktmpdir("rfusefs_pathmapper"))
-    end
-
-    def real_path(file)
-        tmpdir + file
-    end
-
-    def pathmap(file,mapped_path, content = mapped_path, options = {})
-        real_file = tmpdir + file
-        real_file.open("w") do |f|
-            f << content
-        end
-        fs.map_file(real_file,mapped_path,options)
-    end
-
-    def fs
-        @fs ||= FuseFS::PathMapperFS.new()
-    end
-
-    def mount()
-        return @mountpoint if @mountpoint
-        @mountpoint = Pathname.new(Dir.mktmpdir("rfusefs_pathmapper_mnt"))
-        FuseFS.mount(fs,@mountpoint)
-        sleep(0.5)
-        @mountpoint
-    end
-
-    def cleanup
-        if @mountpoint
-            FuseFS.unmount(@mountpoint)
-            sleep(0.5)
-            FileUtils.rmdir(@mountpoint)
-        end
-        FileUtils.rm_r(@tmpdir)
-    end
-end
-
-
-describe FuseFS::PathMapperFS do
-
-    let(:fixture) { PMFixture.new() }
-    let(:pathmap_fs) { fixture.fs }
-    let(:tmpdir) { fixture.tmpdir }
-    let(:mountpoint) { fixture.mount }
-
-    before(:each) do
-        fixture.pathmap("hello.txt","/textfiles/hello")
-        fixture.pathmap("mysong.mp3","/artist/album/mysong.mp3")
-        fixture.pathmap("apicture.jpeg","/pictures/201103/apicture.jpg")
-    end
-
-    after(:each) do
-        fixture.cleanup
-    end
-
-    context "fusefs api" do
-
-        it "maps files and directories" do
-            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
-            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
-            expect(pathmap_fs.size("/textfiles/hello")).to eq(16)
-        end
-
-        it "reads the contents of a file" do
-            expect(pathmap_fs.read_file("/textfiles/hello")).to eq("/textfiles/hello")
-        end
-
-        it "does not allow writes" do
-            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"
-            expect(atime).to eq(picture.atime())
-            expect(mtime).to eq(picture.mtime())
-            expect(ctime).to eq(picture.ctime())
-        end
-
-        context "with extended attributes" do
-            let (:hello_realpath) {fixture.real_path("hello.txt")}
-            let (:hello_xattr) { Xattr.new(hello_realpath) }
-            let (:pm_file_xattr) { pathmap_fs.xattr("/textfiles/hello") }
-            let (:pm_dir_xattr) { pathmap_fs.xattr("/textfiles") }
-
-            before(:each) do
-                # attribute set on real file
-                hello_xattr["user.file_attr"] = "fileValue"
-
-                # additional attribute on file
-                pathmap_fs.node("/textfiles/hello")[:xattr] =
-                    { "user.add_attr" => "addValue" }
-
-                # additional attribute on directory
-                pathmap_fs.node("/textfiles")[:xattr] =
-                    { "user.dir_attr" => "dirValue" }
-
-            end
-
-            it "should list extended attributes" do
-                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
-                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
-                expect(hello_xattr.list).not_to include("user.add_attr")
-
-                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"
-                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")
-                expect(hello_xattr.list).not_to include("user.file_attr")
-            end
-
-            it "raise EACCES when writing to additional attributes" do
-                expect {pm_file_xattr["user.add_attr"] = "newValue"}.to raise_error(Errno::EACCES)
-            end
-
-            it "raise EACCES when removing additional attributes" do
-                expect {pm_file_xattr.delete("user.add_attr")}.to raise_error(Errno::EACCES)
-            end
-
-            it "should list additional attributes from virtual directories" do
-                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
-                expect(pm_dir_xattr["user.dir_attr"]).to eq("dirValue")
-
-            end
-
-            it "should raise EACCES when writing additional attributes on virtual directories" do
-                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
-                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" })
-                expect(pathmap_fs.xattr("/textfiles/mapped_xattr")["user.xattr"]).to eq("map_file")
-            end
-        end
-
-        context "filesystem statistics" do
-
-            it "reports accumulated stats about mapped files" do
-                used_space, used_nodes, max_space, max_nodes = pathmap_fs.statistics("/pictures/201103/apicture.jpg")
-                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
-
-        context "writing to a pathmapped FS" do
-            before(:each) do
-                pathmap_fs.allow_write=true
-                pathmap_fs.write_to("textfiles/hello","updated content")
-            end
-
-            it "updates the contents of the real file" do
-                hello_path = tmpdir + "hello.txt"
-                expect(hello_path.read).to eq("updated content")
-            end
-
-            it "updates the contents of the mapped file" do
-                expect(pathmap_fs.read_file("textfiles/hello")).to eq("updated content")
-            end
-
-            it "changes the reported file size" do
-                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")
-                expect(used_space).to eq(68)
-            end
-        end
-
-    end
-
-    context "a real Fuse mounted filesystem" do
-        before(:each) do
-            pathmap_fs.allow_write=true
-        end
-
-        it "maps files and directories" do
-            expect((mountpoint + "textfiles").directory?).to be_truthy
-            expect((mountpoint + "textfiles/hello").file?).to be_truthy
-        end
-
-        it "lists the mapped contents of directories" do
-            expect((mountpoint + "textfiles").entries).to match_array(pathnames(".","..","hello"))
-        end
-
-        it "represents the stat information of the underlying files" do
-            hellopath=(mountpoint + "textfiles/hello")
-            realpath=(tmpdir + "hello.txt")
-            mappedstat = hellopath.stat
-            realstat = realpath.stat
-            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"
-            expect(hellopath.read).to eq("/textfiles/hello")
-        end
-
-        it "writes the files" do
-            hellopath= mountpoint + "textfiles/hello"
-            real_path = tmpdir + "hello.txt"
-            hellopath.open("w") do |f|
-                f.print "updated content"
-            end
-            expect(hellopath.read).to eq("updated content")
-            expect(real_path.read).to eq("updated content")
-        end
-
-        context "extended attributes" do
-            let (:hello_realpath) {fixture.real_path("hello.txt")}
-            let (:hello_xattr) { hello_realpath.xattr }
-            let (:file_xattr) { (mountpoint + "textfiles/hello").xattr }
-            let (:dir_xattr) { (mountpoint + "textfiles").xattr }
-
-            before(:each) do
-                # attribute set on real file
-                hello_xattr["user.file_attr"] = "fileValue"
-
-                # additional attribute on file
-                pathmap_fs.node("/textfiles/hello")[:xattr] =
-                    { "user.add_attr" => "addValue" }
-
-                # additional attribute on directory
-                pathmap_fs.node("/textfiles")[:xattr] =
-                    { "user.dir_attr" => "dirValue" }
-
-            end
-
-            it "should list extended attributes" do
-                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
-                expect(file_xattr["user.file_attr"]).to eq("fileValue")
-            end
-
-            it "should read additional attributes" do
-                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"
-                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")
-                expect(hello_xattr.list).not_to include("user.file_attr")
-            end
-
-            it "raise EACCES when writing to additional attributes" do
-                expect {file_xattr["user.add_attr"] = "newValue"}.to raise_error(Errno::EACCES)
-            end
-
-            it "raise EACCES when removing additional attributes" do
-                expect {file_xattr.remove("user.add_attr")}.to raise_error(Errno::EACCES)
-            end
-
-            it "should list additional attributes from virtual directories" do
-                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
-                expect(dir_xattr["user.dir_attr"]).to eq("dirValue")
-            end
-
-            it "should raise EACCES when writing additional attributes on virtual directories" do
-                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
-                expect {dir_xattr.remove("user.dir_attr")}.to raise_error(Errno::EACCES)
-            end
-
-        end
-
-        context "filesystem statistics" do
-            before(:each) do
-                fixture.pathmap("bigfile.txt","/textfiles/bigfile","x" * 2048)
-            end
-
-            it "reports stats for files" do
-                statfs = Sys::Filesystem.stat(mountpoint.to_path)
-                # These are fixed
-                expect(statfs.block_size).to eq(1024)
-                expect(statfs.fragment_size).to eq(1024)
-
-                # These are dependant on the tests above creating files/directories
-                expect(statfs.files).to eq(10)
-                statfs.files_available == 10
-
-                # assume test are less than 1 block, so dependant on bigfile above
-                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)
-                expect(statfs.files).to eq(10)
-                expect(statfs.blocks).to eq(4)
-
-            end
-
-        end
-    end
-
-    context "a real Fuse mount with raw file access" do
-
-        before(:each) do
-            pathmap_fs.use_raw_file_access = true
-            pathmap_fs.allow_write = true
-        end
-
-        it "reads files" do
-            hello_path = (mountpoint + "textfiles/hello")
-            hello_path.open do |f|
-                f.seek(2)
-                expect(f.read(3)).to eq("ext")
-            end
-
-            hello_path.sysopen do |f|
-                f.sysseek(1)
-                expect(f.sysread(3)).to eq("tex")
-            end
-        end
-
-        it "writes files" do
-            hello_path = (mountpoint + "textfiles/hello")
-            real_path = tmpdir + "hello.txt"
-            hello_path.open("r+") do |f|
-                f.sysseek(2)
-                f.syswrite("zzz")
-                f.sysseek(0)
-                expect(f.sysread(6)).to eq("/tzzzf")
-            end
-
-            expect(real_path.read).to eq("/tzzzfiles/hello")
-        end
-
-        it "reports filesystem statistics after raw write" do
-            hello_path = (mountpoint + "textfiles/hello")
-            hello_path.open("w") do |f|
-                f.syswrite("z" * 2048)
-            end
-
-            statfs = Sys::Filesystem.stat(mountpoint.to_path)
-            expect(statfs.blocks).to eq(2)
-        end
-    end
-end

data/spec/rfusefs_spec.rb

@@ -1,505 +0,0 @@
-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