Merge RubyGems-3.3.0 and Bundler-2.3.0

9 files changed, 163 insertions, 125 deletions

diff --git a/spec/bundler/bundler/plugin/installer_spec.rb b/spec/bundler/bundler/plugin/installer_spec.rb
index e89720f6f7..2c50ee5afc 100644
--- a/spec/bundler/bundler/plugin/installer_spec.rb
+++ b/spec/bundler/bundler/plugin/installer_spec.rb
@@ -7,7 +7,7 @@ RSpec.describe Bundler::Plugin::Installer do
     it "uses Gem.sources when non of the source is provided" do
       sources = double(:sources)
       Bundler.settings # initialize it before we have to touch rubygems.ext_lock
-      allow(Bundler).to receive_message_chain("rubygems.sources") { sources }
+      allow(Gem).to receive(:sources) { sources }
 
       allow(installer).to receive(:install_rubygems).
         with("new-plugin", [">= 0"], sources).once
diff --git a/spec/bundler/commands/binstubs_spec.rb b/spec/bundler/commands/binstubs_spec.rb
index 1cd0e16d95..ceef07d36b 100644
--- a/spec/bundler/commands/binstubs_spec.rb
+++ b/spec/bundler/commands/binstubs_spec.rb
@@ -186,11 +186,25 @@ RSpec.describe "bundle binstubs <gem>" do
 
           before do
             lockfile lockfile.gsub(/BUNDLED WITH\n   .*$/m, "BUNDLED WITH\n   55.0")
+
+            update_repo2 do
+              with_built_bundler("55.0") {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) }
+            end
+          end
+
+          it "installs and runs the exact version of bundler", :rubygems => ">= 3.3.0.dev" do
+            sys_exec "bin/bundle install --verbose", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s, "RUBYOPT" => "-r#{spec_dir}/support/hax.rb" }
+            expect(exitstatus).not_to eq(42)
+            expect(out).to include("Bundler 55.1 is running, but your lockfile was generated with 55.0. Installing Bundler 55.0 and restarting using that version.")
+            expect(out).to include("Using bundler 55.0")
+            expect(err).not_to include("Activating bundler (~> 55.0) failed:")
           end
 
-          it "runs the available version of bundler when the version is older and the same major" do
-            sys_exec "bin/bundle install"
+          it "runs the available version of bundler", :rubygems => "< 3.3.0.dev" do
+            sys_exec "bin/bundle install --verbose"
             expect(exitstatus).not_to eq(42)
+            expect(out).not_to include("Bundler 55.1 is running, but your lockfile was generated with 55.0. Installing Bundler 55.0 and restarting using that version.")
+            expect(out).to include("Using bundler 55.1")
             expect(err).not_to include("Activating bundler (~> 55.0) failed:")
           end
         end
diff --git a/spec/bundler/commands/check_spec.rb b/spec/bundler/commands/check_spec.rb
index 1fa35136eb..e0c9a04c25 100644
--- a/spec/bundler/commands/check_spec.rb
+++ b/spec/bundler/commands/check_spec.rb
@@ -471,10 +471,10 @@ RSpec.describe "bundle check" do
     end
 
     context "is newer" do
-      it "does not change the lock but warns" do
+      it "does not change the lock and does not warn" do
         lockfile lock_with(Bundler::VERSION.succ)
         bundle :check
-        expect(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 be_empty
         expect(lockfile).to eq lock_with(Bundler::VERSION.succ)
       end
     end
diff --git a/spec/bundler/lock/lockfile_spec.rb b/spec/bundler/lock/lockfile_spec.rb
index 8befb0d400..a2a50d4cf0 100644
--- a/spec/bundler/lock/lockfile_spec.rb
+++ b/spec/bundler/lock/lockfile_spec.rb
@@ -39,7 +39,7 @@ RSpec.describe "the lockfile format" do
     G
   end
 
-  it "updates the lockfile's bundler version if current ver. is newer" do
+  it "updates the lockfile's bundler version if current ver. is newer, and version was forced through BUNDLER_VERSION" do
     system_gems "bundler-1.8.2"
 
     lockfile <<-L
@@ -64,12 +64,15 @@ RSpec.describe "the lockfile format" do
          1.8.2
     L
 
-    install_gemfile <<-G, :env => { "BUNDLER_VERSION" => Bundler::VERSION }
+    install_gemfile <<-G, :verbose => true, :env => { "BUNDLER_VERSION" => Bundler::VERSION }
       source "#{file_uri_for(gem_repo2)}"
 
       gem "rack"
     G
 
+    expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with 1.8.2.")
+    expect(out).to include("Using bundler #{Bundler::VERSION}")
+
     expect(lockfile).to eq <<~G
       GEM
         remote: #{file_uri_for(gem_repo2)}/
@@ -87,9 +90,13 @@ RSpec.describe "the lockfile format" do
     G
   end
 
-  it "does not update the lockfile's bundler version if nothing changed during bundle install" do
+  it "does not update the lockfile's bundler version if nothing changed during bundle install, but uses the locked version", :rubygems => ">= 3.3.0.a" do
     version = "#{Bundler::VERSION.split(".").first}.0.0.a"
 
+    update_repo2 do
+      with_built_bundler(version) {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) }
+    end
+
     lockfile <<-L
       GEM
         remote: #{file_uri_for(gem_repo2)}/
