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

11 files changed, 0 insertions, 4316 deletions

diff --git a/spec/bundler/install/gemfile/eval_gemfile_spec.rb b/spec/bundler/install/gemfile/eval_gemfile_spec.rb
deleted file mode 100644
index 035d3692aa..0000000000
--- a/spec/bundler/install/gemfile/eval_gemfile_spec.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with gemfile that uses eval_gemfile" do
-  before do
-    build_lib("gunks", :path => bundled_app.join("gems/gunks")) do |s|
-      s.name    = "gunks"
-      s.version = "0.0.1"
-    end
-  end
-
-  context "eval-ed Gemfile points to an internal gemspec" do
-    before do
-      create_file "Gemfile-other", <<-G
-        gemspec :path => 'gems/gunks'
-      G
-    end
-
-    it "installs the gemspec specified gem" do
-      install_gemfile <<-G
-        eval_gemfile 'Gemfile-other'
-      G
-      expect(out).to include("Resolving dependencies")
-      expect(out).to include("Bundle complete")
-
-      expect(the_bundle).to include_gem "gunks 0.0.1", :source => "path@#{bundled_app("gems", "gunks")}"
-    end
-  end
-
-  context "eval-ed Gemfile has relative-path gems" do
-    before do
-      build_lib("a", :path => "gems/a")
-      create_file "nested/Gemfile-nested", <<-G
-        gem "a", :path => "../gems/a"
-      G
-
-      gemfile <<-G
-        eval_gemfile "nested/Gemfile-nested"
-      G
-    end
-
-    it "installs the path gem" do
-      bundle! :install
-      expect(the_bundle).to include_gem("a 1.0")
-    end
-
-    # Make sure that we are properly comparing path based gems between the
-    # parsed lockfile and the evaluated gemfile.
-    it "bundles with --deployment" do
-      bundle! :install
-      bundle! :install, forgotten_command_line_options(:deployment => true)
-    end
-  end
-
-  context "Gemfile uses gemspec paths after eval-ing a Gemfile" do
-    before { create_file "other/Gemfile-other" }
-
-    it "installs the gemspec specified gem" do
-      install_gemfile <<-G
-        eval_gemfile 'other/Gemfile-other'
-        gemspec :path => 'gems/gunks'
-      G
-      expect(out).to include("Resolving dependencies")
-      expect(out).to include("Bundle complete")
-
-      expect(the_bundle).to include_gem "gunks 0.0.1", :source => "path@#{bundled_app("gems", "gunks")}"
-    end
-  end
-
-  context "eval-ed Gemfile references other gemfiles" do
-    it "works with relative paths" do
-      create_file "other/Gemfile-other", "gem 'rack'"
-      create_file "other/Gemfile", "eval_gemfile 'Gemfile-other'"
-      create_file "Gemfile-alt", <<-G
-        source "file:#{gem_repo1}"
-        eval_gemfile "other/Gemfile"
-      G
-      install_gemfile! "eval_gemfile File.expand_path('Gemfile-alt')"
-
-      expect(the_bundle).to include_gem "rack 1.0.0"
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/gemspec_spec.rb b/spec/bundler/install/gemfile/gemspec_spec.rb
deleted file mode 100644
index 86cd2d8f3f..0000000000
--- a/spec/bundler/install/gemfile/gemspec_spec.rb
+++ /dev/null
@@ -1,672 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install from an existing gemspec" do
-  before(:each) do
-    build_repo2 do
-      build_gem "bar"
-      build_gem "bar-dev"
-    end
-  end
-
-  it "should install runtime and development dependencies" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("Gemfile", "source :rubygems\ngemspec")
-      s.add_dependency "bar", "=1.0.0"
-      s.add_development_dependency "bar-dev", "=1.0.0"
-    end
-    install_gemfile <<-G
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-
-    expect(the_bundle).to include_gems "bar 1.0.0"
-    expect(the_bundle).to include_gems "bar-dev 1.0.0", :groups => :development
-  end
-
-  it "that is hidden should install runtime and development dependencies" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("Gemfile", "source :rubygems\ngemspec")
-      s.add_dependency "bar", "=1.0.0"
-      s.add_development_dependency "bar-dev", "=1.0.0"
-    end
-    FileUtils.mv tmp.join("foo", "foo.gemspec"), tmp.join("foo", ".gemspec")
-
-    install_gemfile <<-G
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-
-    expect(the_bundle).to include_gems "bar 1.0.0"
-    expect(the_bundle).to include_gems "bar-dev 1.0.0", :groups => :development
-  end
-
-  it "should handle a list of requirements" do
-    update_repo2 do
-      build_gem "baz", "1.0"
-      build_gem "baz", "1.1"
-    end
-
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("Gemfile", "source :rubygems\ngemspec")
-      s.add_dependency "baz", ">= 1.0", "< 1.1"
-    end
-    install_gemfile <<-G
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-
-    expect(the_bundle).to include_gems "baz 1.0"
-  end
-
-  it "should raise if there are no gemspecs available" do
-    build_lib("foo", :path => tmp.join("foo"), :gemspec => false)
-
-    install_gemfile(<<-G)
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-    expect(last_command.bundler_err).to match(/There are no gemspecs at #{tmp.join('foo')}/)
-  end
-
-  it "should raise if there are too many gemspecs available" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("foo2.gemspec", build_spec("foo", "4.0").first.to_ruby)
-    end
-
-    install_gemfile(<<-G)
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-    expect(last_command.bundler_err).to match(/There are multiple gemspecs at #{tmp.join('foo')}/)
-  end
-
-  it "should pick a specific gemspec" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("foo2.gemspec", "")
-      s.add_dependency "bar", "=1.0.0"
-      s.add_development_dependency "bar-dev", "=1.0.0"
-    end
-
-    install_gemfile(<<-G)
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}', :name => 'foo'
-    G
-
-    expect(the_bundle).to include_gems "bar 1.0.0"
-    expect(the_bundle).to include_gems "bar-dev 1.0.0", :groups => :development
-  end
-
-  it "should use a specific group for development dependencies" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("foo2.gemspec", "")
-      s.add_dependency "bar", "=1.0.0"
-      s.add_development_dependency "bar-dev", "=1.0.0"
-    end
-
-    install_gemfile(<<-G)
-      source "file://#{gem_repo2}"
-      gemspec :path => '#{tmp.join("foo")}', :name => 'foo', :development_group => :dev
-    G
-
-    expect(the_bundle).to include_gems "bar 1.0.0"
-    expect(the_bundle).not_to include_gems "bar-dev 1.0.0", :groups => :development
-    expect(the_bundle).to include_gems "bar-dev 1.0.0", :groups => :dev
-  end
-
-  it "should match a lockfile even if the gemspec defines development dependencies" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.write("Gemfile", "source 'file://#{gem_repo1}'\ngemspec")
-      s.add_dependency "actionpack", "=2.3.2"
-      s.add_development_dependency "rake", "=10.0.2"
-    end
-
-    Dir.chdir(tmp.join("foo")) do
-      bundle "install"
-      # This should really be able to rely on $stderr, but, it's not written
-      # right, so we can't. In fact, this is a bug negation test, and so it'll
-      # ghost pass in future, and will only catch a regression if the message
-      # doesn't change. Exit codes should be used correctly (they can be more
-      # than just 0 and 1).
-      output = bundle("install --deployment")
-      expect(output).not_to match(/You have added to the Gemfile/)
-      expect(output).not_to match(/You have deleted from the Gemfile/)
-      expect(output).not_to match(/install in deployment mode after changing/)
-    end
-  end
-
-  it "should match a lockfile without needing to re-resolve" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.add_dependency "rack"
-    end
-
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-
-    bundle! "install", :verbose => true
-
-    message = "Found no changes, using resolution from the lockfile"
-    expect(out.scan(message).size).to eq(1)
-  end
-
-  it "should match a lockfile without needing to re-resolve with development dependencies" do
-    simulate_platform java
-
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.add_dependency "rack"
-      s.add_development_dependency "thin"
-    end
-
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-
-    bundle! "install", :verbose => true
-
-    message = "Found no changes, using resolution from the lockfile"
-    expect(out.scan(message).size).to eq(1)
-  end
-
-  it "should match a lockfile on non-ruby platforms with a transitive platform dependency" do
-    simulate_platform java
-    simulate_ruby_engine "jruby"
-
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.add_dependency "platform_specific"
-    end
-
-    system_gems "platform_specific-1.0-java", :path => :bundle_path, :keep_path => true
-
-    install_gemfile! <<-G
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-
-    bundle! "update --bundler", :verbose => true
-    expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 JAVA"
-  end
-
-  it "should evaluate the gemspec in its directory" do
-    build_lib("foo", :path => tmp.join("foo"))
-    File.open(tmp.join("foo/foo.gemspec"), "w") do |s|
-      s.write "raise 'ahh' unless Dir.pwd == '#{tmp.join("foo")}'"
-    end
-
-    install_gemfile <<-G
-      gemspec :path => '#{tmp.join("foo")}'
-    G
-    expect(last_command.stdboth).not_to include("ahh")
-  end
-
-  it "allows the gemspec to activate other gems" do
-    ENV["BUNDLE_PATH__SYSTEM"] = "true"
-    # see https://github.com/bundler/bundler/issues/5409
-    #
-    # issue was caused by rubygems having an unresolved gem during a require,
-    # so emulate that
-    system_gems %w[rack-1.0.0 rack-0.9.1 rack-obama-1.0]
-
-    build_lib("foo", :path => bundled_app)
-    gemspec = bundled_app("foo.gemspec").read
-    bundled_app("foo.gemspec").open("w") do |f|
-      f.write "#{gemspec.strip}.tap { gem 'rack-obama'; require 'rack-obama' }"
-    end
-
-    install_gemfile! <<-G
-      gemspec
-    G
-
-    expect(the_bundle).to include_gem "foo 1.0"
-  end
-
-  it "allows conflicts" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.version = "1.0.0"
-      s.add_dependency "bar", "= 1.0.0"
-    end
-    build_gem "deps", :to_bundle => true do |s|
-      s.add_dependency "foo", "= 0.0.1"
-    end
-    build_gem "foo", "0.0.1", :to_bundle => true
-
-    install_gemfile <<-G
-      source "file://#{gem_repo2}"
-      gem "deps"
-      gemspec :path => '#{tmp.join("foo")}', :name => 'foo'
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0.0"
-  end
-
-  it "does not break Gem.finish_resolve with conflicts", :rubygems => ">= 2" do
-    build_lib("foo", :path => tmp.join("foo")) do |s|
-      s.version = "1.0.0"
-      s.add_dependency "bar", "= 1.0.0"
-    end
-    update_repo2 do
-      build_gem "deps" do |s|
-        s.add_dependency "foo", "= 0.0.1"
-      end
-      build_gem "foo", "0.0.1"
-    end
-
-    install_gemfile! <<-G
-      source "file://#{gem_repo2}"
-      gem "deps"
-      gemspec :path => '#{tmp.join("foo")}', :name => 'foo'
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0.0"
-
-    run! "Gem.finish_resolve; puts 'WIN'"
-    expect(out).to eq("WIN")
-  end
-
-  context "in deployment mode" do
-    context "when the lockfile was not updated after a change to the gemspec's dependencies" do
-      it "reports that installation failed" do
-        build_lib "cocoapods", :path => bundled_app do |s|
-          s.add_dependency "activesupport", ">= 1"
-        end
-
-        install_gemfile! <<-G
-          source "file://#{gem_repo1}"
-          gemspec
-        G
-
-        expect(the_bundle).to include_gems("cocoapods 1.0", "activesupport 2.3.5")
-
-        build_lib "cocoapods", :path => bundled_app do |s|
-          s.add_dependency "activesupport", ">= 1.0.1"
-        end
-
-        bundle :install, forgotten_command_line_options(:deployment => true)
-
-        expect(out).to include("changed")
-      end
-    end
-  end
-
-  context "when child gemspecs conflict with a released gemspec" do
-    before do
-      # build the "parent" gem that depends on another gem in the same repo
-      build_lib "source_conflict", :path => bundled_app do |s|
-        s.add_dependency "rack_middleware"
-      end
-
-      # build the "child" gem that is the same version as a released gem, but
-      # has completely different and conflicting dependency requirements
-      build_lib "rack_middleware", "1.0", :path => bundled_app("rack_middleware") do |s|
-        s.add_dependency "rack", "1.0" # anything other than 0.9.1
-      end
-    end
-
-    it "should install the child gemspec's deps" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gemspec
-      G
-
-      expect(the_bundle).to include_gems "rack 1.0"
-    end
-  end
-
-  context "with a lockfile and some missing dependencies" do
-    let(:source_uri) { "http://localgemserver.test" }
-
-    context "previously bundled for Ruby" do
-      let(:platform) { "ruby" }
-      let(:explicit_platform) { false }
-
-      before do
-        build_lib("foo", :path => tmp.join("foo")) do |s|
-          s.add_dependency "rack", "=1.0.0"
-        end
-
-        if explicit_platform
-          create_file(
-            tmp.join("foo", "foo-#{platform}.gemspec"),
-            build_spec("foo", "1.0", platform) do
-              dep "rack", "=1.0.0"
-              @spec.authors = "authors"
-              @spec.summary = "summary"
-            end.first.to_ruby
-          )
-        end
-
-        gemfile <<-G
-          source "#{source_uri}"
-          gemspec :path => "../foo"
-        G
-
-        lockfile <<-L
-          PATH
-            remote: ../foo
-            specs:
-              foo (1.0)
-                rack (= 1.0.0)
-
-          GEM
-            remote: #{source_uri}
-            specs:
-              rack (1.0.0)
-
-          PLATFORMS
-            #{generic_local_platform}
-
-          DEPENDENCIES
-            foo!
-
-          BUNDLED WITH
-             #{Bundler::VERSION}
-        L
-      end
-
-      context "using JRuby with explicit platform" do
-        let(:platform) { "java" }
-        let(:explicit_platform) { true }
-
-        it "should install" do
-          simulate_ruby_engine "jruby" do
-            simulate_platform "java" do
-              results = bundle "install", :artifice => "endpoint"
-              expect(results).to include("Installing rack 1.0.0")
-              expect(the_bundle).to include_gems "rack 1.0.0"
-            end
-          end
-        end
-      end
-
-      context "using JRuby" do
-        let(:platform) { "java" }
-
-        it "should install" do
-          simulate_ruby_engine "jruby" do
-            simulate_platform "java" do
-              results = bundle "install", :artifice => "endpoint"
-              expect(results).to include("Installing rack 1.0.0")
-              expect(the_bundle).to include_gems "rack 1.0.0"
-            end
-          end
-        end
-      end
-
-      context "using Windows" do
-        it "should install" do
-          simulate_windows do
-            results = bundle "install", :artifice => "endpoint"
-            expect(results).to include("Installing rack 1.0.0")
-            expect(the_bundle).to include_gems "rack 1.0.0"
-          end
-        end
-      end
-    end
-
-    context "bundled for ruby and jruby" do
-      let(:platform_specific_type) { :runtime }
-      let(:dependency) { "platform_specific" }
-      before do
-        build_repo2 do
-          build_gem "indirect_platform_specific" do |s|
-            s.add_runtime_dependency "platform_specific"
-          end
-        end
-
-        build_lib "foo", :path => "." do |s|
-          if platform_specific_type == :runtime
-            s.add_runtime_dependency dependency
-          elsif platform_specific_type == :development
-            s.add_development_dependency dependency
-          else
-            raise "wrong dependency type #{platform_specific_type}, can only be :development or :runtime"
-          end
-        end
-
-        %w[ruby jruby].each do |platform|
-          simulate_platform(platform) do
-            install_gemfile <<-G
-              source "file://localhost#{gem_repo2}"
-              gemspec
-            G
-          end
-        end
-      end
-
-      context "on ruby", :bundler => "< 2" do
-        before do
-          simulate_platform("ruby")
-          bundle :install
-        end
-
-        context "as a runtime dependency" do
-          it "keeps java dependencies in the lockfile" do
-            expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 RUBY"
-            expect(lockfile).to eq strip_whitespace(<<-L)
-              PATH
-                remote: .
-                specs:
-                  foo (1.0)
-                    platform_specific
-
-              GEM
-                remote: file://localhost#{gem_repo2}/
-                specs:
-                  platform_specific (1.0)
-                  platform_specific (1.0-java)
-
-              PLATFORMS
-                java
-                ruby
-
-              DEPENDENCIES
-                foo!
-
-              BUNDLED WITH
-                 #{Bundler::VERSION}
-            L
-          end
-        end
-
-        context "as a development dependency" do
-          let(:platform_specific_type) { :development }
-
-          it "keeps java dependencies in the lockfile" do
-            expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 RUBY"
-            expect(lockfile).to eq strip_whitespace(<<-L)
-              PATH
-                remote: .
-                specs:
-                  foo (1.0)
-
-              GEM
-                remote: file://localhost#{gem_repo2}/
-                specs:
-                  platform_specific (1.0)
-                  platform_specific (1.0-java)
-
-              PLATFORMS
-                java
-                ruby
-
-              DEPENDENCIES
-                foo!
-                platform_specific
-
-              BUNDLED WITH
-                 #{Bundler::VERSION}
-            L
-          end
-        end
-
-        context "with an indirect platform-specific development dependency" do
-          let(:platform_specific_type) { :development }
-          let(:dependency) { "indirect_platform_specific" }
-
-          it "keeps java dependencies in the lockfile" do
-            expect(the_bundle).to include_gems "foo 1.0", "indirect_platform_specific 1.0", "platform_specific 1.0 RUBY"
-            expect(lockfile).to eq strip_whitespace(<<-L)
-              PATH
-                remote: .
-                specs:
-                  foo (1.0)
-
-              GEM
-                remote: file://localhost#{gem_repo2}/
-                specs:
-                  indirect_platform_specific (1.0)
-                    platform_specific
-                  platform_specific (1.0)
-                  platform_specific (1.0-java)
-
-              PLATFORMS
-                java
-                ruby
-
-              DEPENDENCIES
-                foo!
-                indirect_platform_specific
-
-              BUNDLED WITH
-                 #{Bundler::VERSION}
-            L
-          end
-        end
-      end
-
-      context "on ruby", :bundler => "2" do
-        before do
-          simulate_platform("ruby")
-          bundle :install
-        end
-
-        context "as a runtime dependency" do
-          it "keeps java dependencies in the lockfile" do
-            expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 RUBY"
-            expect(lockfile).to eq strip_whitespace(<<-L)
-              GEM
-                remote: file://localhost#{gem_repo2}/
-                specs:
-                  platform_specific (1.0)
-                  platform_specific (1.0-java)
-
-              PATH
-                remote: .
-                specs:
-                  foo (1.0)
-                    platform_specific
-
-              PLATFORMS
-                java
-                ruby
-
-              DEPENDENCIES
-                foo!
-
-              BUNDLED WITH
-                 #{Bundler::VERSION}
-            L
-          end
-        end
-
-        context "as a development dependency" do
-          let(:platform_specific_type) { :development }
-
-          it "keeps java dependencies in the lockfile" do
-            expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 RUBY"
-            expect(lockfile).to eq strip_whitespace(<<-L)
-              GEM
-                remote: file://localhost#{gem_repo2}/
-                specs:
-                  platform_specific (1.0)
-                  platform_specific (1.0-java)
-
-              PATH
-                remote: .
-                specs:
-                  foo (1.0)
-
-              PLATFORMS
-                java
-                ruby
-
-              DEPENDENCIES
-                foo!
-                platform_specific
-
-              BUNDLED WITH
-                 #{Bundler::VERSION}
-            L
-          end
-        end
-
-        context "with an indirect platform-specific development dependency" do
-          let(:platform_specific_type) { :development }
-          let(:dependency) { "indirect_platform_specific" }
-
-          it "keeps java dependencies in the lockfile" do
-            expect(the_bundle).to include_gems "foo 1.0", "indirect_platform_specific 1.0", "platform_specific 1.0 RUBY"
-            expect(lockfile).to eq strip_whitespace(<<-L)
-              GEM
-                remote: file://localhost#{gem_repo2}/
-                specs:
-                  indirect_platform_specific (1.0)
-                    platform_specific
-                  platform_specific (1.0)
-                  platform_specific (1.0-java)
-
-              PATH
-                remote: .
-                specs:
-                  foo (1.0)
-
-              PLATFORMS
-                java
-                ruby
-
-              DEPENDENCIES
-                foo!
-                indirect_platform_specific
-
-              BUNDLED WITH
-                 #{Bundler::VERSION}
-            L
-          end
-        end
-      end
-    end
-  end
-
-  context "with multiple platforms" do
-    before do
-      build_lib("foo", :path => tmp.join("foo")) do |s|
-        s.version = "1.0.0"
-        s.add_development_dependency "rack"
-        s.write "foo-universal-java.gemspec", build_spec("foo", "1.0.0", "universal-java") {|sj| sj.runtime "rack", "1.0.0" }.first.to_ruby
-      end
-    end
-
-    it "installs the ruby platform gemspec" do
-      simulate_platform "ruby"
-
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gemspec :path => '#{tmp.join("foo")}', :name => 'foo'
-      G
-
-      expect(the_bundle).to include_gems "foo 1.0.0", "rack 1.0.0"
-    end
-
-    it "installs the ruby platform gemspec and skips dev deps with --without development" do
-      simulate_platform "ruby"
-
-      install_gemfile! <<-G, forgotten_command_line_options(:without => "development")
-        source "file://#{gem_repo1}"
-        gemspec :path => '#{tmp.join("foo")}', :name => 'foo'
-      G
-
-      expect(the_bundle).to include_gem "foo 1.0.0"
-      expect(the_bundle).not_to include_gem "rack"
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/git_spec.rb b/spec/bundler/install/gemfile/git_spec.rb
deleted file mode 100644
index 57d83a5295..0000000000
--- a/spec/bundler/install/gemfile/git_spec.rb
+++ /dev/null
@@ -1,1351 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with git sources" do
-  describe "when floating on master" do
-    before :each do
-      build_git "foo" do |s|
-        s.executables = "foobar"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        git "#{lib_path("foo-1.0")}" do
-          gem 'foo'
-        end
-      G
-    end
-
-    it "fetches gems" do
-      expect(the_bundle).to include_gems("foo 1.0")
-
-      run <<-RUBY
-        require 'foo'
-        puts "WIN" unless defined?(FOO_PREV_REF)
-      RUBY
-
-      expect(out).to eq("WIN")
-    end
-
-    it "caches the git repo", :bundler => "< 2" do
-      expect(Dir["#{default_bundle_path}/cache/bundler/git/foo-1.0-*"]).to have_attributes :size => 1
-    end
-
-    it "caches the git repo globally" do
-      simulate_new_machine
-      bundle! "config global_gem_cache true"
-      bundle! :install
-      expect(Dir["#{home}/.bundle/cache/git/foo-1.0-*"]).to have_attributes :size => 1
-    end
-
-    it "caches the evaluated gemspec" do
-      git = update_git "foo" do |s|
-        s.executables = ["foobar"] # we added this the first time, so keep it now
-        s.files = ["bin/foobar"] # updating git nukes the files list
-        foospec = s.to_ruby.gsub(/s\.files.*/, 's.files = `git ls-files -z`.split("\x0")')
-        s.write "foo.gemspec", foospec
-      end
-
-      bundle "update foo"
-
-      sha = git.ref_for("master", 11)
-      spec_file = default_bundle_path.join("bundler/gems/foo-1.0-#{sha}/foo.gemspec").to_s
-      ruby_code = Gem::Specification.load(spec_file).to_ruby
-      file_code = File.read(spec_file)
-      expect(file_code).to eq(ruby_code)
-    end
-
-    it "does not update the git source implicitly" do
-      update_git "foo"
-
-      in_app_root2 do
-        install_gemfile bundled_app2("Gemfile"), <<-G
-          git "#{lib_path("foo-1.0")}" do
-            gem 'foo'
-          end
-        G
-      end
-
-      in_app_root do
-        run <<-RUBY
-          require 'foo'
-          puts "fail" if defined?(FOO_PREV_REF)
-        RUBY
-
-        expect(out).to be_empty
-      end
-    end
-
-    it "sets up git gem executables on the path" do
-      bundle "exec foobar"
-      expect(out).to eq("1.0")
-    end
-
-    it "complains if pinned specs don't exist in the git repo" do
-      build_git "foo"
-
-      install_gemfile <<-G
-        gem "foo", "1.1", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      expect(out).to include("The source contains 'foo' at: 1.0")
-    end
-
-    it "complains with version and platform if pinned specs don't exist in the git repo" do
-      simulate_platform "java"
-
-      build_git "only_java" do |s|
-        s.platform = "java"
-      end
-
-      install_gemfile <<-G
-        platforms :jruby do
-          gem "only_java", "1.2", :git => "#{lib_path("only_java-1.0-java")}"
-        end
-      G
-
-      expect(out).to include("The source contains 'only_java' at: 1.0 java")
-    end
-
-    it "complains with multiple versions and platforms if pinned specs don't exist in the git repo" do
-      simulate_platform "java"
-
-      build_git "only_java", "1.0" do |s|
-        s.platform = "java"
-      end
-
-      build_git "only_java", "1.1" do |s|
-        s.platform = "java"
-        s.write "only_java1-0.gemspec", File.read("#{lib_path("only_java-1.0-java")}/only_java.gemspec")
-      end
-
-      install_gemfile <<-G
-        platforms :jruby do
-          gem "only_java", "1.2", :git => "#{lib_path("only_java-1.1-java")}"
-        end
-      G
-
-      expect(out).to include("The source contains 'only_java' at: 1.0 java, 1.1 java")
-    end
-
-    it "still works after moving the application directory" do
-      bundle "install --path vendor/bundle"
-      FileUtils.mv bundled_app, tmp("bundled_app.bck")
-
-      Dir.chdir tmp("bundled_app.bck")
-      expect(the_bundle).to include_gems "foo 1.0"
-    end
-
-    it "can still install after moving the application directory" do
-      bundle "install --path vendor/bundle"
-      FileUtils.mv bundled_app, tmp("bundled_app.bck")
-
-      update_git "foo", "1.1", :path => lib_path("foo-1.0")
-
-      Dir.chdir tmp("bundled_app.bck")
-      gemfile tmp("bundled_app.bck/Gemfile"), <<-G
-        source "file://#{gem_repo1}"
-        git "#{lib_path("foo-1.0")}" do
-          gem 'foo'
-        end
-
-        gem "rack", "1.0"
-      G
-
-      bundle "update foo"
-
-      expect(the_bundle).to include_gems "foo 1.1", "rack 1.0"
-    end
-  end
-
-  describe "with an empty git block" do
-    before do
-      build_git "foo"
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-
-        git "#{lib_path("foo-1.0")}" do
-          # this page left intentionally blank
-        end
-      G
-    end
-
-    it "does not explode" do
-      bundle "install"
-      expect(the_bundle).to include_gems "rack 1.0"
-    end
-  end
-
-  describe "when specifying a revision" do
-    before(:each) do
-      build_git "foo"
-      @revision = revision_for(lib_path("foo-1.0"))
-      update_git "foo"
-    end
-
-    it "works" do
-      install_gemfile <<-G
-        git "#{lib_path("foo-1.0")}", :ref => "#{@revision}" do
-          gem "foo"
-        end
-      G
-
-      run <<-RUBY
-        require 'foo'
-        puts "WIN" unless defined?(FOO_PREV_REF)
-      RUBY
-
-      expect(out).to eq("WIN")
-    end
-
-    it "works when the revision is a symbol" do
-      install_gemfile <<-G
-        git "#{lib_path("foo-1.0")}", :ref => #{@revision.to_sym.inspect} do
-          gem "foo"
-        end
-      G
-      expect(err).to lack_errors
-
-      run <<-RUBY
-        require 'foo'
-        puts "WIN" unless defined?(FOO_PREV_REF)
-      RUBY
-
-      expect(out).to eq("WIN")
-    end
-
-    it "works when the revision is a non-head ref" do
-      # want to ensure we don't fallback to master
-      update_git "foo", :path => lib_path("foo-1.0") do |s|
-        s.write("lib/foo.rb", "raise 'FAIL'")
-      end
-
-      Dir.chdir(lib_path("foo-1.0")) do
-        `git update-ref -m 'Bundler Spec!' refs/bundler/1 master~1`
-      end
-
-      # want to ensure we don't fallback to HEAD
-      update_git "foo", :path => lib_path("foo-1.0"), :branch => "rando" do |s|
-        s.write("lib/foo.rb", "raise 'FAIL'")
-      end
-
-      install_gemfile! <<-G
-        git "#{lib_path("foo-1.0")}", :ref => "refs/bundler/1" do
-          gem "foo"
-        end
-      G
-      expect(err).to lack_errors
-
-      run! <<-RUBY
-        require 'foo'
-        puts "WIN" if defined?(FOO)
-      RUBY
-
-      expect(out).to eq("WIN")
-    end
-
-    it "works when the revision is a non-head ref and it was previously downloaded" do
-      install_gemfile! <<-G
-        git "#{lib_path("foo-1.0")}" do
-          gem "foo"
-        end
-      G
-
-      # want to ensure we don't fallback to master
-      update_git "foo", :path => lib_path("foo-1.0") do |s|
-        s.write("lib/foo.rb", "raise 'FAIL'")
-      end
-
-      Dir.chdir(lib_path("foo-1.0")) do
-        `git update-ref -m 'Bundler Spec!' refs/bundler/1 master~1`
-      end
-
-      # want to ensure we don't fallback to HEAD
-      update_git "foo", :path => lib_path("foo-1.0"), :branch => "rando" do |s|
-        s.write("lib/foo.rb", "raise 'FAIL'")
-      end
-
-      install_gemfile! <<-G
-        git "#{lib_path("foo-1.0")}", :ref => "refs/bundler/1" do
-          gem "foo"
-        end
-      G
-      expect(err).to lack_errors
-
-      run! <<-RUBY
-        require 'foo'
-        puts "WIN" if defined?(FOO)
-      RUBY
-
-      expect(out).to eq("WIN")
-    end
-
-    it "does not download random non-head refs" do
-      Dir.chdir(lib_path("foo-1.0")) do
-        sys_exec!("git update-ref -m 'Bundler Spec!' refs/bundler/1 master~1")
-      end
-
-      bundle! "config global_gem_cache true"
-
-      install_gemfile! <<-G
-        git "#{lib_path("foo-1.0")}" do
-          gem "foo"
-        end
-      G
-
-      # ensure we also git fetch after cloning
-      bundle! :update, :all => bundle_update_requires_all?
-
-      Dir.chdir(Dir[home(".bundle/cache/git/foo-*")].first) do
-        sys_exec("git ls-remote .")
-      end
-
-      expect(out).not_to include("refs/bundler/1")
-    end
-  end
-
-  describe "when specifying a branch" do
-    let(:branch) { "branch" }
-    let(:repo) { build_git("foo").path }
-    before(:each) do
-      update_git("foo", :path => repo, :branch => branch)
-    end
-
-    it "works" do
-      install_gemfile <<-G
-        git "#{repo}", :branch => #{branch.dump} do
-          gem "foo"
-        end
-      G
-
-      expect(the_bundle).to include_gems("foo 1.0")
-    end
-
-    context "when the branch starts with a `#`" do
-      let(:branch) { "#149/redirect-url-fragment" }
-      it "works" do
-        install_gemfile <<-G
-          git "#{repo}", :branch => #{branch.dump} do
-            gem "foo"
-          end
-        G
-
-        expect(the_bundle).to include_gems("foo 1.0")
-      end
-    end
-
-    context "when the branch includes quotes" do
-      let(:branch) { %('") }
-      it "works" do
-        install_gemfile <<-G
-          git "#{repo}", :branch => #{branch.dump} do
-            gem "foo"
-          end
-        G
-
-        expect(the_bundle).to include_gems("foo 1.0")
-      end
-    end
-  end
-
-  describe "when specifying a tag" do
-    let(:tag) { "tag" }
-    let(:repo) { build_git("foo").path }
-    before(:each) do
-      update_git("foo", :path => repo, :tag => tag)
-    end
-
-    it "works" do
-      install_gemfile <<-G
-        git "#{repo}", :tag => #{tag.dump} do
-          gem "foo"
-        end
-      G
-
-      expect(the_bundle).to include_gems("foo 1.0")
-    end
-
-    context "when the tag starts with a `#`" do
-      let(:tag) { "#149/redirect-url-fragment" }
-      it "works" do
-        install_gemfile <<-G
-          git "#{repo}", :tag => #{tag.dump} do
-            gem "foo"
-          end
-        G
-
-        expect(the_bundle).to include_gems("foo 1.0")
-      end
-    end
-
-    context "when the tag includes quotes" do
-      let(:tag) { %('") }
-      it "works" do
-        install_gemfile <<-G
-          git "#{repo}", :tag => #{tag.dump} do
-            gem "foo"
-          end
-        G
-
-        expect(the_bundle).to include_gems("foo 1.0")
-      end
-    end
-  end
-
-  describe "when specifying local override" do
-    it "uses the local repository instead of checking a new one out" do
-      # We don't generate it because we actually don't need it
-      # build_git "rack", "0.8"
-
-      build_git "rack", "0.8", :path => lib_path("local-rack") do |s|
-        s.write "lib/rack.rb", "puts :LOCAL"
-      end
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle! %(config local.rack #{lib_path("local-rack")})
-      bundle! :install
-
-      run "require 'rack'"
-      expect(out).to eq("LOCAL")
-    end
-
-    it "chooses the local repository on runtime" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      update_git "rack", "0.8", :path => lib_path("local-rack") do |s|
-        s.write "lib/rack.rb", "puts :LOCAL"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      run "require 'rack'"
-      expect(out).to eq("LOCAL")
-    end
-
-    it "unlocks the source when the dependencies have changed while switching to the local" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      update_git "rack", "0.8", :path => lib_path("local-rack") do |s|
-        s.write "rack.gemspec", build_spec("rack", "0.8") { runtime "rspec", "> 0" }.first.to_ruby
-        s.write "lib/rack.rb", "puts :LOCAL"
-      end
-
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle! %(config local.rack #{lib_path("local-rack")})
-      bundle! :install
-      run! "require 'rack'"
-      expect(out).to eq("LOCAL")
-    end
-
-    it "updates specs on runtime" do
-      system_gems "nokogiri-1.4.2"
-
-      build_git "rack", "0.8"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      lockfile0 = File.read(bundled_app("Gemfile.lock"))
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-      update_git "rack", "0.8", :path => lib_path("local-rack") do |s|
-        s.add_dependency "nokogiri", "1.4.2"
-      end
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      run "require 'rack'"
-
-      lockfile1 = File.read(bundled_app("Gemfile.lock"))
-      expect(lockfile1).not_to eq(lockfile0)
-    end
-
-    it "updates ref on install" do
-      build_git "rack", "0.8"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      lockfile0 = File.read(bundled_app("Gemfile.lock"))
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-      update_git "rack", "0.8", :path => lib_path("local-rack")
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle :install
-
-      lockfile1 = File.read(bundled_app("Gemfile.lock"))
-      expect(lockfile1).not_to eq(lockfile0)
-    end
-
-    it "explodes if given path does not exist on install" do
-      build_git "rack", "0.8"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle :install
-      expect(out).to match(/Cannot use local override for rack-0.8 because #{Regexp.escape(lib_path('local-rack').to_s)} does not exist/)
-    end
-
-    it "explodes if branch is not given on install" do
-      build_git "rack", "0.8"
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle :install
-      expect(out).to match(/cannot use local override/i)
-    end
-
-    it "does not explode if disable_local_branch_check is given" do
-      build_git "rack", "0.8"
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle %(config disable_local_branch_check true)
-      bundle :install
-      expect(out).to match(/Bundle complete!/)
-    end
-
-    it "explodes on different branches on install" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      update_git "rack", "0.8", :path => lib_path("local-rack"), :branch => "another" do |s|
-        s.write "lib/rack.rb", "puts :LOCAL"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle :install
-      expect(out).to match(/is using branch another but Gemfile specifies master/)
-    end
-
-    it "explodes on invalid revision on install" do
-      build_git "rack", "0.8"
-
-      build_git "rack", "0.8", :path => lib_path("local-rack") do |s|
-        s.write "lib/rack.rb", "puts :LOCAL"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle :install
-      expect(out).to match(/The Gemfile lock is pointing to revision \w+/)
-    end
-  end
-
-  describe "specified inline" do
-    # TODO: Figure out how to write this test so that it is not flaky depending
-    #       on the current network situation.
-    # it "supports private git URLs" do
-    #   gemfile <<-G
-    #     gem "thingy", :git => "git@notthere.fallingsnow.net:somebody/thingy.git"
-    #   G
-    #
-    #   bundle :install
-    #
-    #   # p out
-    #   # p err
-    #   puts err unless err.empty? # This spec fails randomly every so often
-    #   err.should include("notthere.fallingsnow.net")
-    #   err.should include("ssh")
-    # end
-
-    it "installs from git even if a newer gem is available elsewhere" do
-      build_git "rack", "0.8"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}"
-      G
-
-      expect(the_bundle).to include_gems "rack 0.8"
-    end
-
-    it "installs dependencies from git even if a newer gem is available elsewhere" do
-      system_gems "rack-1.0.0"
-
-      build_lib "rack", "1.0", :path => lib_path("nested/bar") do |s|
-        s.write "lib/rack.rb", "puts 'WIN OVERRIDE'"
-      end
-
-      build_git "foo", :path => lib_path("nested") do |s|
-        s.add_dependency "rack", "= 1.0"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "foo", :git => "#{lib_path("nested")}"
-      G
-
-      run "require 'rack'"
-      expect(out).to eq("WIN OVERRIDE")
-    end
-
-    it "correctly unlocks when changing to a git source" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", "0.9.1"
-      G
-
-      build_git "rack", :path => lib_path("rack")
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", "1.0.0", :git => "#{lib_path("rack")}"
-      G
-
-      expect(the_bundle).to include_gems "rack 1.0.0"
-    end
-
-    it "correctly unlocks when changing to a git source without versions" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      build_git "rack", "1.2", :path => lib_path("rack")
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack")}"
-      G
-
-      expect(the_bundle).to include_gems "rack 1.2"
-    end
-  end
-
-  describe "block syntax" do
-    it "pulls all gems from a git block" do
-      build_lib "omg", :path => lib_path("hi2u/omg")
-      build_lib "hi2u", :path => lib_path("hi2u")
-
-      install_gemfile <<-G
-        path "#{lib_path("hi2u")}" do
-          gem "omg"
-          gem "hi2u"
-        end
-      G
-
-      expect(the_bundle).to include_gems "omg 1.0", "hi2u 1.0"
-    end
-  end
-
-  it "uses a ref if specified" do
-    build_git "foo"
-    @revision = revision_for(lib_path("foo-1.0"))
-    update_git "foo"
-
-    install_gemfile <<-G
-      gem "foo", :git => "#{lib_path("foo-1.0")}", :ref => "#{@revision}"
-    G
-
-    run <<-RUBY
-      require 'foo'
-      puts "WIN" unless defined?(FOO_PREV_REF)
-    RUBY
-
-    expect(out).to eq("WIN")
-  end
-
-  it "correctly handles cases with invalid gemspecs" do
-    build_git "foo" do |s|
-      s.summary = nil
-    end
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "foo", :git => "#{lib_path("foo-1.0")}"
-      gem "rails", "2.3.2"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-    expect(the_bundle).to include_gems "rails 2.3.2"
-  end
-
-  it "runs the gemspec in the context of its parent directory" do
-    build_lib "bar", :path => lib_path("foo/bar"), :gemspec => false do |s|
-      s.write lib_path("foo/bar/lib/version.rb"), %(BAR_VERSION = '1.0')
-      s.write "bar.gemspec", <<-G
-        $:.unshift Dir.pwd # For 1.9
-        require 'lib/version'
-        Gem::Specification.new do |s|
-          s.name        = 'bar'
-          s.author      = 'no one'
-          s.version     = BAR_VERSION
-          s.summary     = 'Bar'
-          s.files       = Dir["lib/**/*.rb"]
-        end
-      G
-    end
-
-    build_git "foo", :path => lib_path("foo") do |s|
-      s.write "bin/foo", ""
-    end
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "bar", :git => "#{lib_path("foo")}"
-      gem "rails", "2.3.2"
-    G
-
-    expect(the_bundle).to include_gems "bar 1.0"
-    expect(the_bundle).to include_gems "rails 2.3.2"
-  end
-
-  it "installs from git even if a rubygems gem is present" do
-    build_gem "foo", "1.0", :path => lib_path("fake_foo"), :to_system => true do |s|
-      s.write "lib/foo.rb", "raise 'FAIL'"
-    end
-
-    build_git "foo", "1.0"
-
-    install_gemfile <<-G
-      gem "foo", "1.0", :git => "#{lib_path("foo-1.0")}"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-  end
-
-  it "fakes the gem out if there is no gemspec" do
-    build_git "foo", :gemspec => false
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "foo", "1.0", :git => "#{lib_path("foo-1.0")}"
-      gem "rails", "2.3.2"
-    G
-
-    expect(the_bundle).to include_gems("foo 1.0")
-    expect(the_bundle).to include_gems("rails 2.3.2")
-  end
-
-  it "catches git errors and spits out useful output" do
-    gemfile <<-G
-      gem "foo", "1.0", :git => "omgomg"
-    G
-
-    bundle :install
-
-    expect(out).to include("Git error:")
-    expect(err).to include("fatal")
-    expect(err).to include("omgomg")
-  end
-
-  it "works when the gem path has spaces in it" do
-    build_git "foo", :path => lib_path("foo space-1.0")
-
-    install_gemfile <<-G
-      gem "foo", :git => "#{lib_path("foo space-1.0")}"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-  end
-
-  it "handles repos that have been force-pushed" do
-    build_git "forced", "1.0"
-
-    install_gemfile <<-G
-      git "#{lib_path("forced-1.0")}" do
-        gem 'forced'
-      end
-    G
-    expect(the_bundle).to include_gems "forced 1.0"
-
-    update_git "forced" do |s|
-      s.write "lib/forced.rb", "FORCED = '1.1'"
-    end
-
-    bundle "update", :all => bundle_update_requires_all?
-    expect(the_bundle).to include_gems "forced 1.1"
-
-    Dir.chdir(lib_path("forced-1.0")) do
-      `git reset --hard HEAD^`
-    end
-
-    bundle "update", :all => bundle_update_requires_all?
-    expect(the_bundle).to include_gems "forced 1.0"
-  end
-
-  it "ignores submodules if :submodule is not passed" do
-    build_git "submodule", "1.0"
-    build_git "has_submodule", "1.0" do |s|
-      s.add_dependency "submodule"
-    end
-    Dir.chdir(lib_path("has_submodule-1.0")) do
-      sys_exec "git submodule add #{lib_path("submodule-1.0")} submodule-1.0"
-      `git commit -m "submodulator"`
-    end
-
-    install_gemfile <<-G
-      git "#{lib_path("has_submodule-1.0")}" do
-        gem "has_submodule"
-      end
-    G
-    expect(out).to match(/could not find gem 'submodule/i)
-
-    expect(the_bundle).not_to include_gems "has_submodule 1.0"
-  end
-
-  it "handles repos with submodules" do
-    build_git "submodule", "1.0"
-    build_git "has_submodule", "1.0" do |s|
-      s.add_dependency "submodule"
-    end
-    Dir.chdir(lib_path("has_submodule-1.0")) do
-      sys_exec "git submodule add #{lib_path("submodule-1.0")} submodule-1.0"
-      `git commit -m "submodulator"`
-    end
-
-    install_gemfile <<-G
-      git "#{lib_path("has_submodule-1.0")}", :submodules => true do
-        gem "has_submodule"
-      end
-    G
-
-    expect(the_bundle).to include_gems "has_submodule 1.0"
-  end
-
-  it "handles implicit updates when modifying the source info" do
-    git = build_git "foo"
-
-    install_gemfile <<-G
-      git "#{lib_path("foo-1.0")}" do
-        gem "foo"
-      end
-    G
-
-    update_git "foo"
-    update_git "foo"
-
-    install_gemfile <<-G
-      git "#{lib_path("foo-1.0")}", :ref => "#{git.ref_for("HEAD^")}" do
-        gem "foo"
-      end
-    G
-
-    run <<-RUBY
-      require 'foo'
-      puts "WIN" if FOO_PREV_REF == '#{git.ref_for("HEAD^^")}'
-    RUBY
-
-    expect(out).to eq("WIN")
-  end
-
-  it "does not to a remote fetch if the revision is cached locally" do
-    build_git "foo"
-
-    install_gemfile <<-G
-      gem "foo", :git => "#{lib_path("foo-1.0")}"
-    G
-
-    FileUtils.rm_rf(lib_path("foo-1.0"))
-
-    bundle "install"
-    expect(out).not_to match(/updating/i)
-  end
-
-  it "doesn't blow up if bundle install is run twice in a row" do
-    build_git "foo"
-
-    gemfile <<-G
-      gem "foo", :git => "#{lib_path("foo-1.0")}"
-    G
-
-    bundle "install"
-    bundle "install"
-    expect(exitstatus).to eq(0) if exitstatus
-  end
-
-  it "prints a friendly error if a file blocks the git repo" do
-    build_git "foo"
-
-    FileUtils.mkdir_p(default_bundle_path)
-    FileUtils.touch(default_bundle_path("bundler"))
-
-    install_gemfile <<-G
-      gem "foo", :git => "#{lib_path("foo-1.0")}"
-    G
-
-    expect(exitstatus).to_not eq(0) if exitstatus
-    expect(out).to include("Bundler could not install a gem because it " \
-                           "needs to create a directory, but a file exists " \
-                           "- #{default_bundle_path("bundler")}")
-  end
-
-  it "does not duplicate git gem sources" do
-    build_lib "foo", :path => lib_path("nested/foo")
-    build_lib "bar", :path => lib_path("nested/bar")
-
-    build_git "foo", :path => lib_path("nested")
-    build_git "bar", :path => lib_path("nested")
-
-    gemfile <<-G
-      gem "foo", :git => "#{lib_path("nested")}"
-      gem "bar", :git => "#{lib_path("nested")}"
-    G
-
-    bundle "install"
-    expect(File.read(bundled_app("Gemfile.lock")).scan("GIT").size).to eq(1)
-  end
-
-  describe "switching sources" do
-    it "doesn't explode when switching Path to Git sources" do
-      build_gem "foo", "1.0", :to_system => true do |s|
-        s.write "lib/foo.rb", "raise 'fail'"
-      end
-      build_lib "foo", "1.0", :path => lib_path("bar/foo")
-      build_git "bar", "1.0", :path => lib_path("bar") do |s|
-        s.add_dependency "foo"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "bar", :path => "#{lib_path("bar")}"
-      G
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "bar", :git => "#{lib_path("bar")}"
-      G
-
-      expect(the_bundle).to include_gems "foo 1.0", "bar 1.0"
-    end
-
-    it "doesn't explode when switching Gem to Git source" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack-obama"
-        gem "rack", "1.0.0"
-      G
-
-      build_git "rack", "1.0" do |s|
-        s.write "lib/new_file.rb", "puts 'USING GIT'"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack-obama"
-        gem "rack", "1.0.0", :git => "#{lib_path("rack-1.0")}"
-      G
-
-      run "require 'new_file'"
-      expect(out).to eq("USING GIT")
-    end
-  end
-
-  describe "bundle install after the remote has been updated" do
-    it "installs" do
-      build_git "valim"
-
-      install_gemfile <<-G
-        gem "valim", :git => "file://#{lib_path("valim-1.0")}"
-      G
-
-      old_revision = revision_for(lib_path("valim-1.0"))
-      update_git "valim"
-      new_revision = revision_for(lib_path("valim-1.0"))
-
-      lockfile = File.read(bundled_app("Gemfile.lock"))
-      File.open(bundled_app("Gemfile.lock"), "w") do |file|
-        file.puts lockfile.gsub(/revision: #{old_revision}/, "revision: #{new_revision}")
-      end
-
-      bundle "install"
-
-      run <<-R
-        require "valim"
-        puts VALIM_PREV_REF
-      R
-
-      expect(out).to eq(old_revision)
-    end
-
-    it "gives a helpful error message when the remote ref no longer exists" do
-      build_git "foo"
-      revision = revision_for(lib_path("foo-1.0"))
-
-      install_gemfile <<-G
-        gem "foo", :git => "file://#{lib_path("foo-1.0")}", :ref => "#{revision}"
-      G
-      bundle "install"
-      expect(out).to_not match(/Revision.*does not exist/)
-
-      install_gemfile <<-G
-        gem "foo", :git => "file://#{lib_path("foo-1.0")}", :ref => "deadbeef"
-      G
-      bundle "install"
-      expect(out).to include("Revision deadbeef does not exist in the repository")
-    end
-  end
-
-  describe "bundle install --deployment with git sources" do
-    it "works" do
-      build_git "valim", :path => lib_path("valim")
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "valim", "= 1.0", :git => "#{lib_path("valim")}"
-      G
-
-      simulate_new_machine
-
-      bundle! :install, forgotten_command_line_options(:deployment => true)
-    end
-  end
-
-  describe "gem install hooks" do
-    it "runs pre-install hooks" do
-      build_git "foo"
-      gemfile <<-G
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      File.open(lib_path("install_hooks.rb"), "w") do |h|
-        h.write <<-H
-          require 'rubygems'
-          Gem.pre_install_hooks << lambda do |inst|
-            STDERR.puts "Ran pre-install hook: \#{inst.spec.full_name}"
-          end
-        H
-      end
-
-      bundle :install,
-        :requires => [lib_path("install_hooks.rb")]
-      expect(err).to eq_err("Ran pre-install hook: foo-1.0")
-    end
-
-    it "runs post-install hooks" do
-      build_git "foo"
-      gemfile <<-G
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      File.open(lib_path("install_hooks.rb"), "w") do |h|
-        h.write <<-H
-          require 'rubygems'
-          Gem.post_install_hooks << lambda do |inst|
-            STDERR.puts "Ran post-install hook: \#{inst.spec.full_name}"
-          end
-        H
-      end
-
-      bundle :install,
-        :requires => [lib_path("install_hooks.rb")]
-      expect(err).to eq_err("Ran post-install hook: foo-1.0")
-    end
-
-    it "complains if the install hook fails" do
-      build_git "foo"
-      gemfile <<-G
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      File.open(lib_path("install_hooks.rb"), "w") do |h|
-        h.write <<-H
-          require 'rubygems'
-          Gem.pre_install_hooks << lambda do |inst|
-            false
-          end
-        H
-      end
-
-      bundle :install,
-        :requires => [lib_path("install_hooks.rb")]
-      expect(out).to include("failed for foo-1.0")
-    end
-  end
-
-  context "with an extension" do
-    it "installs the extension", :ruby_repo do
-      build_git "foo" do |s|
-        s.add_dependency "rake"
-        s.extensions << "Rakefile"
-        s.write "Rakefile", <<-RUBY
-          task :default do
-            path = File.expand_path("../lib", __FILE__)
-            FileUtils.mkdir_p(path)
-            File.open("\#{path}/foo.rb", "w") do |f|
-              f.puts "FOO = 'YES'"
-            end
-          end
-        RUBY
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      run <<-R
-        require 'foo'
-        puts FOO
-      R
-      expect(out).to eq("YES")
-
-      run! <<-R
-        puts $:.grep(/ext/)
-      R
-      expect(out).to eq(Pathname.glob(default_bundle_path("bundler/gems/extensions/**/foo-1.0-*")).first.to_s)
-    end
-
-    it "does not use old extension after ref changes", :ruby_repo do
-      git_reader = build_git "foo", :no_default => true do |s|
-        s.extensions = ["ext/extconf.rb"]
-        s.write "ext/extconf.rb", <<-RUBY
-          require "mkmf"
-          create_makefile("foo")
-        RUBY
-        s.write "ext/foo.c", "void Init_foo() {}"
-      end
-
-      2.times do |i|
-        Dir.chdir(git_reader.path) do
-          File.open("ext/foo.c", "w") do |file|
-            file.write <<-C
-              #include "ruby.h"
-              VALUE foo() { return INT2FIX(#{i}); }
-              void Init_foo() { rb_define_global_function("foo", &foo, 0); }
-            C
-          end
-          `git commit -m 'commit for iteration #{i}' ext/foo.c`
-        end
-        git_commit_sha = git_reader.ref_for("HEAD")
-
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "foo", :git => "#{lib_path("foo-1.0")}", :ref => "#{git_commit_sha}"
-        G
-
-        run <<-R
-          require 'foo'
-          puts foo
-        R
-
-        expect(out).to eq(i.to_s)
-      end
-    end
-
-    it "does not prompt to gem install if extension fails" do
-      build_git "foo" do |s|
-        s.add_dependency "rake"
-        s.extensions << "Rakefile"
-        s.write "Rakefile", <<-RUBY
-          task :default do
-            raise
-          end
-        RUBY
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      expect(last_command.bundler_err).to end_with(<<-M.strip)
-An error occurred while installing foo (1.0), and Bundler cannot continue.
-
-In Gemfile:
-  foo
-      M
-      expect(out).not_to include("gem install foo")
-    end
-
-    it "does not reinstall the extension", :ruby_repo, :rubygems => ">= 2.3.0" do
-      build_git "foo" do |s|
-        s.add_dependency "rake"
-        s.extensions << "Rakefile"
-        s.write "Rakefile", <<-RUBY
-          task :default do
-            path = File.expand_path("../lib", __FILE__)
-            FileUtils.mkdir_p(path)
-            cur_time = Time.now.to_f.to_s
-            File.open("\#{path}/foo.rb", "w") do |f|
-              f.puts "FOO = \#{cur_time}"
-            end
-          end
-        RUBY
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      run! <<-R
-        require 'foo'
-        puts FOO
-      R
-
-      installed_time = out
-      expect(installed_time).to match(/\A\d+\.\d+\z/)
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      run! <<-R
-        require 'foo'
-        puts FOO
-      R
-      expect(out).to eq(installed_time)
-    end
-  end
-
-  it "ignores git environment variables" do
-    build_git "xxxxxx" do |s|
-      s.executables = "xxxxxxbar"
-    end
-
-    Bundler::SharedHelpers.with_clean_git_env do
-      ENV["GIT_DIR"]       = "bar"
-      ENV["GIT_WORK_TREE"] = "bar"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        git "#{lib_path("xxxxxx-1.0")}" do
-          gem 'xxxxxx'
-        end
-      G
-
-      expect(exitstatus).to eq(0) if exitstatus
-      expect(ENV["GIT_DIR"]).to eq("bar")
-      expect(ENV["GIT_WORK_TREE"]).to eq("bar")
-    end
-  end
-
-  describe "without git installed" do
-    it "prints a better error message" do
-      build_git "foo"
-
-      install_gemfile <<-G
-        git "#{lib_path("foo-1.0")}" do
-          gem 'foo'
-        end
-      G
-
-      with_path_as("") do
-        bundle "update", :all => bundle_update_requires_all?
-      end
-      expect(last_command.bundler_err).
-        to include("You need to install git to be able to use gems from git repositories. For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git")
-    end
-
-    it "installs a packaged git gem successfully" do
-      build_git "foo"
-
-      install_gemfile <<-G
-        git "#{lib_path("foo-1.0")}" do
-          gem 'foo'
-        end
-      G
-      bundle :package, forgotten_command_line_options([:all, :cache_all] => true)
-      simulate_new_machine
-
-      bundle! "install", :env => { "PATH" => "" }
-      expect(out).to_not include("You need to install git to be able to use gems from git repositories.")
-    end
-  end
-
-  describe "when the git source is overridden with a local git repo" do
-    before do
-      bundle! "config --global local.foo #{lib_path("foo")}"
-    end
-
-    describe "and git output is colorized" do
-      before do
-        File.open("#{ENV["HOME"]}/.gitconfig", "w") do |f|
-          f.write("[color]\n\tui = always\n")
-        end
-      end
-
-      it "installs successfully" do
-        build_git "foo", "1.0", :path => lib_path("foo")
-
-        gemfile <<-G
-          gem "foo", :git => "#{lib_path("foo")}", :branch => "master"
-        G
-
-        bundle :install
-        expect(the_bundle).to include_gems "foo 1.0"
-      end
-    end
-  end
-
-  context "git sources that include credentials" do
-    context "that are username and password" do
-      let(:credentials) { "user1:password1" }
-
-      it "does not display the password" do
-        install_gemfile <<-G
-          git "https://#{credentials}@github.com/company/private-repo" do
-            gem "foo"
-          end
-        G
-
-        bundle :install
-        expect(last_command.stdboth).to_not include("password1")
-        expect(last_command.stdout).to include("Fetching https://user1@github.com/company/private-repo")
-      end
-    end
-
-    context "that is an oauth token" do
-      let(:credentials) { "oauth_token" }
-
-      it "displays the oauth scheme but not the oauth token" do
-        install_gemfile <<-G
-          git "https://#{credentials}:x-oauth-basic@github.com/company/private-repo" do
-            gem "foo"
-          end
-        G
-
-        bundle :install
-        expect(last_command.stdboth).to_not include("oauth_token")
-        expect(last_command.stdout).to include("Fetching https://x-oauth-basic@github.com/company/private-repo")
-      end
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/groups_spec.rb b/spec/bundler/install/gemfile/groups_spec.rb
deleted file mode 100644
index 19c379e188..0000000000
--- a/spec/bundler/install/gemfile/groups_spec.rb
+++ /dev/null
@@ -1,384 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with groups" do
-  describe "installing with no options" do
-    before :each do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        group :emo do
-          gem "activesupport", "2.3.5"
-        end
-        gem "thin", :groups => [:emo]
-      G
-    end
-
-    it "installs gems in the default group" do
-      expect(the_bundle).to include_gems "rack 1.0.0"
-    end
-
-    it "installs gems in a group block into that group" do
-      expect(the_bundle).to include_gems "activesupport 2.3.5"
-
-      load_error_run <<-R, "activesupport", :default
-        require 'activesupport'
-        puts ACTIVESUPPORT
-      R
-
-      expect(err).to eq_err("ZOMG LOAD ERROR")
-    end
-
-    it "installs gems with inline :groups into those groups" do
-      expect(the_bundle).to include_gems "thin 1.0"
-
-      load_error_run <<-R, "thin", :default
-        require 'thin'
-        puts THIN
-      R
-
-      expect(err).to eq_err("ZOMG LOAD ERROR")
-    end
-
-    it "sets up everything if Bundler.setup is used with no groups" do
-      output = run("require 'rack'; puts RACK")
-      expect(output).to eq("1.0.0")
-
-      output = run("require 'activesupport'; puts ACTIVESUPPORT")
-      expect(output).to eq("2.3.5")
-
-      output = run("require 'thin'; puts THIN")
-      expect(output).to eq("1.0")
-    end
-
-    it "removes old groups when new groups are set up" do
-      load_error_run <<-RUBY, "thin", :emo
-        Bundler.setup(:default)
-        require 'thin'
-        puts THIN
-      RUBY
-
-      expect(err).to eq_err("ZOMG LOAD ERROR")
-    end
-
-    it "sets up old groups when they have previously been removed" do
-      output = run <<-RUBY, :emo
-        Bundler.setup(:default)
-        Bundler.setup(:default, :emo)
-        require 'thin'; puts THIN
-      RUBY
-      expect(output).to eq("1.0")
-    end
-  end
-
-  describe "installing --without" do
-    describe "with gems assigned to a single group" do
-      before :each do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-          group :emo do
-            gem "activesupport", "2.3.5"
-          end
-          group :debugging, :optional => true do
-            gem "thin"
-          end
-        G
-      end
-
-      it "installs gems in the default group" do
-        bundle! :install, forgotten_command_line_options(:without => "emo")
-        expect(the_bundle).to include_gems "rack 1.0.0", :groups => [:default]
-      end
-
-      it "does not install gems from the excluded group" do
-        bundle :install, :without => "emo"
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5", :groups => [:default]
-      end
-
-      it "does not install gems from the previously excluded group" do
-        bundle :install, forgotten_command_line_options(:without => "emo")
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5"
-        bundle :install
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5"
-      end
-
-      it "does not say it installed gems from the excluded group" do
-        bundle! :install, forgotten_command_line_options(:without => "emo")
-        expect(out).not_to include("activesupport")
-      end
-
-      it "allows Bundler.setup for specific groups" do
-        bundle :install, forgotten_command_line_options(:without => "emo")
-        run!("require 'rack'; puts RACK", :default)
-        expect(out).to eq("1.0.0")
-      end
-
-      it "does not effect the resolve" do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "activesupport"
-          group :emo do
-            gem "rails", "2.3.2"
-          end
-        G
-
-        bundle :install, forgotten_command_line_options(:without => "emo")
-        expect(the_bundle).to include_gems "activesupport 2.3.2", :groups => [:default]
-      end
-
-      it "still works on a different machine and excludes gems" do
-        bundle :install, forgotten_command_line_options(:without => "emo")
-
-        simulate_new_machine
-        bundle :install, forgotten_command_line_options(:without => "emo")
-
-        expect(the_bundle).to include_gems "rack 1.0.0", :groups => [:default]
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5", :groups => [:default]
-      end
-
-      it "still works when BUNDLE_WITHOUT is set" do
-        ENV["BUNDLE_WITHOUT"] = "emo"
-
-        bundle :install
-        expect(out).not_to include("activesupport")
-
-        expect(the_bundle).to include_gems "rack 1.0.0", :groups => [:default]
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5", :groups => [:default]
-
-        ENV["BUNDLE_WITHOUT"] = nil
-      end
-
-      it "clears without when passed an empty list" do
-        bundle :install, forgotten_command_line_options(:without => "emo")
-
-        bundle :install, forgotten_command_line_options(:without => "")
-        expect(the_bundle).to include_gems "activesupport 2.3.5"
-      end
-
-      it "doesn't clear without when nothing is passed" do
-        bundle :install, forgotten_command_line_options(:without => "emo")
-
-        bundle :install
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5"
-      end
-
-      it "does not install gems from the optional group" do
-        bundle :install
-        expect(the_bundle).not_to include_gems "thin 1.0"
-      end
-
-      it "does install gems from the optional group when requested" do
-        bundle :install, forgotten_command_line_options(:with => "debugging")
-        expect(the_bundle).to include_gems "thin 1.0"
-      end
-
-      it "does install gems from the previously requested group" do
-        bundle :install, forgotten_command_line_options(:with => "debugging")
-        expect(the_bundle).to include_gems "thin 1.0"
-        bundle :install
-        expect(the_bundle).to include_gems "thin 1.0"
-      end
-
-      it "does install gems from the optional groups requested with BUNDLE_WITH" do
-        ENV["BUNDLE_WITH"] = "debugging"
-        bundle :install
-        expect(the_bundle).to include_gems "thin 1.0"
-        ENV["BUNDLE_WITH"] = nil
-      end
-
-      it "clears with when passed an empty list" do
-        bundle :install, forgotten_command_line_options(:with => "debugging")
-        bundle :install, forgotten_command_line_options(:with => "")
-        expect(the_bundle).not_to include_gems "thin 1.0"
-      end
-
-      it "does remove groups from without when passed at --with", :bundler => "< 2" do
-        bundle :install, forgotten_command_line_options(:without => "emo")
-        bundle :install, forgotten_command_line_options(:with => "emo")
-        expect(the_bundle).to include_gems "activesupport 2.3.5"
-      end
-
-      it "does remove groups from with when passed at --without", :bundler => "< 2" do
-        bundle :install, forgotten_command_line_options(:with => "debugging")
-        bundle :install, forgotten_command_line_options(:without => "debugging")
-        expect(the_bundle).not_to include_gem "thin 1.0"
-      end
-
-      it "errors out when passing a group to with and without via CLI flags", :bundler => "< 2" do
-        bundle :install, forgotten_command_line_options(:with => "emo debugging", :without => "emo")
-        expect(last_command).to be_failure
-        expect(out).to include("The offending groups are: emo")
-      end
-
-      it "allows the BUNDLE_WITH setting to override BUNDLE_WITHOUT" do
-        ENV["BUNDLE_WITH"] = "debugging"
-
-        bundle! :install
-        expect(the_bundle).to include_gem "thin 1.0"
-
-        ENV["BUNDLE_WITHOUT"] = "debugging"
-        expect(the_bundle).to include_gem "thin 1.0"
-
-        bundle! :install
-        expect(the_bundle).to include_gem "thin 1.0"
-      end
-
-      it "can add and remove a group at the same time" do
-        bundle :install, forgotten_command_line_options(:with => "debugging", :without => "emo")
-        expect(the_bundle).to include_gems "thin 1.0"
-        expect(the_bundle).not_to include_gems "activesupport 2.3.5"
-      end
-
-      it "does have no effect when listing a not optional group in with" do
-        bundle :install, forgotten_command_line_options(:with => "emo")
-        expect(the_bundle).to include_gems "activesupport 2.3.5"
-      end
-
-      it "does have no effect when listing an optional group in without" do
-        bundle :install, forgotten_command_line_options(:without => "debugging")
-        expect(the_bundle).not_to include_gems "thin 1.0"
-      end
-    end
-
-    describe "with gems assigned to multiple groups" do
-      before :each do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-          group :emo, :lolercoaster do
-            gem "activesupport", "2.3.5"
-          end
-        G
-      end
-
-      it "installs gems in the default group" do
-        bundle! :install, forgotten_command_line_options(:without => "emo lolercoaster")
-        expect(the_bundle).to include_gems "rack 1.0.0"
-      end
-
-      it "installs the gem if any of its groups are installed" do
-        bundle! :install, forgotten_command_line_options(:without => "emo")
-        expect(the_bundle).to include_gems "rack 1.0.0", "activesupport 2.3.5"
-      end
-
-      describe "with a gem defined multiple times in different groups" do
-        before :each do
-          gemfile <<-G
-            source "file://#{gem_repo1}"
-            gem "rack"
-
-            group :emo do
-              gem "activesupport", "2.3.5"
-            end
-
-            group :lolercoaster do
-              gem "activesupport", "2.3.5"
-            end
-          G
-        end
-
-        it "installs the gem w/ option --without emo" do
-          bundle :install, forgotten_command_line_options(:without => "emo")
-          expect(the_bundle).to include_gems "activesupport 2.3.5"
-        end
-
-        it "installs the gem w/ option --without lolercoaster" do
-          bundle :install, forgotten_command_line_options(:without => "lolercoaster")
-          expect(the_bundle).to include_gems "activesupport 2.3.5"
-        end
-
-        it "does not install the gem w/ option --without emo lolercoaster" do
-          bundle :install, forgotten_command_line_options(:without => "emo lolercoaster")
-          expect(the_bundle).not_to include_gems "activesupport 2.3.5"
-        end
-
-        it "does not install the gem w/ option --without 'emo lolercoaster'" do
-          bundle :install, forgotten_command_line_options(:without => "'emo lolercoaster'")
-          expect(the_bundle).not_to include_gems "activesupport 2.3.5"
-        end
-      end
-    end
-
-    describe "nesting groups" do
-      before :each do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-          group :emo do
-            group :lolercoaster do
-              gem "activesupport", "2.3.5"
-            end
-          end
-        G
-      end
-
-      it "installs gems in the default group" do
-        bundle! :install, forgotten_command_line_options(:without => "emo lolercoaster")
-        expect(the_bundle).to include_gems "rack 1.0.0"
-      end
-
-      it "installs the gem if any of its groups are installed" do
-        bundle! :install, forgotten_command_line_options(:without => "emo")
-        expect(the_bundle).to include_gems "rack 1.0.0", "activesupport 2.3.5"
-      end
-    end
-  end
-
-  describe "when loading only the default group" do
-    it "should not load all groups" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :groups => :development
-      G
-
-      ruby <<-R
-        require "bundler"
-        Bundler.setup :default
-        Bundler.require :default
-        puts RACK
-        begin
-          require "activesupport"
-        rescue LoadError
-          puts "no activesupport"
-        end
-      R
-
-      expect(out).to include("1.0")
-      expect(out).to include("no activesupport")
-    end
-  end
-
-  describe "when locked and installed with --without" do
-    before(:each) do
-      build_repo2
-      system_gems "rack-0.9.1" do
-        install_gemfile <<-G, forgotten_command_line_options(:without => "rack")
-          source "file://#{gem_repo2}"
-          gem "rack"
-
-          group :rack do
-            gem "rack_middleware"
-          end
-        G
-      end
-    end
-
-    it "uses the correct versions even if --without was used on the original" do
-      expect(the_bundle).to include_gems "rack 0.9.1"
-      expect(the_bundle).not_to include_gems "rack_middleware 1.0"
-      simulate_new_machine
-
-      bundle :install
-
-      expect(the_bundle).to include_gems "rack 0.9.1"
-      expect(the_bundle).to include_gems "rack_middleware 1.0"
-    end
-
-    it "does not hit the remote a second time" do
-      FileUtils.rm_rf gem_repo2
-      bundle! :install, forgotten_command_line_options(:without => "rack").merge(:verbose => true)
-      expect(last_command.stdboth).not_to match(/fetching/i)
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/install_if.rb b/spec/bundler/install/gemfile/install_if.rb
deleted file mode 100644
index 1319051fdb..0000000000
--- a/spec/bundler/install/gemfile/install_if.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-describe "bundle install with install_if conditionals" do
-  it "follows the install_if DSL" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      install_if(lambda { true }) do
-        gem "activesupport", "2.3.5"
-      end
-      gem "thin", :install_if => false
-      install_if(lambda { false }) do
-        gem "foo"
-      end
-      gem "rack"
-    G
-
-    expect(the_bundle).to include_gems("rack 1.0", "activesupport 2.3.5")
-    expect(the_bundle).not_to include_gems("thin")
-    expect(the_bundle).not_to include_gems("foo")
-
-    lockfile_should_be <<-L
-      GEM
-        remote: file:#{gem_repo1}/
-        specs:
-          activesupport (2.3.5)
-          foo (1.0)
-          rack (1.0.0)
-          thin (1.0)
-            rack
-
-      PLATFORMS
-        ruby
-
-      DEPENDENCIES
-        activesupport (= 2.3.5)
-        foo
-        rack
-        thin
-
-      BUNDLED WITH
-         #{Bundler::VERSION}
-    L
-  end
-end
diff --git a/spec/bundler/install/gemfile/lockfile_spec.rb b/spec/bundler/install/gemfile/lockfile_spec.rb
deleted file mode 100644
index dc1baca6ea..0000000000
--- a/spec/bundler/install/gemfile/lockfile_spec.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with a lockfile present" do
-  let(:gf) { <<-G }
-    source "file://#{gem_repo1}"
-
-    gem "rack", "1.0.0"
-  G
-
-  subject do
-    install_gemfile(gf)
-  end
-
-  context "gemfile evaluation" do
-    let(:gf) { super() + "\n\n File.open('evals', 'a') {|f| f << %(1\n) } unless ENV['BUNDLER_SPEC_NO_APPEND']" }
-
-    context "with plugins disabled" do
-      before do
-        bundle! "config plugins false"
-        subject
-      end
-
-      it "does not evaluate the gemfile twice" do
-        bundle! :install
-
-        with_env_vars("BUNDLER_SPEC_NO_APPEND" => "1") { expect(the_bundle).to include_gem "rack 1.0.0" }
-
-        # The first eval is from the initial install, we're testing that the
-        # second install doesn't double-eval
-        expect(bundled_app("evals").read.lines.to_a.size).to eq(2)
-      end
-
-      context "when the gem is not installed" do
-        before { FileUtils.rm_rf ".bundle" }
-
-        it "does not evaluate the gemfile twice" do
-          bundle! :install
-
-          with_env_vars("BUNDLER_SPEC_NO_APPEND" => "1") { expect(the_bundle).to include_gem "rack 1.0.0" }
-
-          # The first eval is from the initial install, we're testing that the
-          # second install doesn't double-eval
-          expect(bundled_app("evals").read.lines.to_a.size).to eq(2)
-        end
-      end
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/path_spec.rb b/spec/bundler/install/gemfile/path_spec.rb
deleted file mode 100644
index f7789e7ea5..0000000000
--- a/spec/bundler/install/gemfile/path_spec.rb
+++ /dev/null
@@ -1,630 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with explicit source paths" do
-  it "fetches gems with a global path source", :bundler => "< 2" do
-    build_lib "foo"
-
-    install_gemfile <<-G
-      path "#{lib_path("foo-1.0")}"
-      gem 'foo'
-    G
-
-    expect(the_bundle).to include_gems("foo 1.0")
-  end
-
-  it "fetches gems" do
-    build_lib "foo"
-
-    install_gemfile <<-G
-      path "#{lib_path("foo-1.0")}" do
-        gem 'foo'
-      end
-    G
-
-    expect(the_bundle).to include_gems("foo 1.0")
-  end
-
-  it "supports pinned paths" do
-    build_lib "foo"
-
-    install_gemfile <<-G
-      gem 'foo', :path => "#{lib_path("foo-1.0")}"
-    G
-
-    expect(the_bundle).to include_gems("foo 1.0")
-  end
-
-  it "supports relative paths" do
-    build_lib "foo"
-
-    relative_path = lib_path("foo-1.0").relative_path_from(Pathname.new(Dir.pwd))
-
-    install_gemfile <<-G
-      gem 'foo', :path => "#{relative_path}"
-    G
-
-    expect(the_bundle).to include_gems("foo 1.0")
-  end
-
-  it "expands paths" do
-    build_lib "foo"
-
-    relative_path = lib_path("foo-1.0").relative_path_from(Pathname.new("~").expand_path)
-
-    install_gemfile <<-G
-      gem 'foo', :path => "~/#{relative_path}"
-    G
-
-    expect(the_bundle).to include_gems("foo 1.0")
-  end
-
-  it "expands paths raise error with not existing user's home dir" do
-    build_lib "foo"
-    username = "some_unexisting_user"
-    relative_path = lib_path("foo-1.0").relative_path_from(Pathname.new("/home/#{username}").expand_path)
-
-    install_gemfile <<-G
-      gem 'foo', :path => "~#{username}/#{relative_path}"
-    G
-    expect(out).to match("There was an error while trying to use the path `~#{username}/#{relative_path}`.")
-    expect(out).to match("user #{username} doesn't exist")
-  end
-
-  it "expands paths relative to Bundler.root" do
-    build_lib "foo", :path => bundled_app("foo-1.0")
-
-    install_gemfile <<-G
-      gem 'foo', :path => "./foo-1.0"
-    G
-
-    bundled_app("subdir").mkpath
-    Dir.chdir(bundled_app("subdir")) do
-      expect(the_bundle).to include_gems("foo 1.0")
-    end
-  end
-
-  it "expands paths when comparing locked paths to Gemfile paths" do
-    build_lib "foo", :path => bundled_app("foo-1.0")
-
-    install_gemfile <<-G
-      gem 'foo', :path => File.expand_path("../foo-1.0", __FILE__)
-    G
-
-    bundle! :install, forgotten_command_line_options(:frozen => true)
-    expect(exitstatus).to eq(0) if exitstatus
-  end
-
-  it "installs dependencies from the path even if a newer gem is available elsewhere" do
-    system_gems "rack-1.0.0"
-
-    build_lib "rack", "1.0", :path => lib_path("nested/bar") do |s|
-      s.write "lib/rack.rb", "puts 'WIN OVERRIDE'"
-    end
-
-    build_lib "foo", :path => lib_path("nested") do |s|
-      s.add_dependency "rack", "= 1.0"
-    end
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "foo", :path => "#{lib_path("nested")}"
-    G
-
-    run "require 'rack'"
-    expect(out).to eq("WIN OVERRIDE")
-  end
-
-  it "works" do
-    build_gem "foo", "1.0.0", :to_system => true do |s|
-      s.write "lib/foo.rb", "puts 'FAIL'"
-    end
-
-    build_lib "omg", "1.0", :path => lib_path("omg") do |s|
-      s.add_dependency "foo"
-    end
-
-    build_lib "foo", "1.0.0", :path => lib_path("omg/foo")
-
-    install_gemfile <<-G
-      gem "omg", :path => "#{lib_path("omg")}"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-  end
-
-  it "prefers gemspecs closer to the path root" do
-    build_lib "premailer", "1.0.0", :path => lib_path("premailer") do |s|
-      s.write "gemfiles/ruby187.gemspec", <<-G
-        Gem::Specification.new do |s|
-          s.name    = 'premailer'
-          s.version = '1.0.0'
-          s.summary = 'Hi'
-          s.authors = 'Me'
-        end
-      G
-    end
-
-    install_gemfile <<-G
-      gem "premailer", :path => "#{lib_path("premailer")}"
-    G
-
-    # Installation of the 'gemfiles' gemspec would fail since it will be unable
-    # to require 'premailer.rb'
-    expect(the_bundle).to include_gems "premailer 1.0.0"
-  end
-
-  it "warns on invalid specs", :rubygems => "1.7" do
-    build_lib "foo"
-
-    gemspec = lib_path("foo-1.0").join("foo.gemspec").to_s
-    File.open(gemspec, "w") do |f|
-      f.write <<-G
-        Gem::Specification.new do |s|
-          s.name = "foo"
-        end
-      G
-    end
-
-    install_gemfile <<-G
-      gem "foo", :path => "#{lib_path("foo-1.0")}"
-    G
-
-    expect(out).to_not include("ERROR REPORT")
-    expect(out).to_not include("Your Gemfile has no gem server sources.")
-    expect(out).to match(/is not valid. Please fix this gemspec./)
-    expect(out).to match(/The validation error was 'missing value for attribute version'/)
-    expect(out).to match(/You have one or more invalid gemspecs that need to be fixed/)
-  end
-
-  it "supports gemspec syntax" do
-    build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-      s.add_dependency "rack", "1.0"
-    end
-
-    gemfile = <<-G
-      source "file://#{gem_repo1}"
-      gemspec
-    G
-
-    File.open(lib_path("foo/Gemfile"), "w") {|f| f.puts gemfile }
-
-    Dir.chdir(lib_path("foo")) do
-      bundle "install"
-      expect(the_bundle).to include_gems "foo 1.0"
-      expect(the_bundle).to include_gems "rack 1.0"
-    end
-  end
-
-  it "supports gemspec syntax with an alternative path" do
-    build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-      s.add_dependency "rack", "1.0"
-    end
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gemspec :path => "#{lib_path("foo")}"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-    expect(the_bundle).to include_gems "rack 1.0"
-  end
-
-  it "doesn't automatically unlock dependencies when using the gemspec syntax" do
-    build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-      s.add_dependency "rack", ">= 1.0"
-    end
-
-    Dir.chdir lib_path("foo")
-
-    install_gemfile lib_path("foo/Gemfile"), <<-G
-      source "file://#{gem_repo1}"
-      gemspec
-    G
-
-    build_gem "rack", "1.0.1", :to_system => true
-
-    bundle "install"
-
-    expect(the_bundle).to include_gems "foo 1.0"
-    expect(the_bundle).to include_gems "rack 1.0"
-  end
-
-  it "doesn't automatically unlock dependencies when using the gemspec syntax and the gem has development dependencies" do
-    build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-      s.add_dependency "rack", ">= 1.0"
-      s.add_development_dependency "activesupport"
-    end
-
-    Dir.chdir lib_path("foo")
-
-    install_gemfile lib_path("foo/Gemfile"), <<-G
-      source "file://#{gem_repo1}"
-      gemspec
-    G
-
-    build_gem "rack", "1.0.1", :to_system => true
-
-    bundle "install"
-
-    expect(the_bundle).to include_gems "foo 1.0"
-    expect(the_bundle).to include_gems "rack 1.0"
-  end
-
-  it "raises if there are multiple gemspecs" do
-    build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-      s.write "bar.gemspec", build_spec("bar", "1.0").first.to_ruby
-    end
-
-    install_gemfile <<-G
-      gemspec :path => "#{lib_path("foo")}"
-    G
-
-    expect(exitstatus).to eq(15) if exitstatus
-    expect(out).to match(/There are multiple gemspecs/)
-  end
-
-  it "allows :name to be specified to resolve ambiguity" do
-    build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-      s.write "bar.gemspec"
-    end
-
-    install_gemfile <<-G
-      gemspec :path => "#{lib_path("foo")}", :name => "foo"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-  end
-
-  it "sets up executables" do
-    build_lib "foo" do |s|
-      s.executables = "foobar"
-    end
-
-    install_gemfile <<-G
-      path "#{lib_path("foo-1.0")}" do
-        gem 'foo'
-      end
-    G
-    expect(the_bundle).to include_gems "foo 1.0"
-
-    bundle "exec foobar"
-    expect(out).to eq("1.0")
-  end
-
-  it "handles directories in bin/" do
-    build_lib "foo"
-    lib_path("foo-1.0").join("foo.gemspec").rmtree
-    lib_path("foo-1.0").join("bin/performance").mkpath
-
-    install_gemfile <<-G
-      gem 'foo', '1.0', :path => "#{lib_path("foo-1.0")}"
-    G
-    expect(err).to lack_errors
-  end
-
-  it "removes the .gem file after installing" do
-    build_lib "foo"
-
-    install_gemfile <<-G
-      gem 'foo', :path => "#{lib_path("foo-1.0")}"
-    G
-
-    expect(lib_path("foo-1.0").join("foo-1.0.gem")).not_to exist
-  end
-
-  describe "block syntax" do
-    it "pulls all gems from a path block" do
-      build_lib "omg"
-      build_lib "hi2u"
-
-      install_gemfile <<-G
-        path "#{lib_path}" do
-          gem "omg"
-          gem "hi2u"
-        end
-      G
-
-      expect(the_bundle).to include_gems "omg 1.0", "hi2u 1.0"
-    end
-  end
-
-  it "keeps source pinning" do
-    build_lib "foo", "1.0", :path => lib_path("foo")
-    build_lib "omg", "1.0", :path => lib_path("omg")
-    build_lib "foo", "1.0", :path => lib_path("omg/foo") do |s|
-      s.write "lib/foo.rb", "puts 'FAIL'"
-    end
-
-    install_gemfile <<-G
-      gem "foo", :path => "#{lib_path("foo")}"
-      gem "omg", :path => "#{lib_path("omg")}"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-  end
-
-  it "works when the path does not have a gemspec" do
-    build_lib "foo", :gemspec => false
-
-    gemfile <<-G
-      gem "foo", "1.0", :path => "#{lib_path("foo-1.0")}"
-    G
-
-    expect(the_bundle).to include_gems "foo 1.0"
-
-    expect(the_bundle).to include_gems "foo 1.0"
-  end
-
-  it "works when the path does not have a gemspec but there is a lockfile" do
-    lockfile <<-L
-    PATH
-      remote: vendor/bar
-      specs:
-
-    GEM
-      remote: http://rubygems.org
-    L
-
-    in_app_root { FileUtils.mkdir_p("vendor/bar") }
-
-    install_gemfile <<-G
-      gem "bar", "1.0.0", path: "vendor/bar", require: "bar/nyard"
-    G
-    expect(exitstatus).to eq(0) if exitstatus
-  end
-
-  context "existing lockfile" do
-    it "rubygems gems don't re-resolve without changes" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem 'rack-obama', '1.0'
-        gem 'net-ssh', '1.0'
-      G
-
-      bundle :check, :env => { "DEBUG" => 1 }
-      expect(out).to match(/using resolution from the lockfile/)
-      expect(the_bundle).to include_gems "rack-obama 1.0", "net-ssh 1.0"
-    end
-
-    it "source path gems w/deps don't re-resolve without changes" do
-      build_lib "rack-obama", "1.0", :path => lib_path("omg") do |s|
-        s.add_dependency "yard"
-      end
-
-      build_lib "net-ssh", "1.0", :path => lib_path("omg") do |s|
-        s.add_dependency "yard"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem 'rack-obama', :path => "#{lib_path("omg")}"
-        gem 'net-ssh', :path => "#{lib_path("omg")}"
-      G
-
-      bundle :check, :env => { "DEBUG" => 1 }
-      expect(out).to match(/using resolution from the lockfile/)
-      expect(the_bundle).to include_gems "rack-obama 1.0", "net-ssh 1.0"
-    end
-  end
-
-  it "installs executable stubs" do
-    build_lib "foo" do |s|
-      s.executables = ["foo"]
-    end
-
-    install_gemfile <<-G
-      gem "foo", :path => "#{lib_path("foo-1.0")}"
-    G
-
-    bundle "exec foo"
-    expect(out).to eq("1.0")
-  end
-
-  describe "when the gem version in the path is updated" do
-    before :each do
-      build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-        s.add_dependency "bar"
-      end
-      build_lib "bar", "1.0", :path => lib_path("foo/bar")
-
-      install_gemfile <<-G
-        gem "foo", :path => "#{lib_path("foo")}"
-      G
-    end
-
-    it "unlocks all gems when the top level gem is updated" do
-      build_lib "foo", "2.0", :path => lib_path("foo") do |s|
-        s.add_dependency "bar"
-      end
-
-      bundle "install"
-
-      expect(the_bundle).to include_gems "foo 2.0", "bar 1.0"
-    end
-
-    it "unlocks all gems when a child dependency gem is updated" do
-      build_lib "bar", "2.0", :path => lib_path("foo/bar")
-
-      bundle "install"
-
-      expect(the_bundle).to include_gems "foo 1.0", "bar 2.0"
-    end
-  end
-
-  describe "when dependencies in the path are updated" do
-    before :each do
-      build_lib "foo", "1.0", :path => lib_path("foo")
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "foo", :path => "#{lib_path("foo")}"
-      G
-    end
-
-    it "gets dependencies that are updated in the path" do
-      build_lib "foo", "1.0", :path => lib_path("foo") do |s|
-        s.add_dependency "rack"
-      end
-
-      bundle "install"
-
-      expect(the_bundle).to include_gems "rack 1.0.0"
-    end
-  end
-
-  describe "switching sources" do
-    it "doesn't switch pinned git sources to rubygems when pinning the parent gem to a path source" do
-      build_gem "foo", "1.0", :to_system => true do |s|
-        s.write "lib/foo.rb", "raise 'fail'"
-      end
-      build_lib "foo", "1.0", :path => lib_path("bar/foo")
-      build_git "bar", "1.0", :path => lib_path("bar") do |s|
-        s.add_dependency "foo"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "bar", :git => "#{lib_path("bar")}"
-      G
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "bar", :path => "#{lib_path("bar")}"
-      G
-
-      expect(the_bundle).to include_gems "foo 1.0", "bar 1.0"
-    end
-
-    it "switches the source when the gem existed in rubygems and the path was already being used for another gem" do
-      build_lib "foo", "1.0", :path => lib_path("foo")
-      build_gem "bar", "1.0", :to_system => true do |s|
-        s.write "lib/bar.rb", "raise 'fail'"
-      end
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "bar"
-        path "#{lib_path("foo")}" do
-          gem "foo"
-        end
-      G
-
-      build_lib "bar", "1.0", :path => lib_path("foo/bar")
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        path "#{lib_path("foo")}" do
-          gem "foo"
-          gem "bar"
-        end
-      G
-
-      expect(the_bundle).to include_gems "bar 1.0"
-    end
-  end
-
-  describe "when there are both a gemspec and remote gems" do
-    it "doesn't query rubygems for local gemspec name" do
-      build_lib "private_lib", "2.2", :path => lib_path("private_lib")
-      gemfile = <<-G
-        source "http://localgemserver.test"
-        gemspec
-        gem 'rack'
-      G
-      File.open(lib_path("private_lib/Gemfile"), "w") {|f| f.puts gemfile }
-
-      Dir.chdir(lib_path("private_lib")) do
-        bundle :install, :env => { "DEBUG" => 1 }, :artifice => "endpoint"
-        expect(out).to match(%r{^HTTP GET http://localgemserver\.test/api/v1/dependencies\?gems=rack$})
-        expect(out).not_to match(/^HTTP GET.*private_lib/)
-        expect(the_bundle).to include_gems "private_lib 2.2"
-        expect(the_bundle).to include_gems "rack 1.0"
-      end
-    end
-  end
-
-  describe "gem install hooks" do
-    it "runs pre-install hooks" do
-      build_git "foo"
-      gemfile <<-G
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      File.open(lib_path("install_hooks.rb"), "w") do |h|
-        h.write <<-H
-          require 'rubygems'
-          Gem.pre_install_hooks << lambda do |inst|
-            STDERR.puts "Ran pre-install hook: \#{inst.spec.full_name}"
-          end
-        H
-      end
-
-      bundle :install,
-        :requires => [lib_path("install_hooks.rb")]
-      expect(err).to eq_err("Ran pre-install hook: foo-1.0")
-    end
-
-    it "runs post-install hooks" do
-      build_git "foo"
-      gemfile <<-G
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      File.open(lib_path("install_hooks.rb"), "w") do |h|
-        h.write <<-H
-          require 'rubygems'
-          Gem.post_install_hooks << lambda do |inst|
-            STDERR.puts "Ran post-install hook: \#{inst.spec.full_name}"
-          end
-        H
-      end
-
-      bundle :install,
-        :requires => [lib_path("install_hooks.rb")]
-      expect(err).to eq_err("Ran post-install hook: foo-1.0")
-    end
-
-    it "complains if the install hook fails" do
-      build_git "foo"
-      gemfile <<-G
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      G
-
-      File.open(lib_path("install_hooks.rb"), "w") do |h|
-        h.write <<-H
-          require 'rubygems'
-          Gem.pre_install_hooks << lambda do |inst|
-            false
-          end
-        H
-      end
-
-      bundle :install,
-        :requires => [lib_path("install_hooks.rb")]
-      expect(out).to include("failed for foo-1.0")
-    end
-
-    it "loads plugins from the path gem" do
-      foo_file = home("foo_plugin_loaded")
-      bar_file = home("bar_plugin_loaded")
-      expect(foo_file).not_to be_file
-      expect(bar_file).not_to be_file
-
-      build_lib "foo" do |s|
-        s.write("lib/rubygems_plugin.rb", "FileUtils.touch('#{foo_file}')")
-      end
-
-      build_git "bar" do |s|
-        s.write("lib/rubygems_plugin.rb", "FileUtils.touch('#{bar_file}')")
-      end
-
-      install_gemfile! <<-G
-        gem "foo", :path => "#{lib_path("foo-1.0")}"
-        gem "bar", :path => "#{lib_path("bar-1.0")}"
-      G
-
-      expect(foo_file).to be_file
-      expect(bar_file).to be_file
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/platform_spec.rb b/spec/bundler/install/gemfile/platform_spec.rb
deleted file mode 100644
index d7d4e0a53c..0000000000
--- a/spec/bundler/install/gemfile/platform_spec.rb
+++ /dev/null
@@ -1,264 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install across platforms" do
-  it "maintains the same lockfile if all gems are compatible across platforms" do
-    lockfile <<-G
-      GEM
-        remote: file:#{gem_repo1}/
-        specs:
-          rack (0.9.1)
-
-      PLATFORMS
-        #{not_local}
-
-      DEPENDENCIES
-        rack
-    G
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "rack"
-    G
-
-    expect(the_bundle).to include_gems "rack 0.9.1"
-  end
-
-  it "pulls in the correct platform specific gem" do
-    lockfile <<-G
-      GEM
-        remote: file:#{gem_repo1}
-        specs:
-          platform_specific (1.0)
-          platform_specific (1.0-java)
-          platform_specific (1.0-x86-mswin32)
-
-      PLATFORMS
-        ruby
-
-      DEPENDENCIES
-        platform_specific
-    G
-
-    simulate_platform "java"
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "platform_specific"
-    G
-
-    expect(the_bundle).to include_gems "platform_specific 1.0 JAVA"
-  end
-
-  it "works with gems that have different dependencies" do
-    simulate_platform "java"
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "nokogiri"
-    G
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2 JAVA", "weakling 0.0.3"
-
-    simulate_new_machine
-
-    simulate_platform "ruby"
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "nokogiri"
-    G
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2"
-    expect(the_bundle).not_to include_gems "weakling"
-  end
-
-  it "works the other way with gems that have different dependencies" do
-    simulate_platform "ruby"
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "nokogiri"
-    G
-
-    simulate_platform "java"
-    bundle "install"
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2 JAVA", "weakling 0.0.3"
-  end
-
-  it "works with gems that have extra platform-specific runtime dependencies", :bundler => "< 2" do
-    simulate_platform x64_mac
-
-    update_repo2 do
-      build_gem "facter", "2.4.6"
-      build_gem "facter", "2.4.6" do |s|
-        s.platform = "universal-darwin"
-        s.add_runtime_dependency "CFPropertyList"
-      end
-      build_gem "CFPropertyList"
-    end
-
-    install_gemfile! <<-G
-      source "file://#{gem_repo2}"
-
-      gem "facter"
-    G
-
-    expect(out).to include "Unable to use the platform-specific (universal-darwin) version of facter (2.4.6) " \
-      "because it has different dependencies from the ruby version. " \
-      "To use the platform-specific version of the gem, run `bundle config specific_platform true` and install again."
-
-    expect(the_bundle).to include_gem "facter 2.4.6"
-    expect(the_bundle).not_to include_gem "CFPropertyList"
-  end
-
-  it "fetches gems again after changing the version of Ruby" do
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "rack", "1.0.0"
-    G
-
-    bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
-
-    new_version = Gem::ConfigMap[:ruby_version] == "1.8" ? "1.9.1" : "1.8"
-    FileUtils.mv(vendored_gems, bundled_app("vendor/bundle", Gem.ruby_engine, new_version))
-
-    bundle! :install
-    expect(vendored_gems("gems/rack-1.0.0")).to exist
-  end
-end
-
-RSpec.describe "bundle install with platform conditionals" do
-  it "installs gems tagged w/ the current platforms" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      platforms :#{local_tag} do
-        gem "nokogiri"
-      end
-    G
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2"
-  end
-
-  it "does not install gems tagged w/ another platforms" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-      platforms :#{not_local_tag} do
-        gem "nokogiri"
-      end
-    G
-
-    expect(the_bundle).to include_gems "rack 1.0"
-    expect(the_bundle).not_to include_gems "nokogiri 1.4.2"
-  end
-
-  it "installs gems tagged w/ the current platforms inline" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "nokogiri", :platforms => :#{local_tag}
-    G
-    expect(the_bundle).to include_gems "nokogiri 1.4.2"
-  end
-
-  it "does not install gems tagged w/ another platforms inline" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-      gem "nokogiri", :platforms => :#{not_local_tag}
-    G
-    expect(the_bundle).to include_gems "rack 1.0"
-    expect(the_bundle).not_to include_gems "nokogiri 1.4.2"
-  end
-
-  it "installs gems tagged w/ the current platform inline" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "nokogiri", :platform => :#{local_tag}
-    G
-    expect(the_bundle).to include_gems "nokogiri 1.4.2"
-  end
-
-  it "doesn't install gems tagged w/ another platform inline" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "nokogiri", :platform => :#{not_local_tag}
-    G
-    expect(the_bundle).not_to include_gems "nokogiri 1.4.2"
-  end
-
-  it "does not blow up on sources with all platform-excluded specs" do
-    build_git "foo"
-
-    install_gemfile <<-G
-      platform :#{not_local_tag} do
-        gem "foo", :git => "#{lib_path("foo-1.0")}"
-      end
-    G
-
-    bundle :list
-    expect(exitstatus).to eq(0) if exitstatus
-  end
-
-  it "does not attempt to install gems from :rbx when using --local" do
-    simulate_platform "ruby"
-    simulate_ruby_engine "ruby"
-
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "some_gem", :platform => :rbx
-    G
-
-    bundle "install --local"
-    expect(out).not_to match(/Could not find gem 'some_gem/)
-  end
-
-  it "does not attempt to install gems from other rubies when using --local" do
-    simulate_platform "ruby"
-    simulate_ruby_engine "ruby"
-    other_ruby_version_tag = RUBY_VERSION =~ /^1\.8/ ? :ruby_19 : :ruby_18
-
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "some_gem", platform: :#{other_ruby_version_tag}
-    G
-
-    bundle "install --local"
-    expect(out).not_to match(/Could not find gem 'some_gem/)
-  end
-
-  it "prints a helpful warning when a dependency is unused on any platform" do
-    simulate_platform "ruby"
-    simulate_ruby_engine "ruby"
-
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      gem "rack", :platform => [:mingw, :mswin, :x64_mingw, :jruby]
-    G
-
-    bundle! "install"
-
-    expect(out).to include <<-O.strip
-The dependency #{Gem::Dependency.new("rack", ">= 0")} will be unused by any of the platforms Bundler is installing for. Bundler is installing for ruby but the dependency is only for x86-mingw32, x86-mswin32, x64-mingw32, java. To add those platforms to the bundle, run `bundle lock --add-platform x86-mingw32 x86-mswin32 x64-mingw32 java`.
-    O
-  end
-end
-
-RSpec.describe "when a gem has no architecture" do
-  it "still installs correctly" do
-    simulate_platform mswin
-
-    gemfile <<-G
-      # Try to install gem with nil arch
-      source "http://localgemserver.test/"
-      gem "rcov"
-    G
-
-    bundle :install, :artifice => "windows"
-    expect(the_bundle).to include_gems "rcov 1.0.0"
-  end
-end
diff --git a/spec/bundler/install/gemfile/ruby_spec.rb b/spec/bundler/install/gemfile/ruby_spec.rb
deleted file mode 100644
index 24fe021fa3..0000000000
--- a/spec/bundler/install/gemfile/ruby_spec.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "ruby requirement" do
-  def locked_ruby_version
-    Bundler::RubyVersion.from_string(Bundler::LockfileParser.new(lockfile).ruby_version)
-  end
-
-  # As discovered by https://github.com/bundler/bundler/issues/4147, there is
-  # no test coverage to ensure that adding a gem is possible with a ruby
-  # requirement. This test verifies the fix, committed in bfbad5c5.
-  it "allows adding gems" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby "#{RUBY_VERSION}"
-      gem "rack"
-    G
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby "#{RUBY_VERSION}"
-      gem "rack"
-      gem "rack-obama"
-    G
-
-    expect(exitstatus).to eq(0) if exitstatus
-    expect(the_bundle).to include_gems "rack-obama 1.0"
-  end
-
-  it "allows removing the ruby version requirement" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby "~> #{RUBY_VERSION}"
-      gem "rack"
-    G
-
-    expect(lockfile).to include("RUBY VERSION")
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    expect(the_bundle).to include_gems "rack 1.0.0"
-    expect(lockfile).not_to include("RUBY VERSION")
-  end
-
-  it "allows changing the ruby version requirement to something compatible" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby ">= 1.0.0"
-      gem "rack"
-    G
-
-    expect(locked_ruby_version).to eq(Bundler::RubyVersion.system)
-
-    simulate_ruby_version "5100"
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby ">= 1.0.1"
-      gem "rack"
-    G
-
-    expect(the_bundle).to include_gems "rack 1.0.0"
-    expect(locked_ruby_version).to eq(Bundler::RubyVersion.system)
-  end
-
-  it "allows changing the ruby version requirement to something incompatible" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby ">= 1.0.0"
-      gem "rack"
-    G
-
-    expect(locked_ruby_version).to eq(Bundler::RubyVersion.system)
-
-    simulate_ruby_version "5100"
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby ">= 5000.0"
-      gem "rack"
-    G
-
-    expect(the_bundle).to include_gems "rack 1.0.0"
-    expect(locked_ruby_version.versions).to eq(["5100"])
-  end
-
-  it "allows requirements with trailing whitespace" do
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      ruby "#{RUBY_VERSION}\\n \t\\n"
-      gem "rack"
-    G
-
-    expect(the_bundle).to include_gems "rack 1.0.0"
-  end
-
-  it "fails gracefully with malformed requirements" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      ruby ">= 0", "-.\\0"
-      gem "rack"
-    G
-
-    expect(out).to include("There was an error parsing") # i.e. DSL error, not error template
-  end
-end
diff --git a/spec/bundler/install/gemfile/sources_spec.rb b/spec/bundler/install/gemfile/sources_spec.rb
deleted file mode 100644
index 8ba3ec2d27..0000000000
--- a/spec/bundler/install/gemfile/sources_spec.rb
+++ /dev/null
@@ -1,619 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with gems on multiple sources" do
-  # repo1 is built automatically before all of the specs run
-  # it contains rack-obama 1.0.0 and rack 0.9.1 & 1.0.0 amongst other gems
-
-  context "without source affinity" do
-    before do
-      # Oh no! Someone evil is trying to hijack rack :(
-      # need this to be broken to check for correct source ordering
-      build_repo gem_repo3 do
-        build_gem "rack", repo3_rack_version do |s|
-          s.write "lib/rack.rb", "RACK = 'FAIL'"
-        end
-      end
-    end
-
-    context "with multiple toplevel sources" do
-      let(:repo3_rack_version) { "1.0.0" }
-
-      before do
-        gemfile <<-G
-          source "file://localhost#{gem_repo3}"
-          source "file://localhost#{gem_repo1}"
-          gem "rack-obama"
-          gem "rack"
-        G
-        bundle "config major_deprecations true"
-      end
-
-      it "warns about ambiguous gems, but installs anyway, prioritizing sources last to first", :bundler => "< 2" do
-        bundle :install
-
-        expect(out).to have_major_deprecation a_string_including("Your Gemfile contains multiple primary sources.")
-        expect(out).to include("Warning: the gem 'rack' was found in multiple sources.")
-        expect(out).to include("Installed from: file://localhost#{gem_repo1}")
-        expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0", :source => "remote1")
-      end
-
-      it "errors when disable_multisource is set" do
-        bundle "config disable_multisource true"
-        bundle :install
-        expect(out).to include("Each source after the first must include a block")
-        expect(exitstatus).to eq(4) if exitstatus
-      end
-    end
-
-    context "when different versions of the same gem are in multiple sources" do
-      let(:repo3_rack_version) { "1.2" }
-
-      before do
-        gemfile <<-G
-          source "file://localhost#{gem_repo3}"
-          source "file://localhost#{gem_repo1}"
-          gem "rack-obama"
-          gem "rack", "1.0.0" # force it to install the working version in repo1
-        G
-        bundle "config major_deprecations true"
-      end
-
-      it "warns about ambiguous gems, but installs anyway", :bundler => "< 2" do
-        bundle :install
-
-        expect(out).to have_major_deprecation a_string_including("Your Gemfile contains multiple primary sources.")
-        expect(out).to include("Warning: the gem 'rack' was found in multiple sources.")
-        expect(out).to include("Installed from: file://localhost#{gem_repo1}")
-        expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0", :source => "remote1")
-      end
-    end
-  end
-
-  context "with source affinity" do
-    context "with sources given by a block" do
-      before do
-        # Oh no! Someone evil is trying to hijack rack :(
-        # need this to be broken to check for correct source ordering
-        build_repo gem_repo3 do
-          build_gem "rack", "1.0.0" do |s|
-            s.write "lib/rack.rb", "RACK = 'FAIL'"
-          end
-
-          build_gem "rack-obama" do |s|
-            s.add_dependency "rack"
-          end
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo3}"
-          source "file://#{gem_repo1}" do
-            gem "thin" # comes first to test name sorting
-            gem "rack"
-          end
-          gem "rack-obama" # shoud come from repo3!
-        G
-      end
-
-      it "installs the gems without any warning" do
-        bundle! :install
-        expect(out).not_to include("Warning")
-        expect(the_bundle).to include_gems("rack-obama 1.0.0")
-        expect(the_bundle).to include_gems("rack 1.0.0", :source => "remote1")
-      end
-
-      it "can cache and deploy" do
-        bundle! :package
-
-        expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist
-        expect(bundled_app("vendor/cache/rack-obama-1.0.gem")).to exist
-
-        bundle! :install, forgotten_command_line_options(:deployment => true)
-
-        expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0")
-      end
-    end
-
-    context "with sources set by an option" do
-      before do
-        # Oh no! Someone evil is trying to hijack rack :(
-        # need this to be broken to check for correct source ordering
-        build_repo gem_repo3 do
-          build_gem "rack", "1.0.0" do |s|
-            s.write "lib/rack.rb", "RACK = 'FAIL'"
-          end
-
-          build_gem "rack-obama" do |s|
-            s.add_dependency "rack"
-          end
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo3}"
-          gem "rack-obama" # should come from repo3!
-          gem "rack", :source => "file://#{gem_repo1}"
-        G
-      end
-
-      it "installs the gems without any warning" do
-        bundle :install
-        expect(out).not_to include("Warning")
-        expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0")
-      end
-    end
-
-    context "when a pinned gem has an indirect dependency" do
-      before do
-        build_repo gem_repo3 do
-          build_gem "depends_on_rack", "1.0.1" do |s|
-            s.add_dependency "rack"
-          end
-        end
-      end
-
-      context "when the indirect dependency is in the pinned source" do
-        before do
-          # we need a working rack gem in repo3
-          update_repo gem_repo3 do
-            build_gem "rack", "1.0.0"
-          end
-
-          gemfile <<-G
-            source "file://#{gem_repo2}"
-            source "file://#{gem_repo3}" do
-              gem "depends_on_rack"
-            end
-          G
-        end
-
-        context "and not in any other sources" do
-          before do
-            build_repo(gem_repo2) {}
-          end
-
-          it "installs from the same source without any warning" do
-            bundle :install
-            expect(out).not_to include("Warning")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-          end
-        end
-
-        context "and in another source" do
-          before do
-            # need this to be broken to check for correct source ordering
-            build_repo gem_repo2 do
-              build_gem "rack", "1.0.0" do |s|
-                s.write "lib/rack.rb", "RACK = 'FAIL'"
-              end
-            end
-          end
-
-          context "when lockfile_uses_separate_rubygems_sources is set" do
-            before do
-              bundle! "config lockfile_uses_separate_rubygems_sources true"
-              bundle! "config disable_multisource true"
-            end
-
-            it "installs from the same source without any warning" do
-              bundle! :install
-
-              expect(out).not_to include("Warning: the gem 'rack' was found in multiple sources.")
-              expect(err).not_to include("Warning: the gem 'rack' was found in multiple sources.")
-              expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-
-              # when there is already a lock file, and the gems are missing, so try again
-              system_gems []
-              bundle! :install
-
-              expect(out).not_to include("Warning: the gem 'rack' was found in multiple sources.")
-              expect(err).not_to include("Warning: the gem 'rack' was found in multiple sources.")
-              expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-            end
-          end
-        end
-      end
-
-      context "when the indirect dependency is in a different source" do
-        before do
-          # In these tests, we need a working rack gem in repo2 and not repo3
-          build_repo gem_repo2 do
-            build_gem "rack", "1.0.0"
-          end
-        end
-
-        context "and not in any other sources" do
-          before do
-            gemfile <<-G
-              source "file://#{gem_repo2}"
-              source "file://#{gem_repo3}" do
-                gem "depends_on_rack"
-              end
-            G
-          end
-
-          it "installs from the other source without any warning" do
-            bundle :install
-            expect(out).not_to include("Warning")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-          end
-        end
-
-        context "and in yet another source" do
-          before do
-            gemfile <<-G
-              source "file://localhost#{gem_repo1}"
-              source "file://localhost#{gem_repo2}"
-              source "file://localhost#{gem_repo3}" do
-                gem "depends_on_rack"
-              end
-            G
-          end
-
-          it "installs from the other source and warns about ambiguous gems", :bundler => "< 2" do
-            bundle "config major_deprecations true"
-            bundle :install
-            expect(out).to have_major_deprecation a_string_including("Your Gemfile contains multiple primary sources.")
-            expect(out).to include("Warning: the gem 'rack' was found in multiple sources.")
-            expect(out).to include("Installed from: file://localhost#{gem_repo2}")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-          end
-        end
-
-        context "and only the dependency is pinned" do
-          before do
-            # need this to be broken to check for correct source ordering
-            build_repo gem_repo2 do
-              build_gem "rack", "1.0.0" do |s|
-                s.write "lib/rack.rb", "RACK = 'FAIL'"
-              end
-            end
-
-            gemfile <<-G
-              source "file://#{gem_repo3}" # contains depends_on_rack
-              source "file://#{gem_repo2}" # contains broken rack
-
-              gem "depends_on_rack" # installed from gem_repo3
-              gem "rack", :source => "file://#{gem_repo1}"
-            G
-          end
-
-          it "installs the dependency from the pinned source without warning", :bundler => "< 2" do
-            bundle :install
-
-            expect(out).not_to include("Warning: the gem 'rack' was found in multiple sources.")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-
-            # In https://github.com/bundler/bundler/issues/3585 this failed
-            # when there is already a lock file, and the gems are missing, so try again
-            system_gems []
-            bundle :install
-
-            expect(out).not_to include("Warning: the gem 'rack' was found in multiple sources.")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0")
-          end
-        end
-      end
-    end
-
-    context "when a top-level gem has an indirect dependency" do
-      context "when lockfile_uses_separate_rubygems_sources is set" do
-        before do
-          bundle! "config lockfile_uses_separate_rubygems_sources true"
-          bundle! "config disable_multisource true"
-        end
-
-        before do
-          build_repo gem_repo2 do
-            build_gem "depends_on_rack", "1.0.1" do |s|
-              s.add_dependency "rack"
-            end
-          end
-
-          build_repo gem_repo3 do
-            build_gem "unrelated_gem", "1.0.0"
-          end
-
-          gemfile <<-G
-            source "file://#{gem_repo2}"
-
-            gem "depends_on_rack"
-
-            source "file://#{gem_repo3}" do
-              gem "unrelated_gem"
-            end
-          G
-        end
-
-        context "and the dependency is only in the top-level source" do
-          before do
-            update_repo gem_repo2 do
-              build_gem "rack", "1.0.0"
-            end
-          end
-
-          it "installs all gems without warning" do
-            bundle :install
-            expect(out).not_to include("Warning")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0", "unrelated_gem 1.0.0")
-          end
-        end
-
-        context "and the dependency is only in a pinned source" do
-          before do
-            update_repo gem_repo3 do
-              build_gem "rack", "1.0.0" do |s|
-                s.write "lib/rack.rb", "RACK = 'FAIL'"
-              end
-            end
-          end
-
-          it "does not find the dependency" do
-            bundle :install
-            expect(out).to include("Could not find gem 'rack', which is required by gem 'depends_on_rack', in any of the relevant sources")
-          end
-        end
-
-        context "and the dependency is in both the top-level and a pinned source" do
-          before do
-            update_repo gem_repo2 do
-              build_gem "rack", "1.0.0"
-            end
-
-            update_repo gem_repo3 do
-              build_gem "rack", "1.0.0" do |s|
-                s.write "lib/rack.rb", "RACK = 'FAIL'"
-              end
-            end
-          end
-
-          it "installs the dependency from the top-level source without warning" do
-            bundle :install
-            expect(out).not_to include("Warning")
-            expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0", "unrelated_gem 1.0.0")
-          end
-        end
-      end
-    end
-
-    context "with a gem that is only found in the wrong source" do
-      before do
-        build_repo gem_repo3 do
-          build_gem "not_in_repo1", "1.0.0"
-        end
-
-        gemfile <<-G
-          source "file://#{gem_repo3}"
-          gem "not_in_repo1", :source => "file://#{gem_repo1}"
-        G
-      end
-
-      it "does not install the gem" do
-        bundle :install
-        expect(out).to include("Could not find gem 'not_in_repo1'")
-      end
-    end
-
-    context "with an existing lockfile" do
-      before do
-        system_gems "rack-0.9.1", "rack-1.0.0", :path => :bundle_path
-
-        lockfile <<-L
-          GEM
-            remote: file:#{gem_repo1}
-            remote: file:#{gem_repo3}
-            specs:
-              rack (0.9.1)
-
-          PLATFORMS
-            ruby
-
-          DEPENDENCIES
-            rack!
-        L
-
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          source "file://#{gem_repo3}" do
-            gem 'rack'
-          end
-        G
-      end
-
-      # Reproduction of https://github.com/bundler/bundler/issues/3298
-      it "does not unlock the installed gem on exec" do
-        expect(the_bundle).to include_gems("rack 0.9.1")
-      end
-    end
-
-    context "with a path gem in the same Gemfile" do
-      before do
-        build_lib "foo"
-
-        gemfile <<-G
-          gem "rack", :source => "file://#{gem_repo1}"
-          gem "foo", :path => "#{lib_path("foo-1.0")}"
-        G
-      end
-
-      it "does not unlock the non-path gem after install" do
-        bundle! :install
-
-        bundle! %(exec ruby -e 'puts "OK"'), :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-
-        expect(out).to include("OK")
-      end
-    end
-  end
-
-  context "when an older version of the same gem also ships with Ruby" do
-    before do
-      system_gems "rack-0.9.1"
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack" # shoud come from repo1!
-      G
-    end
-
-    it "installs the gems without any warning" do
-      bundle :install
-      expect(out).not_to include("Warning")
-      expect(the_bundle).to include_gems("rack 1.0.0")
-    end
-  end
-
-  context "when a single source contains multiple locked gems" do
-    before do
-      # 1. With these gems,
-      build_repo4 do
-        build_gem "foo", "0.1"
-        build_gem "bar", "0.1"
-      end
-
-      # 2. Installing this gemfile will produce...
-      gemfile <<-G
-        source 'file://#{gem_repo1}'
-        gem 'rack'
-        gem 'foo', '~> 0.1', :source => 'file://#{gem_repo4}'
-        gem 'bar', '~> 0.1', :source => 'file://#{gem_repo4}'
-      G
-
-      # 3. this lockfile.
-      lockfile <<-L
-        GEM
-          remote: file:/Users/andre/src/bundler/bundler/tmp/gems/remote1/
-          remote: file:/Users/andre/src/bundler/bundler/tmp/gems/remote4/
-          specs:
-            bar (0.1)
-            foo (0.1)
-            rack (1.0.0)
-
-        PLATFORMS
-          ruby
-
-        DEPENDENCIES
-          bar (~> 0.1)!
-          foo (~> 0.1)!
-          rack
-      L
-
-      bundle! :install, forgotten_command_line_options(:path => "../gems/system")
-
-      # 4. Then we add some new versions...
-      update_repo4 do
-        build_gem "foo", "0.2"
-        build_gem "bar", "0.3"
-      end
-    end
-
-    it "allows them to be unlocked separately" do
-      # 5. and install this gemfile, updating only foo.
-      install_gemfile <<-G
-        source 'file://#{gem_repo1}'
-        gem 'rack'
-        gem 'foo', '~> 0.2', :source => 'file://#{gem_repo4}'
-        gem 'bar', '~> 0.1', :source => 'file://#{gem_repo4}'
-      G
-
-      # 6. Which should update foo to 0.2, but not the (locked) bar 0.1
-      expect(the_bundle).to include_gems("foo 0.2", "bar 0.1")
-    end
-  end
-
-  context "re-resolving" do
-    context "when there is a mix of sources in the gemfile" do
-      before do
-        build_repo3
-        build_lib "path1"
-        build_lib "path2"
-        build_git "git1"
-        build_git "git2"
-
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rails"
-
-          source "file://#{gem_repo3}" do
-            gem "rack"
-          end
-
-          gem "path1", :path => "#{lib_path("path1-1.0")}"
-          gem "path2", :path => "#{lib_path("path2-1.0")}"
-          gem "git1",  :git  => "#{lib_path("git1-1.0")}"
-          gem "git2",  :git  => "#{lib_path("git2-1.0")}"
-        G
-      end
-
-      it "does not re-resolve" do
-        bundle :install, :verbose => true
-        expect(out).to include("using resolution from the lockfile")
-        expect(out).not_to include("re-resolving dependencies")
-      end
-    end
-  end
-
-  context "when a gem is installed to system gems" do
-    before do
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-    end
-
-    context "and the gemfile changes" do
-      it "is still able to find that gem from remote sources" do
-        source_uri = "file://#{gem_repo1}"
-        second_uri = "file://#{gem_repo4}"
-
-        build_repo4 do
-          build_gem "rack", "2.0.1.1.forked"
-          build_gem "thor", "0.19.1.1.forked"
-        end
-
-        # When this gemfile is installed...
-        gemfile <<-G
-          source "#{source_uri}"
-
-          source "#{second_uri}" do
-            gem "rack", "2.0.1.1.forked"
-            gem "thor"
-          end
-          gem "rack-obama"
-        G
-
-        # It creates this lockfile.
-        lockfile <<-L
-          GEM
-            remote: #{source_uri}/
-            remote: #{second_uri}/
-            specs:
-              rack (2.0.1.1.forked)
-              rack-obama (1.0)
-                rack
-              thor (0.19.1.1.forked)
-
-          PLATFORMS
-            ruby
-
-          DEPENDENCIES
-            rack (= 2.0.1.1.forked)!
-            rack-obama
-            thor!
-        L
-
-        # Then we change the Gemfile by adding a version to thor
-        gemfile <<-G
-          source "#{source_uri}"
-
-          source "#{second_uri}" do
-            gem "rack", "2.0.1.1.forked"
-            gem "thor", "0.19.1.1.forked"
-          end
-          gem "rack-obama"
-        G
-
-        # But we should still be able to find rack 2.0.1.1.forked and install it
-        bundle! :install
-      end
-    end
-  end
-end
diff --git a/spec/bundler/install/gemfile/specific_platform_spec.rb b/spec/bundler/install/gemfile/specific_platform_spec.rb
deleted file mode 100644
index 9c725416d5..0000000000
--- a/spec/bundler/install/gemfile/specific_platform_spec.rb
+++ /dev/null
@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundle install with specific_platform enabled" do
-  before do
-    bundle "config specific_platform true"
-
-    build_repo2 do
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1")
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1") {|s| s.platform = "x86_64-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1") {|s| s.platform = "x86-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1") {|s| s.platform = "x86-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1") {|s| s.platform = "x64-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1") {|s| s.platform = "universal-darwin" }
-
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5") {|s| s.platform = "x86_64-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5") {|s| s.platform = "x86-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5") {|s| s.platform = "x64-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5") {|s| s.platform = "x86-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.5")
-
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.4") {|s| s.platform = "universal-darwin" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.4") {|s| s.platform = "x86_64-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.4") {|s| s.platform = "x86-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.4") {|s| s.platform = "x86-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.4") {|s| s.platform = "x64-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.4")
-
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.3")
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.3") {|s| s.platform = "x86_64-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.3") {|s| s.platform = "x86-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.3") {|s| s.platform = "x86-linux" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.3") {|s| s.platform = "x64-mingw32" }
-      build_gem("google-protobuf", "3.0.0.alpha.5.0.3") {|s| s.platform = "universal-darwin" }
-
-      build_gem("google-protobuf", "3.0.0.alpha.4.0")
-      build_gem("google-protobuf", "3.0.0.alpha.3.1.pre")
-      build_gem("google-protobuf", "3.0.0.alpha.3")
-      build_gem("google-protobuf", "3.0.0.alpha.2.0")
-      build_gem("google-protobuf", "3.0.0.alpha.1.1")
-      build_gem("google-protobuf", "3.0.0.alpha.1.0")
-
-      build_gem("facter", "2.4.6")
-      build_gem("facter", "2.4.6") do |s|
-        s.platform = "universal-darwin"
-        s.add_runtime_dependency "CFPropertyList"
-      end
-      build_gem("CFPropertyList")
-    end
-  end
-
-  let(:google_protobuf) { <<-G }
-    source "file:#{gem_repo2}"
-    gem "google-protobuf"
-  G
-
-  context "when on a darwin machine" do
-    before { simulate_platform "x86_64-darwin-15" }
-
-    it "locks to both the specific darwin platform and ruby" do
-      install_gemfile!(google_protobuf)
-      expect(the_bundle.locked_gems.platforms).to eq([pl("ruby"), pl("x86_64-darwin-15")])
-      expect(the_bundle).to include_gem("google-protobuf 3.0.0.alpha.5.0.5.1 universal-darwin")
-      expect(the_bundle.locked_gems.specs.map(&:full_name)).to eq(%w[
-        google-protobuf-3.0.0.alpha.5.0.5.1
-        google-protobuf-3.0.0.alpha.5.0.5.1-universal-darwin
-      ])
-    end
-
-    it "caches both the universal-darwin and ruby gems when --all-platforms is passed" do
-      gemfile(google_protobuf)
-      bundle! "package --all-platforms"
-      expect([cached_gem("google-protobuf-3.0.0.alpha.5.0.5.1"), cached_gem("google-protobuf-3.0.0.alpha.5.0.5.1-universal-darwin")]).
-        to all(exist)
-    end
-
-    it "uses the platform-specific gem with extra dependencies" do
-      install_gemfile! <<-G
-        source "file:#{gem_repo2}"
-        gem "facter"
-      G
-
-      expect(the_bundle.locked_gems.platforms).to eq([pl("ruby"), pl("x86_64-darwin-15")])
-      expect(the_bundle).to include_gems("facter 2.4.6 universal-darwin", "CFPropertyList 1.0")
-      expect(the_bundle.locked_gems.specs.map(&:full_name)).to eq(["CFPropertyList-1.0",
-                                                                   "facter-2.4.6",
-                                                                   "facter-2.4.6-universal-darwin"])
-    end
-
-    context "when adding a platform via lock --add_platform" do
-      it "adds the foreign platform" do
-        install_gemfile!(google_protobuf)
-        bundle! "lock --add-platform=#{x64_mingw}"
-
-        expect(the_bundle.locked_gems.platforms).to eq([rb, x64_mingw, pl("x86_64-darwin-15")])
-        expect(the_bundle.locked_gems.specs.map(&:full_name)).to eq(%w[
-          google-protobuf-3.0.0.alpha.5.0.5.1
-          google-protobuf-3.0.0.alpha.5.0.5.1-universal-darwin
-          google-protobuf-3.0.0.alpha.5.0.5.1-x64-mingw32
-        ])
-      end
-
-      it "falls back on plain ruby when that version doesnt have a platform-specific gem" do
-        install_gemfile!(google_protobuf)
-        bundle! "lock --add-platform=#{java}"
-
-        expect(the_bundle.locked_gems.platforms).to eq([java, rb, pl("x86_64-darwin-15")])
-        expect(the_bundle.locked_gems.specs.map(&:full_name)).to eq(%w[
-          google-protobuf-3.0.0.alpha.5.0.5.1
-          google-protobuf-3.0.0.alpha.5.0.5.1-universal-darwin
-        ])
-      end
-    end
-  end
-end