isolate 1.10.2 → 2.0.0.pre.0

data/test/test_isolate.rb

@@ -1,25 +1,13 @@
-require "minitest/autorun"
-require "rubygems/dependency_installer"
-require "rubygems/requirement"
+require "isolate/test"
+
 require "isolate"
 
-class TestIsolate < MiniTest::Unit::TestCase
+class TestIsolate < Isolate::Test
   WITH_HOE = "test/fixtures/with-hoe"
 
-  def setup
-    @isolate = Isolate.new "tmp/gems", :install => false, :verbose => false
-    @env     = ENV.to_hash
-
-    Gem.loaded_specs.clear
-  end
-
   def teardown
-    @isolate.disable
-    Isolate.instance.disable if Isolate.instance
-    Gem::DependencyInstaller.reset_value
-    Gem::Uninstaller.reset_value
-    FileUtils.rm_rf "tmp/gems"
-    ENV.replace @env
+    Isolate.sandbox.disable if Isolate.sandbox
+    super
   end
 
   def test_self_env
@@ -40,233 +28,15 @@ class TestIsolate < MiniTest::Unit::TestCase
     assert_equal "baz", Isolate.env
   end
 
-  def test_self_gems
-    assert_nil Isolate.instance
+  def test_self_now!
+    assert_nil Isolate.sandbox
 
-    Isolate.gems WITH_HOE do
+    Isolate.now! :path => WITH_HOE, :multiruby => false, :system => false do
       gem "hoe"
     end
 
