rfuse 1.1.2 → 1.2.0.rc202009.69

data/spec/basic_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-require 'pathname'
-require 'tempfile'
-require 'sys/filesystem'
-
-describe RFuse::Fuse do
-
-    let(:dir_stat) { RFuse::Stat.directory(0444) }
-    let(:file_stat) { RFuse::Stat.file(0444) }
-    let!(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil); m }
-    let(:mountpoint) { tempmount() }
-
-    context "links" do
-        it "should create and resolve symbolic links"
-        it "should create and resolve hard links"
-
-    end
-
-    context "directories" do
-        it "should make directories" do
-
-            mockfs.stub(:getattr).and_return(nil)
-            mockfs.stub(:getattr).with(anything(),"/aDirectory").and_return(nil,dir_stat)
-            mockfs.should_receive(:mkdir).with(anything(),"/aDirectory",anything())
-
-            with_fuse(mountpoint,mockfs) do
-                Dir.mkdir("#{mountpoint}/aDirectory")
-            end
-        end
-
-        it "should list directories" do
-
-            mockfs.should_receive(:readdir) do | ctx, path, filler,offset,ffi |
-                filler.push("hello",nil,0)
-                filler.push("world",nil,0)
-            end
-
-            with_fuse(mountpoint,mockfs) do
-                entries = Dir.entries(mountpoint)
-                entries.size.should == 2
-                entries.should include("hello")
-                entries.should include("world")
-            end
-        end
-    end
-
-    context "permissions" do
-        it "should process chmod" do
-            mockfs.stub(:getattr).with(anything(),"/myPerms").and_return(file_stat)
-
-            mockfs.should_receive(:chmod).with(anything(),"/myPerms",file_mode(0644))
-
-            with_fuse(mountpoint,mockfs) do
-                File.chmod(0644,"#{mountpoint}/myPerms").should == 1
-            end
-        end
-    end
-
-    context "timestamps" do
-
-
-        it "should support stat with subsecond resolution" do
-            testns = Tempfile.new("testns")
-            stat = File.stat(testns.path)
-
-            # so if this Ruby has usec resolution for File.stat
-            # we'd expect to skip this test 1 in 100,000 times...
-            no_usecs = (stat.mtime.usec == 0)
-
-            if no_usecs
-                puts "Skipping due to no usec resolution for File.stat"
-            else
-                atime,mtime,ctime =  usec_times(60,600,3600)
-
-                file_stat.atime = atime
-                file_stat.mtime = mtime
-                file_stat.ctime = ctime
-
-                # ruby can't set file times with ns res, o we are limited to usecs
-                mockfs.stub(:getattr).with(anything(),"/nanos").and_return(file_stat)
-
-                with_fuse(mountpoint,mockfs) do
-                    stat = File.stat("#{mountpoint}/nanos")
-                    stat.atime.usec.should == atime.usec
-                    stat.atime.should == atime
-                    stat.ctime.should == ctime
-                    stat.mtime.should == mtime
-                end
-            end
-        end
-
-        it "should set file access and modification times subsecond resolution" do
-            atime,mtime = usec_times(60,600)
-
-            atime_ns = (atime.to_i * (10**9)) + (atime.nsec)
-            mtime_ns = (mtime.to_i * (10**9)) + (mtime.nsec)
-
-            mockfs.stub(:getattr).with(anything(),"/usec").and_return(file_stat)
-            mockfs.should_receive(:utimens).with(anything,"/usec",atime_ns,mtime_ns)
-
-            with_fuse(mountpoint,mockfs) do
-                File.utime(atime,mtime,"#{mountpoint}/usec").should == 1
-            end
-        end
-        it "should set file access and modification times" do
-
-            atime = Time.now()
-            mtime = atime + 1
-
-            mockfs.stub(:getattr).with(anything(),"/times").and_return(file_stat)
-            mockfs.should_receive(:utime).with(anything(),"/times",atime.to_i,mtime.to_i)
-
-            with_fuse(mountpoint,mockfs) do
-                File.utime(atime,mtime,"#{mountpoint}/times").should == 1
-            end
-        end
-
-    end
-
-    context "file io" do
-
-        it "should create files" do
-
-            mockfs.stub(:getattr).with(anything(),"/newfile").and_return(nil,file_stat)
-            mockfs.should_receive(:mknod).with(anything(),"/newfile",file_mode(0644),0,0)
-
-            with_fuse(mountpoint,mockfs) do
-                File.open("#{mountpoint}/newfile","w",0644) { |f| }
-            end
-        end
-
-        # ruby doesn't seem to have a native method to create these
-        # maybe try ruby-mkfifo
-        it "should create special device files"
-
-        it "should read files" do
-
-            file_stat.size = 12
-            mockfs.stub(:getattr).with(anything(),"/test").and_return(file_stat)
-
-
-            reads = 0
-            mockfs.stub(:read) { |ctx,path,size,offset,ffi|
-                reads += 2
-                "hello\000world\000"[offset,reads]
-            }
-
-            with_fuse(mountpoint,mockfs) do
-                File.open("#{mountpoint}/test") do |f|
-                    val = f.gets
-                    val.should == "hello\000world\000"
-                end
-            end
-        end
-
-        it "should read over null characters in a real file" do
-            file_stat.size = 2
-            File.open("/tmp/nulltest","w") { |f| f.print "\000\000" }
-
-            mockfs.stub(:getattr).with(anything(),"/testnull").and_return(file_stat)
-
-            mockfs.stub(:read) { |ctx,path,size,offset,ffi|
-                IO.read("/tmp/nulltest",size,offset)
-            }
-
-            with_fuse(mountpoint,mockfs) do
-                File.open("#{mountpoint}/testnull") do |f|
-                    val = f.gets
-                    val.should == "\000\000"
-                    val.size.should == 2
-                end
-            end
-        end
-
-    end
-
-    context "filesystem statistics" do
-
-        let (:statvfs) {
-            RFuse::StatVfs.new(
-                :bsize => 2048,
-                "frsize" => 1024,
-                "blocks" =>  9999,
-                "bfree" => 8888,
-                "bavail" => 7777,
-                "files" => 6000,
-                "ffree" => 5555)
-        }
-
-        it "should report filesystem statistics" do
-            mockfs.stub(:getattr).with(anything(),"/test").and_return(dir_stat)
-            mockfs.stub(:getattr).with(anything(),"/test/statfs").and_return(file_stat)
-
-            mockfs.should_receive(:statfs).with(anything(),"/test/statfs").and_return(statvfs)
-
-            #also exercise StatVfs
-            statvfs.f_files=6666
-
-            with_fuse(mountpoint,mockfs) do
-
-                results = Sys::Filesystem.stat("#{mountpoint}/test/statfs")
-                results.block_size.should == 2048
-                results.fragment_size.should == 1024
-                results.blocks.should == 9999
-                results.blocks_available.should == 7777
-                results.blocks_free.should == 8888
-                results.files.should == 6666
-                results.files_available == 5555
-            end
-        end
-    end
-
-    context "exceptions" do
-
-        it "should capture exceptions appropriately" do
-
-            mockfs.should_receive(:getattr).with(anything(),"/exceptions").and_raise(RuntimeError)
-
-            with_fuse(mountpoint,mockfs) do
-                begin
-                    File.stat("#{mountpoint}/exceptions")
-                    raise "should not get here"
-                rescue Errno::ENOENT
-                    #all good
-                end
-            end
-        end
-
-        it "should pass Errno exceptions through" do
-            mockfs.should_receive(:getattr).with(anything(),"/exceptions").and_raise(Errno::EPERM)
-
-            with_fuse(mountpoint,mockfs) do
-                begin
-                    File.stat("#{mountpoint}/exceptions")
-                    raise "should not get here"
-                rescue Errno::EPERM
-                    #all good
-                end
-            end
-        end
-
-    end
-end

