rfuse 1.1.2 → 1.2.0.rc202009.69

data/spec/options_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-require 'pathname'
-require 'tempfile'
-
-describe RFuse 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 "mount options" do
-        it "should handle -h" do
-            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-h")
-            fuse.mounted?.should be_falsey
-            lambda { fuse.loop }.should raise_error(RFuse::Error)
-        end
-
-        it "should behave sensibly for bad mountpoint" do
-            fuse = RFuse::FuseDelegator.new(mockfs,"bad/mount/point")
-            fuse.mounted?.should be_falsey
-            lambda { fuse.loop }.should raise_error(RFuse::Error)
-        end
-
-        it "should behave sensibly for bad options" do
-            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-eviloption")
-            fuse.mounted?.should be_falsey
-            lambda { fuse.loop }.should raise_error(RFuse::Error)
-        end
-
-        it "should handle a Pathname as a mountpoint" do
-            fuse = RFuse::FuseDelegator.new(mockfs,Pathname.new(mountpoint))
-            fuse.mounted?.should be(true)
-            fuse.unmount()
-        end
-    end
-
-    context "#parse_options" do
-
-        it "should detect -h" do
-            argv = [ "/mountpoint","-h" ]
-            result = RFuse.parse_options(argv)
-
-            result[:help].should be(true)
-            result[:mountpoint].should == "/mountpoint"
-            result[:debug].should be_falsey
-        end
-
-        it "should detect -h mixed with -o" do
-            argv = [ "/mountpoint","-h", "-o", "debug" ]
-            result = RFuse.parse_options(argv)
-
-            result[:help].should be(true)
-            result[:mountpoint].should == "/mountpoint"
-            result[:debug].should be(true)
-        end
-
-        it "should detect debug" do
-            argv = [ "/mountpoint","-o","debug" ]
-            result = RFuse.parse_options(argv)
-
-            result[:debug].should be(true)
-            result[:help].should be_falsey
-
-            argv = [ "/mountpoint","-o","default_permissions,debug" ]
-            result = RFuse.parse_options(argv)
-            result[:debug].should be(true)
-        end
-
-        it "detects debug as -d" do
-            argv = [ "/mountpoint","-o","someopt","-d" ]
-            result = RFuse.parse_options(argv)
-            result[:debug].should be(true)
-        end
-
-        it "should remove local options" do
-            argv = [ "/mountpoint","-o","debug,myoption" ]
-
-            result = RFuse.parse_options(argv,:myoption)
-
-            result[:debug].should be(true)
-            result[:myoption].should be(true)
-
-            argv.should == [ "/mountpoint", "-o", "debug" ]
-        end
-
-        it "should remove the only local option" do
-            argv = ["/mountpoint","-o","myoption" ]
-
-            result = RFuse.parse_options(argv,:myoption)
-
-            result[:myoption].should be(true)
-            argv.should == [ "/mountpoint" ]
-        end
-
-
-        it "parses the value from the only local option" do
-            argv = [ "adevice", "/mountpoint", "-o","someopt=somevalue"]
-            result = RFuse.parse_options(argv,:someopt)
-
-            result[:someopt].should == "somevalue"
-            argv.should == [ "/mountpoint" ]
-        end
-
-        it "should parse values from options" do
-            argv = [ "/mountpoint", "-o", "debug,someopt=somevalue" ]
-            result = RFuse.parse_options(argv)
-
-            result[:someopt].should == "somevalue"
-        end
-
-        it "should parse values and remove local options" do
-            argv = [ "/mountpoint", "-o", "debug,someopt=somevalue" ]
-            result = RFuse.parse_options(argv,:someopt)
-
-            result[:someopt].should == "somevalue"
-            argv[2].should == "debug"
-        end
-
-        it "should parse and remove optional device" do
-
-            argv = [ "a device", "/mountpoint" , "-o", "rw,debug,default_permissions" ]
-            result = RFuse.parse_options(argv)
-
-            result[:device].should == "a device"
-            result[:mountpoint].should == "/mountpoint"
-            result[:rw].should be(true)
-            result[:debug].should be(true)
-            result[:default_permissions].should be(true)
-
-            argv.should == [ "/mountpoint" , "-o", "rw,debug,default_permissions" ]
-        end
-
-        context "with '-' in device" do
-            it "should parse the device correctly" do
-                argv = [ "a-device", "/mountpoint" , "-o", "rw,debug,default_permissions" ]
-                result = RFuse.parse_options(argv)
-
-                result[:device].should == "a-device"
-            end
-        end
-    end
-end