-    refute_nil Isolate.instance
-    assert_equal File.expand_path(WITH_HOE), Isolate.instance.path
-    assert_equal "hoe", Isolate.instance.entries.first.name
-  end
-
-  def test_activate
-    @isolate = Isolate.new WITH_HOE
-
-    assert_nil Gem.loaded_specs["hoe"]
-
-    @isolate.gem "hoe"
-    @isolate.activate
-
-    refute_nil Gem.loaded_specs["hoe"]
-  end
-
-  def test_activate_environment
-    @isolate = Isolate.new WITH_HOE, :verbose => false
-    @isolate.gem "rubyforge"
-
-    @isolate.environment "borg" do
-      gem "hoe"
-    end
-
-    @isolate.activate
-    assert_nil Gem.loaded_specs["hoe"]
-    refute_nil Gem.loaded_specs["rubyforge"]
-  end
-
-  def test_activate_environment_explicit
-    @isolate = Isolate.new WITH_HOE
-
-    @isolate.gem "rubyforge"
-
-    @isolate.environment "borg" do
-      gem "hoe"
-    end
-
-    @isolate.activate "borg"
-    refute_nil Gem.loaded_specs["hoe"]
-    refute_nil Gem.loaded_specs["rubyforge"]
-  end
-
-  def test_activate_install
-    @isolate = Isolate.new "tmp/gems", :install => true, :verbose => false
-
-    @isolate.gem "foo"
-
-    # rescuing because activate, well, actually tries to activate
-    begin; @isolate.activate; rescue Gem::LoadError; end
-
-    assert_equal ["foo", Gem::Requirement.default],
-      Gem::DependencyInstaller.value.shift
-  end
-
-  def test_activate_install_environment
-    @isolate = Isolate.new "tmp/gems", :install => true
-    @isolate.environment(:nope) { gem "foo" }
-
-    @isolate.activate
-    assert_empty Gem::DependencyInstaller.value
-  end
-
-  def test_activate_ret
-    assert_equal @isolate, @isolate.activate
-  end
-
-  # TODO: cleanup with 2 versions of same gem, 1 activated
-  # TODO: install with 1 older version, 1 new gem to be installed
-
-  def test_cleanup
-    @isolate = Isolate.new WITH_HOE, :verbose => false
-    # no gems specified on purpose
-    @isolate.activate
-
-    expected = [["hoe",       "2.3.3", WITH_HOE],
-                ["rake",      "0.8.7", WITH_HOE],
-                ["rubyforge", "1.0.4", WITH_HOE]]
-
-    assert_equal expected, Gem::Uninstaller.value
-  end
-
-  def test_disable
-    home, path, bin = ENV.values_at "GEM_HOME", "GEM_PATH", "PATH"
-    load_path  = $LOAD_PATH.dup
-
-    @isolate.enable
-
-    refute_equal home, ENV["GEM_HOME"]
-    refute_equal path, ENV["GEM_PATH"]
-    refute_equal bin,  ENV["PATH"]
-
-    refute_equal load_path, $LOAD_PATH
-
-    @isolate.disable
-
-    assert_equal home, ENV["GEM_HOME"]
-    assert_equal path, ENV["GEM_PATH"]
-    assert_equal bin,  ENV["PATH"]
-    assert_equal load_path, $LOAD_PATH
-  end
-
-  def test_disable_ret
-    assert_equal @isolate, @isolate.disable
-  end
-
-  def test_enable
-    refute_empty Gem.find_files("minitest/unit.rb"),
-      "There's a minitest/unit in the current env, since we're running it."
-
-    @isolate.enable
-
-    assert_equal @isolate.path, ENV["GEM_PATH"]
-    assert_equal @isolate.path, ENV["GEM_HOME"]
-    assert ENV["PATH"].include?(File.join(@isolate.path, "bin")), "in path"
-
-    assert_equal [], Gem.find_files("minitest/unit.rb"),
-      "Can't find minitest/unit now, 'cause we're activated!"
-
-    assert_empty Gem.loaded_specs
-    assert_equal [@isolate.path], Gem.path
-  end
-
-  def test_enable_ret
-    assert_equal @isolate, @isolate.enable
-  end
-
-  def test_environment
-    @isolate.gem "none"
-
-    @isolate.environment "test", "ci" do
-      gem "test-ci"
-
-      environment "production" do
-        gem "test-ci-production"
-      end
-    end
-
-    none, test_ci, test_ci_production = @isolate.entries
-
-    assert_equal [], none.environments
-    assert_equal %w(test ci), test_ci.environments
-    assert_equal %w(test ci production), test_ci_production.environments
-  end
-
-  def test_gem
-    g = @isolate.gem "foo"
-    assert_includes @isolate.entries, g
-
-    assert_equal "foo", g.name
-    assert_equal Gem::Requirement.create(">= 0"), g.requirement
-  end
-
-  def test_gem_multi_requirements
-    g = @isolate.gem "foo", "= 1.0", "< 2.0"
-    assert_equal Gem::Requirement.create(["= 1.0", "< 2.0"]), g.requirement
-  end
-
-  def test_gem_options
-    g = @isolate.gem "foo", :source => "somewhere"
-    assert_equal "somewhere", g.options[:source]
-  end
-
-  def test_initialize
-    i = Isolate.new "foo/gems"
-    assert_equal File.expand_path("foo/gems"), i.path
-  end
-
-  def test_initialize_block
-    i = Isolate.new "foo/gems" do
-      gem "hoe"
-    end
-
-    assert_equal "hoe", i.entries.first.name
-  end
-
-  def test_initialize_options
-    i = Isolate.new "foo/gems"
-    assert i.install?
-    assert i.verbose?
-    assert i.cleanup?
-
-    i = Isolate.new "foo/gems",
-      :cleanup => false, :install => false, :verbose => false
-
-    refute i.cleanup?
-    refute i.install?
-    refute i.verbose?
-
-    i = Isolate.new "foo/gems", :install => false
-    refute i.cleanup?, "no install, no cleanup"
-
-    i = Isolate.new "foo/gems", :file => "test/fixtures/isolate.rb"
-    assert_equal "hoe", i.entries.first.name
-  end
-end
-
-module BrutalStub
-  @@value = []
-  def value; @@value end
-  def reset_value; value.clear end
-end
-
-class Gem::DependencyInstaller
-  extend BrutalStub
-
-  alias old_install install
-  def install name, requirement
-    self.class.value << [name, requirement]
-  end
-end
-
-class Gem::Uninstaller
-  extend BrutalStub
-
-  attr_reader :gem, :version, :gem_home
-  alias old_uninstall uninstall
-  def uninstall
-    self.class.value << [self.gem,
-                         self.version.to_s,
-                         self.gem_home.sub(Dir.pwd + "/", '')]
+    refute_nil Isolate.sandbox
+    assert_equal File.expand_path(WITH_HOE), Isolate.sandbox.path
+    assert_equal "hoe", Isolate.sandbox.entries.first.name
   end
 end

