Postponing the Bundler merge.

  I faced a big issue about Bundler with ruby core.
  I have no time to resolve it issue before 2.5 final release.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@61416 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

7 files changed, 0 insertions, 1861 deletions

diff --git a/spec/bundler/other/bundle_ruby_spec.rb b/spec/bundler/other/bundle_ruby_spec.rb
deleted file mode 100644
index 87e1b8b085..0000000000
--- a/spec/bundler/other/bundle_ruby_spec.rb
+++ /dev/null
@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle_ruby", :ruby_repo, :bundler => "< 2" do
-  context "without patchlevel" do
-    it "returns the ruby version" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.9.3", :engine => 'ruby', :engine_version => '1.9.3'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("ruby 1.9.3")
-    end
-
-    it "engine defaults to MRI" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.9.3"
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("ruby 1.9.3")
-    end
-
-    it "handles jruby" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'jruby', :engine_version => '1.6.5'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("ruby 1.8.7 (jruby 1.6.5)")
-    end
-
-    it "handles rbx" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'rbx', :engine_version => '1.2.4'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("ruby 1.8.7 (rbx 1.2.4)")
-    end
-
-    it "raises an error if engine is used but engine version is not" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'rbx'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-      expect(exitstatus).not_to eq(0) if exitstatus
-
-      bundle_ruby
-      expect(out).to include("Please define :engine_version")
-    end
-
-    it "raises an error if engine_version is used but engine is not" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine_version => '1.2.4'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-      expect(exitstatus).not_to eq(0) if exitstatus
-
-      bundle_ruby
-      expect(out).to include("Please define :engine")
-    end
-
-    it "raises an error if engine version doesn't match ruby version for MRI" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'ruby', :engine_version => '1.2.4'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-      expect(exitstatus).not_to eq(0) if exitstatus
-
-      bundle_ruby
-      expect(out).to include("ruby_version must match the :engine_version for MRI")
-    end
-
-    it "should print if no ruby version is specified" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("No ruby version specified")
-    end
-  end
-
-  context "when using patchlevel" do
-    it "returns the ruby version" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.9.3", :patchlevel => '429', :engine => 'ruby', :engine_version => '1.9.3'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("ruby 1.9.3p429")
-    end
-
-    it "handles an engine" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.9.3", :patchlevel => '392', :engine => 'jruby', :engine_version => '1.7.4'
-
-        gem "foo"
-      G
-
-      bundle_ruby
-
-      expect(out).to include("ruby 1.9.3p392 (jruby 1.7.4)")
-    end
-  end
-end
diff --git a/spec/bundler/other/cli_dispatch_spec.rb b/spec/bundler/other/cli_dispatch_spec.rb
deleted file mode 100644
index a9d0bf7462..0000000000
--- a/spec/bundler/other/cli_dispatch_spec.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle command names" do
-  it "work when given fully" do
-    bundle "install"
-    expect(last_command.bundler_err).to eq("Could not locate Gemfile")
-    expect(last_command.stdboth).not_to include("Ambiguous command")
-  end
-
-  it "work when not ambiguous" do
-    bundle "ins"
-    expect(last_command.bundler_err).to eq("Could not locate Gemfile")
-    expect(last_command.stdboth).not_to include("Ambiguous command")
-  end
-
-  it "print a friendly error when ambiguous" do
-    bundle "in"
-    expect(last_command.bundler_err).to eq("Ambiguous command in matches [info, init, inject, install]")
-  end
-
-  context "when cache_command_is_package is set" do
-    before { bundle! "config cache_command_is_package true" }
-
-    it "dispatches `bundle cache` to the package command" do
-      bundle "cache --verbose"
-      expect(last_command.stdout).to start_with "Running `bundle package --no-color --verbose`"
-    end
-  end
-end
diff --git a/spec/bundler/other/compatibility_guard_spec.rb b/spec/bundler/other/compatibility_guard_spec.rb
deleted file mode 100644
index ac05ebd918..0000000000
--- a/spec/bundler/other/compatibility_guard_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundler compatibility guard" do
-  context "when the bundler version is 2+" do
-    before { simulate_bundler_version "2.0.a" }
-
-    context "when running on Ruby < 2.3", :ruby => "< 2.3" do
-      before { simulate_rubygems_version "2.6.11" }
-
-      it "raises a friendly error" do
-        bundle :version
-        expect(err).to eq("Bundler 2 requires Ruby 2.3 or later. Either install bundler 1 or update to a supported Ruby version.")
-      end
-    end
-
-    context "when running on RubyGems < 2.5", :ruby => ">= 2.5" do
-      before { simulate_rubygems_version "1.3.6" }
-
-      it "raises a friendly error" do
-        bundle :version
-        expect(err).to eq("Bundler 2 requires RubyGems 2.5 or later. Either install bundler 1 or update to a supported RubyGems version.")
-      end
-    end
-  end
-end
diff --git a/spec/bundler/other/ext_spec.rb b/spec/bundler/other/ext_spec.rb
deleted file mode 100644
index 3f6f8b4928..0000000000
--- a/spec/bundler/other/ext_spec.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Gem::Specification#match_platform" do
-  it "does not match platforms other than the gem platform" do
-    darwin = gem "lol", "1.0", "platform_specific-1.0-x86-darwin-10"
-    expect(darwin.match_platform(pl("java"))).to eq(false)
-  end
-
-  context "when platform is a string" do
-    it "matches when platform is a string" do
-      lazy_spec = Bundler::LazySpecification.new("lol", "1.0", "universal-mingw32")
-      expect(lazy_spec.match_platform(pl("x86-mingw32"))).to eq(true)
-      expect(lazy_spec.match_platform(pl("x64-mingw32"))).to eq(true)
-    end
-  end
-end
-
-RSpec.describe "Bundler::GemHelpers#generic" do
-  include Bundler::GemHelpers
-
-  it "converts non-windows platforms into ruby" do
-    expect(generic(pl("x86-darwin-10"))).to eq(pl("ruby"))
-    expect(generic(pl("ruby"))).to eq(pl("ruby"))
-  end
-
-  it "converts java platform variants into java" do
-    expect(generic(pl("universal-java-17"))).to eq(pl("java"))
-    expect(generic(pl("java"))).to eq(pl("java"))
-  end
-
-  it "converts mswin platform variants into x86-mswin32" do
-    expect(generic(pl("mswin32"))).to eq(pl("x86-mswin32"))
-    expect(generic(pl("i386-mswin32"))).to eq(pl("x86-mswin32"))
-    expect(generic(pl("x86-mswin32"))).to eq(pl("x86-mswin32"))
-  end
-
-  it "converts 32-bit mingw platform variants into x86-mingw32" do
-    expect(generic(pl("mingw32"))).to eq(pl("x86-mingw32"))
-    expect(generic(pl("i386-mingw32"))).to eq(pl("x86-mingw32"))
-    expect(generic(pl("x86-mingw32"))).to eq(pl("x86-mingw32"))
-  end
-
-  it "converts 64-bit mingw platform variants into x64-mingw32" do
-    expect(generic(pl("x64-mingw32"))).to eq(pl("x64-mingw32"))
-    expect(generic(pl("x86_64-mingw32"))).to eq(pl("x64-mingw32"))
-  end
-end
-
-RSpec.describe "Gem::SourceIndex#refresh!" do
-  before do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-  end
-
-  it "does not explode when called", :rubygems => "1.7" do
-    run "Gem.source_index.refresh!"
-    run "Gem::SourceIndex.new([]).refresh!"
-  end
-
-  it "does not explode when called", :rubygems => "< 1.7" do
-    run "Gem.source_index.refresh!"
-    run "Gem::SourceIndex.from_gems_in([]).refresh!"
-  end
-end
diff --git a/spec/bundler/other/major_deprecation_spec.rb b/spec/bundler/other/major_deprecation_spec.rb
deleted file mode 100644
index fba177b497..0000000000
--- a/spec/bundler/other/major_deprecation_spec.rb
+++ /dev/null
@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "major deprecations", :bundler => "< 2" do
-  let(:warnings) { last_command.bundler_err } # change to err in 2.0
-  let(:warnings_without_version_messages) { warnings.gsub(/#{Spec::Matchers::MAJOR_DEPRECATION}Bundler will only support ruby(gems)? >= .*/, "") }
-
-  context "in a .99 version" do
-    before do
-      simulate_bundler_version "1.99.1"
-      bundle "config --delete major_deprecations"
-    end
-
-    it "prints major deprecations without being configured" do
-      ruby <<-R
-        require "bundler"
-        Bundler::SharedHelpers.major_deprecation(Bundler::VERSION)
-      R
-
-      expect(warnings).to have_major_deprecation("1.99.1")
-    end
-  end
-
-  before do
-    bundle "config major_deprecations true"
-
-    create_file "gems.rb", <<-G
-      source "file:#{gem_repo1}"
-      ruby #{RUBY_VERSION.dump}
-      gem "rack"
-    G
-    bundle! "install"
-  end
-
-  describe "bundle_ruby" do
-    it "prints a deprecation" do
-      bundle_ruby
-      warnings.gsub! "\nruby #{RUBY_VERSION}", ""
-      expect(warnings).to have_major_deprecation "the bundle_ruby executable has been removed in favor of `bundle platform --ruby`"
-    end
-  end
-
-  describe "Bundler" do
-    describe ".clean_env" do
-      it "is deprecated in favor of .original_env" do
-        source = "Bundler.clean_env"
-        bundle "exec ruby -e #{source.dump}"
-        expect(warnings).to have_major_deprecation "`Bundler.clean_env` has weird edge cases, use `.original_env` instead"
-      end
-    end
-
-    describe ".environment" do
-      it "is deprecated in favor of .load" do
-        source = "Bundler.environment"
-        bundle "exec ruby -e #{source.dump}"
-        expect(warnings).to have_major_deprecation "Bundler.environment has been removed in favor of Bundler.load"
-      end
-    end
-
-    shared_examples_for "environmental deprecations" do |trigger|
-      describe "ruby version", :ruby => "< 2.0" do
-        it "requires a newer ruby version" do
-          instance_eval(&trigger)
-          expect(warnings).to have_major_deprecation "Bundler will only support ruby >= 2.0, you are running #{RUBY_VERSION}"
-        end
-      end
-
-      describe "rubygems version", :rubygems => "< 2.0" do
-        it "requires a newer rubygems version" do
-          instance_eval(&trigger)
-          expect(warnings).to have_major_deprecation "Bundler will only support rubygems >= 2.0, you are running #{Gem::VERSION}"
-        end
-      end
-    end
-
-    describe "-rbundler/setup" do
-      it_behaves_like "environmental deprecations", proc { ruby "require 'bundler/setup'" }
-    end
-
-    describe "Bundler.setup" do
-      it_behaves_like "environmental deprecations", proc { ruby "require 'bundler'; Bundler.setup" }
-    end
-
-    describe "bundle check" do
-      it_behaves_like "environmental deprecations", proc { bundle :check }
-    end
-
-    describe "bundle update --quiet" do
-      it "does not print any deprecations" do
-        bundle :update, :quiet => true
-        expect(warnings_without_version_messages).not_to have_major_deprecation
-      end
-    end
-
-    describe "bundle update" do
-      before do
-        create_file("gems.rb", "")
-        bundle! "install"
-      end
-
-      it "warns when no options are given" do
-        bundle! "update"
-        expect(warnings).to have_major_deprecation a_string_including("Pass --all to `bundle update` to update everything")
-      end
-
-      it "does not warn when --all is passed" do
-        bundle! "update --all"
-        expect(warnings_without_version_messages).not_to have_major_deprecation
-      end
-    end
-
-    describe "bundle install --binstubs" do
-      it "should output a deprecation warning" do
-        gemfile <<-G
-          gem 'rack'
-        G
-
-        bundle :install, :binstubs => true
-        expect(warnings).to have_major_deprecation a_string_including("The --binstubs option will be removed")
-      end
-    end
-  end
-
-  context "when bundle is run" do
-    it "should not warn about gems.rb" do
-      create_file "gems.rb", <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      bundle :install
-      expect(warnings_without_version_messages).not_to have_major_deprecation
-    end
-
-    it "should print a Gemfile deprecation warning" do
-      create_file "gems.rb"
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-      expect(the_bundle).to include_gem "rack 1.0"
-
-      expect(warnings).to have_major_deprecation a_string_including("gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock.")
-    end
-
-    context "with flags" do
-      it "should print a deprecation warning about autoremembering flags" do
-        install_gemfile <<-G, :path => "vendor/bundle"
-          source "file://#{gem_repo1}"
-          gem "rack"
-        G
-
-        expect(warnings).to have_major_deprecation a_string_including(
-          "flags passed to commands will no longer be automatically remembered."
-        )
-      end
-    end
-  end
-
-  context "when Bundler.setup is run in a ruby script" do
-    it "should print a single deprecation warning" do
-      create_file "gems.rb"
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :group => :test
-      G
-
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        require 'bundler/vendored_thor'
-
-        Bundler.ui = Bundler::UI::Shell.new
-        Bundler.setup
-        Bundler.setup
-      RUBY
-
-      expect(warnings_without_version_messages).to have_major_deprecation("gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock.")
-    end
-  end
-
-  context "when `bundler/deployment` is required in a ruby script" do
-    it "should print a capistrano deprecation warning" do
-      ruby(<<-RUBY)
-        require 'bundler/deployment'
-      RUBY
-
-      expect(warnings).to have_major_deprecation("Bundler no longer integrates " \
-                             "with Capistrano, but Capistrano provides " \
-                             "its own integration with Bundler via the " \
-                             "capistrano-bundler gem. Use it instead.")
-    end
-  end
-
-  describe Bundler::Dsl do
-    before do
-      @rubygems = double("rubygems")
-      allow(Bundler::Source::Rubygems).to receive(:new) { @rubygems }
-    end
-
-    context "with github gems" do
-      it "warns about the https change" do
-        msg = <<-EOS
-The :github git source is deprecated, and will be removed in Bundler 2.0. Change any "reponame" :github sources to "username/reponame". Add this code to the top of your Gemfile to ensure it continues to work:
-
-    git_source(:github) {|repo_name| "https://github.com/\#{repo_name}.git" }
-
-        EOS
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(2, msg)
-        subject.gem("sparks", :github => "indirect/sparks")
-      end
-
-      it "upgrades to https on request" do
-        Bundler.settings.temporary "github.https" => true
-        msg = <<-EOS
-The :github git source is deprecated, and will be removed in Bundler 2.0. Change any "reponame" :github sources to "username/reponame". Add this code to the top of your Gemfile to ensure it continues to work:
-
-    git_source(:github) {|repo_name| "https://github.com/\#{repo_name}.git" }
-
-        EOS
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(2, msg)
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(2, "The `github.https` setting will be removed")
-        subject.gem("sparks", :github => "indirect/sparks")
-        github_uri = "https://github.com/indirect/sparks.git"
-        expect(subject.dependencies.first.source.uri).to eq(github_uri)
-      end
-    end
-
-    context "with bitbucket gems" do
-      it "warns about removal" do
-        allow(Bundler.ui).to receive(:deprecate)
-        msg = <<-EOS
-The :bitbucket git source is deprecated, and will be removed in Bundler 2.0. Add this code to the top of your Gemfile to ensure it continues to work:
-
-    git_source(:bitbucket) do |repo_name|
-      user_name, repo_name = repo_name.split("/")
-      repo_name ||= user_name
-      "https://\#{user_name}@bitbucket.org/\#{user_name}/\#{repo_name}.git"
-    end
-
-        EOS
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(2, msg)
-        subject.gem("not-really-a-gem", :bitbucket => "mcorp/flatlab-rails")
-      end
-    end
-
-    context "with gist gems" do
-      it "warns about removal" do
-        allow(Bundler.ui).to receive(:deprecate)
-        msg = "The :gist git source is deprecated, and will be removed " \
-          "in Bundler 2.0. Add this code to the top of your Gemfile to ensure it " \
-          "continues to work:\n\n    git_source(:gist) {|repo_name| " \
-          "\"https://gist.github.com/\#{repo_name}.git\" }\n\n"
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(2, msg)
-        subject.gem("not-really-a-gem", :gist => "1234")
-      end
-    end
-  end
-
-  context "bundle show" do
-    it "prints a deprecation warning" do
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      bundle! :show
-
-      warnings.gsub!(/gems included.*?\[DEPRECATED/im, "[DEPRECATED")
-
-      expect(warnings).to have_major_deprecation a_string_including("use `bundle list` instead of `bundle show`")
-    end
-  end
-
-  context "bundle console" do
-    it "prints a deprecation warning" do
-      bundle "console"
-
-      expect(warnings).to have_major_deprecation \
-        a_string_including("bundle console will be replaced by `bin/console` generated by `bundle gem <name>`")
-    end
-  end
-end
diff --git a/spec/bundler/other/platform_spec.rb b/spec/bundler/other/platform_spec.rb
deleted file mode 100644
index fea5daf5ac..0000000000
--- a/spec/bundler/other/platform_spec.rb
+++ /dev/null
@@ -1,1299 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle platform" do
-  context "without flags" do
-    let(:bundle_platform_platforms_string) do
-      platforms = [rb]
-      platforms.unshift(specific_local_platform) if Bundler.feature_flag.bundler_2_mode?
-      platforms.map {|pl| "* #{pl}" }.join("\n")
-    end
-
-    it "returns all the output" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        #{ruby_version_correct}
-
-        gem "foo"
-      G
-
-      bundle "platform"
-      expect(out).to eq(<<-G.chomp)
-Your platform is: #{RUBY_PLATFORM}
-
-Your app has gems that work on these platforms:
-#{bundle_platform_platforms_string}
-
-Your Gemfile specifies a Ruby version requirement:
-* ruby #{RUBY_VERSION}
-
-Your current platform satisfies the Ruby version requirement.
-G
-    end
-
-    it "returns all the output including the patchlevel" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        #{ruby_version_correct_patchlevel}
-
-        gem "foo"
-      G
-
-      bundle "platform"
-      expect(out).to eq(<<-G.chomp)
-Your platform is: #{RUBY_PLATFORM}
-
-Your app has gems that work on these platforms:
-#{bundle_platform_platforms_string}
-
-Your Gemfile specifies a Ruby version requirement:
-* ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}
-
-Your current platform satisfies the Ruby version requirement.
-G
-    end
-
-    it "doesn't print ruby version requirement if it isn't specified" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        gem "foo"
-      G
-
-      bundle "platform"
-      expect(out).to eq(<<-G.chomp)
-Your platform is: #{RUBY_PLATFORM}
-
-Your app has gems that work on these platforms:
-#{bundle_platform_platforms_string}
-
-Your Gemfile does not specify a Ruby version requirement.
-G
-    end
-
-    it "doesn't match the ruby version requirement" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        #{ruby_version_incorrect}
-
-        gem "foo"
-      G
-
-      bundle "platform"
-      expect(out).to eq(<<-G.chomp)
-Your platform is: #{RUBY_PLATFORM}
-
-Your app has gems that work on these platforms:
-#{bundle_platform_platforms_string}
-
-Your Gemfile specifies a Ruby version requirement:
-* ruby #{not_local_ruby_version}
-
-Your Ruby version is #{RUBY_VERSION}, but your Gemfile specified #{not_local_ruby_version}
-G
-    end
-  end
-
-  context "--ruby" do
-    it "returns ruby version when explicit" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.9.3", :engine => 'ruby', :engine_version => '1.9.3'
-
-        gem "foo"
-      G
-
-      bundle "platform --ruby"
-
-      expect(out).to eq("ruby 1.9.3")
-    end
-
-    it "defaults to MRI" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.9.3"
-
-        gem "foo"
-      G
-
-      bundle "platform --ruby"
-
-      expect(out).to eq("ruby 1.9.3")
-    end
-
-    it "handles jruby" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'jruby', :engine_version => '1.6.5'
-
-        gem "foo"
-      G
-
-      bundle "platform --ruby"
-
-      expect(out).to eq("ruby 1.8.7 (jruby 1.6.5)")
-    end
-
-    it "handles rbx" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'rbx', :engine_version => '1.2.4'
-
-        gem "foo"
-      G
-
-      bundle "platform --ruby"
-
-      expect(out).to eq("ruby 1.8.7 (rbx 1.2.4)")
-    end
-
-    it "raises an error if engine is used but engine version is not" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'rbx'
-
-        gem "foo"
-      G
-
-      bundle "platform"
-
-      expect(exitstatus).not_to eq(0) if exitstatus
-    end
-
-    it "raises an error if engine_version is used but engine is not" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine_version => '1.2.4'
-
-        gem "foo"
-      G
-
-      bundle "platform"
-
-      expect(exitstatus).not_to eq(0) if exitstatus
-    end
-
-    it "raises an error if engine version doesn't match ruby version for MRI" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        ruby "1.8.7", :engine => 'ruby', :engine_version => '1.2.4'
-
-        gem "foo"
-      G
-
-      bundle "platform"
-
-      expect(exitstatus).not_to eq(0) if exitstatus
-    end
-
-    it "should print if no ruby version is specified" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        gem "foo"
-      G
-
-      bundle "platform --ruby"
-
-      expect(out).to eq("No ruby version specified")
-    end
-
-    it "handles when there is a locked requirement" do
-      gemfile <<-G
-        ruby "< 1.8.7"
-      G
-
-      lockfile <<-L
-        GEM
-          specs:
-
-        PLATFORMS
-          ruby
-
-        DEPENDENCIES
-
-        RUBY VERSION
-           ruby 1.0.0p127
-
-        BUNDLED WITH
-           #{Bundler::VERSION}
-      L
-
-      bundle! "platform --ruby"
-      expect(out).to eq("ruby 1.0.0p127")
-    end
-
-    it "handles when there is a requirement in the gemfile" do
-      gemfile <<-G
-        ruby ">= 1.8.7"
-      G
-
-      bundle! "platform --ruby"
-      expect(out).to eq("ruby 1.8.7")
-    end
-
-    it "handles when there are multiple requirements in the gemfile" do
-      gemfile <<-G
-        ruby ">= 1.8.7", "< 2.0.0"
-      G
-
-      bundle! "platform --ruby"
-      expect(out).to eq("ruby 1.8.7")
-    end
-  end
-
-  let(:ruby_version_correct) { "ruby \"#{RUBY_VERSION}\", :engine => \"#{local_ruby_engine}\", :engine_version => \"#{local_engine_version}\"" }
-  let(:ruby_version_correct_engineless) { "ruby \"#{RUBY_VERSION}\"" }
-  let(:ruby_version_correct_patchlevel) { "#{ruby_version_correct}, :patchlevel => '#{RUBY_PATCHLEVEL}'" }
-  let(:ruby_version_incorrect) { "ruby \"#{not_local_ruby_version}\", :engine => \"#{local_ruby_engine}\", :engine_version => \"#{not_local_ruby_version}\"" }
-  let(:engine_incorrect) { "ruby \"#{RUBY_VERSION}\", :engine => \"#{not_local_tag}\", :engine_version => \"#{RUBY_VERSION}\"" }
-  let(:engine_version_incorrect) { "ruby \"#{RUBY_VERSION}\", :engine => \"#{local_ruby_engine}\", :engine_version => \"#{not_local_engine_version}\"" }
-  let(:patchlevel_incorrect) { "#{ruby_version_correct}, :patchlevel => '#{not_local_patchlevel}'" }
-  let(:patchlevel_fixnum) { "#{ruby_version_correct}, :patchlevel => #{RUBY_PATCHLEVEL}1" }
-
-  def should_be_ruby_version_incorrect
-    expect(exitstatus).to eq(18) if exitstatus
-    expect(out).to be_include("Your Ruby version is #{RUBY_VERSION}, but your Gemfile specified #{not_local_ruby_version}")
-  end
-
-  def should_be_engine_incorrect
-    expect(exitstatus).to eq(18) if exitstatus
-    expect(out).to be_include("Your Ruby engine is #{local_ruby_engine}, but your Gemfile specified #{not_local_tag}")
-  end
-
-  def should_be_engine_version_incorrect
-    expect(exitstatus).to eq(18) if exitstatus
-    expect(out).to be_include("Your #{local_ruby_engine} version is #{local_engine_version}, but your Gemfile specified #{local_ruby_engine} #{not_local_engine_version}")
-  end
-
-  def should_be_patchlevel_incorrect
-    expect(exitstatus).to eq(18) if exitstatus
-    expect(out).to be_include("Your Ruby patchlevel is #{RUBY_PATCHLEVEL}, but your Gemfile specified #{not_local_patchlevel}")
-  end
-
-  def should_be_patchlevel_fixnum
-    expect(exitstatus).to eq(18) if exitstatus
-    expect(out).to be_include("The Ruby patchlevel in your Gemfile must be a string")
-  end
-
-  context "bundle install" do
-    it "installs fine when the ruby version matches" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{ruby_version_correct}
-      G
-
-      expect(bundled_app("Gemfile.lock")).to exist
-    end
-
-    it "installs fine with any engine" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-
-          #{ruby_version_correct_engineless}
-        G
-
-        expect(bundled_app("Gemfile.lock")).to exist
-      end
-    end
-
-    it "installs fine when the patchlevel matches" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{ruby_version_correct_patchlevel}
-      G
-
-      expect(bundled_app("Gemfile.lock")).to exist
-    end
-
-    it "doesn't install when the ruby version doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{ruby_version_incorrect}
-      G
-
-      expect(bundled_app("Gemfile.lock")).not_to exist
-      should_be_ruby_version_incorrect
-    end
-
-    it "doesn't install when engine doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{engine_incorrect}
-      G
-
-      expect(bundled_app("Gemfile.lock")).not_to exist
-      should_be_engine_incorrect
-    end
-
-    it "doesn't install when engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-
-          #{engine_version_incorrect}
-        G
-
-        expect(bundled_app("Gemfile.lock")).not_to exist
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "doesn't install when patchlevel doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-
-      expect(bundled_app("Gemfile.lock")).not_to exist
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle check" do
-    it "checks fine when the ruby version matches" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{ruby_version_correct}
-      G
-
-      bundle :check
-      expect(exitstatus).to eq(0) if exitstatus
-      expect(out).to eq("Resolving dependencies...\nThe Gemfile's dependencies are satisfied")
-    end
-
-    it "checks fine with any engine" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-        G
-
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle :check
-        expect(exitstatus).to eq(0) if exitstatus
-        expect(out).to eq("Resolving dependencies...\nThe Gemfile's dependencies are satisfied")
-      end
-    end
-
-    it "fails when ruby version doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle :check
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails when engine doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{engine_incorrect}
-      G
-
-      bundle :check
-      should_be_engine_incorrect
-    end
-
-    it "fails when engine version doesn't match" do
-      simulate_ruby_engine "ruby" do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-        G
-
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-
-          #{engine_version_incorrect}
-        G
-
-        bundle :check
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-
-      bundle :check
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle update" do
-    before do
-      build_repo2
-
-      install_gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport"
-        gem "rack-obama"
-      G
-    end
-
-    it "updates successfully when the ruby version matches" do
-      gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport"
-        gem "rack-obama"
-
-        #{ruby_version_correct}
-      G
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-      end
-
-      bundle "update", :all => bundle_update_requires_all?
-      expect(the_bundle).to include_gems "rack 1.2", "rack-obama 1.0", "activesupport 3.0"
-    end
-
-    it "updates fine with any engine" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          source "file://#{gem_repo2}"
-          gem "activesupport"
-          gem "rack-obama"
-
-          #{ruby_version_correct_engineless}
-        G
-        update_repo2 do
-          build_gem "activesupport", "3.0"
-        end
-
-        bundle "update", :all => bundle_update_requires_all?
-        expect(the_bundle).to include_gems "rack 1.2", "rack-obama 1.0", "activesupport 3.0"
-      end
-    end
-
-    it "fails when ruby version doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport"
-        gem "rack-obama"
-
-        #{ruby_version_incorrect}
-      G
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-      end
-
-      bundle :update, :all => bundle_update_requires_all?
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails when ruby engine doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport"
-        gem "rack-obama"
-
-        #{engine_incorrect}
-      G
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-      end
-
-      bundle :update, :all => bundle_update_requires_all?
-      should_be_engine_incorrect
-    end
-
-    it "fails when ruby engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          source "file://#{gem_repo2}"
-          gem "activesupport"
-          gem "rack-obama"
-
-          #{engine_version_incorrect}
-        G
-        update_repo2 do
-          build_gem "activesupport", "3.0"
-        end
-
-        bundle :update, :all => bundle_update_requires_all?
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-      end
-
-      bundle :update, :all => bundle_update_requires_all?
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle info" do
-    before do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rails"
-      G
-    end
-
-    it "prints path if ruby version is correct" do
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rails"
-
-        #{ruby_version_correct}
-      G
-
-      bundle "info rails --path"
-      expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s)
-    end
-
-    it "prints path if ruby version is correct for any engine" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile! <<-G
-          source "file://#{gem_repo1}"
-          gem "rails"
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle "info rails --path"
-        expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s)
-      end
-    end
-
-    it "fails if ruby version doesn't match", :bundler => "< 2" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rails"
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle "show rails"
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails if engine doesn't match", :bundler => "< 2" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rails"
-
-        #{engine_incorrect}
-      G
-
-      bundle "show rails"
-      should_be_engine_incorrect
-    end
-
-    it "fails if engine version doesn't match", :bundler => "< 2" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rails"
-
-          #{engine_version_incorrect}
-        G
-
-        bundle "show rails"
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match", :bundler => "< 2" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-      end
-
-      bundle "show rails"
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle cache" do
-    before do
-      install_gemfile <<-G
-        source "file:#{gem_repo1}"
-        gem 'rack'
-      G
-    end
-
-    it "copies the .gem file to vendor/cache when ruby version matches" do
-      gemfile <<-G
-        gem 'rack'
-
-        #{ruby_version_correct}
-      G
-
-      bundle :cache
-      expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist
-    end
-
-    it "copies the .gem file to vendor/cache when ruby version matches for any engine" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile! <<-G
-          source "file:#{gem_repo1}"
-          gem 'rack'
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle! :cache
-        expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist
-      end
-    end
-
-    it "fails if the ruby version doesn't match" do
-      gemfile <<-G
-        gem 'rack'
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle :cache
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails if the engine doesn't match" do
-      gemfile <<-G
-        gem 'rack'
-
-        #{engine_incorrect}
-      G
-
-      bundle :cache
-      should_be_engine_incorrect
-    end
-
-    it "fails if the engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          gem 'rack'
-
-          #{engine_version_incorrect}
-        G
-
-        bundle :cache
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-
-      bundle :cache
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle pack" do
-    before do
-      install_gemfile! <<-G
-        source "file:#{gem_repo1}"
-        gem 'rack'
-      G
-    end
-
-    it "copies the .gem file to vendor/cache when ruby version matches" do
-      gemfile <<-G
-        gem 'rack'
-
-        #{ruby_version_correct}
-      G
-
-      bundle :pack
-      expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist
-    end
-
-    it "copies the .gem file to vendor/cache when ruby version matches any engine" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile! <<-G
-          source "file:#{gem_repo1}"
-          gem 'rack'
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle :pack
-        expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist
-      end
-    end
-
-    it "fails if the ruby version doesn't match" do
-      gemfile <<-G
-        gem 'rack'
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle :pack
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails if the engine doesn't match" do
-      gemfile <<-G
-        gem 'rack'
-
-        #{engine_incorrect}
-      G
-
-      bundle :pack
-      should_be_engine_incorrect
-    end
-
-    it "fails if the engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          gem 'rack'
-
-          #{engine_version_incorrect}
-        G
-
-        bundle :pack
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-
-      bundle :pack
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle exec" do
-    before do
-      ENV["BUNDLER_FORCE_TTY"] = "true"
-      system_gems "rack-1.0.0", "rack-0.9.1", :path => :bundle_path
-    end
-
-    it "activates the correct gem when ruby version matches" do
-      gemfile <<-G
-        gem "rack", "0.9.1"
-
-        #{ruby_version_correct}
-      G
-
-      bundle "exec rackup"
-      expect(out).to eq("0.9.1")
-    end
-
-    it "activates the correct gem when ruby version matches any engine" do
-      simulate_ruby_engine "jruby" do
-        system_gems "rack-1.0.0", "rack-0.9.1", :path => :bundle_path
-        gemfile <<-G
-          gem "rack", "0.9.1"
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle "exec rackup"
-        expect(out).to eq("0.9.1")
-      end
-    end
-
-    it "fails when the ruby version doesn't match" do
-      gemfile <<-G
-        gem "rack", "0.9.1"
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle "exec rackup"
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails when the engine doesn't match" do
-      gemfile <<-G
-        gem "rack", "0.9.1"
-
-        #{engine_incorrect}
-      G
-
-      bundle "exec rackup"
-      should_be_engine_incorrect
-    end
-
-    # it "fails when the engine version doesn't match" do
-    #   simulate_ruby_engine "jruby" do
-    #     gemfile <<-G
-    #       gem "rack", "0.9.1"
-    #
-    #       #{engine_version_incorrect}
-    #     G
-    #
-    #     bundle "exec rackup"
-    #     should_be_engine_version_incorrect
-    #   end
-    # end
-
-    it "fails when patchlevel doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-
-      bundle "exec rackup"
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle console", :bundler => "< 2" do
-    before do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :group => :test
-        gem "rack_middleware", :group => :development
-      G
-    end
-
-    it "starts IRB with the default group loaded when ruby version matches" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :group => :test
-        gem "rack_middleware", :group => :development
-
-        #{ruby_version_correct}
-      G
-
-      bundle "console" do |input, _, _|
-        input.puts("puts RACK")
-        input.puts("exit")
-      end
-      expect(out).to include("0.9.1")
-    end
-
-    it "starts IRB with the default group loaded when ruby version matches any engine" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-          gem "activesupport", :group => :test
-          gem "rack_middleware", :group => :development
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle "console" do |input, _, _|
-          input.puts("puts RACK")
-          input.puts("exit")
-        end
-        expect(out).to include("0.9.1")
-      end
-    end
-
-    it "fails when ruby version doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :group => :test
-        gem "rack_middleware", :group => :development
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle "console"
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails when engine doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :group => :test
-        gem "rack_middleware", :group => :development
-
-        #{engine_incorrect}
-      G
-
-      bundle "console"
-      should_be_engine_incorrect
-    end
-
-    it "fails when engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-          gem "activesupport", :group => :test
-          gem "rack_middleware", :group => :development
-
-          #{engine_version_incorrect}
-        G
-
-        bundle "console"
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match" do
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :group => :test
-        gem "rack_middleware", :group => :development
-
-        #{patchlevel_incorrect}
-      G
-
-      bundle "console"
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "Bundler.setup" do
-    before do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "yard"
-        gem "rack", :group => :test
-      G
-
-      ENV["BUNDLER_FORCE_TTY"] = "true"
-    end
-
-    it "makes a Gemfile.lock if setup succeeds" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "yard"
-        gem "rack"
-
-        #{ruby_version_correct}
-      G
-
-      FileUtils.rm(bundled_app("Gemfile.lock"))
-
-      run "1"
-      expect(bundled_app("Gemfile.lock")).to exist
-    end
-
-    it "makes a Gemfile.lock if setup succeeds for any engine" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "yard"
-          gem "rack"
-
-          #{ruby_version_correct_engineless}
-        G
-
-        FileUtils.rm(bundled_app("Gemfile.lock"))
-
-        run "1"
-        expect(bundled_app("Gemfile.lock")).to exist
-      end
-    end
-
-    it "fails when ruby version doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "yard"
-        gem "rack"
-
-        #{ruby_version_incorrect}
-      G
-
-      FileUtils.rm(bundled_app("Gemfile.lock"))
-
-      ruby <<-R
-        require 'rubygems'
-        require 'bundler/setup'
-      R
-
-      expect(bundled_app("Gemfile.lock")).not_to exist
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails when engine doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "yard"
-        gem "rack"
-
-        #{engine_incorrect}
-      G
-
-      FileUtils.rm(bundled_app("Gemfile.lock"))
-
-      ruby <<-R
-        require 'rubygems'
-        require 'bundler/setup'
-      R
-
-      expect(bundled_app("Gemfile.lock")).not_to exist
-      should_be_engine_incorrect
-    end
-
-    it "fails when engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "yard"
-          gem "rack"
-
-          #{engine_version_incorrect}
-        G
-
-        FileUtils.rm(bundled_app("Gemfile.lock"))
-
-        ruby <<-R
-          require 'rubygems'
-          require 'bundler/setup'
-        R
-
-        expect(bundled_app("Gemfile.lock")).not_to exist
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when patchlevel doesn't match" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "yard"
-        gem "rack"
-
-        #{patchlevel_incorrect}
-      G
-
-      FileUtils.rm(bundled_app("Gemfile.lock"))
-
-      ruby <<-R
-        require 'rubygems'
-        require 'bundler/setup'
-      R
-
-      expect(bundled_app("Gemfile.lock")).not_to exist
-      should_be_patchlevel_incorrect
-    end
-  end
-
-  context "bundle outdated" do
-    before do
-      build_repo2 do
-        build_git "foo", :path => lib_path("foo")
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport", "2.3.5"
-        gem "foo", :git => "#{lib_path("foo")}"
-      G
-    end
-
-    it "returns list of outdated gems when the ruby version matches" do
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-        update_git "foo", :path => lib_path("foo")
-      end
-
-      gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport", "2.3.5"
-        gem "foo", :git => "#{lib_path("foo")}"
-
-        #{ruby_version_correct}
-      G
-
-      bundle "outdated"
-      expect(out).to include("activesupport (newest 3.0, installed 2.3.5, requested = 2.3.5")
-      expect(out).to include("foo (newest 1.0")
-    end
-
-    it "returns list of outdated gems when the ruby version matches for any engine" do
-      simulate_ruby_engine "jruby" do
-        bundle! :install
-        update_repo2 do
-          build_gem "activesupport", "3.0"
-          update_git "foo", :path => lib_path("foo")
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo2}"
-          gem "activesupport", "2.3.5"
-          gem "foo", :git => "#{lib_path("foo")}"
-
-          #{ruby_version_correct_engineless}
-        G
-
-        bundle "outdated"
-        expect(out).to include("activesupport (newest 3.0, installed 2.3.5, requested = 2.3.5)")
-        expect(out).to include("foo (newest 1.0")
-      end
-    end
-
-    it "fails when the ruby version doesn't match" do
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-        update_git "foo", :path => lib_path("foo")
-      end
-
-      gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport", "2.3.5"
-        gem "foo", :git => "#{lib_path("foo")}"
-
-        #{ruby_version_incorrect}
-      G
-
-      bundle "outdated"
-      should_be_ruby_version_incorrect
-    end
-
-    it "fails when the engine doesn't match" do
-      update_repo2 do
-        build_gem "activesupport", "3.0"
-        update_git "foo", :path => lib_path("foo")
-      end
-
-      gemfile <<-G
-        source "file://#{gem_repo2}"
-        gem "activesupport", "2.3.5"
-        gem "foo", :git => "#{lib_path("foo")}"
-
-        #{engine_incorrect}
-      G
-
-      bundle "outdated"
-      should_be_engine_incorrect
-    end
-
-    it "fails when the engine version doesn't match" do
-      simulate_ruby_engine "jruby" do
-        update_repo2 do
-          build_gem "activesupport", "3.0"
-          update_git "foo", :path => lib_path("foo")
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo2}"
-          gem "activesupport", "2.3.5"
-          gem "foo", :git => "#{lib_path("foo")}"
-
-          #{engine_version_incorrect}
-        G
-
-        bundle "outdated"
-        should_be_engine_version_incorrect
-      end
-    end
-
-    it "fails when the patchlevel doesn't match" do
-      simulate_ruby_engine "jruby" do
-        update_repo2 do
-          build_gem "activesupport", "3.0"
-          update_git "foo", :path => lib_path("foo")
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo2}"
-          gem "activesupport", "2.3.5"
-          gem "foo", :git => "#{lib_path("foo")}"
-
-          #{patchlevel_incorrect}
-        G
-
-        bundle "outdated"
-        should_be_patchlevel_incorrect
-      end
-    end
-
-    it "fails when the patchlevel is a fixnum" do
-      simulate_ruby_engine "jruby" do
-        update_repo2 do
-          build_gem "activesupport", "3.0"
-          update_git "foo", :path => lib_path("foo")
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo2}"
-          gem "activesupport", "2.3.5"
-          gem "foo", :git => "#{lib_path("foo")}"
-
-          #{patchlevel_fixnum}
-        G
-
-        bundle "outdated"
-        should_be_patchlevel_fixnum
-      end
-    end
-  end
-end
diff --git a/spec/bundler/other/ssl_cert_spec.rb b/spec/bundler/other/ssl_cert_spec.rb
deleted file mode 100644
index 6d957276fc..0000000000
--- a/spec/bundler/other/ssl_cert_spec.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/ssl_certs/certificate_manager"
-
-RSpec.describe "SSL Certificates", :rubygems_master do
-  hosts = %w[
-    rubygems.org
-    index.rubygems.org
-    rubygems.global.ssl.fastly.net
-    staging.rubygems.org
-  ]
-
-  hosts.each do |host|
-    it "can securely connect to #{host}", :realworld do
-      Bundler::SSLCerts::CertificateManager.new.connect_to(host)
-    end
-  end
-end