@@ -106,12 +113,15 @@ RSpec.describe "the lockfile format" do
          #{version}
     L
 
-    install_gemfile <<-G
+    install_gemfile <<-G, :verbose => true, :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s }
       source "#{file_uri_for(gem_repo2)}"
 
       gem "rack"
     G
 
+    expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{version}.")
+    expect(out).to include("Using bundler #{version}")
+
     expect(lockfile).to eq <<~G
       GEM
         remote: #{file_uri_for(gem_repo2)}/
@@ -129,97 +139,12 @@ RSpec.describe "the lockfile format" do
     G
   end
 
-  it "updates the lockfile's bundler version if not present" do
-    lockfile <<-L
-      GEM
-        remote: #{file_uri_for(gem_repo2)}/
-        specs:
-          rack (1.0.0)
-
-      PLATFORMS
-        #{lockfile_platforms}
-
-      DEPENDENCIES
-        rack
-    L
-
-    install_gemfile <<-G
-      source "#{file_uri_for(gem_repo2)}"
-
-      gem "rack", "> 0"
-    G
-
-    expect(lockfile).to eq <<~G
-      GEM
-        remote: #{file_uri_for(gem_repo2)}/
-        specs:
-          rack (1.0.0)
-
-      PLATFORMS
-        #{lockfile_platforms}
-
-      DEPENDENCIES
-        rack (> 0)
-
-      BUNDLED WITH
-         #{Bundler::VERSION}
-    G
-  end
-
-  it "warns if the current version is older than lockfile's bundler version, and locked version is a final release" do
-    current_version = "999.998.999"
-    system_gems "bundler-#{current_version}"
-    newer_minor = "999.999.0"
-
-    lockfile <<-L
-      GEM
-        remote: #{file_uri_for(gem_repo2)}/
-        specs:
-          rack (1.0.0)
-
-      PLATFORMS
-        #{lockfile_platforms}
-
-      DEPENDENCIES
-        rack
-
-      BUNDLED WITH
-         #{newer_minor}
-    L
-
-    install_gemfile <<-G, :env => { "BUNDLER_VERSION" => current_version }
-      source "#{file_uri_for(gem_repo2)}"
-
-      gem "rack"
-    G
-
-    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:#{newer_minor}`."
-    expect(err).to include warning_message
-
-    expect(lockfile).to eq <<~G
-      GEM
-        remote: #{file_uri_for(gem_repo2)}/
-        specs:
-          rack (1.0.0)
-
-      PLATFORMS
-        #{lockfile_platforms}
-
-      DEPENDENCIES
-        rack
-
-      BUNDLED WITH
-         #{newer_minor}
-    G
-  end
+  it "does not update the lockfile's bundler version if nothing changed during bundle install, and uses the latest version", :rubygems => "< 3.3.0.a" do
+    version = "#{Bundler::VERSION.split(".").first}.0.0.a"
 
-  it "warns if the current version is older than lockfile's bundler version, and locked version is a prerelease" do
-    current_version = "999.998.999"
-    system_gems "bundler-#{current_version}"
-    newer_minor = "999.999.0.pre1"
+    update_repo2 do
+      with_built_bundler(version) {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) }
+    end
 
     lockfile <<-L
       GEM
@@ -234,20 +159,17 @@ RSpec.describe "the lockfile format" do
         rack
 
       BUNDLED WITH
-         #{newer_minor}
+         #{version}
     L
 
-    install_gemfile <<-G, :env => { "BUNDLER_VERSION" => current_version }
+    install_gemfile <<-G, :verbose => true, :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s }
       source "#{file_uri_for(gem_repo2)}"
 
       gem "rack"
     G
 
-    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:#{newer_minor} --pre`."
-    expect(err).to include warning_message
+    expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{version}.")
+    expect(out).to include("Using bundler #{Bundler::VERSION}")
 
     expect(lockfile).to eq <<~G
       GEM
@@ -262,15 +184,11 @@ RSpec.describe "the lockfile format" do
         rack
 
       BUNDLED WITH
-         #{newer_minor}
+         #{version}
     G
   end
 
