virtfs 0.0.1

data/spec/chroot_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe "VirtFS.dir_chroot (#{$fs_interface} interface)" do
+  before(:all) do
+    @full_path  = VfsRealFile.expand_path(__FILE__)
+    @this_dir   = VfsRealFile.expand_path(__dir__)
+    @root       = File::SEPARATOR
+
+    @new_root      = VfsRealFile.expand_path(VfsRealFile.join(__dir__, ".."))
+    @new_this_dir  = VfsRealFile.expand_path(VfsRealFile.join("/", VfsRealFile.basename(__dir__)))
+    @new_full_path = VfsRealFile.expand_path(VfsRealFile.join(@new_this_dir, VfsRealFile.basename(__FILE__)))
+  end
+
+  before(:each) do
+    reset_context
+    @native_fs  = nativefs_class.new
+    VirtFS.mount(@native_fs, @root)
+  end
+
+  describe "Dir.chroot" do
+    it "should raise Errno::ENOENT when directory does exist" do
+      expect do
+        VirtFS::VDir.chroot("/not_a_dir/foo.d")
+      end.to raise_error(
+        Errno::ENOENT, /No such file or directory/
+      )
+    end
+
+    it "should return 0 on success" do
+      expect(VirtFS::VDir.chroot(@this_dir)).to eq(0)
+    end
+
+    it "should set the value of root accordingly" do
+      VirtFS::VDir.chroot(@new_root)
+      expect(VirtFS.root).to eq(@new_root)
+    end
+
+    it "should set the current directory to '/'" do
+      VirtFS::VDir.chroot(@new_root)
+      expect(VirtFS::VDir.getwd).to eq(File::SEPARATOR)
+    end
+
+    it "should find directory through new full path" do
+      VirtFS::VDir.chroot(@new_root)
+      expect(VirtFS::VDir.exist?(@new_this_dir)).to be true
+    end
+
+    it "should find file through new full path" do
+      VirtFS::VDir.chroot(@new_root)
+      expect(VirtFS::VFile.exist?(@new_full_path)).to be true
+    end
+  end
+
+  describe "Dir.chdir" do
+    before(:all) do
+      @parent_dir         = @new_root
+      @child_dir          = @this_dir
+      @rel_child_dir_name = VfsRealFile.basename(@child_dir)
+      @abs_child_dir_name = VfsRealFile.join("/", @rel_child_dir_name)
+    end
+
+    it "should raise Errno::ENOENT when directory does exist under current root" do
+      VirtFS::VDir.chroot(@child_dir)
+      expect do
+        VirtFS::VDir.chdir(@parent_dir)
+      end.to raise_error(
+        Errno::ENOENT, /No such file or directory/
+      )
+    end
+
+    it "should cd to absolute path based on new root" do
+      VirtFS::VDir.chroot(@parent_dir)
+      VirtFS::VDir.chdir(@abs_child_dir_name)
+      expect(VirtFS::VDir.getwd).to eq(@abs_child_dir_name)
+    end
+
+    it "should cd to relative path based on new root" do
+      VirtFS::VDir.chroot(@parent_dir)
+      VirtFS::VDir.chdir(@rel_child_dir_name)
+      expect(VirtFS::VDir.getwd).to eq(@abs_child_dir_name)
+    end
+
+    it "should not permit traversal above root" do
+      VirtFS::VDir.chroot(@parent_dir)
+      VirtFS::VDir.chdir("..")
+      expect(VirtFS::VDir.getwd).to eq("/")
+      VirtFS::VDir.chdir(VfsRealFile.join("..", ".."))
+      expect(VirtFS::VDir.getwd).to eq("/")
+      VirtFS::VDir.chdir(VfsRealFile.join("..", "..", ".."))
+      expect(VirtFS::VDir.getwd).to eq("/")
+    end
+
+    it "should traverse up to root, then back down" do
+      VirtFS::VDir.chroot(@parent_dir)
+      VirtFS::VDir.chdir(VfsRealFile.join("..", "..", "..", @rel_child_dir_name))
+      expect(VirtFS::VDir.getwd).to eq(@abs_child_dir_name)
+    end
+  end
+
+  describe "Dir.glob" do
+    it "should enumerate the same file names as the standard Dir.glob - simple glob" do
+      VirtFS::VDir.chroot(@new_root)
+      VfsRealDir.chdir(@new_root) do # for VfsRealDir.glob
+        expect(VirtFS::VDir.glob("*")).to match_array(VfsRealDir.glob("*"))
+        expect(VirtFS::VDir.glob("*/*.rb")).to match_array(VfsRealDir.glob("*/*.rb"))
+      end
+    end
+
+    it "should enumerate the same file names as the standard Dir.glob - relative glob" do
+      VirtFS::VDir.chroot(@new_root)
+      VfsRealDir.chdir(@new_root) do # for VfsRealDir.glob
+        # We're at root, so the ".." will keep us at root.
+        v_results = VirtFS::VDir.glob("../**/*.rb").collect { |f| VfsRealFile.basename(f) }.sort
+        # We're not at root in the real FS, so omitting the ".." should result in the same files.
+        r_results = VfsRealDir.glob("**/*.rb").collect { |f| VfsRealFile.basename(f) }.sort
+        expect(v_results).to eq(r_results)
+      end
+    end
+  end
+end