data/test/test_isolate_entry.rb

@@ -0,0 +1,86 @@
+require "isolate/entry"
+require "isolate/test"
+
+class TestIsolateEntry < Isolate::Test
+  def setup
+    @sandbox = Object.new
+    def @sandbox.environments; @e ||= [] end
+    def @sandbox.path; "tmp/gems" end
+
+    super
+  end
+
+  def test_initialize
+    @sandbox.environments.concat %w(foo bar)
+
+    entry = e "baz", "> 1.0", "< 2.0", :quux => :corge
+
+    assert_equal %w(foo bar), entry.environments
+    assert_equal "baz", entry.name
+    assert_equal Gem::Requirement.new("> 1.0", "< 2.0"), entry.requirement
+    assert_equal :corge, entry.options[:quux]
+
+    entry = e "plugh"
+
+    assert_equal Gem::Requirement.default, entry.requirement
+    assert_equal({}, entry.options)
+  end
+
+  def test_install_file
+    file  = "test/fixtures/blort-0.0.gem"
+    entry = e file
+    entry.install
+
+    assert_equal File.expand_path(file),
+      Gem::DependencyInstaller.value.first.first
+  end
+
+  def test_matches?
+    @sandbox.environments << "test"
+    entry = e "hi"
+
+    assert entry.matches?("test")
+    assert !entry.matches?("double secret production")
+
+    entry.environments.clear
+    assert entry.matches?("double secret production")
+  end
+
+  def test_matches_spec?
+    entry = e "hi", "1.1"
+
+    assert entry.matches_spec?(spec "hi", "1.1")
+    assert !entry.matches_spec?(spec "bye", "1.1")
+    assert !entry.matches_spec?(spec "hi", "1.2")
+  end
+
+  def test_update
+    entry = e "hi", "1.1"
+
+    assert_equal [], entry.environments
+
+    @sandbox.environments.concat %w(corge corge plugh)
+    entry.update
+
+    assert_equal %w(corge plugh), entry.environments
+
+    entry.update :foo => :bar
+    entry.update :bar => :baz
+
+    assert_equal({ :foo => :bar, :bar => :baz }, entry.options)
+
+    entry.update :args => "--first"
+    entry.update :args => "--second"
+    assert_equal "--second", entry.options[:args]
+  end
+
+  def e *args
+    Isolate::Entry.new @sandbox, *args
+  end
+
+  Spec = Struct.new :name, :version
+
+  def spec name, version
+    Spec.new name, Gem::Version.new(version)
+  end
+end

data/test/test_isolate_sandbox.rb

