rfuse 1.1.2 → 1.2.3

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

data/spec/xattr_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'ffi-xattr'
-
-describe RFuse::Fuse do
-        it "should handle extended attributes" do
-            mockfs = mock("fuse")
-
-            file_stat = RFuse::Stat.file(0444,:size => 11)
-
-            mockfs.stub(:getattr).and_return(file_stat)
-            mockfs.stub(:getxattr) { |ctx,path,name|
-                case name
-                when "user.one"
-                    "1"
-                when "user.two"
-                    "2"
-                when "user.large"
-                    "x" * 1000
-                else
-                    ""
-                end
-            }
-
-            mockfs.stub(:listxattr).with(anything(),"/myfile").and_return([ "user.one","user.two","user.large" ])
-            mockfs.should_receive(:setxattr).with(anything(),"/myfile","user.three","updated",anything())
-            mockfs.should_receive(:removexattr).with(anything(),"/myfile","user.one")
-
-            mountpoint = tempmount()
-
-            with_fuse(mountpoint,mockfs) do
-                xattr = Xattr.new("#{mountpoint}/myfile")
-                xattr.list.should include("user.one")
-                xattr.list.should include("user.two")
-                xattr.list.size.should == 3
-
-                xattr['user.one'].should == "1"
-                xattr['user.two'].should == "2"
-                xattr['user.three']= "updated"
-                xattr['xxxxx'].should be_nil
-                xattr.remove('user.one')
-                # And now with a non-ruby system #TODO. There'd be a way to guard this properly
-                if system("getfattr --version")
-                    system("getfattr -d #{mountpoint}/myfile > /dev/null").should be(true)
-                else
-                    puts "Warning Skipping getfattr test"
-                end
-            end
-        end
-end