data/spec/context_manager_class_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe VirtFS, " - context manager class operations (#{$fs_interface} interface)" do
+  before(:all) do
+    @root = File::SEPARATOR
+  end
+
+  before(:each) do
+    reset_context
+  end
+
+  context "Before any FS operations" do
+    describe "context_manager.managers" do
+      it "should return a Hash" do
+        cm_hash = VirtFS.context_manager.managers
+        expect(cm_hash).to be_kind_of(Hash)
+      end
+
+      it "should return an empty hash before any operations" do
+        cm_hash = VirtFS.context_manager.managers
+        expect(cm_hash.empty?).to be true
+      end
+    end
+
+    describe "context_manager.current!" do
+      it "should raise VirtFS::NoContextError when there's no context for the ThreadGroup" do
+        expect do
+          VirtFS.context_manager.current!
+        end.to raise_exception(VirtFS::NoContextError, /No filesystem context defined for thread group:/)
+      end
+    end
+
+    describe "context!" do
+      it "should raise VirtFS::NoContextError when there's no context for the ThreadGroup" do
+        expect do
+          VirtFS.context!
+        end.to raise_exception(VirtFS::NoContextError, /No filesystem context defined for thread group:/)
+      end
+    end
+
+    describe "context_manager.current" do
+      it "should return a ContextManager bound to our ThreadGroup" do
+        cmanager = VirtFS.context_manager.current
+        expect(cmanager.thread_group).to eq(Thread.current.group)
+      end
+    end
+
+    describe "context" do
+      it "should return a Context bound to our ThreadGroup" do
+        context = VirtFS.context
+        expect(context).to be_kind_of(VirtFS::Context)
+      end
+    end
+
+    describe "context_manager.manager_for" do
+      it "should raise ArgumentError when not passed a ThreadGroup object" do
+        expect do
+          VirtFS.context_manager.manager_for(nil)
+        end.to raise_exception(ArgumentError, "value must be a ThreadGroup object")
+      end
+
+      it "should return nil when given an unused ThreadGroup" do
+        expect(VirtFS.context_manager.manager_for(ThreadGroup.new)).to be nil
+      end
+
+      it "should return nil when given our ThreadGroup" do
+        expect(VirtFS.context_manager.manager_for(Thread.current.group)).to be nil
+      end
+    end
+
+    describe "context_manager.new_manager_for" do
+      it "should raise ArgumentError when not passed a ThreadGroup object" do
+        expect do
+          VirtFS.context_manager.new_manager_for(nil)
+        end.to raise_exception(ArgumentError, "value must be a ThreadGroup object")
+      end
+
+      it "should return a ContextManager when given an unused ThreadGroup" do
+        expect(VirtFS.context_manager.new_manager_for(ThreadGroup.new)).to be_kind_of(VirtFS::ContextManager)
+      end
+
+      it "should return a ContextManager when given our ThreadGroup" do
+        expect(VirtFS.context_manager.new_manager_for(Thread.current.group)).to be_kind_of(VirtFS::ContextManager)
+      end
+
+      it "should return a ContextManager bound to a new ThreadGroup" do
+        tgroup   = ThreadGroup.new
+        cmanager = VirtFS.context_manager.new_manager_for(tgroup)
+        expect(cmanager.thread_group).to eq(tgroup)
+      end
+
+      it "should return a ContextManager bound to our ThreadGroup" do
+        tgroup   = Thread.current.group
+        cmanager = VirtFS.context_manager.new_manager_for(tgroup)
+        expect(cmanager.thread_group).to eq(tgroup)
+      end
+
+      it "new ContextManager should be retrievable by ThreadGroup" do
+        tgroup   = Thread.current.group
+        cmanager = VirtFS.context_manager.new_manager_for(tgroup)
+        expect(VirtFS.context_manager.manager_for(tgroup)).to eq(cmanager)
+      end
+    end
+
+    describe "context_manager.remove_manager_for" do
+      it "should raise ArgumentError when not passed a ThreadGroup object" do
+        expect do
+          VirtFS.context_manager.remove_manager_for(nil)
+        end.to raise_exception(ArgumentError, "value must be a ThreadGroup object")
+      end
+
+      it "should return nil when given an unused ThreadGroup" do
+        expect(VirtFS.context_manager.remove_manager_for(ThreadGroup.new)).to be nil
+      end
+
+      it "should return nil when given our ThreadGroup" do
+        expect(VirtFS.context_manager.remove_manager_for(Thread.current.group)).to be nil
+      end
+    end
+  end
+
+  context "With root mounted by main thread/thread_group" do
+    before(:each) do
+      @native_fs = nativefs_class.new
+      VirtFS.mount(@native_fs, @root)
+    end
+
+    describe "context_manager.managers" do
+      it "should return a Hash" do
+        cm_hash = VirtFS.context_manager.managers
+        expect(cm_hash).to be_kind_of(Hash)
+      end
+
+      it "should return a Hash with one entry" do
+        cm_hash = VirtFS.context_manager.managers
+        expect(cm_hash.length).to eq(1)
+      end
+
+      it "should contain a ContextManager" do
+        cm = VirtFS.context_manager.managers.values.first
+        expect(cm).to be_kind_of(VirtFS::ContextManager)
+      end
+
+      it "should contain a ContextManager bound to the current ThreadGroup" do
+        cm = VirtFS.context_manager.managers.values.first
+        expect(cm.thread_group).to eq(Thread.current.group)
+      end
+    end
+
+    describe "context_manager_for" do
+      it "should raise ArgumentError when not passed a ThreadGroup object" do
+        expect do
+          VirtFS.context_manager.manager_for(nil)
+        end.to raise_exception(ArgumentError, "value must be a ThreadGroup object")
+      end
+
+      it "should return nil when given an unused ThreadGroup" do
+        expect(VirtFS.context_manager.manager_for(ThreadGroup.new)).to be nil
+      end
+
+      it "should return a ContextManager when given our ThreadGroup" do
+        cm = VirtFS.context_manager.manager_for(Thread.current.group)
+        expect(cm).to be_kind_of(VirtFS::ContextManager)
+        expect(cm.thread_group).to eq(Thread.current.group)
+      end
+    end
+  end
+
+  context "With root mounted by different thread groups" do
+    before(:each) do
+      @thread_groups = [ThreadGroup.new, ThreadGroup.new, ThreadGroup.new]
+      @thread_groups.each_with_index do |tg, i|
+        tg.add(Thread.current)
+        native_fs = nativefs_class.new
+        native_fs.name = "FS-#{i}"
+        VirtFS.mount(native_fs, @root)
+      end
+    end
+
+    after(:each) do
+      ThreadGroup::Default.add(Thread.current)
+    end
+
+    describe "context_manager.managers" do
+      it "should return a Hash" do
+        cm_hash = VirtFS.context_manager.managers
+        expect(cm_hash).to be_kind_of(Hash)
+      end
+
+      it "should return a hash of the expected length" do
+        cm_hash = VirtFS.context_manager.managers
+        expect(cm_hash.length).to eq(@thread_groups.length)
+      end
+
+      it "hash should contain one entry per thread group" do
+        cm_hash = VirtFS.context_manager.managers
+        @thread_groups.each do |tg|
+          cm = cm_hash[tg]
+          expect(cm).to be_kind_of(VirtFS::ContextManager)
+          expect(cm.thread_group).to eq(tg)
+        end
+      end
+    end
+
+    describe "context_manager.manager_for" do
+      it "should raise ArgumentError when not passed a ThreadGroup object" do
+        expect do
+          VirtFS.context_manager.manager_for(nil)
+        end.to raise_exception(ArgumentError, "value must be a ThreadGroup object")
+      end
+
+      it "should return nil when given an unused ThreadGroup" do
+        expect(VirtFS.context_manager.manager_for(ThreadGroup.new)).to be nil
+      end
+
+      it "should return a ContextManager when given each ThreadGroup" do
+        @thread_groups.each do |tg|
+          cm = VirtFS.context_manager.manager_for(tg)
+          expect(cm).to be_kind_of(VirtFS::ContextManager)
+          expect(cm.thread_group).to eq(tg)
+        end
+      end
+    end
+
+    describe "context_manager.remove_manager_for" do
+      it "should raise ArgumentError when not passed a ThreadGroup object" do
+        expect do
+          VirtFS.context_manager.remove_manager_for(nil)
+        end.to raise_exception(ArgumentError, "value must be a ThreadGroup object")
+      end
+
+      it "should return nil when given an unused ThreadGroup" do
+        expect(VirtFS.context_manager.remove_manager_for(ThreadGroup.new)).to be nil
+      end
+
+      it "should return nil when given our ThreadGroup" do
+        @thread_groups.each do |tg|
+          cm = VirtFS.context_manager.manager_for(tg)
+          expect(cm).to be_kind_of(VirtFS::ContextManager)
+          expect(VirtFS.context_manager.remove_manager_for(tg)).to eq(cm)
+          expect(VirtFS.context_manager.manager_for(tg)).to be nil
+        end
+      end
+    end
+  end
+end

