Merge bundler master from upstream.

  Pick from 8dd59e3ba97eb80a599f8149f31bf40773b69dc0

62 files changed, 730 insertions, 678 deletions

diff --git a/spec/bundler/bundler/bundler_spec.rb b/spec/bundler/bundler/bundler_spec.rb
index e33c8dc606..f74c1780bd 100644
--- a/spec/bundler/bundler/bundler_spec.rb
+++ b/spec/bundler/bundler/bundler_spec.rb
@@ -370,54 +370,51 @@ EOF
         it { should be true }
       end
     end
-  end
 
-  describe "#requires_sudo?" do
-    before do
-      allow(Bundler).to receive(:which).with("sudo").and_return("/usr/bin/sudo")
-      FileUtils.mkdir_p("tmp/vendor/bundle")
-      FileUtils.mkdir_p("tmp/vendor/bin_dir")
-    end
-    after do
-      FileUtils.rm_rf("tmp/vendor/bundle")
-      FileUtils.rm_rf("tmp/vendor/bin_dir")
-      Bundler.remove_instance_variable(:@requires_sudo_ran)
-      Bundler.remove_instance_variable(:@requires_sudo)
-    end
-    context "writable paths" do
-      it "should return false and display nothing" do
-        allow(Bundler).to receive(:bundle_path).and_return(Pathname("tmp/vendor/bundle"))
-        expect(Bundler.ui).to_not receive(:warn)
-        expect(Bundler.requires_sudo?).to eq(false)
-      end
-    end
-    context "unwritable paths" do
+    context "path writability" do
       before do
-        FileUtils.touch("tmp/vendor/bundle/unwritable1.txt")
-        FileUtils.touch("tmp/vendor/bundle/unwritable2.txt")
-        FileUtils.touch("tmp/vendor/bin_dir/unwritable3.txt")
-        FileUtils.chmod(0o400, "tmp/vendor/bundle/unwritable1.txt")
-        FileUtils.chmod(0o400, "tmp/vendor/bundle/unwritable2.txt")
-        FileUtils.chmod(0o400, "tmp/vendor/bin_dir/unwritable3.txt")
+        FileUtils.mkdir_p("tmp/vendor/bundle")
+        FileUtils.mkdir_p("tmp/vendor/bin_dir")
+      end
+      after do
+        FileUtils.rm_rf("tmp/vendor/bundle")
+        FileUtils.rm_rf("tmp/vendor/bin_dir")
       end
-      it "should return true and display warn message" do
-        allow(Bundler).to receive(:bundle_path).and_return(Pathname("tmp/vendor/bundle"))
-        bin_dir = Pathname("tmp/vendor/bin_dir/")
+      context "writable paths" do
+        it "should return false and display nothing" do
+          allow(Bundler).to receive(:bundle_path).and_return(Pathname("tmp/vendor/bundle"))
+          expect(Bundler.ui).to_not receive(:warn)
+          expect(Bundler.requires_sudo?).to eq(false)
+        end
+      end
+      context "unwritable paths" do
+        before do
+          FileUtils.touch("tmp/vendor/bundle/unwritable1.txt")
+          FileUtils.touch("tmp/vendor/bundle/unwritable2.txt")
+          FileUtils.touch("tmp/vendor/bin_dir/unwritable3.txt")
+          FileUtils.chmod(0o400, "tmp/vendor/bundle/unwritable1.txt")
+          FileUtils.chmod(0o400, "tmp/vendor/bundle/unwritable2.txt")
+          FileUtils.chmod(0o400, "tmp/vendor/bin_dir/unwritable3.txt")
+        end
+        it "should return true and display warn message" do
+          allow(Bundler).to receive(:bundle_path).and_return(Pathname("tmp/vendor/bundle"))
+          bin_dir = Pathname("tmp/vendor/bin_dir/")
 
-        # allow File#writable? to be called with args other than the stubbed on below
-        allow(File).to receive(:writable?).and_call_original
+          # allow File#writable? to be called with args other than the stubbed on below
+          allow(File).to receive(:writable?).and_call_original
 
-        # fake make the directory unwritable
-        allow(File).to receive(:writable?).with(bin_dir).and_return(false)
-        allow(Bundler).to receive(:system_bindir).and_return(Pathname("tmp/vendor/bin_dir/"))
-        message = <<-MESSAGE.chomp
+          # fake make the directory unwritable
+          allow(File).to receive(:writable?).with(bin_dir).and_return(false)
+          allow(Bundler).to receive(:system_bindir).and_return(Pathname("tmp/vendor/bin_dir/"))
+          message = <<-MESSAGE.chomp
 Following files may not be writable, so sudo is needed:
   tmp/vendor/bin_dir/
   tmp/vendor/bundle/unwritable1.txt
   tmp/vendor/bundle/unwritable2.txt
 MESSAGE
-        expect(Bundler.ui).to receive(:warn).with(message)
-        expect(Bundler.requires_sudo?).to eq(true)
+          expect(Bundler.ui).to receive(:warn).with(message)
+          expect(Bundler.requires_sudo?).to eq(true)
+        end
       end
     end
   end
@@ -457,6 +454,7 @@ MESSAGE
 
       it "should use custom home path as root for other paths" do
         ENV["BUNDLE_USER_HOME"] = bundle_user_home_custom.to_s
+        allow(Bundler.rubygems).to receive(:user_home).and_raise
         expect(Bundler.user_bundle_path).to           eq(bundle_user_home_custom)
         expect(Bundler.user_bundle_path("home")).to   eq(bundle_user_home_custom)
         expect(Bundler.user_bundle_path("cache")).to  eq(bundle_user_home_custom.join("cache"))
diff --git a/spec/bundler/bundler/cli_spec.rb b/spec/bundler/bundler/cli_spec.rb
index 6a505358d1..2e12fbfc6b 100644
--- a/spec/bundler/bundler/cli_spec.rb
+++ b/spec/bundler/bundler/cli_spec.rb
@@ -30,8 +30,8 @@ RSpec.describe "bundle executable" do
   context "with no arguments" do
     it "prints a concise help message", :bundler => "3" do
       bundle! ""
-      expect(last_command.stderr).to be_empty
-      expect(last_command.stdout).to include("Bundler version #{Bundler::VERSION}").
+      expect(err).to be_empty
+      expect(out).to include("Bundler version #{Bundler::VERSION}").
         and include("\n\nBundler commands:\n\n").
         and include("\n\n  Primary commands:\n").
         and include("\n\n  Utilities:\n").
@@ -72,17 +72,17 @@ RSpec.describe "bundle executable" do
     it "prints the running command" do
       gemfile ""
       bundle! "info bundler", :verbose => true
-      expect(last_command.stdout).to start_with("Running `bundle info bundler --verbose` with bundler #{Bundler::VERSION}")
+      expect(out).to start_with("Running `bundle info bundler --verbose` with bundler #{Bundler::VERSION}")
     end
 
     it "doesn't print defaults" do
       install_gemfile! "", :verbose => true
-      expect(last_command.stdout).to start_with("Running `bundle install --retry 0 --verbose` with bundler #{Bundler::VERSION}")
+      expect(out).to start_with("Running `bundle install --retry 0 --verbose` with bundler #{Bundler::VERSION}")
     end
 
     it "doesn't print defaults" do
       install_gemfile! "", :verbose => true
-      expect(last_command.stdout).to start_with("Running `bundle install --retry 0 --verbose` with bundler #{Bundler::VERSION}")
+      expect(out).to start_with("Running `bundle install --retry 0 --verbose` with bundler #{Bundler::VERSION}")
     end
   end
 
@@ -125,7 +125,7 @@ RSpec.describe "bundle executable" do
       let(:latest_version) { "222.0" }
       it "prints the version warning" do
         bundle "fail"
-        expect(last_command.stdout).to start_with(<<-EOS.strip)
+        expect(err).to start_with(<<-EOS.strip)
 The latest bundler is #{latest_version}, but you are currently running #{bundler_version}.
 To install the latest version, run `gem install bundler`
         EOS
@@ -150,7 +150,7 @@ To install the latest version, run `gem install bundler`
         let(:latest_version) { "222.0.0.pre.4" }
         it "prints the version warning" do
           bundle "fail"
-          expect(last_command.stdout).to start_with(<<-EOS.strip)
+          expect(err).to start_with(<<-EOS.strip)
 The latest bundler is #{latest_version}, but you are currently running #{bundler_version}.
 To install the latest version, run `gem install bundler --pre`
           EOS
diff --git a/spec/bundler/bundler/dsl_spec.rb b/spec/bundler/bundler/dsl_spec.rb
index de2a43adc6..214d159d05 100644
--- a/spec/bundler/bundler/dsl_spec.rb
+++ b/spec/bundler/bundler/dsl_spec.rb
@@ -25,60 +25,17 @@ RSpec.describe Bundler::Dsl do
       expect { subject.git_source(:example) }.to raise_error(Bundler::InvalidOption)
     end
 
-    context "github_https feature flag" do
-      it "is true when github.https is true" do
-        bundle "config set github.https true"
-        expect(Bundler.feature_flag.github_https?).to eq true
-      end
-    end
-
-    shared_examples_for "the github DSL" do |protocol|
-      context "when full repo is used" do
-        let(:repo) { "indirect/sparks" }
-
-        it "converts :github to URI using #{protocol}" do
-          subject.gem("sparks", :github => repo)
-          github_uri = "#{protocol}://github.com/#{repo}.git"
-          expect(subject.dependencies.first.source.uri).to eq(github_uri)
-        end
-      end
-
-      context "when shortcut repo is used" do
-        let(:repo) { "rails" }
-
-        it "converts :github to URI using #{protocol}" do
-          subject.gem("sparks", :github => repo)
-          github_uri = "#{protocol}://github.com/#{repo}/#{repo}.git"
-          expect(subject.dependencies.first.source.uri).to eq(github_uri)
-        end
-      end
-    end
-
-    context "default hosts (git, gist)" do
-      context "when github.https config is true" do
-        before { bundle "config set github.https true" }
-
-        it_behaves_like "the github DSL", "https"
-      end
-
-      context "when github.https config is false", :bundler => "2" do
-        before { bundle "config set github.https false" }
-
-        it_behaves_like "the github DSL", "git"
-      end
-
-      context "when github.https config is false", :bundler => "3" do
-        before { bundle "config set github.https false" }
-
-        pending "should show a proper message about the removed setting"
-      end
-
-      context "by default", :bundler => "2" do
-        it_behaves_like "the github DSL", "https"
+    context "default hosts", :bundler => "2" do
+      it "converts :github to URI using https" do
+        subject.gem("sparks", :github => "indirect/sparks")
+        github_uri = "https://github.com/indirect/sparks.git"
+        expect(subject.dependencies.first.source.uri).to eq(github_uri)
       end
 
-      context "by default", :bundler => "3" do
-        it_behaves_like "the github DSL", "https"
+      it "converts :github shortcut to URI using https" do
+        subject.gem("sparks", :github => "rails")
+        github_uri = "https://github.com/rails/rails.git"
+        expect(subject.dependencies.first.source.uri).to eq(github_uri)
       end
 
       it "converts numeric :gist to :git" do
@@ -106,7 +63,7 @@ RSpec.describe Bundler::Dsl do
       end
     end
 
-    context "default git sources", :bundler => "4" do
+    context "default git sources", :bundler => "3" do
       it "has none" do
         expect(subject.instance_variable_get(:@git_sources)).to eq({})
       end
@@ -285,7 +242,7 @@ RSpec.describe Bundler::Dsl do
       end
     end
 
-    describe "#github", :bundler => "3" do
+    describe "#github", :bundler => "2" do
       it "from github" do
         spree_gems = %w[spree_core spree_api spree_backend]
         subject.github "spree" do
@@ -300,19 +257,6 @@ RSpec.describe Bundler::Dsl do
 
     describe "#github", :bundler => "3" do
       it "from github" do
-        spree_gems = %w[spree_core spree_api spree_backend]
-        subject.github "spree" do
-          spree_gems.each {|spree_gem| subject.send :gem, spree_gem }
-        end
-
-        subject.dependencies.each do |d|
-          expect(d.source.uri).to eq("https://github.com/spree/spree.git")
-        end
-      end
-    end
-
-    describe "#github", :bundler => "4" do
-      it "from github" do
         expect do
           spree_gems = %w[spree_core spree_api spree_backend]
           subject.github "spree" do
diff --git a/spec/bundler/bundler/env_spec.rb b/spec/bundler/bundler/env_spec.rb
index 20bd38b021..8323a9a7b3 100644
--- a/spec/bundler/bundler/env_spec.rb
+++ b/spec/bundler/bundler/env_spec.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "openssl"
 require "bundler/settings"
 
 RSpec.describe Bundler::Env do
@@ -17,6 +18,54 @@ RSpec.describe Bundler::Env do
       expect(out).to include(OpenSSL::OPENSSL_VERSION)
     end
 
+    describe "rubygems paths" do
+      it "prints gem home" do
+        with_clear_paths("GEM_HOME", "/a/b/c") do
+          out = described_class.report
+          expect(out).to include("Gem Home    /a/b/c")
+        end
+      end
+
+      it "prints gem path" do
+        with_clear_paths("GEM_PATH", "/a/b/c:/d/e/f") do
+          out = described_class.report
+          expect(out).to include("Gem Path    /a/b/c:/d/e/f")
+        end
+      end
+
+      it "prints user home" do
+        with_clear_paths("HOME", "/a/b/c") do
+          out = described_class.report
+          expect(out).to include("User Home   /a/b/c")
+        end
+      end
+
+      it "prints user path" do
+        with_clear_paths("HOME", "/a/b/c") do
+          out = described_class.report
+          expect(out).to include("User Path   /a/b/c/.gem")
+        end
+      end
+
+      it "prints bin dir" do
+        with_clear_paths("GEM_HOME", "/a/b/c") do
+          out = described_class.report
+          expect(out).to include("Bin Dir     /a/b/c/bin")
+        end
+      end
+
+    private
+
+      def with_clear_paths(env_var, env_value)
+        old_env_var = ENV[env_var]
+        ENV[env_var] = env_value
+        Gem.clear_paths
+        yield
+      ensure
+        ENV[env_var] = old_env_var
+      end
+    end
+
     context "when there is a Gemfile and a lockfile and print_gemfile is true" do
       before do
         gemfile "gem 'rack', '1.0.0'"
diff --git a/spec/bundler/bundler/fetcher/compact_index_spec.rb b/spec/bundler/bundler/fetcher/compact_index_spec.rb
index 5a2d22193a..2f622f6653 100644
--- a/spec/bundler/bundler/fetcher/compact_index_spec.rb
+++ b/spec/bundler/bundler/fetcher/compact_index_spec.rb
@@ -11,11 +11,14 @@ RSpec.describe Bundler::Fetcher::CompactIndex do
   end
 
   describe "#specs_for_names" do
+    let(:thread_list) { Thread.list.select {|thread| thread.status == "run" } }
+    let(:thread_inspection) { thread_list.map {|th| "  * #{th}:\n    #{th.backtrace_locations.join("\n    ")}" }.join("\n") }
+
     it "has only one thread open at the end of the run" do
       compact_index.specs_for_names(["lskdjf"])
 
-      thread_count = Thread.list.count {|thread| thread.status == "run" }
-      expect(thread_count).to eq 1
+      thread_count = thread_list.count
+      expect(thread_count).to eq(1), "Expected 1 active thread after `#specs_for_names`, but found #{thread_count}. In particular, found:\n#{thread_inspection}"
     end
 
     it "calls worker#stop during the run" do
diff --git a/spec/bundler/bundler/fetcher/downloader_spec.rb b/spec/bundler/bundler/fetcher/downloader_spec.rb
index 07b507266b..f985b88982 100644
--- a/spec/bundler/bundler/fetcher/downloader_spec.rb
+++ b/spec/bundler/bundler/fetcher/downloader_spec.rb
@@ -82,6 +82,15 @@ RSpec.describe Bundler::Fetcher::Downloader do
         expect { subject.fetch(uri, options, counter) }.to raise_error(Bundler::Fetcher::AuthenticationRequiredError,
           /Authentication is required for www.uri-to-fetch.com/)
       end
