rfusefs 1.0.2.RC2 → 1.1.1.rc20201114.37

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()
-        mock_fs.should_receive(:mounted)
-        mock_fs.should_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
-            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
-        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" ]
-        end
-
-        it "reports the size of a file" do
-            pathmap_fs.size("/textfiles/hello").should == 16
-        end
-
-        it "reads the contents of a file" do
-            pathmap_fs.read_file("/textfiles/hello").should == "/textfiles/hello"
-        end
-
-        it "does not allow writes" do
-            pathmap_fs.can_write?("/textfiles/hello").should be_false
-        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()
-        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
-                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
-            end
-
-            it "should read extended attributes from underlying file" do
-                pm_file_xattr["user.file_attr"].should == "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")
-
-                pm_file_xattr["user.add_attr"].should == "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"
-            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")
-            end
-
-            it "raise EACCES when writing to additional attributes" do
-                lambda {pm_file_xattr["user.add_attr"] = "newValue"}.should 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)
-            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
-            end
-
-            it "should read additional attributes from virtual directories" do
-                pm_dir_xattr["user.dir_attr"].should == "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)
-            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)
-            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"
-            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")
-                used_space.should == 69
-                used_nodes.should == 9
-                max_space.should be_nil
-                max_nodes.should 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"
-                hello_path.read.should == "updated content"
-            end
-
-            it "updates the contents of the mapped file" do
-                pathmap_fs.read_file("textfiles/hello").should == "updated content"
-            end
-
-            it "changes the reported file size" do
-                pathmap_fs.size("textfiles/hello").should == 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
-            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
-            (mountpoint + "textfiles").directory?.should be_true
-            (mountpoint + "textfiles/hello").file?.should be_true
-        end
-
-        it "lists the mapped contents of directories" do
-            (mountpoint + "textfiles").entries.should =~ 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
-            mappedstat.size.should == realstat.size
-            mappedstat.atime.should == realstat.atime
-            mappedstat.mtime.should == realstat.mtime
-            mappedstat.ctime.should == realstat.ctime
-        end
-
-        it "reads the files" do
-            hellopath= mountpoint + "textfiles/hello"
-            hellopath.read.should == "/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
-            hellopath.read.should == "updated content"
-            real_path.read.should == "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
-                file_xattr.list.should include("user.file_attr")
-                file_xattr.list.should include("user.add_attr")
-                file_xattr.list.size.should == 2
-            end
-
-            it "should read extended attributes from underlying file" do
-                file_xattr["user.file_attr"].should == "fileValue"
-            end
-
-            it "should read additional attributes" do
-                file_xattr["user.add_attr"].should == "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"
-            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")
-            end
-
-            it "raise EACCES when writing to additional attributes" do
-                lambda {file_xattr["user.add_attr"] = "newValue"}.should 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)
-            end
-
-            it "should list additional attributes from virtual directories" do
-                dir_xattr.list.should include("user.dir_attr")
-                dir_xattr.list.size.should == 1
-            end
-
-            it "should read additional attributes from virtual directories" do
-                dir_xattr["user.dir_attr"].should == "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)
-            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)
-            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
-                statfs.block_size.should == 1024
-                statfs.fragment_size.should == 1024
-
-                # These are dependant on the tests above creating files/directories
-                statfs.files.should == 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
-            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
-
-            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)
-                f.read(3).should == "ext"
-            end
-
-            hello_path.sysopen do |f|
-                f.sysseek(1)
-                f.sysread(3).should == "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)
-                f.sysread(6).should == "/tzzzf"
-            end
-
-            real_path.read.should == "/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)
-            statfs.blocks.should == 2
-        end
-    end
-end

data/spec/rfusefs_spec.rb

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