data/spec/ruby_loop_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe RFuse::Fuse do
-
-    let(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil) ; m }
-    let(:mountpoint) { tempmount() }
-
-    context "#loop" do
-        it "should exit from another thread and allow multiple loops" do
-
-            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint)
-            t = Thread.new { sleep 0.2;  fuse.exit }
-            fuse.loop()
-            t.join
-            t = Thread.new { sleep 0.2;  fuse.exit }
-            fuse.loop
-            t.join
-            fuse.unmount
-            fuse.mounted?.should be(false)
-        end
-
-
-        # This will never work!
-        #it "should allow threads to operate on the filesystem" do
-        #
-        #    mockfs = mock("fuse")
-        #    mockfs.stub(:getattr).and_return(nil)
-        #
-        #    fuse = RFuse::FuseDelegator.new(mockfs,"/tmp/rfuse-spec")
-        #
-        #    t = Thread.new { sleep 0.5 ; File.stat("/tmp/rfuse-spec/thread") ; fuse.exit }
-        #
-        #    fuse.loop()
-        #    fuse.unmount()
-        #end
-
-        it "should allow other threads to be scheduled" do
-
-            file_stat = RFuse::Stat.file(0444)
-
-            thread_ran = false
-
-            mockfs.stub(:getattr).with(anything(),"/before") {
-                thread_ran.should be(false)
-                file_stat
-            }
-
-            mockfs.stub(:getattr).with(anything(),"/missing") {
-                #GC.start()
-                thread_ran.should be(true)
-                file_stat
-            }
-
-            t = Thread.new() { sleep 0.5 ; thread_ran = true }
-            with_fuse(mountpoint,mockfs) do
-                File.stat("#{mountpoint}/before");
-                sleep 1;
-                File.stat("#{mountpoint}/missing");
-            end
-        end
-    end
-end
-

data/spec/run_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe RFuse::Fuse do
-    context "#run" do
-
-        let(:file_stat) { RFuse::Stat.file(0444) }
-        let(:mountpoint) { tempmount() }
-        let(:mockfs) { m = double("fuse"); allow(m).to receive(:getattr) { |ctx,path| puts "#{ctx},#{path}"}; m }
-        let(:fuse) { RFuse::FuseDelegator.new(mockfs,mountpoint) }
-
-        it "runs a mounted filesystem with default traps" do
-
-            # expect traps to be set
-            expect(mockfs).to receive(:sighup) { }
-            expect(mockfs).to receive(:getattr).with(anything(),"/run").and_return(file_stat)
-
-            # Need to call this before we fork..
-            expect(fuse.mountpoint).to eq(mountpoint)
-
-            pid = Process.pid
-
-            fpid = Kernel.fork do
-                File.stat("#{mountpoint}/run")
-                Process.kill("HUP",pid)
-                sleep(0.1)
-                Process.kill("TERM",pid)
-            end
-
-            fuse.run
-
-            rpid,result = Process.waitpid2(fpid)
-            expect(result).to be_success
-
-            expect(fuse).not_to be_mounted
-            expect(Signal.trap("HUP","DEFAULT")).to eq("DEFAULT")
-        end
-
-        it "unmounts the filesystem and resets traps on exception" do
-            expect(mockfs).to receive(:getattr).with(anything(),"/run").and_return(file_stat)
-            # raising an error in a sighandler will exit the loop..
-            expect(mockfs).to receive(:sighup).and_raise("oh noes")
-            pid = Process.pid
-            # Need to call this before we fork..
-            expect(fuse.mountpoint).to eq(mountpoint)
-
-            fpid = Kernel.fork do
-                File.stat("#{mountpoint}/run")
-                Process.kill("HUP",pid)
-            end
-
-            expect { fuse.run }.to raise_error
-
-            pid,result = Process.waitpid2(fpid)
-
-            expect(fuse).not_to be_mounted
-            expect(Signal.trap("HUP","DEFAULT")).to eq("DEFAULT")
-        end
-
-    end
-end

