rfusefs 1.0.2.RC0 → 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()
-        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,202 +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'
-
-class PMFixture
-    attr_reader :tmpdir
-
-    def initialize()
-        @tmpdir = Pathname.new(Dir.mktmpdir("rfusefs_pathmapper"))
-        pathmap(@tmpdir + "hello.txt","/textfiles/hello")
-        pathmap(@tmpdir + "mysong.mp3","/artist/album/mysong.mp3")
-        pathmap(@tmpdir + "apicture.jpeg","/pictures/201103/apicture.jpg")
-    end
-
-    def pathmap(real_file,mapped_path)
-        File.open(real_file.to_s,"w") do |f|
-            f << mapped_path
-        end
-    end
-
-    def fs
-        @fs ||= FuseFS::PathMapperFS.create(@tmpdir) do |file|
-            File.file?(file) ? IO.read(file.to_s) : nil
-        end
-    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
-    before(:each) do 
-        @fixture = PMFixture.new
-        @tmpdir = @fixture.tmpdir
-        @pathmapFS = @fixture.fs
-    end
-
-    after(:each) do
-        @fixture.cleanup
-    end
-
-    context "fusefs api" do
-
-        it "maps files and directories" do
-            @pathmapFS.directory?("/").should be_true
-            @pathmapFS.directory?("/textfiles").should be_true
-            @pathmapFS.directory?("/pictures/201103").should be_true
-            @pathmapFS.file?("/textfiles/hello").should be_true
-            @pathmapFS.directory?("/textfiles/hello").should be_false
-            @pathmapFS.file?("/artist/album/mysong.mp3").should be_true
-            @pathmapFS.directory?("/artist/album/mysong.mp3").should be_false
-            @pathmapFS.file?("/some/unknown/path").should be_false
-            @pathmapFS.directory?("/some/unknown/path").should be_false
-        end
-
-        it "lists the mapped contents of directories" do
-            @pathmapFS.contents("/").should =~ [ "textfiles","artist","pictures" ]
-            @pathmapFS.contents("/artist").should =~ [ "album" ]
-            @pathmapFS.contents("/textfiles").should =~ [ "hello" ]
-        end
-
-        it "reports the size of a file" do
-            @pathmapFS.size("/textfiles/hello").should == 16
-        end
-
-        it "reads the contents of a file" do
-            @pathmapFS.read_file("/textfiles/hello").should == "/textfiles/hello"
-        end
-
-        it "does not allow writes" do
-            @pathmapFS.can_write?("/textfiles/hello").should be_false
-        end
-
-        it "reports the atime,mtime and ctime of the mapped file" do
-            atime,mtime,ctime = @pathmapFS.times("/pictures/201103/apicture.jpg")
-            picture = @tmpdir + "apicture.jpeg"
-            atime.should == picture.atime()
-            mtime.should == picture.mtime()
-            ctime.should == picture.ctime()
-        end
-
-        it "reports filesystem statistics"
-
-        context "writing to a pathmapped FS" do
-            before(:each) do
-                @pathmapFS.allow_write=true
-                @pathmapFS.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
-                @pathmapFS.read_file("textfiles/hello").should == "updated content"
-            end
-
-            it "changes the reported file size" do
-                @pathmapFS.size("textfiles/hello").should == 15
-            end
-
-            it "changes the filesystem statistics"
-        end
-
-    end
-
-    context "a real Fuse mounted filesystem" do
-        before(:each) do
-            @pathmapFS.allow_write=true
-            @mountpoint = @fixture.mount
-        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
-    end
-
-    context "a real Fuse mount with raw file access" do
-
-        before(:each) do
-            @pathmapFS.use_raw_file_access = true
-            @pathmapFS.allow_write = true
-            @mountpoint = @fixture.mount
-        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
-
-    end
-end

data/spec/rfusefs_spec.rb

@@ -1,421 +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 ":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"
-    	
-    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 raw_truncate,raw_write,raw_close 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_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.write(nil,TEST_FILE,"67890",5,ffi).should == 5
-			@fuse.flush(nil,TEST_FILE,ffi)
-			@fuse.release(nil,TEST_FILE,ffi)
-		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) { {} }
-        before(:each) { @mock_fuse.stub!(:xattr).with(TEST_FILE).and_return(xattr) }
-
-        it "should get, set and list attributes" do
-           xattr["user.one"] = "xattr one"
-           
-           @fuse.getxattr(nil,TEST_FILE,"user.one").should == "xattr one"
-           @fuse.setxattr(nil,TEST_FILE,"user.two","xattr two")
-           xattr["user.two"].should == "xattr two"
-           @fuse.listxattr(nil,TEST_FILE).should =~ [ "user.one", "user.two" ]
-           @fuse.removexattr(nil,TEST_FILE,"user.two")
-           xattr.keys.should =~ [ "user.one" ]
-        end
-
-        it "should raise ENODATA is no attribute is available" do
-            lambda{@fuse.getxattr(nil,TEST_FILE,"user.xxxx") }.should raise_error(Errno::ENODATA)
-        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
-
-