+
+      context "when the there are credentials provided in the request" do
+        let(:uri) { URI("http://user:password@www.uri-to-fetch.com") }
+
+        it "should raise a Bundler::Fetcher::BadAuthenticationError that doesn't contain the password" do
+          expect { subject.fetch(uri, options, counter) }.
+            to raise_error(Bundler::Fetcher::BadAuthenticationError, /Bad username or password for www.uri-to-fetch.com/)
+        end
+      end
     end
 
     context "when the request response is a Net::HTTPNotFound" do
diff --git a/spec/bundler/bundler/fetcher/index_spec.rb b/spec/bundler/bundler/fetcher/index_spec.rb
index 0cf0ae764e..d5ededae3e 100644
--- a/spec/bundler/bundler/fetcher/index_spec.rb
+++ b/spec/bundler/bundler/fetcher/index_spec.rb
@@ -35,9 +35,26 @@ RSpec.describe Bundler::Fetcher::Index do
       context "when a 401 response occurs" do
         let(:error_message) { "401" }
 
-        it "should raise a Bundler::Fetcher::AuthenticationRequiredError" do
-          expect { subject.specs(gem_names) }.to raise_error(Bundler::Fetcher::AuthenticationRequiredError,
-            %r{Authentication is required for http://remote-uri.org})
+        before do
+          allow(remote_uri).to receive(:userinfo).and_return(userinfo)
+        end
+
+        context "and there was userinfo" do
+          let(:userinfo) { double(:userinfo) }
+
+          it "should raise a Bundler::Fetcher::BadAuthenticationError" do
+            expect { subject.specs(gem_names) }.to raise_error(Bundler::Fetcher::BadAuthenticationError,
+              %r{Bad username or password for http://remote-uri.org})
+          end
+        end
+
+        context "and there was no userinfo" do
+          let(:userinfo) { nil }
+
+          it "should raise a Bundler::Fetcher::AuthenticationRequiredError" do
+            expect { subject.specs(gem_names) }.to raise_error(Bundler::Fetcher::AuthenticationRequiredError,
+              %r{Authentication is required for http://remote-uri.org})
+          end
         end
       end
 
diff --git a/spec/bundler/bundler/friendly_errors_spec.rb b/spec/bundler/bundler/friendly_errors_spec.rb
index 4ca1e543c1..07ec196b86 100644
--- a/spec/bundler/bundler/friendly_errors_spec.rb
+++ b/spec/bundler/bundler/friendly_errors_spec.rb
@@ -24,7 +24,7 @@ RSpec.describe Bundler, "friendly errors" do
 
       bundle :install, :env => { "DEBUG" => true }
 
-      expect(last_command.stderr).to include("Failed to load #{home(".gemrc")}")
+      expect(err).to include("Failed to load #{home(".gemrc")}")
       expect(exitstatus).to eq(0) if exitstatus
     end
   end
diff --git a/spec/bundler/bundler/plugin/events_spec.rb b/spec/bundler/bundler/plugin/events_spec.rb
index b09e915682..28d70c6fdd 100644
--- a/spec/bundler/bundler/plugin/events_spec.rb
+++ b/spec/bundler/bundler/plugin/events_spec.rb
@@ -2,10 +2,14 @@
 
 RSpec.describe Bundler::Plugin::Events do
   context "plugin events" do
+    before { Bundler::Plugin::Events.send :reset }
+
     describe "#define" do
       it "raises when redefining a constant" do
+        Bundler::Plugin::Events.send(:define, :TEST_EVENT, "foo")
+
         expect do
-          Bundler::Plugin::Events.send(:define, :GEM_BEFORE_INSTALL_ALL, "another-value")
+          Bundler::Plugin::Events.send(:define, :TEST_EVENT, "bar")
         end.to raise_error(ArgumentError)
       end
 
diff --git a/spec/bundler/bundler/ruby_version_spec.rb b/spec/bundler/bundler/ruby_version_spec.rb
index 46a1b2918b..3ac7d9ef3a 100644
--- a/spec/bundler/bundler/ruby_version_spec.rb
+++ b/spec/bundler/bundler/ruby_version_spec.rb
@@ -399,8 +399,14 @@ RSpec.describe "Bundler::RubyVersion and its subclasses" do
 
       let(:bundler_system_ruby_version) { subject }
 
-      before do
-        Bundler::RubyVersion.instance_variable_set("@ruby_version", nil)
+      around do |example|
+        begin
+          old_ruby_version = Bundler::RubyVersion.instance_variable_get("@ruby_version")
+          Bundler::RubyVersion.instance_variable_set("@ruby_version", nil)
+          example.run
+        ensure
+          Bundler::RubyVersion.instance_variable_set("@ruby_version", old_ruby_version)
+        end
       end
 
       it "should return an instance of Bundler::RubyVersion" do
diff --git a/spec/bundler/bundler/shared_helpers_spec.rb b/spec/bundler/bundler/shared_helpers_spec.rb
index f42d9ed485..8e82d1b910 100644
--- a/spec/bundler/bundler/shared_helpers_spec.rb
+++ b/spec/bundler/bundler/shared_helpers_spec.rb
@@ -236,7 +236,7 @@ RSpec.describe Bundler::SharedHelpers do
     shared_examples_for "ENV['RUBYOPT'] gets set correctly" do
       it "ensures -rbundler/setup is at the beginning of ENV['RUBYOPT']" do
         subject.set_bundle_environment
-        expect(ENV["RUBYOPT"].split(" ")).to start_with("-rbundler/setup")
+        expect(ENV["RUBYOPT"].split(" ")).to start_with("-r#{File.expand_path("../../lib/bundler/setup", __dir__)}")
       end
     end
 
diff --git a/spec/bundler/bundler/ui/shell_spec.rb b/spec/bundler/bundler/ui/shell_spec.rb
index 23a7670dd1..632477096e 100644
--- a/spec/bundler/bundler/ui/shell_spec.rb
+++ b/spec/bundler/bundler/ui/shell_spec.rb
@@ -24,13 +24,6 @@ RSpec.describe Bundler::UI::Shell do
     it "prints to stderr" do
       expect { subject.warn("warning") }.to output("warning\n").to_stderr
     end
-
-    context "when stderr flag is enabled" do
-      before { Bundler.settings.temporary(:error_on_stderr => true) }
-      it "prints to stderr" do
-        expect { subject.warn("warning!") }.to output("warning!\n").to_stderr
-      end
-    end
   end
 
   describe "#debug" do
@@ -46,19 +39,12 @@ RSpec.describe Bundler::UI::Shell do
       expect { subject.error("error!!!") }.to output("error!!!\n").to_stderr
     end
 
-    context "when stderr flag is enabled" do
-      before { Bundler.settings.temporary(:error_on_stderr => true) }
-      it "prints to stderr" do
-        expect { subject.error("error!!!") }.to output("error!!!\n").to_stderr
-      end
-
-      context "when stderr is closed" do
-        it "doesn't report anything" do
-          output = capture(:stderr, :closed => true) do
-            subject.error("Something went wrong")
-          end
-          expect(output).to_not eq("Something went wrong\n")
+    context "when stderr is closed" do
+      it "doesn't report anything" do
+        output = capture(:stderr, :closed => true) do
+          subject.error("Something went wrong")
         end
+        expect(output).to_not eq("Something went wrong\n")
       end
     end
   end
diff --git a/spec/bundler/cache/git_spec.rb b/spec/bundler/cache/git_spec.rb
index 55a24ff118..d31d607d25 100644
--- a/spec/bundler/cache/git_spec.rb
+++ b/spec/bundler/cache/git_spec.rb
@@ -59,7 +59,7 @@ end
       bundle! "#{cmd}", forgotten_command_line_options([:all, :cache_all] => true)
       bundle! "#{cmd}", forgotten_command_line_options([:all, :cache_all] => true)
 
-      expect(last_command.stdout).to include "Updating files in vendor/cache"
+      expect(out).to include "Updating files in vendor/cache"
       FileUtils.rm_rf lib_path("foo-1.0")
       expect(the_bundle).to include_gems "foo 1.0"
     end
diff --git a/spec/bundler/commands/add_spec.rb b/spec/bundler/commands/add_spec.rb
index dac1d0f6b9..f5b3f49bb1 100644
--- a/spec/bundler/commands/add_spec.rb
+++ b/spec/bundler/commands/add_spec.rb
@@ -11,6 +11,8 @@ RSpec.describe "bundle add" do
       build_gem "dog", "1.1.3.pre"
     end
 
+    build_git "foo", "2.0"
+
     install_gemfile <<-G
       source "file://#{gem_repo2}"
       gem "weakling", "~> 0.0.1"
@@ -21,7 +23,7 @@ RSpec.describe "bundle add" do
     it "shows error" do
       bundle "add"
 
-      expect(last_command.bundler_err).to include("Please specify gems to add")
+      expect(err).to include("Please specify gems to add")
     end
   end
 
@@ -89,6 +91,28 @@ RSpec.describe "bundle add" do
     end
   end
 
+  describe "with --git" do
+    it "adds dependency with specified github source" do
+      bundle "add foo --git=#{lib_path("foo-2.0")}"
+
+      expect(bundled_app("Gemfile").read).to match(/gem "foo", "~> 2.0", :git => "#{lib_path("foo-2.0")}"/)
+      expect(the_bundle).to include_gems "foo 2.0"
+    end
+  end
+
+  describe "with --git and --branch" do
+    before do
+      update_git "foo", "2.0", :branch => "test"
+    end
+
+    it "adds dependency with specified github source and branch" do
+      bundle "add foo --git=#{lib_path("foo-2.0")} --branch=test"
+
+      expect(bundled_app("Gemfile").read).to match(/gem "foo", "~> 2.0", :git => "#{lib_path("foo-2.0")}", :branch => "test"/)
+      expect(the_bundle).to include_gems "foo 2.0"
+    end
+  end
+
   describe "with --skip-install" do
     it "adds gem to Gemfile but is not installed" do
       bundle "add foo --skip-install --version=2.0"
diff --git a/spec/bundler/commands/binstubs_spec.rb b/spec/bundler/commands/binstubs_spec.rb
index 92fa6812b0..4f310784c7 100644
--- a/spec/bundler/commands/binstubs_spec.rb
+++ b/spec/bundler/commands/binstubs_spec.rb
@@ -70,7 +70,7 @@ RSpec.describe "bundle binstubs <gem>" do
 
       bundle "binstubs rack", :all => true
       expect(last_command).to be_failure
-      expect(last_command.bundler_err).to include("Cannot specify --all with specific gems")
+      expect(err).to include("Cannot specify --all with specific gems")
     end
 
     context "when generating bundle binstub outside bundler" do
@@ -88,7 +88,7 @@ RSpec.describe "bundle binstubs <gem>" do
 
         sys_exec "bin/rackup"
 
-        expect(last_command.stderr).to include("was not generated by Bundler")
+        expect(err).to include("was not generated by Bundler")
       end
     end
 
@@ -135,7 +135,7 @@ RSpec.describe "bundle binstubs <gem>" do
         it "runs the correct version of bundler" do
           sys_exec "#{bundled_app("bin/bundle")} install", "BUNDLER_VERSION" => "999.999.999"
           expect(exitstatus).to eq(42) if exitstatus
-          expect(last_command.stderr).to include("Activating bundler (999.999.999) failed:").
+          expect(err).to include("Activating bundler (999.999.999) failed:").
             and include("To install the version of bundler this project requires, run `gem install bundler -v '999.999.999'`")
         end
       end
@@ -145,7 +145,7 @@ RSpec.describe "bundle binstubs <gem>" do
           lockfile lockfile.gsub(system_bundler_version, "999.999.999")
           sys_exec "#{bundled_app("bin/bundle")} install"
           expect(exitstatus).to eq(42) if exitstatus
-          expect(last_command.stderr).to include("Activating bundler (999.999.999) failed:").
+          expect(err).to include("Activating bundler (999.999.999) failed:").
             and include("To install the version of bundler this project requires, run `gem install bundler -v '999.999.999'`")
         end
 
@@ -154,7 +154,7 @@ RSpec.describe "bundle binstubs <gem>" do
           lockfile lockfile.gsub(system_bundler_version, "44.0")
           sys_exec "#{bundled_app("bin/bundle")} install"
           expect(exitstatus).to eq(42) if exitstatus
-          expect(last_command.stderr).to include("Activating bundler (44.0) failed:").
+          expect(err).to include("Activating bundler (44.0) failed:").
             and include("To install the version of bundler this project requires, run `gem install bundler -v '44.0'`")
         end
 
@@ -163,7 +163,7 @@ RSpec.describe "bundle binstubs <gem>" do
           lockfile lockfile.gsub(system_bundler_version, "2.12.0.a")
           sys_exec "#{bundled_app("bin/bundle")} install"
           expect(exitstatus).to eq(42) if exitstatus
-          expect(last_command.stderr).to include("Activating bundler (2.12.0.a) failed:").
+          expect(err).to include("Activating bundler (2.12.0.a) failed:").
             and include("To install the version of bundler this project requires, run `gem install bundler -v '2.12.0.a'`")
         end
       end
@@ -173,13 +173,13 @@ RSpec.describe "bundle binstubs <gem>" do
 
         it "calls through to the latest bundler version" do
           sys_exec! "#{bundled_app("bin/bundle")} update --bundler"
-          expect(last_command.stdout).to eq %(system bundler #{system_bundler_version}\n["update", "--bundler"])
+          expect(out).to eq %(system bundler #{system_bundler_version}\n["update", "--bundler"])
         end
 
         it "calls through to the explicit bundler version" do
           sys_exec "#{bundled_app("bin/bundle")} update --bundler=999.999.999"
           expect(exitstatus).to eq(42) if exitstatus
-          expect(last_command.stderr).to include("Activating bundler (999.999.999) failed:").
+          expect(err).to include("Activating bundler (999.999.999) failed:").
             and include("To install the version of bundler this project requires, run `gem install bundler -v '999.999.999'`")
         end
       end
@@ -205,7 +205,7 @@ RSpec.describe "bundle binstubs <gem>" do
           it "attempts to load that version" do
             sys_exec bundled_app("bin/rackup").to_s
             expect(exitstatus).to eq(42) if exitstatus
-            expect(last_command.stderr).to include("Activating bundler (999.999.999) failed:").
+            expect(err).to include("Activating bundler (999.999.999) failed:").
               and include("To install the version of bundler this project requires, run `gem install bundler -v '999.999.999'`")
           end
         end
diff --git a/spec/bundler/commands/check_spec.rb b/spec/bundler/commands/check_spec.rb
index 7114610644..cf88736612 100644
--- a/spec/bundler/commands/check_spec.rb
+++ b/spec/bundler/commands/check_spec.rb
@@ -338,7 +338,7 @@ RSpec.describe "bundle check" do
       it "does not change the lock but warns" do
         lockfile lock_with(Bundler::VERSION.succ)
         bundle! :check
-        expect(last_command.bundler_err).to include("the running version of Bundler (#{Bundler::VERSION}) is older than the version that created the lockfile (#{Bundler::VERSION.succ})")
+        expect(err).to include("the running version of Bundler (#{Bundler::VERSION}) is older than the version that created the lockfile (#{Bundler::VERSION.succ})")
         lockfile_should_be lock_with(Bundler::VERSION.succ)
       end
     end
diff --git a/spec/bundler/commands/config_spec.rb b/spec/bundler/commands/config_spec.rb
index 976916a9fe..40fab95803 100644
--- a/spec/bundler/commands/config_spec.rb
+++ b/spec/bundler/commands/config_spec.rb
@@ -391,86 +391,86 @@ E
   describe "subcommands" do
     it "list", :ruby_repo do
       bundle! "config list"
-      expect(last_command.stdout).to eq "Settings are listed in order of priority. The top value will be used.\nspec_run\nSet via BUNDLE_SPEC_RUN: \"true\""
+      expect(out).to eq "Settings are listed in order of priority. The top value will be used.\nspec_run\nSet via BUNDLE_SPEC_RUN: \"true\""
 
       bundle! "config list", :parseable => true
-      expect(last_command.stdout).to eq "spec_run=true"
+      expect(out).to eq "spec_run=true"
     end
 
     it "get" do
       ENV["BUNDLE_BAR"] = "bar_val"
 
       bundle! "config get foo"
-      expect(last_command.stdout).to eq "Settings for `foo` in order of priority. The top value will be used\nYou have not configured a value for `foo`"
+      expect(out).to eq "Settings for `foo` in order of priority. The top value will be used\nYou have not configured a value for `foo`"
 
       ENV["BUNDLE_FOO"] = "foo_val"
 
       bundle! "config get foo --parseable"
-      expect(last_command.stdout).to eq "foo=foo_val"
+      expect(out).to eq "foo=foo_val"
 
       bundle! "config get foo"
-      expect(last_command.stdout).to eq "Settings for `foo` in order of priority. The top value will be used\nSet via BUNDLE_FOO: \"foo_val\""
+      expect(out).to eq "Settings for `foo` in order of priority. The top value will be used\nSet via BUNDLE_FOO: \"foo_val\""
     end
 
     it "set" do
       bundle! "config set foo 1"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
 
       bundle! "config set --local foo 2"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
 
       bundle! "config set --global foo 3"
-      expect(last_command.stdout).to eq "Your application has set foo to \"2\". This will override the global value you are currently setting"
+      expect(out).to eq "Your application has set foo to \"2\". This will override the global value you are currently setting"
 
       bundle! "config set --parseable --local foo 4"
-      expect(last_command.stdout).to eq "foo=4"
+      expect(out).to eq "foo=4"
 
       bundle! "config set --local foo 4.1"
-      expect(last_command.stdout).to eq "You are replacing the current local value of foo, which is currently \"4\""
+      expect(out).to eq "You are replacing the current local value of foo, which is currently \"4\""
 
       bundle "config set --global --local foo 5"
       expect(last_command).to be_failure
-      expect(last_command.bundler_err).to eq "The options global and local were specified. Please only use one of the switches at a time."
+      expect(err).to eq "The options global and local were specified. Please only use one of the switches at a time."
     end
 
     it "unset" do
       bundle! "config unset foo"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
 
       bundle! "config set foo 1"
       bundle! "config unset foo --parseable"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
 
       bundle! "config set --local foo 1"
       bundle! "config set --global foo 2"
 
       bundle! "config unset foo"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
       expect(bundle!("config get foo")).to eq "Settings for `foo` in order of priority. The top value will be used\nYou have not configured a value for `foo`"
 
       bundle! "config set --local foo 1"
       bundle! "config set --global foo 2"
 
       bundle! "config unset foo --local"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
       expect(bundle!("config get foo")).to eq "Settings for `foo` in order of priority. The top value will be used\nSet for the current user (#{home(".bundle/config")}): \"2\""
       bundle! "config unset foo --global"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
       expect(bundle!("config get foo")).to eq "Settings for `foo` in order of priority. The top value will be used\nYou have not configured a value for `foo`"
 
       bundle! "config set --local foo 1"
       bundle! "config set --global foo 2"
 
       bundle! "config unset foo --global"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
       expect(bundle!("config get foo")).to eq "Settings for `foo` in order of priority. The top value will be used\nSet for your local app (#{bundled_app(".bundle/config")}): \"1\""
       bundle! "config unset foo --local"
-      expect(last_command.stdout).to eq ""
+      expect(out).to eq ""
       expect(bundle!("config get foo")).to eq "Settings for `foo` in order of priority. The top value will be used\nYou have not configured a value for `foo`"
 
       bundle "config unset foo --local --global"
       expect(last_command).to be_failure
-      expect(last_command.bundler_err).to eq "The options global and local were specified. Please only use one of the switches at a time."
+      expect(err).to eq "The options global and local were specified. Please only use one of the switches at a time."
     end
   end
 end
diff --git a/spec/bundler/commands/exec_spec.rb b/spec/bundler/commands/exec_spec.rb
index 66096a91a1..8f49c576b5 100644
--- a/spec/bundler/commands/exec_spec.rb
+++ b/spec/bundler/commands/exec_spec.rb
@@ -55,6 +55,17 @@ RSpec.describe "bundle exec" do
     expect(out).to eq("hi")
   end
 
+  it "respects custom process title when loading through ruby" do
+    script_that_changes_its_own_title_and_checks_if_picked_up_by_ps_unix_utility = <<~RUBY
+      Process.setproctitle("1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16")
+      puts `ps -eo args | grep [1]-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16`
+    RUBY
+    create_file "Gemfile"
+    create_file "a.rb", script_that_changes_its_own_title_and_checks_if_picked_up_by_ps_unix_utility
+    bundle "exec ruby a.rb"
+    expect(out).to eq("1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16")
+  end
+
   it "accepts --verbose" do
     install_gemfile 'gem "rack"'
     bundle "exec --verbose echo foobar"
@@ -88,14 +99,14 @@ RSpec.describe "bundle exec" do
     sys_exec "#{Gem.ruby} #{command.path}"
 
     expect(out).to eq("")
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   it "accepts --keep-file-descriptors" do
     install_gemfile ""
     bundle "exec --keep-file-descriptors echo foobar"
 
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   it "can run a command named --verbose" do
@@ -156,7 +167,7 @@ RSpec.describe "bundle exec" do
         bundle! "exec irb --version"
 
         expect(out).to include(default_irb_version)
-        expect(last_command.stderr).to be_empty
+        expect(err).to be_empty
       end
     end
 
@@ -182,7 +193,7 @@ RSpec.describe "bundle exec" do
         bundle! "exec irb --version"
 
         expect(out).to include(specified_irb_version)
-        expect(last_command.stderr).to be_empty
+        expect(err).to be_empty
       end
     end
 
@@ -212,7 +223,7 @@ RSpec.describe "bundle exec" do
 
       it "uses resolved version" do
         expect(out).to include(indirect_irb_version)
-        expect(last_command.stderr).to be_empty
+        expect(err).to be_empty
       end
     end
   end
@@ -268,7 +279,7 @@ RSpec.describe "bundle exec" do
     G
 
     rubyopt = ENV["RUBYOPT"]
-    rubyopt = "-rbundler/setup #{rubyopt}"
+    rubyopt = "-r#{File.expand_path("../../lib/bundler/setup", __dir__)} #{rubyopt}"
 
     bundle "exec 'echo $RUBYOPT'"
     expect(out).to have_rubyopts(rubyopt)
@@ -334,7 +345,7 @@ RSpec.describe "bundle exec" do
     [true, false].each do |l|
       bundle! "config set disable_exec_load #{l}"
       bundle "exec rackup"
-      expect(last_command.stderr).to include "can't find executable rackup for gem rack. rack is not currently included in the bundle, perhaps you meant to add it to your Gemfile?"
+      expect(err).to include "can't find executable rackup for gem rack. rack is not currently included in the bundle, perhaps you meant to add it to your Gemfile?"
     end
   end
 
@@ -552,8 +563,8 @@ RSpec.describe "bundle exec" do
 
       bundle "exec irb"
 
-      expect(last_command.stderr).to match("The gemspec at #{lib_path("foo-1.0").join("foo.gemspec")} is not valid")
-      expect(last_command.stderr).to match('"TODO" is not a summary')
+      expect(err).to match("The gemspec at #{lib_path("foo-1.0").join("foo.gemspec")} is not valid")
+      expect(err).to match('"TODO" is not a summary')
     end
   end
 
@@ -614,8 +625,8 @@ RSpec.describe "bundle exec" do
       it "like a normally executed executable" do
         subject
         expect(exitstatus).to eq(exit_code) if exitstatus
-        expect(last_command.stderr).to eq(expected_err)
-        expect(last_command.stdout).to eq(expected)
+        expect(err).to eq(expected_err)
+        expect(out).to eq(expected)
       end
     end
 
@@ -886,7 +897,7 @@ __FILE__: #{path.to_s.inspect}
 
         # sanity check that we get the newer, custom version without bundler
         sys_exec("#{Gem.ruby} #{file}")
-        expect(last_command.stderr).to include("custom openssl should not be loaded")
+        expect(err).to include("custom openssl should not be loaded")
       end
     end
   end
diff --git a/spec/bundler/commands/init_spec.rb b/spec/bundler/commands/init_spec.rb
index 64849beeb9..7960ce85bd 100644
--- a/spec/bundler/commands/init_spec.rb
+++ b/spec/bundler/commands/init_spec.rb
@@ -94,7 +94,7 @@ RSpec.describe "bundle init" do
         end
 
         bundle :init, :gemspec => spec_file
-        expect(last_command.bundler_err).to include("There was an error while loading `test.gemspec`")
+        expect(err).to include("There was an error while loading `test.gemspec`")
       end
     end
   end
diff --git a/spec/bundler/commands/install_spec.rb b/spec/bundler/commands/install_spec.rb
index 21157dd309..1a027a77c9 100644
--- a/spec/bundler/commands/install_spec.rb
+++ b/spec/bundler/commands/install_spec.rb
@@ -16,7 +16,7 @@ RSpec.describe "bundle install with gem sources" do
         raise StandardError, "FAIL"
       G
 
-      expect(last_command.bundler_err).to include('StandardError, "FAIL"')
+      expect(err).to include('StandardError, "FAIL"')
       expect(bundled_app("Gemfile.lock")).not_to exist
     end
 
@@ -404,7 +404,7 @@ RSpec.describe "bundle install with gem sources" do
       G
 
       expect(last_command.stdboth).not_to match(/Error Report/i)
-      expect(last_command.bundler_err).to include("An error occurred while installing ajp-rails (0.0.0), and Bundler cannot continue.").
+      expect(err).to include("An error occurred while installing ajp-rails (0.0.0), and Bundler cannot continue.").
         and include(normalize_uri_file("Make sure that `gem install ajp-rails -v '0.0.0' --source 'file://localhost#{gem_repo2}/'` succeeds before bundling."))
     end
 
diff --git a/spec/bundler/commands/licenses_spec.rb b/spec/bundler/commands/licenses_spec.rb
index 21fd8eaf2f..423921e282 100644
--- a/spec/bundler/commands/licenses_spec.rb
+++ b/spec/bundler/commands/licenses_spec.rb
@@ -12,7 +12,7 @@ RSpec.describe "bundle licenses" do
   it "prints license information for all gems in the bundle" do
     bundle "licenses"
 
-    expect(err).to include("bundler: Unknown")
+    expect(out).to include("bundler: MIT")
     expect(out).to include("with_license: MIT")
   end
 
diff --git a/spec/bundler/commands/lock_spec.rb b/spec/bundler/commands/lock_spec.rb
index f876d719cc..7aaf5c178e 100644
--- a/spec/bundler/commands/lock_spec.rb
+++ b/spec/bundler/commands/lock_spec.rb
@@ -242,7 +242,7 @@ RSpec.describe "bundle lock" do
 
   it "errors when removing all platforms" do
     bundle "lock --remove-platform #{local_platforms.join(" ")}"
-    expect(last_command.bundler_err).to include("Removing all platforms from the bundle is not allowed")
+    expect(err).to include("Removing all platforms from the bundle is not allowed")
   end
 
   # from https://github.com/bundler/bundler/issues/4896
diff --git a/spec/bundler/commands/newgem_spec.rb b/spec/bundler/commands/newgem_spec.rb
index 528ebf7c2b..203b474877 100644
--- a/spec/bundler/commands/newgem_spec.rb
+++ b/spec/bundler/commands/newgem_spec.rb
@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
 RSpec.describe "bundle gem" do
-  def reset!
-    super
-    global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false"
-  end
-
   def execute_bundle_gem(gem_name, flag = "")
     bundle! "gem #{gem_name} #{flag}"
     # reset gemspec cache for each test because of commit 3d4163a
@@ -22,6 +17,7 @@ RSpec.describe "bundle gem" do
   end
 
   before do
+    global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false"
     git_config_content = <<-EOF
     [user]
       name = "Bundler User"
@@ -136,7 +132,6 @@ RSpec.describe "bundle gem" do
     context "git config github.user is absent" do
       before do
         sys_exec("git config --unset github.user")
-        reset!
         in_app_root
         bundle "gem #{gem_name}"
       end
@@ -209,7 +204,6 @@ RSpec.describe "bundle gem" do
 
   context "gem naming with relative paths" do
     before do
-      reset!
       in_app_root
     end
 
@@ -281,7 +275,6 @@ RSpec.describe "bundle gem" do
       before do
         `git config --unset user.name`
         `git config --unset user.email`
-        reset!
         in_app_root
         bundle "gem #{gem_name}"
       end
@@ -322,7 +315,6 @@ RSpec.describe "bundle gem" do
 
     context "--exe parameter set" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --exe"
       end
@@ -338,7 +330,6 @@ RSpec.describe "bundle gem" do
 
     context "--bin parameter set" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --bin"
       end
@@ -354,7 +345,6 @@ RSpec.describe "bundle gem" do
 
     context "no --test parameter" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name}"
       end
@@ -370,7 +360,6 @@ RSpec.describe "bundle gem" do
 
     context "--test parameter set to rspec" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --test=rspec"
       end
@@ -397,7 +386,6 @@ RSpec.describe "bundle gem" do
 
     context "gem.test setting set to rspec" do
       before do
-        reset!
         in_app_root
         bundle "config set gem.test rspec"
         bundle "gem #{gem_name}"
@@ -412,7 +400,6 @@ RSpec.describe "bundle gem" do
 
     context "gem.test setting set to rspec and --test is set to minitest" do
       before do
-        reset!
         in_app_root
         bundle "config set gem.test rspec"
         bundle "gem #{gem_name} --test=minitest"
@@ -426,7 +413,6 @@ RSpec.describe "bundle gem" do
 
     context "--test parameter set to minitest" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --test=minitest"
       end
@@ -456,7 +442,6 @@ RSpec.describe "bundle gem" do
 
     context "gem.test setting set to minitest" do
       before do
-        reset!
         in_app_root
         bundle "config set gem.test minitest"
         bundle "gem #{gem_name}"
@@ -482,7 +467,6 @@ RSpec.describe "bundle gem" do
 
     context "--test with no arguments" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --test"
       end
@@ -499,7 +483,6 @@ RSpec.describe "bundle gem" do
 
     context "--edit option" do
       it "opens the generated gemspec in the user's text editor" do
-        reset!
         in_app_root
         output = bundle "gem #{gem_name} --edit=echo"
         gemspec_path = File.join(Dir.pwd, gem_name, "#{gem_name}.gemspec")
@@ -515,7 +498,6 @@ RSpec.describe "bundle gem" do
       before do
         global_config "BUNDLE_GEM__MIT" => "true", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false"
       end
-      after { reset! }
       it_behaves_like "--mit flag"
       it_behaves_like "--no-mit flag"
     end
@@ -529,7 +511,6 @@ RSpec.describe "bundle gem" do
       before do
         global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "true"
       end
-      after { reset! }
       it_behaves_like "--coc flag"
       it_behaves_like "--no-coc flag"
     end
@@ -572,7 +553,6 @@ RSpec.describe "bundle gem" do
       before do
         `git config --unset user.name`
         `git config --unset user.email`
-        reset!
         in_app_root
         bundle "gem #{gem_name}"
       end
@@ -604,7 +584,6 @@ RSpec.describe "bundle gem" do
 
     context "--bin parameter set" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --bin"
       end
@@ -620,7 +599,6 @@ RSpec.describe "bundle gem" do
 
     context "no --test parameter" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name}"
       end
@@ -636,7 +614,6 @@ RSpec.describe "bundle gem" do
 
     context "--test parameter set to rspec" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --test=rspec"
       end
@@ -671,7 +648,6 @@ RSpec.describe "bundle gem" do
 
     context "--test parameter set to minitest" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --test=minitest"
       end
@@ -713,7 +689,6 @@ RSpec.describe "bundle gem" do
 
     context "--test with no arguments" do
       before do
-        reset!
         in_app_root
         bundle "gem #{gem_name} --test"
       end
@@ -726,7 +701,6 @@ RSpec.describe "bundle gem" do
 
     context "--ext parameter set" do
       before do
-        reset!
         in_app_root
         bundle "gem test_gem --ext"
       end
@@ -770,22 +744,22 @@ RSpec.describe "bundle gem" do
 
     it "fails gracefully with a ." do
       bundle "gem foo.gemspec"
-      expect(last_command.bundler_err).to end_with("Invalid gem name foo.gemspec -- `Foo.gemspec` is an invalid constant name")
+      expect(err).to end_with("Invalid gem name foo.gemspec -- `Foo.gemspec` is an invalid constant name")
     end
 
     it "fails gracefully with a ^" do
       bundle "gem ^"
-      expect(last_command.bundler_err).to end_with("Invalid gem name ^ -- `^` is an invalid constant name")
+      expect(err).to end_with("Invalid gem name ^ -- `^` is an invalid constant name")
     end
 
     it "fails gracefully with a space" do
       bundle "gem 'foo bar'"
-      expect(last_command.bundler_err).to end_with("Invalid gem name foo bar -- `Foo bar` is an invalid constant name")
+      expect(err).to end_with("Invalid gem name foo bar -- `Foo bar` is an invalid constant name")
     end
 
     it "fails gracefully when multiple names are passed" do
       bundle "gem foo bar baz"
-      expect(last_command.bundler_err).to eq(<<-E.strip)
+      expect(err).to eq(<<-E.strip)
 ERROR: "bundle gem" was called with arguments ["foo", "bar", "baz"]
 Usage: "bundle gem NAME [OPTIONS]"
       E
@@ -876,7 +850,7 @@ Usage: "bundle gem NAME [OPTIONS]"
         FileUtils.touch("conflict-foobar")
       end
       bundle "gem conflict-foobar"
-      expect(last_command.bundler_err).to include("Errno::ENOTDIR")
+      expect(err).to include("Errno::ENOTDIR")
       expect(exitstatus).to eql(32) if exitstatus
     end
   end
@@ -887,7 +861,7 @@ Usage: "bundle gem NAME [OPTIONS]"
         FileUtils.mkdir_p("conflict-foobar/Gemfile")
       end
       bundle! "gem conflict-foobar"
-      expect(last_command.stdout).to include("file_clash  conflict-foobar/Gemfile").
+      expect(out).to include("file_clash  conflict-foobar/Gemfile").
         and include "Initializing git repo in #{bundled_app("conflict-foobar")}"
     end
   end
diff --git a/spec/bundler/commands/outdated_spec.rb b/spec/bundler/commands/outdated_spec.rb
index 843bebf6e0..f0c2927218 100644
--- a/spec/bundler/commands/outdated_spec.rb
+++ b/spec/bundler/commands/outdated_spec.rb
@@ -59,15 +59,19 @@ RSpec.describe "bundle outdated" do
       install_gemfile <<-G
         source "file://#{gem_repo2}"
 
+        gem "terranova", '8'
+
         group :development, :test do
           gem 'activesupport', '2.3.5'
         end
       G
 
       update_repo2 { build_gem "activesupport", "3.0" }
+      update_repo2 { build_gem "terranova", "9" }
 
       bundle "outdated --verbose"
       expect(out).to include("activesupport (newest 3.0, installed 2.3.5, requested = 2.3.5) in groups \"development, test\"")
+      expect(out).to include("terranova (newest 9, installed 8, requested = 8) in group \"default\"")
     end
   end
 
@@ -117,10 +121,10 @@ RSpec.describe "bundle outdated" do
     it "returns a sorted list of outdated gems from one group => 'default'" do
       test_group_option("default")
 
-      expect(out).to include("===== Group default =====")
+      expect(out).to include("===== Group \"default\" =====")
       expect(out).to include("terranova (")
 
-      expect(out).not_to include("===== Group development, test =====")
+      expect(out).not_to include("===== Groups \"development, test\" =====")
       expect(out).not_to include("activesupport")
       expect(out).not_to include("duradura")
     end
@@ -128,10 +132,10 @@ RSpec.describe "bundle outdated" do
     it "returns a sorted list of outdated gems from one group => 'development'" do
       test_group_option("development", 2)
 
-      expect(out).not_to include("===== Group default =====")
+      expect(out).not_to include("===== Group \"default\" =====")
       expect(out).not_to include("terranova (")
 
-      expect(out).to include("===== Group development, test =====")
+      expect(out).to include("===== Groups \"development, test\" =====")
       expect(out).to include("activesupport")
       expect(out).to include("duradura")
     end
@@ -139,10 +143,10 @@ RSpec.describe "bundle outdated" do
     it "returns a sorted list of outdated gems from one group => 'test'" do
       test_group_option("test", 2)
 
-      expect(out).not_to include("===== Group default =====")
+      expect(out).not_to include("===== Group \"default\" =====")
       expect(out).not_to include("terranova (")
 
-      expect(out).to include("===== Group development, test =====")
+      expect(out).to include("===== Groups \"development, test\" =====")
       expect(out).to include("activesupport")
       expect(out).to include("duradura")
     end
@@ -184,9 +188,9 @@ RSpec.describe "bundle outdated" do
       end
 
       bundle "outdated --groups"
-      expect(out).to include("===== Group default =====")
+      expect(out).to include("===== Group \"default\" =====")
       expect(out).to include("terranova (newest 9, installed 8, requested = 8)")
-      expect(out).to include("===== Group development, test =====")
+      expect(out).to include("===== Groups \"development, test\" =====")
       expect(out).to include("activesupport (newest 3.0, installed 2.3.5, requested = 2.3.5)")
       expect(out).to include("duradura (newest 8.0, installed 7.0, requested = 7.0)")
 
diff --git a/spec/bundler/commands/package_spec.rb b/spec/bundler/commands/package_spec.rb
index 6cd8e3f85a..b9cc079c5c 100644
--- a/spec/bundler/commands/package_spec.rb
+++ b/spec/bundler/commands/package_spec.rb
@@ -278,7 +278,7 @@ RSpec.describe "bundle install with gem sources" do
       end
 
       bundle :install
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(the_bundle).to include_gems "rack 1.0"
     end
 
diff --git a/spec/bundler/install/post_bundle_message_spec.rb b/spec/bundler/commands/post_bundle_message_spec.rb
index 1efd0b8146..4d3aa7b450 100644
--- a/spec/bundler/install/post_bundle_message_spec.rb
+++ b/spec/bundler/commands/post_bundle_message_spec.rb
@@ -185,21 +185,21 @@ The source does not contain any versions of 'not-a-gem'
     it "with --without one group" do
       bundle! :install, forgotten_command_line_options(:without => "emo")
       bundle! :update, :all => true
-      expect(out).to include("Gems in the group emo were not installed")
+      expect(out).to include("Gems in the group emo were not updated")
       expect(out).to include(bundle_updated_message)
     end
 
     it "with --without two groups" do
       bundle! :install, forgotten_command_line_options(:without => "emo test")
       bundle! :update, :all => true
-      expect(out).to include("Gems in the groups emo and test were not installed")
+      expect(out).to include("Gems in the groups emo and test were not updated")
       expect(out).to include(bundle_updated_message)
     end
 
     it "with --without more groups" do
       bundle! :install, forgotten_command_line_options(:without => "emo obama test")
       bundle! :update, :all => true
-      expect(out).to include("Gems in the groups emo, obama and test were not installed")
+      expect(out).to include("Gems in the groups emo, obama and test were not updated")
       expect(out).to include(bundle_updated_message)
     end
   end
diff --git a/spec/bundler/commands/show_spec.rb b/spec/bundler/commands/show_spec.rb
index 6e1986e35f..6a7d5f267e 100644
--- a/spec/bundler/commands/show_spec.rb
+++ b/spec/bundler/commands/show_spec.rb
@@ -30,21 +30,11 @@ RSpec.describe "bundle show", :bundler => "< 3" do
       expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s)
     end
 
-    it "prints deprecation" do
-      bundle "show rails"
-      expect(err).to eq("[DEPRECATED] use `bundle info rails` instead of `bundle show rails`")
-    end
-
     it "prints path if gem exists in bundle (with --paths option)" do
       bundle "show rails --paths"
       expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s)
     end
 
-    it "prints deprecation when called with a gem and the --paths option" do
-      bundle "show rails --paths"
-      expect(err).to eq("[DEPRECATED] use `bundle info rails --path` instead of `bundle show rails --paths`")
-    end
-
     it "warns if path no longer exists on disk" do
       FileUtils.rm_rf(default_bundle_path("gems", "rails-2.3.2"))
 
@@ -59,10 +49,6 @@ RSpec.describe "bundle show", :bundler => "< 3" do
       expect(out).to eq(root.to_s)
     end
 
-    it "prints deprecation when called with bundler" do
-      bundle "show bundler"
-      expect(err).to eq("[DEPRECATED] use `bundle info bundler` instead of `bundle show bundler`")
-    end
     it "complains if gem not in bundle" do
       bundle "show missing"
       expect(err).to match(/could not find gem 'missing'/i)
@@ -79,19 +65,26 @@ RSpec.describe "bundle show", :bundler => "< 3" do
       expect(gem_list).to eq(gem_list.sort)
     end
 
-    it "prints a deprecation when called with the --paths option" do
-      bundle "show --paths"
+    it "prints summary of gems" do
+      bundle "show --verbose"
 
-      expect(err).to eq("[DEPRECATED] use `bundle list` instead of `bundle show --paths`")
+      expect(out).to include <<~MSG
+        * actionmailer (2.3.2)
+        \tSummary:  This is just a fake gem for testing
+        \tHomepage: http://example.com
+        \tStatus:   Up to date
+      MSG
     end
 
-    it "prints summary of gems" do
+    it "includes bundler in the summary of gems" do
       bundle "show --verbose"
 
-      expect(out).to include("* actionmailer (2.3.2)")
-      expect(out).to include("\tSummary:  This is just a fake gem for testing")
-      expect(out).to include("\tHomepage: No website available.")
-      expect(out).to include("\tStatus:   Up to date")
+      expect(out).to include <<~MSG
+        * bundler (#{Bundler::VERSION})
+        \tSummary:  The best way to manage your application's dependencies
+        \tHomepage: https://bundler.io
+        \tStatus:   Up to date
+      MSG
     end
   end
 
diff --git a/spec/bundler/commands/update_spec.rb b/spec/bundler/commands/update_spec.rb
index 46c208db6c..61a5a1d1f1 100644
--- a/spec/bundler/commands/update_spec.rb
+++ b/spec/bundler/commands/update_spec.rb
@@ -473,6 +473,39 @@ RSpec.describe "bundle update in more complicated situations" do
     expect(the_bundle).to include_gems "thin 2.0", "rack 10.0", "rack-obama 1.0"
   end
 
+  it "will not warn when an explicitly updated git gem changes sha but not version" do
+    build_git "foo"
+
+    install_gemfile! <<-G
+      gem "foo", :git => '#{lib_path("foo-1.0")}'
+    G
+
+    update_git "foo" do |s|
+      s.write "lib/foo2.rb", "puts :foo2"
+    end
+
+    bundle! "update foo"
+
+    expect(last_command.stdboth).not_to include "attempted to update"
+  end
+
+  it "will not warn when changing gem sources but not versions" do
+    build_git "rack"
+
+    install_gemfile! <<-G
+      gem "rack", :git => '#{lib_path("rack-1.0")}'
+    G
+
+    gemfile <<-G
+      source "file://#{gem_repo1}"
+      gem "rack"
+    G
+
+    bundle! "update rack"
+
+    expect(last_command.stdboth).not_to include "attempted to update"
+  end
+
   it "will update only from pinned source" do
     install_gemfile <<-G
       source "file://#{gem_repo2}"
@@ -530,6 +563,41 @@ RSpec.describe "bundle update in more complicated situations" do
       expect(the_bundle).to include_gem "a 1.1"
     end
   end
+
+  context "when the dependency is for a different platform" do
+    before do
+      build_repo4 do
+        build_gem("a", "0.9") {|s| s.platform = "java" }
+        build_gem("a", "1.1") {|s| s.platform = "java" }
+      end
+
+      gemfile <<-G
+        source "file://#{gem_repo4}"
+        gem "a", platform: :jruby
+      G
+
+      lockfile <<-L
+        GEM
+          remote: file://#{gem_repo4}
+          specs:
+            a (0.9-java)
+
+        PLATFORMS
+          java
+
+        DEPENDENCIES
+          a
+      L
+
+      simulate_platform linux
+    end
+
+    it "is not updated because it is not actually included in the bundle" do
+      bundle! "update a"
+      expect(last_command.stdboth).to include "Bundler attempted to update a but it was not considered because it is for a different platform from the current one"
+      expect(the_bundle).to_not include_gem "a"
+    end
+  end
 end
 
 RSpec.describe "bundle update without a Gemfile.lock" do
@@ -565,13 +633,13 @@ RSpec.describe "bundle update when a gem depends on a newer version of bundler"
   it "should explain that bundler conflicted", :bundler => "< 3" do
     bundle "update", :all => true
     expect(last_command.stdboth).not_to match(/in snapshot/i)
-    expect(last_command.bundler_err).to match(/current Bundler version/i).
+    expect(err).to match(/current Bundler version/i).
       and match(/perhaps you need to update bundler/i)
   end
 
   it "should warn that the newer version of Bundler would conflict", :bundler => "3" do
     bundle! "update", :all => true
-    expect(last_command.bundler_err).to include("rails (3.0.1) has dependency bundler").
+    expect(err).to include("rails (3.0.1) has dependency bundler").
       and include("so the dependency is being ignored")
     expect(the_bundle).to include_gem "rails 3.0.1"
   end
@@ -947,7 +1015,7 @@ RSpec.describe "bundle update conservative" do
     it "raises if too many flags are provided" do
       bundle "update --patch --minor", :all => true
 
-      expect(last_command.bundler_err).to eq "Provide only one of the following options: minor, patch"
+      expect(err).to eq "Provide only one of the following options: minor, patch"
     end
   end
 end
diff --git a/spec/bundler/install/bundler_spec.rb b/spec/bundler/install/bundler_spec.rb
index 3347988cdd..fad6d68010 100644
--- a/spec/bundler/install/bundler_spec.rb
+++ b/spec/bundler/install/bundler_spec.rb
@@ -48,7 +48,7 @@ RSpec.describe "bundle install" do
 
         Could not find gem 'bundler (= 0.9.2)' in any
         E
-      expect(last_command.bundler_err).to include(nice_error)
+      expect(err).to include(nice_error)
     end
 
     it "works for gems with multiple versions in its dependencies" do
@@ -104,7 +104,7 @@ RSpec.describe "bundle install" do
             rails_fail was resolved to 1.0, which depends on
               activesupport (= 1.2.3)
       E
-      expect(last_command.bundler_err).to include(nice_error)
+      expect(err).to include(nice_error)
     end
 
     it "causes a conflict if a child dependency conflicts with the Gemfile" do
@@ -122,7 +122,7 @@ RSpec.describe "bundle install" do
             rails_fail was resolved to 1.0, which depends on
               activesupport (= 1.2.3)
       E
-      expect(last_command.bundler_err).to include(nice_error)
+      expect(err).to include(nice_error)
     end
 
     it "can install dependencies with newer bundler version with system gems" do
@@ -140,7 +140,6 @@ RSpec.describe "bundle install" do
 
     it "can install dependencies with newer bundler version with a local path" do
       bundle! "config set path .bundle"
-      bundle! "config set global_path_appends_ruby_scope true"
       install_gemfile! <<-G
         source "file://#{gem_repo2}"
         gem "rails", "3.0"
diff --git a/spec/bundler/install/deploy_spec.rb b/spec/bundler/install/deploy_spec.rb
index 0a12b6f116..9569b4d54c 100644
--- a/spec/bundler/install/deploy_spec.rb
+++ b/spec/bundler/install/deploy_spec.rb
@@ -366,7 +366,7 @@ RSpec.describe "install with --deployment or --frozen" do
       G
 
       expect(the_bundle).not_to include_gems "rack 1.0.0"
-      expect(last_command.stderr).to include strip_whitespace(<<-E).strip
+      expect(err).to include strip_whitespace(<<-E).strip
 The dependencies in your gemfile changed
 
 You have added to the Gemfile:
diff --git a/spec/bundler/install/failure_spec.rb b/spec/bundler/install/failure_spec.rb
index 49e2771dca..ac3c707187 100644
--- a/spec/bundler/install/failure_spec.rb
+++ b/spec/bundler/install/failure_spec.rb
@@ -18,7 +18,7 @@ RSpec.describe "bundle install" do
         source "file:\/\/localhost#{gem_repo2}"
         gem "rails"
       G
-      expect(last_command.bundler_err).to end_with(normalize_uri_file(<<-M.strip))
+      expect(err).to end_with(normalize_uri_file(<<-M.strip))
 An error occurred while installing activesupport (2.3.2), and Bundler cannot continue.
 Make sure that `gem install activesupport -v '2.3.2' --source 'file://localhost#{gem_repo2}/'` succeeds before bundling.
 
@@ -46,7 +46,7 @@ In Gemfile:
           gem "activesupport", :git => "#{lib_path("activesupport")}"
         G
 
-        expect(last_command.bundler_err).to end_with(<<-M.strip)
+        expect(err).to end_with(<<-M.strip)
 An error occurred while installing activesupport (2.3.2), and Bundler cannot continue.
 
 In Gemfile:
@@ -77,7 +77,7 @@ In Gemfile:
           end
         G
 
-        expect(last_command.bundler_err).to end_with(<<-M.strip)
+        expect(err).to end_with(<<-M.strip)
 An error occurred while installing activesupport (2.3.2), and Bundler cannot continue.
 
 
@@ -111,7 +111,7 @@ In Gemfile:
           gem "rails"
         end
       G
-      expect(last_command.bundler_err).to end_with(normalize_uri_file(<<-M.strip))
+      expect(err).to end_with(normalize_uri_file(<<-M.strip))
 An error occurred while installing activesupport (2.3.2), and Bundler cannot continue.
 Make sure that `gem install activesupport -v '2.3.2' --source 'file://localhost#{gem_repo2}/'` succeeds before bundling.
 
diff --git a/spec/bundler/install/gemfile/gemspec_spec.rb b/spec/bundler/install/gemfile/gemspec_spec.rb
index 0bec2e9d96..bf1f4d7b9a 100644
--- a/spec/bundler/install/gemfile/gemspec_spec.rb
+++ b/spec/bundler/install/gemfile/gemspec_spec.rb
@@ -65,7 +65,7 @@ RSpec.describe "bundle install from an existing gemspec" do
       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')}/)
+    expect(err).to match(/There are no gemspecs at #{tmp.join('foo')}/)
   end
 
   it "should raise if there are too many gemspecs available" do
@@ -77,7 +77,7 @@ RSpec.describe "bundle install from an existing gemspec" do
       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')}/)
+    expect(err).to match(/There are multiple gemspecs at #{tmp.join('foo')}/)
   end
 
   it "should pick a specific gemspec" do
diff --git a/spec/bundler/install/gemfile/git_spec.rb b/spec/bundler/install/gemfile/git_spec.rb
index c6738686bb..8ca22f1d87 100644
--- a/spec/bundler/install/gemfile/git_spec.rb
+++ b/spec/bundler/install/gemfile/git_spec.rb
@@ -204,7 +204,7 @@ RSpec.describe "bundle install with git sources" do
           gem "foo"
         end
       G
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
 
       run <<-RUBY
         require 'foo'
@@ -234,7 +234,7 @@ RSpec.describe "bundle install with git sources" do
           gem "foo"
         end
       G
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
 
       run! <<-RUBY
         require 'foo'
@@ -270,7 +270,7 @@ RSpec.describe "bundle install with git sources" do
           gem "foo"
         end
       G
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
 
       run! <<-RUBY
         require 'foo'
@@ -515,7 +515,7 @@ RSpec.describe "bundle install with git sources" do
       bundle solution
       bundle :install
 
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
 
     it "explodes and gives correct solution if branch is not given on install" do
@@ -537,7 +537,7 @@ RSpec.describe "bundle install with git sources" do
       bundle solution
       bundle :install
 
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
 
     it "does not explode if disable_local_branch_check is given" do
@@ -1197,7 +1197,7 @@ RSpec.describe "bundle install with git sources" do
         gem "foo", :git => "#{lib_path("foo-1.0")}"
       G
 
-      expect(last_command.bundler_err).to end_with(<<-M.strip)
+      expect(err).to end_with(<<-M.strip)
 An error occurred while installing foo (1.0), and Bundler cannot continue.
 
 In Gemfile:
@@ -1380,7 +1380,7 @@ In Gemfile:
       with_path_as("") do
         bundle "update", :all => true
       end
-      expect(last_command.bundler_err).
+      expect(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
 
@@ -1437,7 +1437,7 @@ In Gemfile:
         G
 
         expect(last_command.stdboth).to_not include("password1")
-        expect(last_command.stdout).to include("Fetching https://user1@github.com/company/private-repo")
+        expect(out).to include("Fetching https://user1@github.com/company/private-repo")
       end
     end
 
@@ -1452,7 +1452,7 @@ In Gemfile:
         G
 
         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")
+        expect(out).to include("Fetching https://x-oauth-basic@github.com/company/private-repo")
       end
     end
   end
diff --git a/spec/bundler/install/gemfile/path_spec.rb b/spec/bundler/install/gemfile/path_spec.rb
index 54a41b576f..e80764070c 100644
--- a/spec/bundler/install/gemfile/path_spec.rb
+++ b/spec/bundler/install/gemfile/path_spec.rb
@@ -313,7 +313,7 @@ RSpec.describe "bundle install with explicit source paths" do
     install_gemfile <<-G
       gem 'foo', '1.0', :path => "#{lib_path("foo-1.0")}"
     G
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   it "removes the .gem file after installing" do
@@ -484,6 +484,68 @@ RSpec.describe "bundle install with explicit source paths" do
 
       expect(the_bundle).to include_gems "rack 1.0.0"
     end
+
+    it "keeps using the same version if it's compatible" do
+      build_lib "foo", "1.0", :path => lib_path("foo") do |s|
+        s.add_dependency "rack", "0.9.1"
+      end
+
+      bundle "install"
+
+      expect(the_bundle).to include_gems "rack 0.9.1"
+
+      lockfile_should_be <<-G
+        PATH
+          remote: #{lib_path("foo")}
+          specs:
+            foo (1.0)
+              rack (= 0.9.1)
+
+        GEM
+          remote: #{URI.parse("file://#{gem_repo1}/")}
+          specs:
+            rack (0.9.1)
+
+        PLATFORMS
+          #{lockfile_platforms}
+
+        DEPENDENCIES
+          foo!
+
+        BUNDLED WITH
+           #{Bundler::VERSION}
+      G
+
+      build_lib "foo", "1.0", :path => lib_path("foo") do |s|
+        s.add_dependency "rack"
+      end
+
+      bundle "install"
+
+      lockfile_should_be <<-G
+        PATH
+          remote: #{lib_path("foo")}
+          specs:
+            foo (1.0)
+              rack
+
+        GEM
+          remote: #{URI.parse("file://#{gem_repo1}/")}
+          specs:
+            rack (0.9.1)
+
+        PLATFORMS
+          #{lockfile_platforms}
+
+        DEPENDENCIES
+          foo!
+
+        BUNDLED WITH
+           #{Bundler::VERSION}
+      G
+
+      expect(the_bundle).to include_gems "rack 0.9.1"
+    end
   end
 
   describe "switching sources" do
diff --git a/spec/bundler/install/gemfile/sources_spec.rb b/spec/bundler/install/gemfile/sources_spec.rb
index 8e1205dfa3..da364a51bb 100644
--- a/spec/bundler/install/gemfile/sources_spec.rb
+++ b/spec/bundler/install/gemfile/sources_spec.rb
@@ -471,13 +471,13 @@ RSpec.describe "bundle install with gems on multiple sources" do
 
   context "when a single source contains multiple locked gems" do
     before do
-      # 1. With these gems,
+      # With these gems,
       build_repo4 do
         build_gem "foo", "0.1"
         build_gem "bar", "0.1"
       end
 
-      # 2. Installing this gemfile will produce...
+      # Installing this gemfile...
       gemfile <<-G
         source 'file://#{gem_repo1}'
         gem 'rack'
@@ -485,28 +485,9 @@ RSpec.describe "bundle install with gems on multiple sources" do
         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...
+      # And then we add some new versions...
       update_repo4 do
         build_gem "foo", "0.2"
         build_gem "bar", "0.3"
@@ -514,7 +495,7 @@ RSpec.describe "bundle install with gems on multiple sources" do
     end
 
     it "allows them to be unlocked separately" do
-      # 5. and install this gemfile, updating only foo.
+      # And install this gemfile, updating only foo.
       install_gemfile <<-G
         source 'file://#{gem_repo1}'
         gem 'rack'
@@ -522,7 +503,7 @@ RSpec.describe "bundle install with gems on multiple sources" do
         gem 'bar', '~> 0.1', :source => 'file://#{gem_repo4}'
       G
 
-      # 6. Which should update foo to 0.2, but not the (locked) bar 0.1
+      # It 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
@@ -578,7 +559,7 @@ RSpec.describe "bundle install with gems on multiple sources" do
         end
 
         # When this gemfile is installed...
-        gemfile <<-G
+        install_gemfile <<-G
           source "#{source_uri}"
 
           source "#{second_uri}" do
@@ -588,26 +569,6 @@ RSpec.describe "bundle install with gems on multiple sources" do
           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}"
diff --git a/spec/bundler/install/gems/compact_index_spec.rb b/spec/bundler/install/gems/compact_index_spec.rb
index b94b68dbd9..e35b630306 100644
--- a/spec/bundler/install/gems/compact_index_spec.rb
+++ b/spec/bundler/install/gems/compact_index_spec.rb
@@ -60,7 +60,7 @@ RSpec.describe "compact index api" do
     # can't use `include_gems` here since the `require` will conflict on a
     # case-insensitive FS
     run! "Bundler.require; puts Gem.loaded_specs.values_at('rack', 'Rack').map(&:full_name)"
-    expect(last_command.stdout).to eq("rack-1.0\nRack-0.1")
+    expect(out).to eq("rack-1.0\nRack-0.1")
   end
 
   it "should handle multiple gem dependencies on the same gem" do
diff --git a/spec/bundler/install/gems/flex_spec.rb b/spec/bundler/install/gems/flex_spec.rb
index aeb83d6573..d15841124a 100644
--- a/spec/bundler/install/gems/flex_spec.rb
+++ b/spec/bundler/install/gems/flex_spec.rb
@@ -188,7 +188,7 @@ RSpec.describe "bundle flex_install" do
       ruby <<-RUBY
         require 'bundler/setup'
       RUBY
-      expect(last_command.stderr).to match(/could not find gem 'rack-obama/i)
+      expect(err).to match(/could not find gem 'rack-obama/i)
     end
 
     it "suggests bundle update when the Gemfile requires different versions than the lock" do
@@ -209,7 +209,7 @@ RSpec.describe "bundle flex_install" do
       E
 
       bundle :install, :retry => 0
-      expect(last_command.bundler_err).to end_with(nice_error)
+      expect(err).to end_with(nice_error)
     end
   end
 
diff --git a/spec/bundler/install/gems/resolving_spec.rb b/spec/bundler/install/gems/resolving_spec.rb
index cf3aaa719e..7bab676cea 100644
--- a/spec/bundler/install/gems/resolving_spec.rb
+++ b/spec/bundler/install/gems/resolving_spec.rb
@@ -77,7 +77,7 @@ RSpec.describe "bundle install with install-time dependencies" do
 
         bundle :install, :env => { "DEBUG_RESOLVER" => "1" }
 
-        expect(last_command.stderr).to include("Creating possibility state for net_c")
+        expect(err).to include("Creating possibility state for net_c")
       end
     end
 
@@ -91,7 +91,7 @@ RSpec.describe "bundle install with install-time dependencies" do
 
         bundle :install, :env => { "DEBUG_RESOLVER_TREE" => "1" }
 
-        expect(last_command.stderr).to include(" net_b").
+        expect(err).to include(" net_b").
           and include("Starting resolution").
           and include("Finished resolution").
           and include("Attempting to activate")
@@ -171,7 +171,7 @@ RSpec.describe "bundle install with install-time dependencies" do
 
             Ruby\0 (> 9000), which is required by gem 'require_ruby', is not available in the local ruby installation
           E
-          expect(last_command.bundler_err).to end_with(nice_error)
+          expect(err).to end_with(nice_error)
         end
       end
 
diff --git a/spec/bundler/install/gems/standalone_spec.rb b/spec/bundler/install/gems/standalone_spec.rb
index e2cfe5ec4c..68796977a4 100644
--- a/spec/bundler/install/gems/standalone_spec.rb
+++ b/spec/bundler/install/gems/standalone_spec.rb
@@ -175,8 +175,8 @@ RSpec.shared_examples "bundle install --standalone" do
         RUBY
       end
 
-      expect(last_command.stdout).to eq("2.3.2")
-      expect(last_command.stderr).to eq("ZOMG LOAD ERROR")
+      expect(out).to eq("2.3.2")
+      expect(err).to eq("ZOMG LOAD ERROR")
     end
 
     it "allows --without to limit the groups used in a standalone" do
@@ -193,8 +193,8 @@ RSpec.shared_examples "bundle install --standalone" do
         RUBY
       end
 
-      expect(last_command.stdout).to eq("2.3.2")
-      expect(last_command.stderr).to eq("ZOMG LOAD ERROR")
+      expect(out).to eq("2.3.2")
+      expect(err).to eq("ZOMG LOAD ERROR")
     end
 
     it "allows --path to change the location of the standalone bundle", :bundler => "< 3" do
@@ -210,7 +210,7 @@ RSpec.shared_examples "bundle install --standalone" do
         RUBY
       end
 
-      expect(last_command.stdout).to eq("2.3.2")
+      expect(out).to eq("2.3.2")
     end
 
     it "allows --path to change the location of the standalone bundle", :bundler => "3" do
@@ -227,7 +227,7 @@ RSpec.shared_examples "bundle install --standalone" do
         RUBY
       end
 
-      expect(last_command.stdout).to eq("2.3.2")
+      expect(out).to eq("2.3.2")
     end
 
     it "allows remembered --without to limit the groups used in a standalone" do
@@ -245,8 +245,8 @@ RSpec.shared_examples "bundle install --standalone" do
         RUBY
       end
 
-      expect(last_command.stdout).to eq("2.3.2")
-      expect(last_command.stderr).to eq("ZOMG LOAD ERROR")
+      expect(out).to eq("2.3.2")
+      expect(err).to eq("ZOMG LOAD ERROR")
     end
   end
 
diff --git a/spec/bundler/install/gems/sudo_spec.rb b/spec/bundler/install/gems/sudo_spec.rb
index fb41f63a07..0d2d6b7eb4 100644
--- a/spec/bundler/install/gems/sudo_spec.rb
+++ b/spec/bundler/install/gems/sudo_spec.rb
@@ -3,13 +3,20 @@
 RSpec.describe "when using sudo", :sudo => true do
   describe "and BUNDLE_PATH is writable" do
     context "but BUNDLE_PATH/build_info is not writable" do
+      let(:subdir) do
+        system_gem_path("cache")
+      end
+
       before do
         bundle! "config set path.system true"
-        subdir = system_gem_path("cache")
         subdir.mkpath
         sudo "chmod u-w #{subdir}"
       end
 
+      after do
+        sudo "chmod u+w #{subdir}"
+      end
+
       it "installs" do
         install_gemfile <<-G
           source "file://#{gem_repo1}"
@@ -52,8 +59,6 @@ RSpec.describe "when using sudo", :sudo => true do
     end
 
     it "installs when BUNDLE_PATH is owned by root" do
-      bundle! "config set global_path_appends_ruby_scope false" # consistency in tests between 1.x and 2.x modes
-
       bundle_path = tmp("owned_by_root")
       FileUtils.mkdir_p bundle_path
       sudo "chown -R root #{bundle_path}"
@@ -64,14 +69,12 @@ RSpec.describe "when using sudo", :sudo => true do
         gem "rack", '1.0'
       G
 
-      expect(bundle_path.join("gems/rack-1.0.0")).to exist
-      expect(bundle_path.join("gems/rack-1.0.0").stat.uid).to eq(0)
+      expect(bundle_path.join(Bundler.ruby_scope, "gems/rack-1.0.0")).to exist
+      expect(bundle_path.join(Bundler.ruby_scope, "gems/rack-1.0.0").stat.uid).to eq(0)
       expect(the_bundle).to include_gems "rack 1.0"
     end
 
     it "installs when BUNDLE_PATH does not exist" do
-      bundle! "config set global_path_appends_ruby_scope false" # consistency in tests between 1.x and 2.x modes
-
       root_path = tmp("owned_by_root")
       FileUtils.mkdir_p root_path
       sudo "chown -R root #{root_path}"
@@ -83,8 +86,8 @@ RSpec.describe "when using sudo", :sudo => true do
         gem "rack", '1.0'
       G
 
-      expect(bundle_path.join("gems/rack-1.0.0")).to exist
-      expect(bundle_path.join("gems/rack-1.0.0").stat.uid).to eq(0)
+      expect(bundle_path.join(Bundler.ruby_scope, "gems/rack-1.0.0")).to exist
+      expect(bundle_path.join(Bundler.ruby_scope, "gems/rack-1.0.0").stat.uid).to eq(0)
       expect(the_bundle).to include_gems "rack 1.0"
     end
 
@@ -105,6 +108,10 @@ RSpec.describe "when using sudo", :sudo => true do
       sudo "chmod ugo-w #{default_bundle_path}"
     end
 
+    after do
+      sudo "chmod ugo+w #{default_bundle_path}"
+    end
+
     it "installs" do
       install_gemfile <<-G
         source "file://#{gem_repo1}"
@@ -146,6 +153,8 @@ RSpec.describe "when using sudo", :sudo => true do
       bundle :install, :env => { "GEM_HOME" => gem_home.to_s, "GEM_PATH" => nil }
       expect(gem_home.join("bin/rackup")).to exist
       expect(the_bundle).to include_gems "rack 1.0", :env => { "GEM_HOME" => gem_home.to_s, "GEM_PATH" => nil }
+
+      sudo "rm -rf #{tmp("sudo_gem_home")}"
     end
   end
 
diff --git a/spec/bundler/install/gemspecs_spec.rb b/spec/bundler/install/gemspecs_spec.rb
index c9878ccae8..55c7a67b4b 100644
--- a/spec/bundler/install/gemspecs_spec.rb
+++ b/spec/bundler/install/gemspecs_spec.rb
@@ -14,7 +14,7 @@ RSpec.describe "bundle install" do
         gem "yaml_spec"
       G
       bundle :install
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
 
     it "still installs correctly when using path" do
@@ -23,7 +23,7 @@ RSpec.describe "bundle install" do
       install_gemfile <<-G
         gem 'yaml_spec', :path => "#{lib_path("yaml_spec-1.0")}"
       G
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
   end
 
diff --git a/spec/bundler/install/path_spec.rb b/spec/bundler/install/path_spec.rb
index 0947ed9539..b2a3375342 100644
--- a/spec/bundler/install/path_spec.rb
+++ b/spec/bundler/install/path_spec.rb
@@ -113,71 +113,36 @@ RSpec.describe "bundle install" do
           expect(the_bundle).to include_gems "rack 1.0.0"
         end
 
-        context "with global_path_appends_ruby_scope set", :bundler => "3" do
-          it "installs gems to ." do
-            set_bundle_path(type, ".")
-            bundle! "config set --global disable_shared_gems true"
+        it "installs gems to ." do
+          set_bundle_path(type, ".")
+          bundle! "config set --global disable_shared_gems true"
 
-            bundle! :install
-
-            paths_to_exist = %w[cache/rack-1.0.0.gem gems/rack-1.0.0 specifications/rack-1.0.0.gemspec].map {|path| bundled_app(Bundler.ruby_scope, path) }
-            expect(paths_to_exist).to all exist
-            expect(the_bundle).to include_gems "rack 1.0.0"
-          end
-
-          it "installs gems to the path" do
-            set_bundle_path(type, bundled_app("vendor").to_s)
-
-            bundle! :install
+          bundle! :install
 
-            expect(bundled_app("vendor", Bundler.ruby_scope, "gems/rack-1.0.0")).to be_directory
-            expect(the_bundle).to include_gems "rack 1.0.0"
-          end
+          paths_to_exist = %w[cache/rack-1.0.0.gem gems/rack-1.0.0 specifications/rack-1.0.0.gemspec].map {|path| bundled_app(Bundler.ruby_scope, path) }
+          expect(paths_to_exist).to all exist
+          expect(the_bundle).to include_gems "rack 1.0.0"
+        end
 
-          it "installs gems to the path relative to root when relative" do
-            set_bundle_path(type, "vendor")
+        it "installs gems to the path" do
+          set_bundle_path(type, bundled_app("vendor").to_s)
 
-            FileUtils.mkdir_p bundled_app("lol")
-            Dir.chdir(bundled_app("lol")) do
-              bundle! :install
-            end
+          bundle! :install
 
-            expect(bundled_app("vendor", Bundler.ruby_scope, "gems/rack-1.0.0")).to be_directory
-            expect(the_bundle).to include_gems "rack 1.0.0"
-          end
+          expect(bundled_app("vendor", Bundler.ruby_scope, "gems/rack-1.0.0")).to be_directory
+          expect(the_bundle).to include_gems "rack 1.0.0"
         end
 
-        context "with global_path_appends_ruby_scope unset", :bundler => "< 3" do
-          it "installs gems to ." do
-            set_bundle_path(type, ".")
-            bundle! "config set --global disable_shared_gems true"
+        it "installs gems to the path relative to root when relative" do
+          set_bundle_path(type, "vendor")
 
+          FileUtils.mkdir_p bundled_app("lol")
+          Dir.chdir(bundled_app("lol")) do
             bundle! :install
-
-            expect([bundled_app("cache/rack-1.0.0.gem"), bundled_app("gems/rack-1.0.0"), bundled_app("specifications/rack-1.0.0.gemspec")]).to all exist
-            expect(the_bundle).to include_gems "rack 1.0.0"
-          end
-
-          it "installs gems to BUNDLE_PATH with #{type}" do
-            set_bundle_path(type, bundled_app("vendor").to_s)
-
-            bundle :install
-
-            expect(bundled_app("vendor/gems/rack-1.0.0")).to be_directory
-            expect(the_bundle).to include_gems "rack 1.0.0"
           end
 
-          it "installs gems to BUNDLE_PATH relative to root when relative" do
-            set_bundle_path(type, "vendor")
-
-            FileUtils.mkdir_p bundled_app("lol")
-            Dir.chdir(bundled_app("lol")) do
-              bundle :install
-            end
-
-            expect(bundled_app("vendor/gems/rack-1.0.0")).to be_directory
-            expect(the_bundle).to include_gems "rack 1.0.0"
-          end
+          expect(bundled_app("vendor", Bundler.ruby_scope, "gems/rack-1.0.0")).to be_directory
+          expect(the_bundle).to include_gems "rack 1.0.0"
         end
       end
     end
@@ -226,7 +191,7 @@ RSpec.describe "bundle install" do
       vendored_gems("extensions").rmtree
 
       run "require 'very_simple_binary_c'"
-      expect(last_command.stderr).to include("Bundler::GemNotFound")
+      expect(err).to include("Bundler::GemNotFound")
 
       bundle :install, forgotten_command_line_options(:path => "./vendor/bundle")
 
diff --git a/spec/bundler/lock/lockfile_spec.rb b/spec/bundler/lock/lockfile_spec.rb
index 5ee44bf779..c2d44e5cf1 100644
--- a/spec/bundler/lock/lockfile_spec.rb
+++ b/spec/bundler/lock/lockfile_spec.rb
@@ -154,7 +154,10 @@ RSpec.describe "the lockfile format" do
     G
   end
 
-  it "outputs a warning if the current is older than lockfile's bundler version" do
+  it "warns if the current is older than lockfile's bundler version" do
+    current_version = Bundler::VERSION
+    newer_minor = bump_minor(current_version)
+
     lockfile <<-L
       GEM
         remote: file://localhost#{gem_repo1}/
@@ -162,28 +165,27 @@ RSpec.describe "the lockfile format" do
           rack (1.0.0)
 
       PLATFORMS
-        #{generic_local_platform}
+        #{lockfile_platforms}
 
       DEPENDENCIES
         rack
 
       BUNDLED WITH
-         9999999.1.0
+         #{newer_minor}
     L
 
-    simulate_bundler_version "9999999.0.0" do
-      install_gemfile <<-G
-        source "file://localhost#{gem_repo1}"
+    install_gemfile <<-G
+      source "file://localhost#{gem_repo1}"
 
-        gem "rack"
-      G
-    end
+      gem "rack"
+    G
 
-    warning_message = "the running version of Bundler (9999999.0.0) is older " \
-                      "than the version that created the lockfile (9999999.1.0). " \
+    pre_flag = prerelease?(newer_minor) ? " --pre" : ""
+    warning_message = "the running version of Bundler (#{current_version}) is older " \
+                      "than the version that created the lockfile (#{newer_minor}). " \
                       "We suggest you to upgrade to the version that created the " \
-                      "lockfile by running `gem install bundler:9999999.1.0`."
-    expect(last_command.stderr).to include warning_message
+                      "lockfile by running `gem install bundler:#{newer_minor}#{pre_flag}`."
+    expect(err).to include warning_message
 
     lockfile_should_be <<-G
       GEM
@@ -192,18 +194,20 @@ RSpec.describe "the lockfile format" do
           rack (1.0.0)
 
       PLATFORMS
-        #{generic_local_platform}
-        #{specific_local_platform}
+        #{lockfile_platforms}
 
       DEPENDENCIES
         rack
 
       BUNDLED WITH
-         9999999.1.0
+         #{newer_minor}
     G
   end
 
-  it "errors if the current is a major version older than lockfile's bundler version", :bundler => "3" do
+  it "warns when updating bundler major version" do
+    current_version = Bundler::VERSION
+    older_major = previous_major(current_version)
+
     lockfile <<-L
       GEM
         remote: file://localhost#{gem_repo1}/
@@ -217,7 +221,7 @@ RSpec.describe "the lockfile format" do
         rack
 
       BUNDLED WITH
-         9999999.0.0
+         #{older_major}
     L
 
     install_gemfile <<-G
@@ -226,76 +230,9 @@ RSpec.describe "the lockfile format" do
       gem "rack"
     G
 
-    expect(last_command).to be_failure
-    expect(last_command.bundler_err).to include("You must use Bundler 9999999 or greater with this lockfile.")
-  end
-
-  it "shows a friendly error when running with a new bundler 2 lockfile" do
-    lockfile <<-L
-      GEM
-        remote: https://rails-assets.org/
-        specs:
-         rails-assets-bootstrap (3.3.4)
-           rails-assets-jquery (>= 1.9.1)
-         rails-assets-jquery (2.1.4)
-
-      GEM
-        remote: https://rubygems.org/
-        specs:
-         rake (10.4.2)
-
-      PLATFORMS
-        ruby
-
-      DEPENDENCIES
-        rails-assets-bootstrap!
-        rake
-
-      BUNDLED WITH
-         9999999.0.0
-    L
-
-    install_gemfile <<-G
-      source 'https://rubygems.org'
-      gem 'rake'
-
-      source 'https://rails-assets.org' do
-        gem 'rails-assets-bootstrap'
-      end
-    G
-
-    expect(last_command).to be_failure
-    expect(err).to include("You must use Bundler 9999999 or greater with this lockfile.")
-  end
-
-  it "warns when updating bundler major version", :bundler => "< 3" do
-    lockfile <<-L
-      GEM
-        remote: file://localhost#{gem_repo1}/
-        specs:
-          rack (1.0.0)
-
-      PLATFORMS
-        #{generic_local_platform}
-
-      DEPENDENCIES
-        rack
-
-      BUNDLED WITH
-         1.10.0
-    L
-
-    simulate_bundler_version "9999999.0.0" do
-      install_gemfile <<-G
-        source "file://localhost#{gem_repo1}/"
-
-        gem "rack"
-      G
-    end
-
-    expect(last_command.stderr).to include(
+    expect(err).to include(
       "Warning: the lockfile is being updated to Bundler " \
-      "9999999, after which you will be unable to return to Bundler 1."
+      "#{current_version.split(".").first}, after which you will be unable to return to Bundler #{older_major.split(".").first}."
     )
 
     lockfile_should_be <<-G
@@ -305,62 +242,14 @@ RSpec.describe "the lockfile format" do
           rack (1.0.0)
 
       PLATFORMS
-        #{generic_local_platform}
-        #{specific_local_platform}
-
-      DEPENDENCIES
-        rack
-
-      BUNDLED WITH
-         9999999.0.0
-    G
-  end
-
-  it "warns when updating bundler major version", :bundler => "3" do
-    lockfile <<-L
-      GEM
-        remote: file://localhost#{gem_repo1}/
-        specs:
-          rack (1.0.0)
-
-      PLATFORMS
         #{lockfile_platforms}
 
       DEPENDENCIES
         rack
 
       BUNDLED WITH
-         1.10.0
-    L
-
-    simulate_bundler_version "9999999.0.0" do
-      install_gemfile <<-G
-        source "file://localhost#{gem_repo1}/"
-
-        gem "rack"
-      G
-
-      expect(last_command.stderr).to include(
-        "Warning: the lockfile is being updated to Bundler " \
-        "9999999, after which you will be unable to return to Bundler 1."
-      )
-
-      lockfile_should_be <<-G
-        GEM
-          remote: file://localhost#{gem_repo1}/
-          specs:
-            rack (1.0.0)
-
-        PLATFORMS
-          #{lockfile_platforms}
-
-        DEPENDENCIES
-          rack
-
-        BUNDLED WITH
-           9999999.0.0
-      G
-    end
+         #{current_version}
+    G
   end
 
   it "generates a simple lockfile for a single source, gem with dependencies" do
@@ -1579,7 +1468,25 @@ RSpec.describe "the lockfile format" do
       gem "rack"
     G
 
-    expect(last_command.bundler_err).to match(/your Gemfile.lock contains merge conflicts/i)
-    expect(last_command.bundler_err).to match(/git checkout HEAD -- Gemfile.lock/i)
+    expect(err).to match(/your Gemfile.lock contains merge conflicts/i)
+    expect(err).to match(/git checkout HEAD -- Gemfile.lock/i)
+  end
+
+private
+
+  def prerelease?(version)
+    Gem::Version.new(version).prerelease?
+  end
+
+  def previous_major(version)
+    version.split(".").map.with_index {|v, i| i == 0 ? v.to_i - 1 : v }.join(".")
+  end
+
+  def bump_minor(version)
+    bump(version, 1)
+  end
+
+  def bump(version, segment)
+    version.split(".").map.with_index {|v, i| i == segment ? v.to_i + 1 : v }.join(".")
   end
 end
diff --git a/spec/bundler/other/cli_dispatch_spec.rb b/spec/bundler/other/cli_dispatch_spec.rb
index 67127fc6e0..548539ac89 100644
--- a/spec/bundler/other/cli_dispatch_spec.rb
+++ b/spec/bundler/other/cli_dispatch_spec.rb
@@ -3,19 +3,19 @@
 RSpec.describe "bundle command names" do
   it "work when given fully" do
     bundle "install"
-    expect(last_command.bundler_err).to eq("Could not locate Gemfile")
+    expect(err).to eq("Could not locate Gemfile")
     expect(last_command.stdboth).not_to include("Ambiguous command")
   end
 
   it "work when not ambiguous" do
     bundle "ins"
-    expect(last_command.bundler_err).to eq("Could not locate Gemfile")
+    expect(err).to eq("Could not locate Gemfile")
     expect(last_command.stdboth).not_to include("Ambiguous command")
   end
 
   it "print a friendly error when ambiguous" do
     bundle "in"
-    expect(last_command.bundler_err).to eq("Ambiguous command in matches [info, init, inject, install]")
+    expect(err).to eq("Ambiguous command in matches [info, init, inject, install]")
   end
 
   context "when cache_command_is_package is set" do
@@ -23,7 +23,7 @@ RSpec.describe "bundle command names" do
 
     it "dispatches `bundle cache` to the package command" do
       bundle "cache --verbose"
-      expect(last_command.stdout).to start_with "Running `bundle package --verbose`"
+      expect(out).to start_with "Running `bundle package --verbose`"
     end
   end
 end
diff --git a/spec/bundler/other/major_deprecation_spec.rb b/spec/bundler/other/major_deprecation_spec.rb
index 83944e4075..fd12c645a8 100644
--- a/spec/bundler/other/major_deprecation_spec.rb
+++ b/spec/bundler/other/major_deprecation_spec.rb
@@ -365,38 +365,30 @@ RSpec.describe "major deprecations" do
   end
 
   describe Bundler::Dsl do
-    let(:msg) do
-      <<-EOS
-The :github git source is deprecated, and will be removed in the future. Change any "reponame" :github sources to "username/reponame". Add this code to the top of your Gemfile to ensure it continues to work:
-
-    git_source(:github) {|repo_name| "https://github.com/\#{repo_name}.git" }
-
-      EOS
-    end
-
     before do
       @rubygems = double("rubygems")
       allow(Bundler::Source::Rubygems).to receive(:new) { @rubygems }
     end
 
     context "with github gems" do
-      it "warns about the https change if people are opting out" do
-        Bundler.settings.temporary "github.https" => false
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, msg)
-        expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(2, "Setting `github.https` to false is deprecated and won't be supported in the future.")
-        subject.gem("sparks", :github => "indirect/sparks")
-      end
+      it "warns about removal", :bundler => "2" do
+        msg = <<-EOS
+The :github git source is deprecated, and will be removed in the future. Change any "reponame" :github sources to "username/reponame". Add this code to the top of your Gemfile to ensure it continues to work:
 
-      it "upgrades to https by default", :bundler => "2" do
+    git_source(:github) {|repo_name| "https://github.com/\#{repo_name}.git" }
+
+        EOS
         expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, msg)
         subject.gem("sparks", :github => "indirect/sparks")
         github_uri = "https://github.com/indirect/sparks.git"
         expect(subject.dependencies.first.source.uri).to eq(github_uri)
       end
+
+      pending "should fail with a helpful error", :bundler => "3"
     end
 
     context "with bitbucket gems" do
-      it "warns about removal" do
+      it "warns about removal", :bundler => "2" do
         allow(Bundler.ui).to receive(:deprecate)
         msg = <<-EOS
 The :bitbucket git source is deprecated, and will be removed in the future. Add this code to the top of your Gemfile to ensure it continues to work:
@@ -411,10 +403,12 @@ The :bitbucket git source is deprecated, and will be removed in the future. Add
         expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, msg)
         subject.gem("not-really-a-gem", :bitbucket => "mcorp/flatlab-rails")
       end
+
+      pending "should fail with a helpful error", :bundler => "3"
     end
 
     context "with gist gems" do
-      it "warns about removal" do
+      it "warns about removal", :bundler => "2" do
         allow(Bundler.ui).to receive(:deprecate)
         msg = <<-EOS
 The :gist git source is deprecated, and will be removed in the future. Add this code to the top of your Gemfile to ensure it continues to work:
@@ -425,6 +419,8 @@ The :gist git source is deprecated, and will be removed in the future. Add this
         expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, msg)
         subject.gem("not-really-a-gem", :gist => "1234")
       end
+
+      pending "should fail with a helpful error", :bundler => "3"
     end
   end
 
@@ -480,9 +476,33 @@ The :gist git source is deprecated, and will be removed in the future. Add this
       it "prints a deprecation warning recommending `bundle info`", :bundler => "2" do
         expect(deprecations).to include("use `bundle info rack` instead of `bundle show rack`")
       end
+
+      pending "fails with a helpful message", :bundler => "3"
+    end
+
+    context "with the --paths option" do
+      before do
+        bundle "show --paths"
+      end
+
+      it "prints a deprecation warning recommending `bundle list`", :bundler => "2" do
+        expect(deprecations).to include("use `bundle list` instead of `bundle show --paths`")
+      end
+
+      pending "fails with a helpful message", :bundler => "3"
     end
 
-    pending "fails with a helpful message", :bundler => "3"
+    context "with a gem argument and the --paths option" do
+      before do
+        bundle "show rack --paths"
+      end
+
+      it "prints deprecation warning recommending `bundle info`", :bundler => "2" do
+        expect(deprecations).to include("use `bundle info rack --path` instead of `bundle show rack --paths`")
+      end
+
+      pending "fails with a helpful message", :bundler => "3"
+    end
   end
 
   context "bundle console" do
diff --git a/spec/bundler/quality_spec.rb b/spec/bundler/quality_spec.rb
index ca622508c6..b8f2d6ed1b 100644
--- a/spec/bundler/quality_spec.rb
+++ b/spec/bundler/quality_spec.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 if defined?(Encoding) && Encoding.default_external.name != "UTF-8"
   # An approximation of ruby -E UTF-8, since it works on 1.8.7
   Encoding.default_external = Encoding.find("UTF-8")
@@ -171,7 +173,6 @@ RSpec.describe "The library itself" do
       forget_cli_options
       gem.coc
       gem.mit
-      github.https
       inline
       use_gem_version_promoter_for_major_updates
     ]
@@ -225,9 +226,9 @@ RSpec.describe "The library itself" do
         end
 
         # there's no way around this warning
-        last_command.stderr.sub!(/^YAML safe loading.*/, "")
+        err.sub!(/^YAML safe loading.*/, "")
 
-        expect(last_command.stderr).to be_empty, "bundler should build as a gem without warnings, but\n#{err}"
+        expect(err).to be_empty, "bundler should build as a gem without warnings, but\n#{err}"
       ensure
         # clean up the .gem generated
         FileUtils.rm("bundler-#{Bundler::VERSION}.gem")
@@ -273,4 +274,20 @@ RSpec.describe "The library itself" do
       expect(warnings).to be_well_formed
     end
   end
+
+  it "does not use require internally, but require_relative" do
+    Dir.chdir(root) do
+      exempt = %r{templates/|vendor/}
+      all_bad_requires = []
+      lib_files = ruby_core? ? `git ls-files -z -- lib/bundler lib/bundler.rb` : `git ls-files -z -- lib`
+      lib_files.split("\x0").each do |filename|
+        next if filename =~ exempt
+        File.readlines(filename).each_with_index do |line, number|
+          line.scan(/^ *require "bundler/).each { all_bad_requires << "#{filename}:#{number.succ}" }
+        end
+      end
+
+      expect(all_bad_requires).to be_empty, "#{all_bad_requires.size} internal requires that should use `require_relative`: #{all_bad_requires}"
+    end
+  end
 end
diff --git a/spec/bundler/realworld/edgecases_spec.rb b/spec/bundler/realworld/edgecases_spec.rb
index a3662c91e7..6468ee7f1e 100644
--- a/spec/bundler/realworld/edgecases_spec.rb
+++ b/spec/bundler/realworld/edgecases_spec.rb
@@ -204,7 +204,7 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do
     bundle "config set --local path vendor/bundle"
     bundle! :install
     expect(err).not_to include("Could not find rake")
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   it "checks out git repos when the lockfile is corrupted" do
@@ -331,7 +331,7 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do
     L
 
     bundle! :lock
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   it "outputs a helpful error message when gems have invalid gemspecs" do
diff --git a/spec/bundler/realworld/gemfile_source_header_spec.rb b/spec/bundler/realworld/gemfile_source_header_spec.rb
index eaefd0f03e..382485b8fc 100644
--- a/spec/bundler/realworld/gemfile_source_header_spec.rb
+++ b/spec/bundler/realworld/gemfile_source_header_spec.rb
@@ -28,7 +28,7 @@ RSpec.describe "fetching dependencies with a mirrored source", :realworld => tru
     expect(the_bundle).to include_gems "weakling 0.0.3"
   end
 
-  private
+private
 
   def setup_server
     require_rack
diff --git a/spec/bundler/realworld/mirror_probe_spec.rb b/spec/bundler/realworld/mirror_probe_spec.rb
index c5e95f3059..13d1afe124 100644
--- a/spec/bundler/realworld/mirror_probe_spec.rb
+++ b/spec/bundler/realworld/mirror_probe_spec.rb
@@ -86,8 +86,8 @@ RSpec.describe "fetching dependencies with a not available mirror", :realworld =
 
       bundle :install, :artifice => nil
 
-      expect(last_command.stdout).to include "Fetching source index from #{mirror}/"
-      expect(last_command.bundler_err).to include <<-EOS.strip
+      expect(out).to include "Fetching source index from #{mirror}/"
+      expect(err).to include <<-EOS.strip
 Retrying fetcher due to error (2/4): Bundler::HTTPError Could not fetch specs from #{mirror}/
 Retrying fetcher due to error (3/4): Bundler::HTTPError Could not fetch specs from #{mirror}/
 Retrying fetcher due to error (4/4): Bundler::HTTPError Could not fetch specs from #{mirror}/
diff --git a/spec/bundler/runtime/gem_tasks_spec.rb b/spec/bundler/runtime/gem_tasks_spec.rb
index 7026474b0e..eb9db56ead 100644
--- a/spec/bundler/runtime/gem_tasks_spec.rb
+++ b/spec/bundler/runtime/gem_tasks_spec.rb
@@ -19,10 +19,10 @@ RSpec.describe "require 'bundler/gem_tasks'" do
 
   it "includes the relevant tasks" do
     with_gem_path_as(Spec::Path.base_system_gems.to_s) do
-      sys_exec "#{rake} -T"
+      sys_exec "#{rake} -T", "RUBYOPT" => "-I#{bundler_path}"
     end
 
-    expect(last_command.stderr).to eq("")
+    expect(err).to eq("")
     expected_tasks = [
       "rake build",
       "rake clean",
@@ -39,6 +39,6 @@ RSpec.describe "require 'bundler/gem_tasks'" do
     with_gem_path_as(Spec::Path.base_system_gems.to_s) do
       sys_exec! %(#{rake} -e 'load "Rakefile"; puts CLOBBER.inspect')
     end
-    expect(last_command.stdout).to eq '["pkg"]'
+    expect(out).to eq '["pkg"]'
   end
 end
diff --git a/spec/bundler/runtime/inline_spec.rb b/spec/bundler/runtime/inline_spec.rb
index 96a3fa09ae..d53c3d1c15 100644
--- a/spec/bundler/runtime/inline_spec.rb
+++ b/spec/bundler/runtime/inline_spec.rb
@@ -67,7 +67,7 @@ RSpec.describe "bundler/inline#gemfile" do
       puts "success"
     RUBY
 
-    expect(last_command.stderr).to include "Could not find gem 'eleven'"
+    expect(err).to include "Could not find gem 'eleven'"
     expect(out).not_to include "success"
 
     script <<-RUBY
@@ -90,7 +90,7 @@ RSpec.describe "bundler/inline#gemfile" do
     expect(out).to include("Installing activesupport")
     err.gsub! %r{.*lib/sinatra/base\.rb:\d+: warning: constant ::Fixnum is deprecated$}, ""
     err.strip!
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
     expect(exitstatus).to be_zero if exitstatus
   end
 
@@ -134,7 +134,7 @@ RSpec.describe "bundler/inline#gemfile" do
 
       puts "success"
     RUBY
-    expect(last_command.stderr).to include "Unknown options: arglebargle"
+    expect(err).to include "Unknown options: arglebargle"
     expect(out).not_to include "success"
   end
 
@@ -165,7 +165,7 @@ RSpec.describe "bundler/inline#gemfile" do
     RUBY
 
     expect(out).to eq("1.0.0")
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
     expect(exitstatus).to be_zero if exitstatus
   end
 
@@ -183,7 +183,7 @@ RSpec.describe "bundler/inline#gemfile" do
     RUBY
 
     expect(out).to eq("1.0.0\n2.0.0")
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
     expect(exitstatus).to be_zero if exitstatus
   end
 
@@ -203,7 +203,7 @@ RSpec.describe "bundler/inline#gemfile" do
     RUBY
 
     expect(out).to eq("two\nfour")
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
     expect(exitstatus).to be_zero if exitstatus
   end
 
@@ -240,6 +240,20 @@ RSpec.describe "bundler/inline#gemfile" do
       RUBY
     end
 
+    expect(err).to be_empty
+    expect(exitstatus).to be_zero if exitstatus
+  end
+
+  it "installs inline gems when frozen is set" do
+    script <<-RUBY, :env => { "BUNDLE_FROZEN" => "true" }
+      gemfile do
+        source "file://#{gem_repo1}"
+        gem "rack"
+      end
+
+      puts RACK
+    RUBY
+
     expect(last_command.stderr).to be_empty
     expect(exitstatus).to be_zero if exitstatus
   end
@@ -258,7 +272,7 @@ RSpec.describe "bundler/inline#gemfile" do
       RUBY
     end
 
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
     expect(exitstatus).to be_zero if exitstatus
   end
 
@@ -274,6 +288,19 @@ RSpec.describe "bundler/inline#gemfile" do
       puts RACK
     RUBY
     expect(last_command).to be_success
-    expect(last_command.stdout).to eq "1.0.0"
+    expect(out).to eq "1.0.0"
+  end
+
+  it "skips platform warnings" do
+    simulate_platform "ruby"
+
+    script <<-RUBY
+      gemfile(true) do
+        source "file://#{gem_repo1}"
+        gem "rack", platform: :jruby
+      end
+    RUBY
+
+    expect(err).to be_empty
   end
 end
diff --git a/spec/bundler/runtime/require_spec.rb b/spec/bundler/runtime/require_spec.rb
index c9cfa199d3..f149c9d489 100644
--- a/spec/bundler/runtime/require_spec.rb
+++ b/spec/bundler/runtime/require_spec.rb
@@ -136,8 +136,8 @@ RSpec.describe "Bundler.require" do
     G
 
     run "Bundler.require"
-    expect(last_command.stderr).to match("error while trying to load the gem 'faulty'")
-    expect(last_command.stderr).to match("Gem Internal Error Message")
+    expect(err).to match("error while trying to load the gem 'faulty'")
+    expect(err).to match("Gem Internal Error Message")
   end
 
   it "doesn't swallow the error when the library has an unrelated error" do
@@ -198,7 +198,7 @@ RSpec.describe "Bundler.require" do
       RUBY
       ruby(cmd)
 
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
 
     it "does not mangle explicitly given requires" do
@@ -432,7 +432,7 @@ RSpec.describe "Bundler.require with platform specific dependencies" do
     G
 
     run "Bundler.require"
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   it "requires gems pinned to multiple platforms, including the current one" do
@@ -447,6 +447,6 @@ RSpec.describe "Bundler.require with platform specific dependencies" do
     run "Bundler.require; puts RACK"
 
     expect(out).to eq("1.0.0")
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 end
diff --git a/spec/bundler/runtime/setup_spec.rb b/spec/bundler/runtime/setup_spec.rb
index c81baa34ea..90c3df8661 100644
--- a/spec/bundler/runtime/setup_spec.rb
+++ b/spec/bundler/runtime/setup_spec.rb
@@ -19,7 +19,7 @@ RSpec.describe "Bundler.setup" do
         require 'rack'
         puts RACK
       RUBY
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to eq("1.0.0")
     end
   end
@@ -45,7 +45,7 @@ RSpec.describe "Bundler.setup" do
           puts "WIN"
         end
       RUBY
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to eq("WIN")
     end
 
@@ -58,7 +58,7 @@ RSpec.describe "Bundler.setup" do
         require 'rack'
         puts RACK
       RUBY
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to eq("1.0.0")
     end
 
@@ -72,7 +72,7 @@ RSpec.describe "Bundler.setup" do
         require 'rack'
         puts RACK
       RUBY
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to eq("1.0.0")
     end
 
@@ -90,7 +90,7 @@ RSpec.describe "Bundler.setup" do
           puts "FAIL"
         end
       RUBY
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to match("WIN")
     end
 
@@ -104,8 +104,8 @@ RSpec.describe "Bundler.setup" do
         puts "FAIL"
       RUBY
 
-      expect(last_command.stderr).to match("rack")
-      expect(last_command.stderr).to match("LoadError")
+      expect(err).to match("rack")
+      expect(err).to match("LoadError")
       expect(out).not_to match("FAIL")
     end
   end
@@ -141,7 +141,7 @@ RSpec.describe "Bundler.setup" do
       load_path = out.split("\n")
       rack_load_order = load_path.index {|path| path.include?("rack") }
 
-      expect(last_command.stderr).to eq("")
+      expect(err).to eq("")
       expect(load_path).to include(a_string_ending_with("dash_i_dir"), "rubylib_dir")
       expect(rack_load_order).to be > 0
     end
@@ -364,7 +364,7 @@ RSpec.describe "Bundler.setup" do
           end
         R
 
-        expect(last_command.stderr).to be_empty
+        expect(err).to be_empty
       end
 
       it "replaces #gem but raises when the version is wrong" do
@@ -390,7 +390,7 @@ RSpec.describe "Bundler.setup" do
           end
         R
 
-        expect(last_command.stderr).to be_empty
+        expect(err).to be_empty
       end
     end
 
@@ -449,7 +449,7 @@ RSpec.describe "Bundler.setup" do
 
     it "provides a useful exception when the git repo is not checked out yet" do
       run "1"
-      expect(last_command.stderr).to match(/the git source #{lib_path('rack-1.0.0')} is not yet checked out. Please run `bundle install`/i)
+      expect(err).to match(/the git source #{lib_path('rack-1.0.0')} is not yet checked out. Please run `bundle install`/i)
     end
 
     it "does not hit the git binary if the lockfile is available and up to date" do
@@ -535,7 +535,7 @@ RSpec.describe "Bundler.setup" do
 
       FileUtils.rm_rf(lib_path("local-rack"))
       run "require 'rack'"
-      expect(last_command.stderr).to match(/Cannot use local override for rack-0.8 because #{Regexp.escape(lib_path('local-rack').to_s)} does not exist/)
+      expect(err).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 runtime" do
@@ -557,7 +557,7 @@ RSpec.describe "Bundler.setup" do
       G
 
       run "require 'rack'"
-      expect(last_command.stderr).to match(/because :branch is not specified in Gemfile/)
+      expect(err).to match(/because :branch is not specified in Gemfile/)
     end
 
     it "explodes on different branches on runtime" do
@@ -579,7 +579,7 @@ RSpec.describe "Bundler.setup" do
       G
 
       run "require 'rack'"
-      expect(last_command.stderr).to match(/is using branch master but Gemfile specifies changed/)
+      expect(err).to match(/is using branch master but Gemfile specifies changed/)
     end
 
     it "explodes on refs with different branches on runtime" do
@@ -599,7 +599,7 @@ RSpec.describe "Bundler.setup" do
 
       bundle %(config set local.rack #{lib_path("local-rack")})
       run "require 'rack'"
-      expect(last_command.stderr).to match(/is using branch master but Gemfile specifies nonexistant/)
+      expect(err).to match(/is using branch master but Gemfile specifies nonexistant/)
     end
   end
 
@@ -711,7 +711,7 @@ end
     ENV["GEM_HOME"] = ""
     bundle %(exec ruby -e "require 'set'")
 
-    expect(last_command.stderr).to be_empty
+    expect(err).to be_empty
   end
 
   describe "$MANPATH" do
@@ -878,7 +878,7 @@ end
           require 'foo'
         R
       end
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
 
     it "should make sure the Bundler.root is really included in the path relative to the Gemfile" do
@@ -903,7 +903,7 @@ end
         R
       end
 
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
   end
 
@@ -1053,7 +1053,7 @@ end
         Bundler.load
       RUBY
 
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to eq("")
     end
   end
@@ -1065,7 +1065,7 @@ end
       G
 
       bundle %(exec ruby -e "require 'bundler'; Bundler.setup")
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
     end
   end
 
@@ -1260,14 +1260,14 @@ end
       it "activates no gems with -rbundler/setup" do
         install_gemfile! ""
         ruby! code, :env => { :RUBYOPT => activation_warning_hack_rubyopt + " -rbundler/setup" }
-        expect(last_command.stdout).to eq("{}")
+        expect(out).to eq("{}")
       end
 
       it "activates no gems with bundle exec" do
         install_gemfile! ""
         create_file("script.rb", code)
         bundle! "exec ruby ./script.rb", :env => { :RUBYOPT => activation_warning_hack_rubyopt }
-        expect(last_command.stdout).to eq("{}")
+        expect(out).to eq("{}")
       end
 
       it "activates no gems with bundle exec that is loaded" do
@@ -1275,7 +1275,7 @@ end
         create_file("script.rb", "#!/usr/bin/env ruby\n\n#{code}")
         FileUtils.chmod(0o777, bundled_app("script.rb"))
         bundle! "exec ./script.rb", :artifice => nil, :env => { :RUBYOPT => activation_warning_hack_rubyopt }
-        expect(last_command.stdout).to eq("{}")
+        expect(out).to eq("{}")
       end
 
       let(:default_gems) do
@@ -1355,7 +1355,7 @@ end
       RUBY
 
       expect(last_command.stdboth).not_to include "FAIL"
-      expect(last_command.stderr).to include "private method `gem'"
+      expect(err).to include "private method `gem'"
     end
 
     it "keeps Kernel#require private" do
@@ -1371,7 +1371,7 @@ end
       RUBY
 
       expect(last_command.stdboth).not_to include "FAIL"
-      expect(last_command.stderr).to include "private method `require'"
+      expect(err).to include "private method `require'"
     end
   end
 end
diff --git a/spec/bundler/runtime/with_unbundled_env_spec.rb b/spec/bundler/runtime/with_unbundled_env_spec.rb
index b4503cba32..b901f28c8b 100644
--- a/spec/bundler/runtime/with_unbundled_env_spec.rb
+++ b/spec/bundler/runtime/with_unbundled_env_spec.rb
@@ -46,7 +46,7 @@ RSpec.describe "Bundler.with_env helpers" do
         build_bundler_context
         bundle! "exec '#{Gem.ruby}' #{bundled_app("exe.rb")} 2"
       end
-      expect(last_command.stderr).to eq <<-EOS.strip
+      expect(err).to eq <<-EOS.strip
 2 false
 1 true
 0 true
@@ -153,29 +153,50 @@ RSpec.describe "Bundler.with_env helpers" do
   end
 
   describe "Bundler.original_system" do
+    let(:code) do
+      <<~RUBY
+        Bundler.original_system(%([ "\$BUNDLE_FOO" = "bar" ] && exit 42))
+
+        exit $?.exitstatus
+      RUBY
+    end
+
     it "runs system inside with_original_env" do
-      code = 'exit Bundler.original_system(%(test "\$BUNDLE_FOO" = "bar"))'
       lib = File.expand_path("../../lib", __dir__)
       system({ "BUNDLE_FOO" => "bar" }, "ruby -I#{lib} -rbundler -e '#{code}'")
-      expect($?.exitstatus).to eq(0)
+      expect($?.exitstatus).to eq(42)
     end
   end
 
   describe "Bundler.clean_system", :bundler => 2 do
+    let(:code) do
+      <<~RUBY
+        Bundler.clean_system(%([ "\$BUNDLE_FOO" = "bar" ] || exit 42))
+
+        exit $?.exitstatus
+      RUBY
+    end
+
     it "runs system inside with_clean_env" do
-      code = 'exit Bundler.clean_system(%(test "\$BUNDLE_FOO" = "bar"))'
       lib = File.expand_path("../../lib", __dir__)
       system({ "BUNDLE_FOO" => "bar" }, "ruby -I#{lib} -rbundler -e '#{code}'")
-      expect($?.exitstatus).to eq(1)
+      expect($?.exitstatus).to eq(42)
     end
   end
 
   describe "Bundler.unbundled_system" do
+    let(:code) do
+      <<~RUBY
+        Bundler.unbundled_system(%([ "\$BUNDLE_FOO" = "bar" ] || exit 42))
+
+        exit $?.exitstatus
+      RUBY
+    end
+
     it "runs system inside with_unbundled_env" do
-      code = 'exit Bundler.clean_system(%(test "\$BUNDLE_FOO" = "bar"))'
       lib = File.expand_path("../../lib", __dir__)
       system({ "BUNDLE_FOO" => "bar" }, "ruby -I#{lib} -rbundler -e '#{code}'")
-      expect($?.exitstatus).to eq(1)
+      expect($?.exitstatus).to eq(42)
     end
   end
 
diff --git a/spec/bundler/spec_helper.rb b/spec/bundler/spec_helper.rb
index e8e7cc9a1f..d3de1ff784 100644
--- a/spec/bundler/spec_helper.rb
+++ b/spec/bundler/spec_helper.rb
@@ -23,14 +23,6 @@ end
 $debug = false
 
 Spec::Manpages.setup unless Gem.win_platform?
-Spec::Rubygems.setup
-ENV["RUBYOPT"] = "#{ENV["RUBYOPT"]} -r#{Spec::Path.spec_dir}/support/hax.rb"
-ENV["BUNDLE_SPEC_RUN"] = "true"
-
-# Don't wrap output in tests
-ENV["THOR_COLUMNS"] = "10000"
-
-Spec::CodeClimate.setup
 
 module Gem
   def self.ruby=(ruby)
@@ -60,6 +52,8 @@ RSpec.configure do |config|
   # forever due to memory constraints
   config.fail_fast ||= 25 if ENV["CI"]
 
+  config.bisect_runner = :shell
+
   if ENV["BUNDLER_SUDO_TESTS"] && Spec::Sudo.present?
     config.filter_run :sudo => true
   else
@@ -72,8 +66,11 @@ RSpec.configure do |config|
     config.filter_run_excluding :realworld => true
   end
 
+  git_version = Bundler::Source::Git::GitProxy.new(nil, nil, nil).version
+
   config.filter_run_excluding :ruby => RequirementChecker.against(RUBY_VERSION)
   config.filter_run_excluding :rubygems => RequirementChecker.against(Gem::VERSION)
+  config.filter_run_excluding :git => RequirementChecker.against(git_version)
   config.filter_run_excluding :rubygems_master => (ENV["RGV"] != "master")
   config.filter_run_excluding :bundler => RequirementChecker.against(Bundler::VERSION.split(".")[0])
   config.filter_run_excluding :ruby_repo => !(ENV["BUNDLE_RUBY"] && ENV["BUNDLE_GEM"]).nil?
@@ -101,6 +98,15 @@ RSpec.configure do |config|
   end
 
   config.before :suite do
+    Spec::Rubygems.setup
+    ENV["RUBYOPT"] = original_env["RUBYOPT"] = "#{ENV["RUBYOPT"]} -r#{Spec::Path.spec_dir}/support/hax.rb"
+    ENV["BUNDLE_SPEC_RUN"] = original_env["BUNDLE_SPEC_RUN"] = "true"
+
+    # Don't wrap output in tests
+    ENV["THOR_COLUMNS"] = "10000"
+
+    original_env = ENV.to_hash.delete_if {|k, _v| k.start_with?(Bundler::EnvironmentPreserver::BUNDLER_PREFIX) }
+
     if ENV["BUNDLE_RUBY"]
       FileUtils.cp_r Spec::Path.bindir, File.join(Spec::Path.root, "lib", "exe")
     end
@@ -110,14 +116,15 @@ RSpec.configure do |config|
     build_repo1
   end
 
-  config.before :each do
+  config.around :each do |example|
+    ENV.replace(original_env)
     reset!
     system_gems []
     in_app_root
     @command_executions = []
-  end
 
-  config.after :each do |example|
+    example.run
+
     all_output = @command_executions.map(&:to_s_verbose).join("\n\n")
     if example.exception && !all_output.empty?
       warn all_output unless config.formatters.grep(RSpec::Core::Formatters::DocumentationFormatter).empty?
@@ -128,7 +135,6 @@ RSpec.configure do |config|
     end
 
     Dir.chdir(original_wd)
-    ENV.replace(original_env)
   end
 
   config.after :suite do
diff --git a/spec/bundler/support/code_climate.rb b/spec/bundler/support/code_climate.rb
deleted file mode 100644
index a15442cabe..0000000000
--- a/spec/bundler/support/code_climate.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Spec
-  module CodeClimate
-    def self.setup
-      require "codeclimate-test-reporter"
-      ::CodeClimate::TestReporter.start
-      configure_exclusions
-    rescue LoadError
-      # it's fine if CodeClimate isn't set up
-      nil
-    end
-
-    def self.configure_exclusions
-      SimpleCov.start do
-        add_filter "/bin/"
-        add_filter "/lib/bundler/man/"
-        add_filter "/lib/bundler/vendor/"
-        add_filter "/man/"
-        add_filter "/pkg/"
-        add_filter "/spec/"
-        add_filter "/tmp/"
-      end
-    end
-  end
-end
diff --git a/spec/bundler/support/command_execution.rb b/spec/bundler/support/command_execution.rb
index 556285ac52..cec531d6c3 100644
--- a/spec/bundler/support/command_execution.rb
+++ b/spec/bundler/support/command_execution.rb
@@ -27,14 +27,6 @@ module Spec
       @stdboth ||= [stderr, stdout].join("\n").strip
     end
 
-    def bundler_err
-      if Bundler::VERSION.start_with?("1.")
-        stdout
-      else
-        stderr
-      end
-    end
-
     def to_s_verbose
       [
         to_s,
diff --git a/spec/bundler/support/hax.rb b/spec/bundler/support/hax.rb
index b14e4a5943..202e8dcc32 100644
--- a/spec/bundler/support/hax.rb
+++ b/spec/bundler/support/hax.rb
@@ -21,6 +21,8 @@ module Gem
 end
 
 if ENV["BUNDLER_SPEC_VERSION"]
+  require "bundler/version"
+
   module Bundler
     remove_const(:VERSION) if const_defined?(:VERSION)
     VERSION = ENV["BUNDLER_SPEC_VERSION"].dup
diff --git a/spec/bundler/support/helpers.rb b/spec/bundler/support/helpers.rb
index 09e7419a98..478fe60822 100644
--- a/spec/bundler/support/helpers.rb
+++ b/spec/bundler/support/helpers.rb
@@ -45,13 +45,13 @@ module Spec
     end
 
     def err
-      Bundler.feature_flag.error_on_stderr? ? last_command.stderr : last_command.stdout
+      last_command.stderr
     end
 
     MAJOR_DEPRECATION = /^\[DEPRECATED\]\s*/.freeze
 
     def err_without_deprecations
-      last_command.stderr.gsub(/#{MAJOR_DEPRECATION}.+[\n]?/, "")
+      err.gsub(/#{MAJOR_DEPRECATION}.+[\n]?/, "")
     end
 
     def deprecations
diff --git a/spec/bundler/support/matchers.rb b/spec/bundler/support/matchers.rb
index f9efe32a38..5d1a6a7919 100644
--- a/spec/bundler/support/matchers.rb
+++ b/spec/bundler/support/matchers.rb
@@ -133,7 +133,7 @@ module Spec
           rescue StandardError => e
             next "#{name} is not installed:\n#{indent(e)}"
           end
-          actual_version, actual_platform = last_command.stdout.strip.split(/\s+/, 2)
+          actual_version, actual_platform = out.strip.split(/\s+/, 2)
           unless Gem::Version.new(actual_version) == Gem::Version.new(version)
             next "#{name} was expected to be at version #{version} but was #{actual_version}"
           end
@@ -147,7 +147,7 @@ module Spec
           rescue StandardError
             next "#{name} does not have a source defined:\n#{indent(e)}"
           end
-          unless last_command.stdout.strip == source
+          unless out.strip == source
             next "Expected #{name} (#{version}) to be installed from `#{source}`, was actually from `#{out}`"
           end
         end.compact
@@ -172,9 +172,9 @@ module Spec
           rescue StandardError => e
             next "checking for #{name} failed:\n#{e}"
           end
-          next if last_command.stdout == "WIN"
+          next if out == "WIN"
           next "expected #{name} to not be installed, but it was" if version.nil?
-          if Gem::Version.new(last_command.stdout) == Gem::Version.new(version)
+          if Gem::Version.new(out) == Gem::Version.new(version)
             next "expected #{name} (#{version}) not to be installed, but it was"
           end
         end.compact
diff --git a/spec/bundler/support/platforms.rb b/spec/bundler/support/platforms.rb
index 0a9e4a8cb6..caac7734bf 100644
--- a/spec/bundler/support/platforms.rb
+++ b/spec/bundler/support/platforms.rb
@@ -105,7 +105,7 @@ module Spec
     end
 
     def local_platforms
-      if Bundler::VERSION.split(".").first.to_i > 2
+      if Bundler.feature_flag.specific_platform?
         [local, specific_local_platform]
       else
         [local]
diff --git a/spec/bundler/update/git_spec.rb b/spec/bundler/update/git_spec.rb
index 4fe22269e2..bc230a3575 100644
--- a/spec/bundler/update/git_spec.rb
+++ b/spec/bundler/update/git_spec.rb
@@ -88,7 +88,7 @@ RSpec.describe "bundle update" do
         gem "foo", "1.0", :git => "#{lib_path("foo_two")}"
       G
 
-      expect(last_command.stderr).to be_empty
+      expect(err).to be_empty
       expect(out).to include("Fetching #{lib_path}/foo_two")
       expect(out).to include("Bundle complete!")
     end
@@ -192,7 +192,7 @@ RSpec.describe "bundle update" do
       lib_path("foo-1.0").join(".git").rmtree
 
       bundle :update, :all => true
-      expect(last_command.bundler_err).to include(lib_path("foo-1.0").to_s).
+      expect(err).to include(lib_path("foo-1.0").to_s).
         and match(/Git error: command `git fetch.+has failed/)
     end