data/spec/fuse_file_info_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-describe RFuse::Fuse do
-
-    let(:dir_stat) { RFuse::Stat.directory(0444) }
-    let(:file_stat) { RFuse::Stat.file(0444) }
-    let!(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil); m }
-    let(:mountpoint) { tempmount() }
-    let(:open_files) { Hash.new() }
-
-    it "should pass fileinfo to #release" do
-
-        file_handle = Object.new()
-        stored_ffi = nil
-        captured_ex = nil
-
-        mockfs.stub(:getattr).with(anything(),"/ffirelease").and_return(file_stat)
-
-        mockfs.should_receive(:open).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
-           stored_ffi = ffi
-           ffi.fh = file_handle
-           ctx.uid.should > 0
-        }
-
-        mockfs.should_receive(:release).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
-            # the return value of release is ignored, so exceptions here are lost
-            begin
-                ffi.fh.should == file_handle
-                ffi.should == stored_ffi
-                # Not sure why ctx.uid is not still set during release
-                ctx.uid.should == 0
-            rescue Exception => ex
-                captured_ex = ex
-            end
-        }
-
-        with_fuse(mountpoint,mockfs) do
-            f1 = File.new("#{mountpoint}/ffirelease")
-            f1.close()
-        end
-
-        raise captured_ex if captured_ex
-    end
-
-    it "should pass fileinfo to #releasedir" do
-
-        file_handle = Object.new()
-        stored_ffi = nil
-        captured_ex = nil
-
-        mockfs.stub(:getattr).with(anything(),"/ffirelease").and_return(dir_stat)
-
-        mockfs.should_receive(:opendir).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
-            stored_ffi = ffi
-            ffi.fh = file_handle
-            ctx.uid.should > 0
-        }
-
-        mockfs.should_receive(:readdir) do | ctx, path, filler,offset,ffi |
-            filler.push("hello",nil,0)
-            filler.push("world",nil,0)
-        end
-
-        mockfs.should_receive(:releasedir).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
-            # the return value of release is ignored, so exceptions here are lost
-            begin
-                ffi.fh.should == file_handle
-                ffi.should == stored_ffi
-                # Not entirely sure why ctx.uid is not set here
-                ctx.uid.should == 0
-            rescue Exception => ex
-                captured_ex = ex
-            end
-        }
-
-        with_fuse(mountpoint,mockfs) do
-            entries = Dir.entries("#{mountpoint}/ffirelease")
-            entries.size.should == 2
-            entries.should include("hello")
-            entries.should include("world")
-        end
-
-        raise captured_ex if captured_ex
-    end
-
-    context "file handles" do
-        it "should retain file handles over GC" do
-
-            file_stat.size = 11
-
-            mockfs.stub(:getattr).with(anything(),"/one").and_return(file_stat)
-            mockfs.stub(:getattr).with(anything(),"/two").and_return(file_stat)
-
-            open_files = {}
-            mockfs.stub(:open) { |ctx,path,ffi|
-                ffi.fh = Object.new()
-                open_files[path] = ffi.fh.object_id
-            }
-
-            mockfs.stub(:read) { |ctx,path,size,offset,ffi|
-                GC.start()
-                open_files[path].should == ffi.fh.object_id
-                "hello world"
-            }
-
-            with_fuse(mountpoint,mockfs) do
-                f1 = File.new("#{mountpoint}/one")
-                f2 = File.new("#{mountpoint}/two")
-
-                val = f1.gets
-                val.should == "hello world"
-                f2.gets.should == "hello world"
-
-                f1.close()
-                f2.close()
-            end
-        end
-    end
-end