data/spec/context_manager_instance_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+
+describe VirtFS, " - context manager instance operations (#{$fs_interface} interface)" do
+  before(:all) do
+    @root = File::SEPARATOR
+  end
+
+  before(:each) do
+    reset_context
+    @my_context_manager = VirtFS.context_manager.current
+  end
+
+  describe "#[]" do
+    it "should return nil given an non-existent key" do
+      expect(@my_context_manager[:not_a_key]).to be nil
+    end
+
+    it "should have a default context" do
+      expect(@my_context_manager[:default]).to be_kind_of(VirtFS::Context)
+    end
+  end
+
+  describe "#[]=" do
+    it "should raise an ArgumentError when not passed a VirtFS::Context object" do
+      expect do
+        @my_context_manager[:new_key] = "not a context object"
+      end.to raise_exception(ArgumentError, "Context must be a VirtFS::Context object")
+    end
+
+    it "should raise an ArgumentError when attempting to change the default context" do
+      expect do
+        @my_context_manager[:default] = VirtFS::Context.new
+      end.to raise_exception(ArgumentError, "Cannot change the default context")
+    end
+
+    it "should return the assigned context on success" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key] = new_context).to eq(new_context)
+    end
+
+    it "should raise an RuntimeError when attempting to change existing value" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key] = new_context).to eq(new_context)
+      expect do
+        @my_context_manager[:new_key] = VirtFS::Context.new
+      end.to raise_exception(RuntimeError, "Context for given key already exists")
+    end
+
+    it "should raise an RuntimeError when attempting assign context to more than one key" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key1] = new_context).to eq(new_context)
+      expect do
+        @my_context_manager[:new_key2] = new_context
+      end.to raise_exception(RuntimeError, /Context already assigned to key:/)
+    end
+
+    it "should delete a context by assigning nil" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key] = new_context).to eq(new_context)
+      expect(@my_context_manager[:new_key] = nil).to be nil
+      expect(@my_context_manager[:new_key]).to be nil
+    end
+
+    it "should permit re-assignment of deleted entry" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key] = new_context).to eq(new_context)
+      expect do
+        @my_context_manager[:new_key] = VirtFS::Context.new
+      end.to raise_exception(RuntimeError, "Context for given key already exists")
+      expect(@my_context_manager[:new_key] = nil).to be nil
+      expect(@my_context_manager[:new_key] = new_context).to eq(new_context)
+    end
+
+    it "should permit assignment to new key after deletion from old key" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key1] = new_context).to eq(new_context)
+      expect do
+        @my_context_manager[:new_key2] = new_context
+      end.to raise_exception(RuntimeError, /Context already assigned to key:/)
+      expect(@my_context_manager[:new_key1] = nil).to be nil
+      expect(@my_context_manager[:new_key2] = new_context).to eq(new_context)
+    end
+  end
+
+  describe "#current_context and #current_context=" do
+    it "should return the default context by default" do
+      expect(@my_context_manager.current_context).to eq(@my_context_manager[:default])
+    end
+
+    it "should raise RuntimeError when key doesn't exist" do
+      expect do
+        @my_context_manager.current_context = :new_key
+      end.to raise_exception(RuntimeError, "Context for given key doesn't exist")
+    end
+
+    it "should set the current_context to a new value" do
+      new_context = VirtFS::Context.new
+      expect(@my_context_manager[:new_key] = new_context).to eq(new_context)
+      expect(@my_context_manager.current_context).to eq(@my_context_manager[:default])
+      @my_context_manager.current_context = :new_key
+      expect(@my_context_manager.current_context).to eq(@my_context_manager[:new_key])
+    end
+  end
+
+  describe "#activated?" do
+    after(:each) do
+      @my_context_manager.deactivate! if @my_context_manager.activated?
+    end
+
+    it "should return false by default" do
+      expect(@my_context_manager.activated?).to be false
+    end
+
+    it "should return true when activated" do
+      @my_context_manager.activate!(:default)
+      expect(@my_context_manager.activated?).to be true
+    end
+  end
+
+  describe "#activate!" do
+    after(:each) do
+      @my_context_manager.deactivate! if @my_context_manager.activated?
+    end
+
+    it "should raise RuntimeError when key doesn't exist" do
+      expect do
+        @my_context_manager.activate!(:new_key)
+      end.to raise_exception(RuntimeError, "Context for given key doesn't exist")
+    end
+
+    it "should raise RuntimeError when already activated" do
+      @my_context_manager.activate!(:default)
+      expect do
+        @my_context_manager.activate!(:default)
+      end.to raise_exception(RuntimeError, "Context already activated")
+    end
+
+    it "should cause activated? to return true" do
+      expect(@my_context_manager.activated?).to be false
+      @my_context_manager.activate!(:default)
+      expect(@my_context_manager.activated?).to be true
+    end
+
+    it "should return the pre-activation context" do
+      new_context = VirtFS::Context.new
+      @my_context_manager[:new_key] = new_context
+      prev_context = @my_context_manager.current_context
+      expect(new_context).not_to eq(prev_context)
+      expect(@my_context_manager.activate!(:new_key)).to eq(prev_context)
+    end
+
+    it "should change the current context" do
+      new_context = VirtFS::Context.new
+      @my_context_manager[:new_key] = new_context
+      expect(@my_context_manager[:default]).not_to eq(new_context)
+      expect(@my_context_manager.current_context).to eq(@my_context_manager[:default])
+      @my_context_manager.activate!(:new_key)
+      expect(@my_context_manager.current_context).to eq(new_context)
+    end
+  end
+
+  describe "#deactivate!" do
+    it "should raise RuntimeError when not activated" do
+      expect do
+        @my_context_manager.deactivate!
+      end.to raise_exception(RuntimeError, "Context not activated")
+    end
+
+    it "should cause activated? to return false" do
+      expect(@my_context_manager.activated?).to be false
+      @my_context_manager.activate!(:default)
+      expect(@my_context_manager.activated?).to be true
+      @my_context_manager.deactivate!
+      expect(@my_context_manager.activated?).to be false
+    end
+
+    it "should return the pre-deactivated context" do
+      new_context = VirtFS::Context.new
+      @my_context_manager[:new_key] = new_context
+      @my_context_manager.activate!(:new_key)
+      expect(@my_context_manager.deactivate!).to eq(new_context)
+    end
+
+    it "should restore original context" do
+      context0 = @my_context_manager.current_context
+      new_context = VirtFS::Context.new
+      @my_context_manager[:new_key] = new_context
+      @my_context_manager.activate!(:new_key)
+      expect(@my_context_manager.current_context).not_to eq(context0)
+      @my_context_manager.deactivate!
+      expect(@my_context_manager.current_context).to eq(context0)
+    end
+  end
+
+  describe "#with" do
+    it "should raise RuntimeError when key doesn't exist" do
+      expect do
+        @my_context_manager.with(:new_key) {}
+      end.to raise_exception(RuntimeError, "Context for given key doesn't exist")
+    end
+
+    it "should raise RuntimeError when already activated" do
+      @my_context_manager.activate!(:default)
+      expect do
+        @my_context_manager.with(:default) {}
+      end.to raise_exception(RuntimeError, "Context already activated")
+    end
+
+    it "should cause activated? to return true within the block" do
+      expect(@my_context_manager.activated?).to be false
+      @my_context_manager.with(:default) do
+        expect(@my_context_manager.activated?).to be true
+      end
+      expect(@my_context_manager.activated?).to be false
+    end
+
+    it "should save and restore original context" do
+      context0 = @my_context_manager.current_context
+      new_context = VirtFS::Context.new
+      @my_context_manager[:new_key] = new_context
+      @my_context_manager.with(:new_key) do
+        expect(@my_context_manager.current_context).not_to eq(context0)
+        expect(@my_context_manager.current_context).to eq(new_context)
+      end
+      expect(@my_context_manager.current_context).to eq(context0)
+    end
+  end
+
+  describe "#without" do
+    it "should not change the current context when not activated" do
+      context0 = @my_context_manager.current_context
+      @my_context_manager.without do
+        expect(@my_context_manager.current_context).to eq(context0)
+      end
+      expect(@my_context_manager.current_context).to eq(context0)
+    end
+
+    it "should deactivate the context for the duration of the block" do
+      context0 = @my_context_manager.current_context
+      new_context = VirtFS::Context.new
+      @my_context_manager[:new_key] = new_context
+      @my_context_manager.with(:new_key) do
+        expect(@my_context_manager.current_context).not_to eq(context0)
+        expect(@my_context_manager.current_context).to eq(new_context)
+
+        @my_context_manager.without do
+          expect(@my_context_manager.current_context).to eq(context0)
+        end
+
+        expect(@my_context_manager.current_context).to eq(new_context)
+      end
+      expect(@my_context_manager.current_context).to eq(context0)
+    end
+  end
+end