virtfs 0.0.1

data/spec/kernel_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+describe "Load/Require operations through VirtFS -" do
+  before(:all) do
+    @root           = VfsRealFile::SEPARATOR
+    @mnt            = VfsRealDir.mktmpdir
+    @top_dir        = "Dir1"
+
+    @rb_file        = "hello_world.rb"
+    @lib_name       = "hello_world"
+    @module_name    = 'HelloWorld'
+
+    @rb_code = <<-END_OF_CODE
+      module #{@module_name}
+        def self.hello
+          "Hello World!"
+        end
+      end
+    END_OF_CODE
+
+    @dir_full_path  = VfsRealFile.join(@mnt, @top_dir)
+    @file_full_path = VfsRealFile.join(@dir_full_path, @rb_file)
+
+    reset_context
+
+    @native_fs1  = nativefs_class.new
+    VirtFS.mount(@native_fs1, @root) # mount / on /
+  end
+
+  after(:all) do
+    VirtFS.umount(@root) if VirtFS.mounted?(@root)
+    VfsRealDir.rmdir(@mnt)
+  end
+
+  before(:each) do
+    @tmp_dir = VfsRealDir.mktmpdir # The subdirectory to mount
+
+    @native_fs2 = nativefs_class.new(@tmp_dir)
+    VirtFS.mount(@native_fs2, @mnt)  # mount @tmp_dir on @mnt
+
+    VirtFS::VDir.mkdir(@dir_full_path)
+    VirtFS::VFile.open(@file_full_path, "w") do |f|
+      f.write(@rb_code)
+    end
+  end
+
+  after(:each) do
+    VirtFS.umount(@mnt) if VirtFS.mounted?(@mnt)
+    FileUtils.remove_dir(@tmp_dir)
+  end
+
+  context "inject" do
+    before(:each) do
+      VirtFS::Kernel.withdraw
+    end
+
+    context "pre injection" do
+      it "virtfs_original_require should be undefined" do
+        expect(::Kernel.private_method_defined?(:virtfs_original_require)).to be false
+      end
+
+      it "virtfs_original_load should be undefined" do
+        expect(::Kernel.private_method_defined?(:virtfs_original_load)).to be false
+      end
+
+      it "virtfs_require should be undefined" do
+        expect(::Kernel.private_method_defined?(:virtfs_require)).to be false
+      end
+
+      it "virtfs_load should be undefined" do
+        expect(::Kernel.private_method_defined?(:virtfs_load)).to be false
+      end
+    end
+
+    context "post injection" do
+      it "virtfs_original_require should be defined" do
+        VirtFS::Kernel.inject
+        expect(::Kernel.private_method_defined?(:virtfs_original_require)).to be true
+      end
+
+      it "virtfs_original_load should be defined" do
+        VirtFS::Kernel.inject
+        expect(::Kernel.private_method_defined?(:virtfs_original_load)).to be true
+      end
+
+      it "virtfs_require should be defined" do
+        VirtFS::Kernel.inject
+        expect(::Kernel.private_method_defined?(:virtfs_require)).to be true
+      end
+
+      it "virtfs_load should be defined" do
+        VirtFS::Kernel.inject
+        expect(::Kernel.private_method_defined?(:virtfs_load)).to be true
+      end
+    end
+  end
+
+  context "withdraw" do
+    before(:each) do
+      VirtFS::Kernel.inject
+    end
+
+    context "pre withdraw" do
+      it "virtfs_original_require should be defined" do
+        expect(::Kernel.private_method_defined?(:virtfs_original_require)).to be true
+      end
+
+      it "virtfs_original_load should be defined" do
+        expect(::Kernel.private_method_defined?(:virtfs_original_load)).to be true
+      end
+
+      it "virtfs_require should be defined" do
+        expect(::Kernel.private_method_defined?(:virtfs_require)).to be true
+      end
+
+      it "virtfs_load should be defined" do
+        expect(::Kernel.private_method_defined?(:virtfs_load)).to be true
+      end
+    end
+
+    context "post withdraw" do
+      it "virtfs_original_require should be undefined" do
+        VirtFS::Kernel.withdraw
+        expect(::Kernel.private_method_defined?(:virtfs_original_require)).to be false
+      end
+
+      it "virtfs_original_load should be undefined" do
+        VirtFS::Kernel.withdraw
+        expect(::Kernel.private_method_defined?(:virtfs_original_load)).to be false
+      end
+
+      it "virtfs_require should be undefined" do
+        VirtFS::Kernel.withdraw
+        expect(::Kernel.private_method_defined?(:virtfs_require)).to be false
+      end
+
+      it "virtfs_load should be undefined" do
+        VirtFS::Kernel.withdraw
+        expect(::Kernel.private_method_defined?(:virtfs_load)).to be false
+      end
+    end
+  end
+
+  context "Check source file" do
+    context "Not Activated" do
+      it "Should exist under MetakitFS" do
+        expect(VirtFS::VFile.exist?(@file_full_path)).to be true
+      end
+
+      it "Should not be visible outside of VirtFS" do
+        expect(VfsRealFile.exist?(@file_full_path)).to be false
+      end
+
+      it "Should be of expected size" do
+        expect(VirtFS::VFile.size(@file_full_path)).to eq(@rb_code.length)
+      end
+
+      it "Should contain expected code" do
+        expect(VirtFS::VFile.read(@file_full_path)).to eq(@rb_code)
+      end
+    end
+
+    context "Activated" do
+      it "Should exist under MetakitFS" do
+        VirtFS.with do
+          expect(File.exist?(@file_full_path)).to be true
+        end
+      end
+
+      it "Should be of expected size" do
+        VirtFS.with do
+          expect(File.size(@file_full_path)).to eq(@rb_code.length)
+        end
+      end
+
+      it "Should contain expected code" do
+        VirtFS.with do
+          expect(File.read(@file_full_path)).to eq(@rb_code)
+        end
+      end
+    end
+  end
+
+  context "load" do
+    before(:each) do
+      Object.send(:remove_const, @module_name) if Object.const_defined?(@module_name)
+    end
+
+    context "Activated" do
+      it "Should return true on successful load" do
+        VirtFS::Kernel.inject
+        VirtFS.with do
+          VirtFS::Kernel.enable # Add option to activate
+          expect(load(@file_full_path)).to be true
+          VirtFS::Kernel.disable
+        end
+      end
+
+      it "Should load code as expected" do
+        VirtFS::Kernel.inject
+        VirtFS.with do
+          VirtFS::Kernel.enable # Add option to activate
+          expect(load(@file_full_path)).to be true
+          VirtFS::Kernel.disable
+          mod = Object.const_get(@module_name)
+          expect(mod.hello).to eq("Hello World!")
+        end
+      end
+    end
+
+    context "Not Activated" do
+      it "Should raise LoadError" do
+        expect do
+          load(@file_full_path)
+        end.to raise_error(
+          LoadError, /cannot load such file/
+        )
+      end
+    end
+  end
+
+  context "require" do
+    before(:each) do
+      Object.send(:remove_const, @module_name) if Object.const_defined?(@module_name)
+      $LOADED_FEATURES.delete(@file_full_path)
+      $LOAD_PATH.delete(@dir_full_path)
+    end
+
+    context "Activated" do
+      it "Should raise LoadError when not in $LOAD_PATH" do
+        VirtFS.with(true) do
+          expect do
+            require(@lib_name)
+          end.to raise_error(
+            LoadError, /cannot load such file/
+          )
+        end
+      end
+
+      it "Should return true when loaded" do
+        $LOAD_PATH << @dir_full_path
+        VirtFS.with(true) do
+          expect(require(@lib_name)).to be true
+        end
+      end
+
+      it "Should return false when already loaded" do
+        $LOAD_PATH << @dir_full_path
+        VirtFS.with(true) do
+          expect(require(@lib_name)).to be true
+          expect(require(@lib_name)).to be false
+        end
+      end
+
+      it "Should add the lib's canonical name to $LOADED_FEATURES" do
+        $LOAD_PATH << @dir_full_path
+        VirtFS.with(true) do
+          expect(require(@lib_name)).to be true
+          expect($LOADED_FEATURES.include?(@file_full_path))
+        end
+      end
+
+      it "Should load the code as expected" do
+        $LOAD_PATH << @dir_full_path
+        VirtFS.with(true) do
+          expect(require(@lib_name)).to be true
+          expect(Object.const_defined?(@module_name)).to be true
+          mod = Object.const_get(@module_name)
+          expect(mod.hello).to eq("Hello World!")
+        end
+      end
+    end
+
+    context "Not Activated" do
+      it "Should raise LoadError" do
+        $LOAD_PATH << @dir_full_path
+        expect do
+          require(@lib_name)
+        end.to raise_error(
+          LoadError, /cannot load such file/
+        )
+      end
+    end
+  end
+end