data/spec/main_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-class MockFuse < RFuse::Fuse; end
-class DuckFuse
-    def initialize(val); end;
-end
-
-describe RFuse do
-
-    # required to capture stderr output of help text from C: library functions
-    matcher :print_to_stderr do |expected|
-        supports_block_expectations
-
-        match do |actual|
-            #$stdout.puts "STDERR=#{$stderr} #{$stderr.fileno}"
-            @captured = File.open(Dir.tmpdir + "/rfuse.stderr","w+") do |f|
-                f.sync
-                old_stderr = STDERR.dup
-                old_f = f.dup
-                begin
-                    STDERR.reopen(f)
-                    actual.call
-                ensure
-                    STDERR.reopen(old_stderr)
-                end
-                old_f.rewind
-                old_f.read
-            end
-            expected.match(@captured)
-        end
-
-        match_when_negated do |actual|
-            !matches?(actual)
-        end
-
-        failure_message do
-            "Expected stderr output...\n#{@captured}\nto match RE - #{expected}"
-        end
-
-        failure_message_when_negated do
-            "Expected stderr output...\n#{@captured}\nto not match RE - #{expected}"
-        end
-    end
-
-    let(:mockfs) { m = double("fuse"); m.stub(:getattr).and_return(nil); m }
-    let(:mountpoint) { tempmount() }
-
-    describe ".main" do
-
-        let(:re_usage) { Regexp.new("^Usage:\n.*-h.*-d.*\n",Regexp::MULTILINE)  }
-        let(:re_help)  { Regexp.new("^Fuse options: \\(\\d.\\d\\)\n.*help.*\n.*debug.*\n\n",Regexp::MULTILINE) }
-        let(:re_fuse)  { Regexp.new(".*(^\\s+-o.*$)+.*",Regexp::MULTILINE) }
-        let(:re_extra_header) { Regexp.new("Filesystem options:\n",Regexp::MULTILINE) }
-
-        # self.main(argv=ARGV,extra_options=[],extra_option_usage="",device=nil,exec=File.basename($0))
-        context "with no mountpoint" do
-            it "prints usage information to stdout" do
-                expect { RFuse.main([]) { } }.to output(re_usage).to_stdout
-            end
-            it "prints mountpoint failure on stderr" do
-                expect { RFuse.main([]) { } }.to output("rfuse: failed, no mountpoint provided\n").to_stderr
-            end
-        end
-
-        context "with help option" do
-            it "does not start filesystem" do
-                expect(mockfs).to receive(:init).exactly(0).times
-                RFuse.main([mountpoint,"-h"]) { mockfs }
-            end
-
-            it "prints usage and kernel options" do
-                # TODO: In Fuse 3.0, this will get complicated because help output moves to stdout
-                re = Regexp.new(re_help.to_s + re_fuse.to_s)
-                expect { RFuse.main([mountpoint,"-h"]) { mockfs } }.to print_to_stderr(re)
-            end
-
-            it "does not print filesystem options header if no extra options" do
-                re = Regexp.new(re_help.to_s + re_fuse.to_s + re_extra_header.to_s)
-                expect { RFuse.main([mountpoint,"-h"]) { mockfs } }.not_to print_to_stderr(re)
-            end
-
-            it "prints local option header if there are local options" do
-                re = Regexp.new(re_help.to_s + re_fuse.to_s + re_extra_header.to_s + "TestOptionUsage")
-                expect { RFuse.main([mountpoint,"-h"],[:myoption],"TestOptionUsage") { mockfs } }.to print_to_stderr(re)
-            end
-
-        end
-
-        it "yields parsed options and cleaned argv" do
-            # We know that main uses parse_options which is tested elsewhere
-            expect { |b| RFuse.main([mountpoint,"-o","myoption"],[:myoption],&b) }.to \
-                yield_with_args(a_hash_including(:mountpoint,:myoption),[mountpoint])
-        end
-
-        context "yield raises exception" do
-            it "prints usage output" do
-                expect { RFuse.main([mountpoint]) { raise RFuse::Error, "MyError"}}.to output(re_usage).to_stdout
-            end
-
-            it "prints the error message" do
-                expect { RFuse.main([mountpoint]) { raise RFuse::Error, "MyError"}}.to output("rfuse failed: MyError\n").to_stderr
-            end
-        end
-
-        it "creates and runs the yielded Fuse filesystem" do
-            # We test create and run separately
-            # expect RFuse.create then mounted? and run
-            fuse = double(fuse)
-            fuse.stub(:mounted?).and_return(true,false)
-            expect(fuse).to receive(:run)
-            expect(RFuse).to receive(:create).with(fuse,[mountpoint],{:mountpoint => mountpoint},[]) { fuse }
-            RFuse.main([mountpoint]) { fuse }
-        end
-    end
-
-    describe ".create" do
-        let(:argv) { [mountpoint] }
-        context "with a Fuse object" do
-            let(:fs) { MockFuse.new(mountpoint) }
-            it "returns the object" do
-                fuse = RFuse.create(fs)
-                expect(fuse).to be(fs)
-                expect(fuse).to be_mounted
-            end
-        end
-
-        context "with a subclass of Fuse" do
-            let(:fs) { MockFuse }
-
-            it "creates a new Fuse object from subclass of Fuse" do
-                fuse = RFuse.create(fs,[mountpoint])
-                expect(fuse).to be_kind_of(MockFuse)
-                expect(fuse.mountpoint).to eq(mountpoint)
-                expect(fuse).to be_mounted
-            end
-        end
-
-        context "with a Class" do
-            let(:fs) { DuckFuse }
-            it "creates a FuseDelegator around a new instance" do
-                expect(fs).to receive(:new).with("OptionValue").and_call_original()
-                expect(RFuse::FuseDelegator).to receive(:new).with(an_instance_of(DuckFuse),mountpoint).and_call_original()
-                fuse = RFuse.create(fs,[mountpoint],{:myopt => "OptionValue"},[:myopt])
-                expect(fuse).to be_kind_of(RFuse::FuseDelegator)
-                expect(fuse.mountpoint).to eq(mountpoint)
-                expect(fuse).to be_mounted
-            end
-        end
-        context "with a non-Fuse Object" do
-            let(:fs) { mockfs }
-            it "starts FuseDelegator with non Fuse object returned from yield" do
-                expect(RFuse::FuseDelegator).to receive(:new).with(mockfs,mountpoint).and_call_original()
-                fuse = RFuse.create(fs,[mountpoint])
-                expect(fuse).to be_kind_of(RFuse::FuseDelegator)
-                expect(fuse.mountpoint).to eq(mountpoint)
-                expect(fuse).to be_mounted
-            end
-        end
-
-    end
-end