-  it "doesn't warn if the current version is older than lockfile's bundler version, and locked version is a dev version" do
-    current_version = "999.998.999"
-    system_gems "bundler-#{current_version}"
-    newer_minor = "999.999.0.dev"
-
+  it "adds the BUNDLED WITH section if not present" do
     lockfile <<-L
       GEM
         remote: #{file_uri_for(gem_repo2)}/
@@ -282,19 +200,14 @@ RSpec.describe "the lockfile format" do
 
       DEPENDENCIES
         rack
-
-      BUNDLED WITH
-         #{newer_minor}
     L
 
-    install_gemfile <<-G, :env => { "BUNDLER_VERSION" => current_version }
+    install_gemfile <<-G
       source "#{file_uri_for(gem_repo2)}"
 
-      gem "rack"
+      gem "rack", "> 0"
     G
 
-    expect(err).to be_empty
-
     expect(lockfile).to eq <<~G
       GEM
         remote: #{file_uri_for(gem_repo2)}/
@@ -305,10 +218,10 @@ RSpec.describe "the lockfile format" do
         #{lockfile_platforms}
 
       DEPENDENCIES
-        rack
+        rack (> 0)
 
       BUNDLED WITH
-         #{newer_minor}
+         #{Bundler::VERSION}
     G
   end
 
diff --git a/spec/bundler/runtime/platform_spec.rb b/spec/bundler/runtime/platform_spec.rb
index 433396d106..b937de8059 100644
--- a/spec/bundler/runtime/platform_spec.rb
+++ b/spec/bundler/runtime/platform_spec.rb
@@ -168,7 +168,7 @@ RSpec.describe "Bundler.setup with multi platform stuff" do
         nokogiri
 
       BUNDLED WITH
-        2.1.4
+        #{Bundler::VERSION}
     G
 
     bundle "install"
diff --git a/spec/bundler/runtime/self_management_spec.rb b/spec/bundler/runtime/self_management_spec.rb
new file mode 100644
index 0000000000..def9361d0f
--- /dev/null
+++ b/spec/bundler/runtime/self_management_spec.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+RSpec.describe "Self management", :rubygems => ">= 3.3.0.dev" do
+  describe "auto switching" do
+    let(:next_minor) do
+      Bundler::VERSION.split(".").map.with_index {|s, i| i == 1 ? s.to_i + 1 : s }[0..2].join(".")
+    end
+
+    before do
+      build_repo2 do
+        with_built_bundler(next_minor) {|gem_path| FileUtils.mv(gem_path, gem_repo2("gems")) }
+      end
+
+      gemfile <<-G
+        source "#{file_uri_for(gem_repo2)}"
+
+        gem "rack"
+      G
+    end
+
+    it "installs locked version when using system path and uses it" do
+      lockfile_bundled_with(next_minor)
+
+      bundle "config set --local path.system true"
+      bundle "install", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s }
+      expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.")
+
+      # It uninstalls the older system bundler
+      bundle "clean --force"
+      expect(out).to eq("Removing bundler (#{Bundler::VERSION})")
+
+      # App now uses locked version
+      bundle "-v"
+      expect(out).to end_with(next_minor[0] == "2" ? "Bundler version #{next_minor}" : next_minor)
+
+      # Subsequent installs use the locked version without reinstalling
+      bundle "install --verbose"
+      expect(out).to include("Using bundler #{next_minor}")
+      expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.")
+    end
+
+    it "installs locked version when using local path and uses it" do
+      lockfile_bundled_with(next_minor)
+
+      bundle "config set --local path vendor/bundle"
+      bundle "install", :env => { "BUNDLER_SPEC_GEM_SOURCES" => file_uri_for(gem_repo2).to_s }
+      expect(out).to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.")
+
+      # It does not uninstall the locked bundler
+      bundle "clean"
+      expect(out).to be_empty
+
+      # App now uses locked version
+      bundle "-v"
+      expect(out).to end_with(next_minor[0] == "2" ? "Bundler version #{next_minor}" : next_minor)
+
+      # Subsequent installs use the locked version without reinstalling
+      bundle "install --verbose"
+      expect(out).to include("Using bundler #{next_minor}")
+      expect(out).not_to include("Bundler #{Bundler::VERSION} is running, but your lockfile was generated with #{next_minor}. Installing Bundler #{next_minor} and restarting using that version.")
+    end
+
+    it "does not try to install a development version" do
+      lockfile_bundled_with("#{next_minor}.dev")
+
+      bundle "install --verbose"
+      expect(out).not_to match(/restarting using that version/)
+
+      bundle "-v"
+      expect(out).to eq(Bundler::VERSION[0] == "2" ? "Bundler version #{Bundler::VERSION}" : Bundler::VERSION)
+    end
+
+    it "shows a discreet message if locked bundler does not exist, and something more complete in `--verbose` mode" do
+      missing_minor ="#{Bundler::VERSION[0]}.999.999"
+
+      lockfile_bundled_with(missing_minor)
+
+      bundle "install"
+      expect(err).to eq("There was an error installing the locked bundler version (#{missing_minor}), rerun with the `--verbose` flag for more details. Going on using bundler #{Bundler::VERSION}.")
+
+      bundle "install --verbose"
+      expect(err).to include("There was an error installing the locked bundler version (#{missing_minor}), rerun with the `--verbose` flag for more details. Going on using bundler #{Bundler::VERSION}.")
+      expect(err).to include("Gem::UnsatisfiableDependencyError")
+
+      bundle "-v"
+      expect(out).to eq(Bundler::VERSION[0] == "2" ? "Bundler version #{Bundler::VERSION}" : Bundler::VERSION)
+    end
+
+    private
+
+    def lockfile_bundled_with(version)
+      lockfile <<~L
+        GEM
+          remote: #{file_uri_for(gem_repo2)}/
+          specs:
+            rack (1.0.0)
+
+        PLATFORMS
+          #{lockfile_platforms}
+
+        DEPENDENCIES
+          rack
+
+        BUNDLED WITH
+           #{version}
+      L
+    end
+  end
+end
diff --git a/spec/bundler/support/filters.rb b/spec/bundler/support/filters.rb
index 3b91897a2e..96f2e2a274 100644
--- a/spec/bundler/support/filters.rb
+++ b/spec/bundler/support/filters.rb
@@ -28,6 +28,7 @@ RSpec.configure do |config|
 
   config.filter_run_excluding :git => RequirementChecker.against(git_version)
   config.filter_run_excluding :bundler => RequirementChecker.against(Bundler::VERSION.split(".")[0])