data/spec/mount_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe VirtFS, "mount indirection (#{$fs_interface} interface) -" do
+  before(:all) do
+    @full_path = File.expand_path(__FILE__)
+    @rel_path  = File.basename(@full_path)
+    @this_dir  = File.dirname(@full_path)
+    @root      = File::SEPARATOR
+  end
+
+  before(:each) do
+    reset_context
+  end
+
+  describe ".mount" do
+    before(:each) do
+      @native_fs = nativefs_class.new
+    end
+
+    context "single filesystem:" do
+      it "should raise RuntimeError when an invalid filesystem is provided" do
+        expect do
+          VirtFS.mount(nil, @root)
+        end.to raise_error(
+          RuntimeError, "mount: invalid filesystem object #{nil.class.name}"
+        )
+      end
+
+      it "should raise Errno::ENOENT when mount point doesn't exist" do
+        expect do
+          VirtFS.mount(@native_fs, @this_dir)
+        end.to raise_error(
+          Errno::ENOENT, "No such file or directory - #{@this_dir}"
+        )
+      end
+
+      it "should raise RuntimeError when attempting to reuse mount point" do
+        expect do
+          VirtFS.mount(@native_fs, @root)
+          VirtFS.mount(nativefs_class.new, @root)
+        end.to raise_error(
+          RuntimeError, "mount: mount point #{@root} is busy"
+        )
+      end
+
+      it "should raise RuntimeError when attempting to mount a mounted filesystem" do
+        expect do
+          VirtFS.mount(@native_fs, @root)
+          VirtFS.mount(@native_fs, @this_dir)
+        end.to raise_error(
+          RuntimeError, "mount: filesystem is busy"
+        )
+      end
+
+      it "should return nil on successful mount" do
+        expect(VirtFS.mount(@native_fs, @root)).to be_nil
+      end
+    end
+
+    context "second filesystem:" do
+      before(:each) do
+        @native_fs2 = nativefs_class.new
+        VirtFS.mount(@native_fs, @root)
+      end
+
+      it "should raise RuntimeError when attempting to reuse mount point" do
+        expect do
+          VirtFS.mount(@native_fs2, @this_dir)
+          VirtFS.mount(nativefs_class.new, @this_dir)
+        end.to raise_error(
+          RuntimeError, "mount: mount point #{@this_dir} is busy"
+        )
+      end
+
+      it "should return nil on successful mount" do
+        expect(VirtFS.mount(@native_fs2, @this_dir)).to be_nil
+      end
+    end
+  end
+
+  describe ".umount" do
+    before(:each) do
+      @native_fs = nativefs_class.new
+    end
+
+    it "should raise RuntimeError when nothing mounted on mount point" do
+      VirtFS.mount(@native_fs, @root)
+      expect do
+        VirtFS.umount(@this_dir)
+      end.to raise_error(
+        RuntimeError, "umount: nothing mounted on #{@this_dir}"
+      )
+    end
+
+    it "should return nil on successful umount" do
+      VirtFS.mount(@native_fs, @root)
+      expect(VirtFS.umount(@root)).to be_nil
+    end
+
+    it "should enable re-mount" do
+      VirtFS.mount(@native_fs, @root)
+      VirtFS.umount(@root)
+      expect(VirtFS.mount(@native_fs, @root)).to be_nil
+    end
+  end
+
+  describe ".path_lookup" do
+    context "with no filesystems mounted" do
+      it "should raise Errno::ENOENT" do
+        expect do
+          VirtFS.path_lookup(@full_path)
+        end.to raise_error(
+          Errno::ENOENT, "No such file or directory - #{@full_path}"
+        )
+      end
+
+      it "should raise Errno::ENOENT with original path in message" do
+        expect do
+          VirtFS.path_lookup(@rel_path)
+        end.to raise_error(
+          Errno::ENOENT, "No such file or directory - #{@rel_path}"
+        )
+      end
+    end
+
+    context "with FS mounted on #{@root}" do
+      before(:each) do
+        @native_fs = nativefs_class.new
+        VirtFS.mount(@native_fs, @root)
+      end
+
+      it "should return native_fs, when given fully qualified path" do
+        fs, _path = VirtFS.path_lookup(@full_path)
+        expect(fs).to eq(@native_fs)
+      end
+
+      it "should return the full path, when given fully qualified path" do
+        _fs, path = VirtFS.path_lookup(@full_path)
+        expect(path).to eq(@full_path) # .sub(@native_fs.mount_point, '')
+      end
+
+      it "should return native_fs, when given relative path" do
+        VirtFS.dir_chdir(@this_dir)
+        fs, _path = VirtFS.path_lookup(@rel_path)
+        expect(fs).to eq(@native_fs)
+      end
+
+      it "should return the full path, when given relative path" do
+        VirtFS.dir_chdir(@this_dir)
+        _fs, path = VirtFS.path_lookup(@rel_path)
+        expect(path).to eq(@full_path) # .sub(@native_fs.mount_point, '')
+      end
+    end
+
+    context "with FS mounted on #{@this_dir}" do
+      before(:each) do
+        @native_fs  = nativefs_class.new
+        @native_fs2 = nativefs_class.new
+        VirtFS.mount(@native_fs,  @root)
+        VirtFS.mount(@native_fs2, @this_dir)
+      end
+
+      it "should return native_fs2, when given fully qualified path" do
+        fs, _path = VirtFS.path_lookup(@full_path)
+        expect(fs).to eq(@native_fs2)
+      end
+
+      it "should return the path relative to the mount point, when given fully qualified path" do
+        _fs, path = VirtFS.path_lookup(@full_path)
+        expect(path).to eq(@full_path.sub(@native_fs2.mount_point, File::SEPARATOR))
+      end
+
+      it "should return native_fs2, when given relative path" do
+        VirtFS.dir_chdir(@this_dir)
+        fs, _path = VirtFS.path_lookup(@rel_path)
+        expect(fs).to eq(@native_fs2)
+      end
+
+      it "should return the path relative to the mount point, when given relative path" do
+        VirtFS.dir_chdir(@this_dir)
+        _fs, path = VirtFS.path_lookup(@rel_path)
+        expect(path).to eq(@full_path.sub(@native_fs2.mount_point, File::SEPARATOR))
+      end
+    end
+  end
+end