data/spec/signals_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-describe RFuse::Fuse do
-
-    let(:mountpoint) { tempmount() }
-    let(:fuse) { RFuse::Fuse.new(mountpoint) }
-
-    before(:each) do
-        # Override traps (note rspec itself traps "INT") with "DEFAULT"
-        @traps = ["INT","TERM","HUP","USR1","USR2"].inject({}) { |h,signame| h[signame] = Signal.trap(signame,"DEFAULT"); h }
-    end
-
-    after(:each) do
-        fuse.unmount()
-        # Restore previously set traps
-        @traps.each_pair { |signame,prev_trap| Signal.trap(signame,prev_trap) }
-    end
-
-    context "#trap_signals" do
-
-        it "returns the list of signals trapped" do
-
-            allow(fuse).to receive(:sighup)
-
-            expect(fuse.trap_signals("HUP")).to include("HUP")
-            expect(Signal.trap("HUP","DEFAULT")).not_to eq("DEFAULT")
-        end
-
-        it "does not override previously set traps" do
-
-            allow(fuse).to receive(:sighup)
-
-            Signal.trap("HUP","HUPCOMMAND")
-
-            expect(fuse.trap_signals()).not_to include("HUP")
-            expect(Signal.trap("HUP","DEFAULT")).to eq("HUPCOMMAND")
-        end
-
-        it "only traps the specified signals" do
-
-            allow(fuse).to receive(:sighup)
-            allow(fuse).to receive(:sigusr2)
-
-            expect(fuse.trap_signals("HUP")).to include("HUP")
-            expect(Signal.trap("HUP","DEFAULT")).not_to eq("DEFAULT")
-            expect(Signal.trap("USR2","DEFAULT")).to eq("DEFAULT")
-        end
-
-        it "allows signals to be handled by the filesystem" do
-            expect(fuse).to receive(:sighup) { fuse.exit }
-
-            expect(fuse.trap_signals("HUP")).to include("HUP")
-
-            pid = Process.pid
-            fork_fuse(fuse) { Process.kill("HUP",pid) }
-            # Exitted loop, but still mounted - ie not with fusermount -u
-            expect(fuse).to be_mounted
-        end
-
-        it "exits on INT by default" do
-            pid = Process.pid
-            expect(fuse.trap_signals("INT")).to include("INT")
-
-            fork_fuse(fuse) { Process.kill("INT",pid) }
-            expect(fuse).to be_mounted
-        end
-
-        it "exits on TERM by default" do
-            pid = Process.pid
-            expect(fuse.trap_signals("TERM")).to include("TERM")
-
-            fork_fuse(fuse) { Process.kill("TERM",pid) }
-            expect(fuse).to be_mounted
-        end
-
-        context "with a delegated filesystem" do
-            let(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil); m }
-            let(:fuse) { RFuse::FuseDelegator.new(mockfs,mountpoint) }
-
-            it "enables FuseDelegator debugging on USR1" do
-
-                pid = Process.pid
-                expect(fuse.trap_signals("USR1","INT")).to include("USR1")
-
-                expect(fuse.debug?).to be(false)
-
-                fork_fuse(fuse) do
-                    Process.kill("USR1",pid)
-                    sleep(0.1)
-                    Process.kill("INT",pid)
-                end
-
-                expect(fuse.debug?).to be(true)
-            end
-
-            it "allows delegate filesystem to override default sig handler method" do
-                expect(mockfs).to receive(:sigint) { fuse.exit }
-
-                pid = Process.pid
-                fuse.trap_signals("INT")
-
-                fork_fuse(fuse) do
-                    Process.kill("INT",pid)
-                end
-            end
-        end
-    end
-end

data/spec/spec_helper.rb

@@ -1,109 +0,0 @@
-require 'rfuse'
-require 'tmpdir'
-
-class FileModeMatcher
-    def initialize(expected)
-        @expected = expected
-    end
-
-    def description
-        "file mode #{@expected}"
-    end
-
-    def ==(actual)
-        (actual | RFuse::Stat::S_IFMT) ==  (@expected | RFuse::Stat::S_IFMT)
-    end
-end
-
-module DoubleAliases
-  def mock(*args, &block)
-    double(*args, &block)
-  end
-  alias stub mock
-end
-
-
-module RFuseHelper
-    # Runs the single threaded fuse loop
-    # on a pre configured mock fuse filesystem
-    # Executes fork block in a separate process
-    # that is expected to return success
-    def with_fuse(mnt,mockfs,*options,&fork_block)
-
-        fuse = RFuse::FuseDelegator.new(mockfs,mnt,*options)
-        fuse.mounted?.should be(true)
-        fork_fuse(fuse) do
-            begin
-                fork_block.call() if fork_block
-            ensure
-                fusermount(mnt)
-            end
-        end
-        fuse.open_files.should be_empty()
-        fuse.mounted?.should be(false)
-    end
-
-    def fork_fuse(fuse,&fork_block)
-
-        fpid = Kernel.fork() { fork_block.call() }
-
-        fuse.loop
-
-        pid,result = Process.waitpid2(fpid)
-        result.should be_success
-    end
-
-    def fusermount(mnt)
-        unless system("fusermount -u #{mnt} >/dev/null 2>&1")
-            sleep(0.5)
-            system("fusermount -u #{mnt}")
-        end
-    end
-
-    def file_mode(mode)
-        FileModeMatcher.new(mode)
-    end
-
-    def tempmount()
-        Dir.mktmpdir("rfuse-spec")
-    end
-
-    # Generate a set of times with non-zero usec values
-    def usec_times(*increments)
-        increments.collect { |inc|
-            begin
-                time = Time.now() + inc
-                sleep(0.001)
-            end until time.usec != 0
-            time
-        }
-    end
-
-end
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = [:should, :expect]
-  end
-  config.mock_with :rspec do |c|
-    c.syntax = [:should, :expect]
-  end
-
-  config.after(:suite) do
-      Dir.glob(Dir.tmpdir + "/rfuse-spec*") do |dir|
-          count = 0
-          begin
-            system("fusermount -u #{dir} >/dev/null 2>&1")
-            FileUtils.rmdir(dir)
-          rescue Errno::EBUSY
-            #puts "Cleaning up #{dir} is busy, retrying..."
-            sleep(0.5)
-            count = count + 1
-            retry unless count > 3
-          end
-      end
-  end
-
-  config.include RFuseHelper
-  config.include DoubleAliases
-end