@@ -0,0 +1,275 @@
+require "isolate/test"
+
+class TestIsolateSandbox < Isolate::Test
+  WITH_HOE = "test/fixtures/with-hoe"
+
+  def setup
+    @sandbox = sandbox
+    super
+  end
+
+  def test_activate
+    @sandbox = sandbox :path => WITH_HOE
+
+    refute_loaded_spec "hoe"
+    @sandbox.gem "hoe"
+
+    result = @sandbox.activate
+    assert_equal @sandbox, result
+    assert_loaded_spec "hoe"
+  end
+
+  def test_activate_environment_explicit
+    @sandbox = sandbox :path => WITH_HOE
+
+    @sandbox.gem "rubyforge"
+    @sandbox.environment(:borg) { gem "hoe" }
+    @sandbox.activate :borg
+
+    assert_loaded_spec "hoe"
+    assert_loaded_spec "rubyforge"
+  end
+
+  def test_activate_environment_implicit
+    s = sandbox :path => WITH_HOE
+
+    s.gem "rubyforge"
+    s.environment(:borg) { gem "hoe" }
+
+    s.activate
+    refute_loaded_spec "hoe"
+    assert_loaded_spec "rubyforge"
+  end
+
+  def test_activate_install
+    s = sandbox :path => WITH_HOE, :install => true
+    s.gem "foo"
+
+    # rescuing because activate, well, actually tries to activate
+    begin; s.activate; rescue Gem::LoadError; end
+
+    assert_equal ["foo", Gem::Requirement.default],
+      Gem::DependencyInstaller.value.shift
+  end
+
+  # TODO: cleanup with 2 versions of same gem, 1 activated
+  # TODO: install with 1 older version, 1 new gem to be installed
+
+  def test_cleanup
+    s = sandbox :path => WITH_HOE, :install => true, :cleanup => true
+    s.activate # no gems on purpose
+
+    expected = [["hoe",       "2.3.3", WITH_HOE],
+                ["rake",      "0.8.7", WITH_HOE],
+                ["rubyforge", "1.0.4", WITH_HOE]]
+
+    assert_equal expected, Gem::Uninstaller.value
+  end
+
+  def test_disable
+    home, path, bin = ENV.values_at "GEM_HOME", "GEM_PATH", "PATH"
+    load_path  = $LOAD_PATH.dup
+
+    @sandbox.enable
+
+    refute_equal home, ENV["GEM_HOME"]
+    refute_equal path, ENV["GEM_PATH"]
+    refute_equal bin,  ENV["PATH"]
+
+    refute_equal load_path, $LOAD_PATH
+
+    result = @sandbox.disable
+    assert_same @sandbox, result
+
+    assert_equal home, ENV["GEM_HOME"]
+    assert_equal path, ENV["GEM_PATH"]
+    assert_equal bin,  ENV["PATH"]
+    assert_equal load_path, $LOAD_PATH
+  end
+
+  def test_enable
+    refute_empty Gem.find_files("hoe.rb"),
+      "There's a hoe.rb somewhere in the current env."
+
+    assert_same @sandbox, @sandbox.enable
+
+    assert_equal @sandbox.path, ENV["GEM_PATH"]
+    assert_equal @sandbox.path, ENV["GEM_HOME"]
+    assert ENV["PATH"].include?(File.join(@sandbox.path, "bin")), "in path"
+
+    assert_equal [], Gem.find_files("hoe.rb"),
+      "Can't find hoe.rb now, 'cause we're activated!"
+
+    assert_empty Gem.loaded_specs
+    assert_equal [@sandbox.path], Gem.path
+  end
+
+  def test_enable_idempotent_path_env
+    bin  = File.join @sandbox.path, "bin"
+    path = ENV["PATH"] = [bin, ENV["PATH"]].join(File::PATH_SEPARATOR)
+
+    @sandbox.enable
+    assert_equal path, ENV["PATH"]
+  end
+
+  def test_idempotent_rubyopt_env
+    @sandbox.enable
+    rubyopt = ENV["RUBYOPT"]
+    @sandbox.disable
+
+    refute_equal rubyopt, ENV["RUBYOPT"]
+
+    ENV["RUBYOPT"] = rubyopt
+    @sandbox.enable
+    assert_equal rubyopt, ENV["RUBYOPT"]
+  end
+
+  def test_environment
+    @sandbox.gem "none"
+
+    @sandbox.environment "test", "ci" do
+      gem "test-ci"
+
+      environment "production" do
+        gem "test-ci-production"
+      end
+    end
+
+    none, test_ci, test_ci_production = @sandbox.entries
+
+    assert_equal [], none.environments
+    assert_equal %w(test ci), test_ci.environments
+    assert_equal %w(test ci production), test_ci_production.environments
+  end
+
+  def test_gem
+    g = @sandbox.gem "foo"
+    assert_includes @sandbox.entries, g
+
+    assert_equal "foo", g.name
+    assert_equal Gem::Requirement.create(">= 0"), g.requirement
+  end
+
+  def test_gem_multi_calls
+    g  = @sandbox.gem "foo"
+    g2 = @sandbox.gem "foo", :foo => :bar
+
+    @sandbox.gem "foo", :bar => :baz
+
+    assert_same g, g2
+    assert_equal :bar, g.options[:foo]
+    assert_equal :baz, g.options[:bar]
+
+    @sandbox.gem "foo", "> 1.7"
+    assert_equal Gem::Requirement.new("> 1.7"), g.requirement
+
+    @sandbox.environment :corge do
+      gem "foo"
+    end
+
+    @sandbox.environment :plurgh do
+      gem "foo"
+    end
+
+    assert_equal %w(corge plurgh), g.environments
+  end
+
+  def test_gem_multi_requirements
+    g = @sandbox.gem "foo", "= 1.0", "< 2.0"
+    assert_equal Gem::Requirement.create(["= 1.0", "< 2.0"]), g.requirement
+  end
+
+  def test_gem_options
+    g = @sandbox.gem "foo", :source => "somewhere"
+    assert_equal "somewhere", g.options[:source]
+  end
+
+  def test_initialize_defaults
+    s = Isolate::Sandbox.new
+
+    assert_equal [], s.entries
+    assert_equal [], s.environments
+    assert_match(/tmp\/isolate/, s.path)
+
+    assert s.cleanup?
+    assert s.install?
+    assert s.system?
+    assert s.verbose?
+    assert s.multiruby?
+  end
+
+  def test_initialize_override_defaults
+    s = Isolate::Sandbox.new :path => "x", :cleanup => false,
+      :install => false, :system => false,
+      :verbose => false, :multiruby => false
+
+    assert_equal File.expand_path("x"), s.path
+
+    refute s.cleanup?
+    refute s.install?
+    refute s.system?
+    refute s.verbose?
+    refute s.multiruby?
+  end
+
+  # First the specifically requested file, then the block (if given),
+  # THEN the local override file (if it exists).
+
+  def test_initialize_file_and_block
+    s = sandbox :file => "test/fixtures/override.rb" do
+      environment :foo do
+        gem "monkey", "2.0", :args => "--panic"
+      end
+    end
+
+    monkey = s.entries.first
+
+    assert_equal %w(foo bar), monkey.environments
+    assert_equal "--asplode", monkey.options[:args]
+    assert_equal Gem::Requirement.new("2.0"), monkey.requirement
+  end
+
+  def test_options
+    @sandbox.options :hello => :monkey
+    assert_equal :monkey, @sandbox.options[:hello]
+  end
+
+  def test_path
+    s = sandbox :multiruby => false do
+      path "tmp/foo"
+    end
+
+    assert_equal File.expand_path("tmp/foo"), s.path
+
+    v = RbConfig::CONFIG.values_at("ruby_install_name", "ruby_version").join "-"
+    s = sandbox :multiruby => true
+    p = File.expand_path("tmp/isolate/#{v}")
+
+    assert_equal p, s.path
+
+    s = sandbox :path => "tmp/isolate/#{v}", :multiruby => false
+    assert_equal p, s.path
+  end
+
+  def assert_loaded_spec name
+    assert Gem.loaded_specs[name],
+      "#{name} is a loaded gemspec, and it shouldn't be!"
+  end
+
+  def refute_loaded_spec name
+    refute Gem.loaded_specs[name],
+      "#{name} is NOT a loaded gemspec, and it should be!"
+  end
+
+  def sandbox *args, &block
+    opts = {
+      :install   => false,
+      :system    => false,
+      :verbose   => false,
+      :multiruby => false
+    }
+
+    opts.merge! args.pop if Hash === args.last
+    Isolate::Sandbox.new opts, &block
+  end
+end