+  config.filter_run_excluding :rubygems => RequirementChecker.against(Gem::VERSION)
   config.filter_run_excluding :ruby_repo => !ENV["GEM_COMMAND"].nil?
   config.filter_run_excluding :no_color_tty => Gem.win_platform? || !ENV["GITHUB_ACTION"].nil?
   config.filter_run_excluding :permissions => Gem.win_platform?
diff --git a/spec/bundler/support/hax.rb b/spec/bundler/support/hax.rb
index 0ad5239128..4a49ffb49f 100644
--- a/spec/bundler/support/hax.rb
+++ b/spec/bundler/support/hax.rb
@@ -32,7 +32,7 @@ module Gem
   end
 
   if ENV["BUNDLER_SPEC_GEM_SOURCES"]
-    @sources = [ENV["BUNDLER_SPEC_GEM_SOURCES"]]
+    self.sources = [ENV["BUNDLER_SPEC_GEM_SOURCES"]]
   end
 
   # We only need this hack for rubygems versions without the BundlerVersionFinder
diff --git a/spec/bundler/support/helpers.rb b/spec/bundler/support/helpers.rb
index f84e68cee8..5238c8b980 100644
--- a/spec/bundler/support/helpers.rb
+++ b/spec/bundler/support/helpers.rb
@@ -166,7 +166,7 @@ module Spec
 
     def gem_command(command, options = {})
       env = options[:env] || {}
-      env["RUBYOPT"] = opt_add("-r#{spec_dir}/support/hax.rb", env["RUBYOPT"] || ENV["RUBYOPT"])
+      env["RUBYOPT"] = opt_add(opt_add("-r#{spec_dir}/support/hax.rb", env["RUBYOPT"]), ENV["RUBYOPT"])
       options[:env] = env
       sys_exec("#{Path.gem_bin} #{command}", options)
     end
@@ -181,7 +181,7 @@ module Spec
 
     def sys_exec(cmd, options = {})
       env = options[:env] || {}
-      env["RUBYOPT"] = opt_add("-r#{spec_dir}/support/switch_rubygems.rb", env["RUBYOPT"] || ENV["RUBYOPT"])
+      env["RUBYOPT"] = opt_add(opt_add("-r#{spec_dir}/support/switch_rubygems.rb", env["RUBYOPT"]), ENV["RUBYOPT"])
       dir = options[:dir] || bundled_app
       command_execution = CommandExecution.new(cmd.to_s, dir)
 
@@ -348,6 +348,7 @@ module Spec
       without_env_side_effects do
         ENV["GEM_HOME"] = path.to_s
         ENV["GEM_PATH"] = path.to_s
+        ENV["BUNDLER_ORIG_GEM_HOME"] = nil
         ENV["BUNDLER_ORIG_GEM_PATH"] = nil
         yield
       end