diff options
Diffstat (limited to 'spec/bundler')
137 files changed, 3126 insertions, 3829 deletions
diff --git a/spec/bundler/bundler/bundler_spec.rb b/spec/bundler/bundler/bundler_spec.rb index 194d6752b2..e33c8dc606 100644 --- a/spec/bundler/bundler/bundler_spec.rb +++ b/spec/bundler/bundler/bundler_spec.rb @@ -1,4 +1,3 @@ -# encoding: utf-8 # frozen_string_literal: true require "bundler" @@ -313,10 +312,9 @@ EOF let(:bundle_path) { Pathname("#{tmpdir}/bundle") } def clear_cached_requires_sudo - # Private in ruby 1.8.7 return unless Bundler.instance_variable_defined?(:@requires_sudo_ran) - Bundler.send(:remove_instance_variable, :@requires_sudo_ran) - Bundler.send(:remove_instance_variable, :@requires_sudo) + Bundler.remove_instance_variable(:@requires_sudo_ran) + Bundler.remove_instance_variable(:@requires_sudo) end before do @@ -383,14 +381,8 @@ EOF after do FileUtils.rm_rf("tmp/vendor/bundle") FileUtils.rm_rf("tmp/vendor/bin_dir") - if Bundler.respond_to?(:remove_instance_variable) - Bundler.remove_instance_variable(:@requires_sudo_ran) - Bundler.remove_instance_variable(:@requires_sudo) - else - # TODO: Remove these code when Bundler drops Ruby 1.8.7 support - Bundler.send(:remove_instance_variable, :@requires_sudo_ran) - Bundler.send(:remove_instance_variable, :@requires_sudo) - end + 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 diff --git a/spec/bundler/bundler/cli_spec.rb b/spec/bundler/bundler/cli_spec.rb index 9a2591ac96..6a505358d1 100644 --- a/spec/bundler/bundler/cli_spec.rb +++ b/spec/bundler/bundler/cli_spec.rb @@ -60,11 +60,11 @@ RSpec.describe "bundle executable" do G bundle :install, :env => { "RUBYGEMS_GEMDEPS" => "foo" } - expect(out).to include("RUBYGEMS_GEMDEPS") - expect(out).to include("conflict with Bundler") + expect(err).to include("RUBYGEMS_GEMDEPS") + expect(err).to include("conflict with Bundler") bundle :install, :env => { "RUBYGEMS_GEMDEPS" => "" } - expect(out).not_to include("RUBYGEMS_GEMDEPS") + expect(err).not_to include("RUBYGEMS_GEMDEPS") end end @@ -97,7 +97,7 @@ RSpec.describe "bundle executable" do let(:bundler_version) { "1.1" } let(:latest_version) { nil } before do - bundle! "config --global disable_version_check false" + bundle! "config set --global disable_version_check false" simulate_bundler_version(bundler_version) if latest_version @@ -132,13 +132,13 @@ To install the latest version, run `gem install bundler` end context "and disable_version_check is set" do - before { bundle! "config disable_version_check true" } + before { bundle! "config set disable_version_check true" } include_examples "no warning" end context "running a parseable command" do it "prints no warning" do - bundle! "config --parseable foo" + bundle! "config get --parseable foo" expect(last_command.stdboth).to eq "" bundle "platform --ruby" diff --git a/spec/bundler/bundler/definition_spec.rb b/spec/bundler/bundler/definition_spec.rb index a27c5b0a54..f048728a9f 100644 --- a/spec/bundler/bundler/definition_spec.rb +++ b/spec/bundler/bundler/definition_spec.rb @@ -88,17 +88,17 @@ RSpec.describe Bundler::Definition do expect(out).to match(/re-resolving dependencies/) lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - PATH remote: #{lib_path("foo")} specs: foo (1.0) rack (= 1.0) + GEM + remote: file://localhost#{gem_repo1}/ + specs: + rack (1.0.0) + PLATFORMS #{lockfile_platforms} @@ -110,7 +110,7 @@ RSpec.describe Bundler::Definition do G end - it "for a path gem with deps and no changes", :bundler => "< 3" do + it "for a path gem with deps and no changes" do build_lib "foo", "1.0", :path => lib_path("foo") do |s| s.add_dependency "rack", "1.0" s.add_development_dependency "net-ssh", "1.0" @@ -137,43 +137,6 @@ RSpec.describe Bundler::Definition do rack (1.0.0) PLATFORMS - ruby - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "for a path gem with deps and no changes", :bundler => "3" do - build_lib "foo", "1.0", :path => lib_path("foo") do |s| - s.add_dependency "rack", "1.0" - s.add_development_dependency "net-ssh", "1.0" - end - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "foo", :path => "#{lib_path("foo")}" - G - - bundle :check, :env => { "DEBUG" => 1 } - - expect(out).to match(/using resolution from the lockfile/) - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PATH - remote: #{lib_path("foo")} - specs: - foo (1.0) - rack (= 1.0) - - PLATFORMS #{lockfile_platforms} DEPENDENCIES diff --git a/spec/bundler/bundler/dsl_spec.rb b/spec/bundler/bundler/dsl_spec.rb index d6bd9ad0a0..a17bfd4938 100644 --- a/spec/bundler/bundler/dsl_spec.rb +++ b/spec/bundler/bundler/dsl_spec.rb @@ -27,25 +27,58 @@ RSpec.describe Bundler::Dsl do context "github_https feature flag" do it "is true when github.https is true" do - bundle "config github.https true" - expect(Bundler.feature_flag.github_https?).to eq "true" + bundle "config set github.https true" + expect(Bundler.feature_flag.github_https?).to eq true end end - context "default hosts (git, gist)", :bundler => "< 3" do - context "when github.https config is true" do - before { bundle "config github.https true" } - it "converts :github to :git using https" do - subject.gem("sparks", :github => "indirect/sparks") - github_uri = "https://github.com/indirect/sparks.git" + 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 - it "converts :github to :git" do - subject.gem("sparks", :github => "indirect/sparks") - github_uri = "git://github.com/indirect/sparks.git" - expect(subject.dependencies.first.source.uri).to eq(github_uri) + 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" + end + + context "by default", :bundler => "3" do + it_behaves_like "the github DSL", "https" end it "converts numeric :gist to :git" do @@ -60,12 +93,6 @@ RSpec.describe Bundler::Dsl do expect(subject.dependencies.first.source.uri).to eq(github_uri) end - it "converts 'rails' to 'rails/rails'" do - subject.gem("rails", :github => "rails") - github_uri = "git://github.com/rails/rails.git" - expect(subject.dependencies.first.source.uri).to eq(github_uri) - end - it "converts :bitbucket to :git" do subject.gem("not-really-a-gem", :bitbucket => "mcorp/flatlab-rails") bitbucket_uri = "https://[email protected]/mcorp/flatlab-rails.git" @@ -79,7 +106,7 @@ RSpec.describe Bundler::Dsl do end end - context "default git sources", :bundler => "3" do + context "default git sources", :bundler => "4" do it "has none" do expect(subject.instance_variable_get(:@git_sources)).to eq({}) end @@ -253,13 +280,39 @@ RSpec.describe Bundler::Dsl do end subject.dependencies.each do |d| - expect(d.source.uri).to eq("git://github.com/spree/spree.git") + expect(d.source.uri).to eq("https://github.com/spree/spree.git") end end end 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 => "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 @@ -272,7 +325,6 @@ RSpec.describe Bundler::Dsl do describe "syntax errors" do it "will raise a Bundler::GemfileError" do - skip "this is failing with ruby 2.7 after r67226. consider merging https://github.com/bundler/bundler/pull/7038 or fixing this test." gemfile "gem 'foo', :path => /unquoted/string/syntax/error" expect { Bundler::Dsl.evaluate(bundled_app("Gemfile"), nil, true) }. to raise_error(Bundler::GemfileError, /There was an error parsing `Gemfile`:( compile error -)? unknown regexp options - trg. Bundler cannot continue./) diff --git a/spec/bundler/bundler/fetcher/compact_index_spec.rb b/spec/bundler/bundler/fetcher/compact_index_spec.rb index e0f58766ea..5a2d22193a 100644 --- a/spec/bundler/bundler/fetcher/compact_index_spec.rb +++ b/spec/bundler/bundler/fetcher/compact_index_spec.rb @@ -44,7 +44,7 @@ RSpec.describe Bundler::Fetcher::CompactIndex do end end - context "when OpenSSL is FIPS-enabled", :ruby => ">= 2.0.0" do + context "when OpenSSL is FIPS-enabled" do def remove_cached_md5_availability return unless Bundler::SharedHelpers.instance_variable_defined?(:@md5_available) Bundler::SharedHelpers.remove_instance_variable(:@md5_available) diff --git a/spec/bundler/bundler/fetcher/downloader_spec.rb b/spec/bundler/bundler/fetcher/downloader_spec.rb index c9b4fa662a..07b507266b 100644 --- a/spec/bundler/bundler/fetcher/downloader_spec.rb +++ b/spec/bundler/bundler/fetcher/downloader_spec.rb @@ -88,7 +88,17 @@ RSpec.describe Bundler::Fetcher::Downloader do let(:http_response) { Net::HTTPNotFound.new("1.1", 404, "Not Found") } it "should raise a Bundler::Fetcher::FallbackError with Net::HTTPNotFound" do - expect { subject.fetch(uri, options, counter) }.to raise_error(Bundler::Fetcher::FallbackError, "Net::HTTPNotFound") + expect { subject.fetch(uri, options, counter) }. + to raise_error(Bundler::Fetcher::FallbackError, "Net::HTTPNotFound: http://www.uri-to-fetch.com/api/v2/endpoint") + end + + context "when the there are credentials provided in the request" do + let(:uri) { URI("http://username:[email protected]/api/v2/endpoint") } + + it "should raise a Bundler::Fetcher::FallbackError that doesn't contain the password" do + expect { subject.fetch(uri, options, counter) }. + to raise_error(Bundler::Fetcher::FallbackError, "Net::HTTPNotFound: http://[email protected]/api/v2/endpoint") + end end end diff --git a/spec/bundler/bundler/friendly_errors_spec.rb b/spec/bundler/bundler/friendly_errors_spec.rb index 2a1be491ef..4ca1e543c1 100644 --- a/spec/bundler/bundler/friendly_errors_spec.rb +++ b/spec/bundler/bundler/friendly_errors_spec.rb @@ -16,22 +16,7 @@ RSpec.describe Bundler, "friendly errors" do FileUtils.rm(Gem.configuration.config_file_name) end - it "reports a relevant friendly error message", :ruby => ">= 1.9", :rubygems => "< 2.5.0" do - gemfile <<-G - source "file://#{gem_repo1}" - gem "rack" - G - - bundle :install, :env => { "DEBUG" => true } - - expect(out).to include("Your RubyGems configuration") - expect(out).to include("invalid YAML syntax") - expect(out).to include("Psych::SyntaxError") - expect(out).not_to include("ERROR REPORT TEMPLATE") - expect(exitstatus).to eq(25) if exitstatus - end - - it "reports a relevant friendly error message", :ruby => ">= 1.9", :rubygems => ">= 2.5.0" do + it "reports a relevant friendly error message" do gemfile <<-G source "file://#{gem_repo1}" gem "rack" diff --git a/spec/bundler/bundler/gem_helper_spec.rb b/spec/bundler/bundler/gem_helper_spec.rb index a627129fe3..dc982c6ee7 100644 --- a/spec/bundler/bundler/gem_helper_spec.rb +++ b/spec/bundler/bundler/gem_helper_spec.rb @@ -29,15 +29,6 @@ RSpec.describe Bundler::GemHelper do end context "interpolates the name" do - before do - # Remove exception that prevents public pushes on older RubyGems versions - if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.0") - content = File.read(app_gemspec_path) - content.sub!(/raise "RubyGems 2\.0 or newer.*/, "") - File.open(app_gemspec_path, "w") {|f| f.write(content) } - end - end - it "when there is only one gemspec" do expect(subject.gemspec.name).to eq(app_name) end @@ -72,7 +63,7 @@ RSpec.describe Bundler::GemHelper do let(:app_version) { "0.1.0" } let(:app_gem_dir) { app_path.join("pkg") } let(:app_gem_path) { app_gem_dir.join("#{app_name}-#{app_version}.gem") } - let(:app_gemspec_content) { remove_push_guard(File.read(app_gemspec_path)) } + let(:app_gemspec_content) { File.read(app_gemspec_path) } before(:each) do content = app_gemspec_content.gsub("TODO: ", "") @@ -81,14 +72,6 @@ RSpec.describe Bundler::GemHelper do File.open(app_gemspec_path, "w") {|file| file << content } end - def remove_push_guard(gemspec_content) - # Remove exception that prevents public pushes on older RubyGems versions - if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.0") - gemspec_content.sub!(/raise "RubyGems 2\.0 or newer.*/, "") - end - gemspec_content - end - it "uses a shell UI for output" do expect(Bundler.ui).to be_a(Bundler::UI::Shell) end @@ -198,6 +181,7 @@ RSpec.describe Bundler::GemHelper do `git init` `git config user.email "[email protected]"` `git config user.name "name"` + `git config commit.gpgsign false` `git config push.default simple` end @@ -225,11 +209,12 @@ RSpec.describe Bundler::GemHelper do end context "succeeds" do + let(:repo) { build_git("foo", :bare => true) } + before do - Dir.chdir(gem_repo1) { `git init --bare` } Dir.chdir(app_path) do - `git remote add origin file://#{gem_repo1}` - `git commit -a -m "initial commit"` + sys_exec("git remote add origin file://#{repo.path}") + sys_exec('git commit -a -m "initial commit"') end end diff --git a/spec/bundler/bundler/installer/gem_installer_spec.rb b/spec/bundler/bundler/installer/gem_installer_spec.rb index 7340a3acc0..8f8d1c6d15 100644 --- a/spec/bundler/bundler/installer/gem_installer_spec.rb +++ b/spec/bundler/bundler/installer/gem_installer_spec.rb @@ -10,14 +10,14 @@ RSpec.describe Bundler::GemInstaller do subject { described_class.new(spec, installer) } context "spec_settings is nil" do - it "invokes install method with empty build_args", :rubygems => ">= 2" do + it "invokes install method with empty build_args" do allow(spec_source).to receive(:install).with(spec, :force => false, :ensure_builtin_gems_cached => false, :build_args => []) subject.install_from_spec end end context "spec_settings is build option" do - it "invokes install method with build_args", :rubygems => ">= 2" do + it "invokes install method with build_args" do allow(Bundler.settings).to receive(:[]).with(:bin) allow(Bundler.settings).to receive(:[]).with(:inline) allow(Bundler.settings).to receive(:[]).with(:forget_cli_options) @@ -26,4 +26,15 @@ RSpec.describe Bundler::GemInstaller do subject.install_from_spec end end + + context "spec_settings is build option with spaces" do + it "invokes install method with build_args" do + allow(Bundler.settings).to receive(:[]).with(:bin) + allow(Bundler.settings).to receive(:[]).with(:inline) + allow(Bundler.settings).to receive(:[]).with(:forget_cli_options) + allow(Bundler.settings).to receive(:[]).with("build.dummy").and_return("--with-dummy-config=dummy --with-another-dummy-config") + expect(spec_source).to receive(:install).with(spec, :force => false, :ensure_builtin_gems_cached => false, :build_args => ["--with-dummy-config=dummy", "--with-another-dummy-config"]) + subject.install_from_spec + end + end end diff --git a/spec/bundler/bundler/mirror_spec.rb b/spec/bundler/bundler/mirror_spec.rb index acd0895f2f..fb476b8465 100644 --- a/spec/bundler/bundler/mirror_spec.rb +++ b/spec/bundler/bundler/mirror_spec.rb @@ -298,8 +298,8 @@ RSpec.describe Bundler::Settings::TCPSocketProbe do context "with a listening TCP Server" do def with_server_and_mirror - server = TCPServer.new("127.0.0.1", 0) - mirror = Bundler::Settings::Mirror.new("http://localhost:#{server.addr[1]}", 1) + server = TCPServer.new("0.0.0.0", 0) + mirror = Bundler::Settings::Mirror.new("http://0.0.0.0:#{server.addr[1]}", 1) yield server, mirror server.close unless server.closed? end diff --git a/spec/bundler/bundler/plugin/index_spec.rb b/spec/bundler/bundler/plugin/index_spec.rb index ca3476ea2a..e18e960fb8 100644 --- a/spec/bundler/bundler/plugin/index_spec.rb +++ b/spec/bundler/bundler/plugin/index_spec.rb @@ -86,6 +86,17 @@ RSpec.describe Bundler::Plugin::Index do expect(new_index.hook_plugins("after-bar")).to eq([plugin_name]) end + it "only registers a gem once for an event" do + path = lib_path(plugin_name) + index.register_plugin(plugin_name, + path.to_s, + [path.join("lib").to_s], + commands, + sources, + hooks + hooks) + expect(index.hook_plugins("after-bar")).to eq([plugin_name]) + end + context "that are not registered", :focused do let(:file) { double("index-file") } diff --git a/spec/bundler/bundler/plugin/installer_spec.rb b/spec/bundler/bundler/plugin/installer_spec.rb index f8bf8450c9..71fef76042 100644 --- a/spec/bundler/bundler/plugin/installer_spec.rb +++ b/spec/bundler/bundler/plugin/installer_spec.rb @@ -3,10 +3,6 @@ RSpec.describe Bundler::Plugin::Installer do subject(:installer) { Bundler::Plugin::Installer.new } - before do - # allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(Pathname.new("/Gemfile")) - end - describe "cli install" do it "uses Gem.sources when non of the source is provided" do sources = double(:sources) @@ -29,6 +25,14 @@ RSpec.describe Bundler::Plugin::Installer do to eq("new-plugin" => spec) end + it "returns the installed spec after installing local git plugins" do + allow(installer).to receive(:install_local_git). + and_return("new-plugin" => spec) + + expect(installer.install(["new-plugin"], :local_git => "/phony/path/repo")). + to eq("new-plugin" => spec) + end + it "returns the installed spec after installing rubygems plugins" do allow(installer).to receive(:install_rubygems). and_return("new-plugin" => spec) @@ -69,6 +73,29 @@ RSpec.describe Bundler::Plugin::Installer do end end + context "local git plugins" do + before do + build_git "ga-plugin", :path => lib_path("ga-plugin") do |s| + s.write "plugins.rb" + end + end + + let(:result) do + installer.install(["ga-plugin"], :local_git => lib_path("ga-plugin").to_s) + end + + it "returns the installed spec after installing" do + spec = result["ga-plugin"] + expect(spec.full_name).to eq "ga-plugin-1.0" + end + + it "has expected full gem path" do + rev = revision_for(lib_path("ga-plugin")) + expect(result["ga-plugin"].full_gem_path). + to eq(Bundler::Plugin.root.join("bundler", "gems", "ga-plugin-#{rev[0..11]}").to_s) + end + end + context "rubygems plugins" do let(:result) do installer.install(["re-plugin"], :source => "file://#{gem_repo2}") diff --git a/spec/bundler/bundler/plugin_spec.rb b/spec/bundler/bundler/plugin_spec.rb index 9266fad1eb..eaa0b80905 100644 --- a/spec/bundler/bundler/plugin_spec.rb +++ b/spec/bundler/bundler/plugin_spec.rb @@ -32,6 +32,29 @@ RSpec.describe Bundler::Plugin do allow(index).to receive(:register_plugin) end + describe "list command" do + context "when no plugins are installed" do + before { allow(index).to receive(:installed_plugins) { [] } } + it "outputs no plugins installed" do + expect(Bundler.ui).to receive(:info).with("No plugins installed") + subject.list + end + end + + context "with installed plugins" do + before do + allow(index).to receive(:installed_plugins) { %w[plug1 plug2] } + allow(index).to receive(:plugin_commands).with("plug1") { %w[c11 c12] } + allow(index).to receive(:plugin_commands).with("plug2") { %w[c21 c22] } + end + it "list plugins followed by commands" do + expected_output = "plug1\n-----\n c11\n c12\n\nplug2\n-----\n c21\n c22\n\n" + expect(Bundler.ui).to receive(:info).with(expected_output) + subject.list + end + end + end + describe "install command" do let(:opts) { { "version" => "~> 1.0", "source" => "foo" } } diff --git a/spec/bundler/bundler/rubygems_integration_spec.rb b/spec/bundler/bundler/rubygems_integration_spec.rb index b1b15d9e5d..26cbaa630b 100644 --- a/spec/bundler/bundler/rubygems_integration_spec.rb +++ b/spec/bundler/bundler/rubygems_integration_spec.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true RSpec.describe Bundler::RubygemsIntegration do - it "uses the same chdir lock as rubygems", :rubygems => "2.1" do + it "uses the same chdir lock as rubygems" do expect(Bundler.rubygems.ext_lock).to eq(Gem::Ext::Builder::CHDIR_MONITOR) end @@ -15,30 +15,18 @@ RSpec.describe Bundler::RubygemsIntegration do end subject { Bundler.rubygems.validate(spec) } - it "skips overly-strict gemspec validation", :rubygems => "< 1.7" do - expect(spec).to_not receive(:validate) - subject - end - - it "validates with packaging mode disabled", :rubygems => "1.7" do + it "validates with packaging mode disabled" do expect(spec).to receive(:validate).with(false) subject end - it "should set a summary to avoid an overly-strict error", :rubygems => "~> 1.7.0" do - spec.summary = nil - expect { subject }.not_to raise_error - expect(spec.summary).to eq("") - end - context "with an invalid spec" do before do expect(spec).to receive(:validate).with(false). and_raise(Gem::InvalidSpecificationException.new("TODO is not an author")) end - it "should raise a Gem::InvalidSpecificationException and produce a helpful warning message", - :rubygems => "1.7" do + it "should raise a Gem::InvalidSpecificationException and produce a helpful warning message" do expect { subject }.to raise_error(Gem::InvalidSpecificationException, "The gemspec at #{__FILE__} is not valid. "\ "Please fix this gemspec.\nThe validation error was 'TODO is not an author'\n") @@ -53,7 +41,7 @@ RSpec.describe Bundler::RubygemsIntegration do end end - describe "#download_gem", :rubygems => ">= 2.0" do + describe "#download_gem" do let(:bundler_retry) { double(Bundler::Retry) } let(:retry) { double("Bundler::Retry") } let(:uri) { URI.parse("https://foo.bar") } @@ -78,7 +66,7 @@ RSpec.describe Bundler::RubygemsIntegration do end end - describe "#fetch_all_remote_specs", :rubygems => ">= 2.0" do + describe "#fetch_all_remote_specs" do let(:uri) { URI("https://example.com") } let(:fetcher) { double("gem_remote_fetcher") } let(:specs_response) { Marshal.dump(["specs"]) } diff --git a/spec/bundler/bundler/settings_spec.rb b/spec/bundler/bundler/settings_spec.rb index 1a31493e20..339428eb48 100644 --- a/spec/bundler/bundler/settings_spec.rb +++ b/spec/bundler/bundler/settings_spec.rb @@ -130,13 +130,15 @@ that would suck --ehhh=oh geez it looks like i might have broken bundler somehow describe "#temporary" do it "reset after used" do - Bundler.settings.set_local :no_install, true + Bundler.settings.set_command_option :no_install, true Bundler.settings.temporary(:no_install => false) do expect(Bundler.settings[:no_install]).to eq false end expect(Bundler.settings[:no_install]).to eq true + + Bundler.settings.set_command_option :no_install, nil end it "returns the return value of the block" do diff --git a/spec/bundler/bundler/shared_helpers_spec.rb b/spec/bundler/bundler/shared_helpers_spec.rb index fcac37b398..f42d9ed485 100644 --- a/spec/bundler/bundler/shared_helpers_spec.rb +++ b/spec/bundler/bundler/shared_helpers_spec.rb @@ -14,7 +14,7 @@ RSpec.describe Bundler::SharedHelpers do before { ENV["BUNDLE_GEMFILE"] = "/path/Gemfile" } context "Gemfile is present" do - let(:expected_gemfile_path) { Pathname.new("/path/Gemfile") } + let(:expected_gemfile_path) { Pathname.new("/path/Gemfile").expand_path } it "returns the Gemfile path" do expect(subject.default_gemfile).to eq(expected_gemfile_path) @@ -288,7 +288,7 @@ RSpec.describe Bundler::SharedHelpers do ) end - context "with a jruby path_separator regex", :ruby => "1.9" do + context "with a jruby path_separator regex" do # In versions of jruby that supported ruby 1.8, the path separator was the standard File::PATH_SEPARATOR let(:regex) { Regexp.new("(?<!jar:file|jar|file|classpath|uri:classloader|uri|http|https):") } it "does not exit if bundle path is the standard uri path" do @@ -389,7 +389,7 @@ RSpec.describe Bundler::SharedHelpers do context "bundle executable in ENV['BUNDLE_BIN_PATH'] does not exist" do before { ENV["BUNDLE_BIN_PATH"] = "/does/not/exist" } - before { Bundler.rubygems.replace_bin_path [], [] } + before { Bundler.rubygems.replace_bin_path [] } it "sets BUNDLE_BIN_PATH to the bundle executable file" do subject.set_bundle_environment @@ -455,7 +455,7 @@ RSpec.describe Bundler::SharedHelpers do end end - context "system throws Errno::ENOTSUP", :ruby => "1.9" do + context "system throws Errno::ENOTSUP" do let(:file_op_block) { proc {|_path| raise Errno::ENOTSUP } } it "raises a OperationNotSupportedError" do diff --git a/spec/bundler/bundler/source/git/git_proxy_spec.rb b/spec/bundler/bundler/source/git/git_proxy_spec.rb index 3a29c97461..016105ccde 100644 --- a/spec/bundler/bundler/source/git/git_proxy_spec.rb +++ b/spec/bundler/bundler/source/git/git_proxy_spec.rb @@ -10,29 +10,33 @@ RSpec.describe Bundler::Source::Git::GitProxy do context "with configured credentials" do it "adds username and password to URI" do - Bundler.settings.temporary(uri => "u:p") - expect(subject).to receive(:git_retry).with(match("https://u:[email protected]/bundler/bundler.git")) - subject.checkout + Bundler.settings.temporary(uri => "u:p") do + expect(subject).to receive(:git_retry).with(match("https://u:[email protected]/bundler/bundler.git")) + subject.checkout + end end it "adds username and password to URI for host" do - Bundler.settings.temporary("github.com" => "u:p") - expect(subject).to receive(:git_retry).with(match("https://u:[email protected]/bundler/bundler.git")) - subject.checkout + Bundler.settings.temporary("github.com" => "u:p") do + expect(subject).to receive(:git_retry).with(match("https://u:[email protected]/bundler/bundler.git")) + subject.checkout + end end it "does not add username and password to mismatched URI" do - Bundler.settings.temporary("https://u:[email protected]/bundler/bundler-mismatch.git" => "u:p") - expect(subject).to receive(:git_retry).with(match(uri)) - subject.checkout + Bundler.settings.temporary("https://u:[email protected]/bundler/bundler-mismatch.git" => "u:p") do + expect(subject).to receive(:git_retry).with(match(uri)) + subject.checkout + end end it "keeps original userinfo" do - Bundler.settings.temporary("github.com" => "u:p") - original = "https://orig:[email protected]/bundler/bundler.git" - subject = described_class.new(Pathname("path"), original, "HEAD") - expect(subject).to receive(:git_retry).with(match(original)) - subject.checkout + Bundler.settings.temporary("github.com" => "u:p") do + original = "https://orig:[email protected]/bundler/bundler.git" + subject = described_class.new(Pathname("path"), original, "HEAD") + expect(subject).to receive(:git_retry).with(match(original)) + subject.checkout + end end end diff --git a/spec/bundler/bundler/source/rubygems/remote_spec.rb b/spec/bundler/bundler/source/rubygems/remote_spec.rb index 9a7ab42128..52fb4e7f1c 100644 --- a/spec/bundler/bundler/source/rubygems/remote_spec.rb +++ b/spec/bundler/bundler/source/rubygems/remote_spec.rb @@ -22,8 +22,9 @@ RSpec.describe Bundler::Source::Rubygems::Remote do end it "applies configured credentials" do - Bundler.settings.temporary(uri_no_auth.to_s => credentials) - expect(remote(uri_no_auth).uri).to eq(uri_with_auth) + Bundler.settings.temporary(uri_no_auth.to_s => credentials) do + expect(remote(uri_no_auth).uri).to eq(uri_with_auth) + end end end @@ -33,8 +34,9 @@ RSpec.describe Bundler::Source::Rubygems::Remote do end it "does not apply given credentials" do - Bundler.settings.temporary(uri_no_auth.to_s => credentials) - expect(remote(uri_no_auth).anonymized_uri).to eq(uri_no_auth) + Bundler.settings.temporary(uri_no_auth.to_s => credentials) do + expect(remote(uri_no_auth).anonymized_uri).to eq(uri_no_auth) + end end end @@ -44,8 +46,9 @@ RSpec.describe Bundler::Source::Rubygems::Remote do end it "only applies the given user" do - Bundler.settings.temporary(uri_no_auth.to_s => credentials) - expect(remote(uri_no_auth).cache_slug).to eq("gems.example.com.username.443.MD5HEX(gems.example.com.username.443./)") + Bundler.settings.temporary(uri_no_auth.to_s => credentials) do + expect(remote(uri_no_auth).cache_slug).to eq("gems.example.com.username.443.MD5HEX(gems.example.com.username.443./)") + end end end end @@ -106,7 +109,9 @@ RSpec.describe Bundler::Source::Rubygems::Remote do let(:mirror_uri_with_auth) { URI("https://username:[email protected]/") } let(:mirror_uri_no_auth) { URI("https://rubygems-mirror.org/") } - before { Bundler.settings.set_local("mirror.https://rubygems.org/", mirror_uri_with_auth.to_s) } + before { Bundler.settings.temporary("mirror.https://rubygems.org/" => mirror_uri_with_auth.to_s) } + + after { Bundler.settings.temporary("mirror.https://rubygems.org/" => nil) } specify "#uri returns the mirror URI with credentials" do expect(remote(uri).uri).to eq(mirror_uri_with_auth) @@ -135,6 +140,11 @@ RSpec.describe Bundler::Source::Rubygems::Remote do Bundler.settings.temporary(mirror_uri_no_auth.to_s => credentials) end + after do + Bundler.settings.temporary("mirror.https://rubygems.org/" => nil) + Bundler.settings.temporary(mirror_uri_no_auth.to_s => nil) + end + specify "#uri returns the mirror URI with credentials" do expect(remote(uri).uri).to eq(mirror_uri_with_auth) end diff --git a/spec/bundler/bundler/source_list_spec.rb b/spec/bundler/bundler/source_list_spec.rb index 541a46c6d0..a78b80ec3b 100644 --- a/spec/bundler/bundler/source_list_spec.rb +++ b/spec/bundler/bundler/source_list_spec.rb @@ -75,7 +75,7 @@ RSpec.describe Bundler::SourceList do let(:msg) do "The git source `git://existing-git.org/path.git` " \ "uses the `git` protocol, which transmits data without encryption. " \ - "Disable this warning with `bundle config git.allow_insecure true`, " \ + "Disable this warning with `bundle config set git.allow_insecure true`, " \ "or switch to the `https` protocol to keep your data secure." end @@ -393,19 +393,19 @@ RSpec.describe Bundler::SourceList do it "returns all sources, without combining rubygems sources", :bundler => "3" do expect(source_list.lock_sources).to eq [ - Bundler::Source::Rubygems.new, - Bundler::Source::Rubygems.new("remotes" => ["https://duplicate-rubygems.org"]), - Bundler::Source::Rubygems.new("remotes" => ["https://first-rubygems.org"]), - Bundler::Source::Rubygems.new("remotes" => ["https://second-rubygems.org"]), - Bundler::Source::Rubygems.new("remotes" => ["https://third-rubygems.org"]), Bundler::Source::Git.new("uri" => "git://first-git.org/path.git"), Bundler::Source::Git.new("uri" => "git://second-git.org/path.git"), Bundler::Source::Git.new("uri" => "git://third-git.org/path.git"), + ASourcePlugin.new("uri" => "https://second-plugin.org/random"), + ASourcePlugin.new("uri" => "https://third-bar.org/foo"), Bundler::Source::Path.new("path" => "/first/path/to/gem"), Bundler::Source::Path.new("path" => "/second/path/to/gem"), Bundler::Source::Path.new("path" => "/third/path/to/gem"), - ASourcePlugin.new("uri" => "https://second-plugin.org/random"), - ASourcePlugin.new("uri" => "https://third-bar.org/foo"), + Bundler::Source::Rubygems.new, + Bundler::Source::Rubygems.new("remotes" => ["https://duplicate-rubygems.org"]), + Bundler::Source::Rubygems.new("remotes" => ["https://first-rubygems.org"]), + Bundler::Source::Rubygems.new("remotes" => ["https://second-rubygems.org"]), + Bundler::Source::Rubygems.new("remotes" => ["https://third-rubygems.org"]), ] end end diff --git a/spec/bundler/bundler/ssl_certs/certificate_manager_spec.rb b/spec/bundler/bundler/ssl_certs/certificate_manager_spec.rb deleted file mode 100644 index 56606a830f..0000000000 --- a/spec/bundler/bundler/ssl_certs/certificate_manager_spec.rb +++ /dev/null @@ -1,140 +0,0 @@ -# frozen_string_literal: true - -require "bundler/ssl_certs/certificate_manager" - -RSpec.describe Bundler::SSLCerts::CertificateManager do - let(:rubygems_path) { root } - let(:stub_cert) { File.join(root.to_s, "lib", "rubygems", "ssl_certs", "rubygems.org", "ssl-cert.pem") } - let(:rubygems_certs_dir) { File.join(root.to_s, "lib", "rubygems", "ssl_certs", "rubygems.org") } - - subject { described_class.new(rubygems_path) } - - # Pretend bundler root is rubygems root - before do - # Backing up rubygems ceriticates - FileUtils.mv(rubygems_certs_dir, rubygems_certs_dir + ".back") if ruby_core? - - FileUtils.mkdir_p(rubygems_certs_dir) - FileUtils.touch(stub_cert) - end - - after do - FileUtils.rm_rf(rubygems_certs_dir) - - # Restore rubygems certificates - FileUtils.mv(rubygems_certs_dir + ".back", rubygems_certs_dir) if ruby_core? - end - - describe "#update_from" do - let(:cert_manager) { double(:cert_manager) } - - before { allow(described_class).to receive(:new).with(rubygems_path).and_return(cert_manager) } - - it "should update the certs through a new certificate manager" do - allow(cert_manager).to receive(:update!) - expect(described_class.update_from!(rubygems_path)).to be_nil - end - end - - describe "#initialize" do - it "should set bundler_cert_path as path of the subdir with bundler ssl certs" do - expect(subject.bundler_cert_path).to eq(File.join(root, "lib/bundler/ssl_certs")) - end - - it "should set bundler_certs as the paths of the bundler ssl certs" do - expect(subject.bundler_certs).to include(File.join(root, "lib/bundler/ssl_certs/rubygems.global.ssl.fastly.net/DigiCertHighAssuranceEVRootCA.pem")) - expect(subject.bundler_certs).to include(File.join(root, "lib/bundler/ssl_certs/index.rubygems.org/GlobalSignRootCA.pem")) - end - - context "when rubygems_path is not nil" do - it "should set rubygems_certs" do - expect(subject.rubygems_certs).to include(File.join(root, "lib", "rubygems", "ssl_certs", "rubygems.org", "ssl-cert.pem")) - end - end - end - - describe "#up_to_date?" do - context "when bundler certs and rubygems certs are the same" do - before do - bundler_certs = Dir[File.join(root.to_s, "lib", "bundler", "ssl_certs", "**", "*.pem")] - FileUtils.rm(stub_cert) - FileUtils.cp(bundler_certs, rubygems_certs_dir) - end - - it "should return true" do - expect(subject).to be_up_to_date - end - end - - context "when bundler certs and rubygems certs are not the same" do - it "should return false" do - expect(subject).to_not be_up_to_date - end - end - end - - describe "#update!" do - context "when certificate manager is not up to date" do - before do - allow(subject).to receive(:up_to_date?).and_return(false) - allow(bundler_fileutils).to receive(:rm) - allow(bundler_fileutils).to receive(:cp) - end - - it "should remove the current bundler certs" do - expect(bundler_fileutils).to receive(:rm).with(subject.bundler_certs) - subject.update! - end - - it "should copy the rubygems certs into bundler certs" do - expect(bundler_fileutils).to receive(:cp).with(subject.rubygems_certs, subject.bundler_cert_path) - subject.update! - end - - it "should return nil" do - expect(subject.update!).to be_nil - end - end - - context "when certificate manager is up to date" do - before { allow(subject).to receive(:up_to_date?).and_return(true) } - - it "should return nil" do - expect(subject.update!).to be_nil - end - end - end - - describe "#connect_to" do - let(:host) { "http://www.host.com" } - let(:http) { Net::HTTP.new(host, 443) } - let(:cert_store) { OpenSSL::X509::Store.new } - let(:http_header_response) { double(:http_header_response) } - - before do - allow(Net::HTTP).to receive(:new).with(host, 443).and_return(http) - allow(OpenSSL::X509::Store).to receive(:new).and_return(cert_store) - allow(http).to receive(:head).with("/").and_return(http_header_response) - end - - it "should use ssl for the http request" do - expect(http).to receive(:use_ssl=).with(true) - subject.connect_to(host) - end - - it "use verify peer mode" do - expect(http).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER) - subject.connect_to(host) - end - - it "set its cert store as a OpenSSL::X509::Store populated with bundler certs" do - expect(cert_store).to receive(:add_file).at_least(:once) - expect(http).to receive(:cert_store=).with(cert_store) - subject.connect_to(host) - end - - it "return the headers of the request response" do - expect(subject.connect_to(host)).to eq(http_header_response) - end - end -end diff --git a/spec/bundler/bundler/stub_specification_spec.rb b/spec/bundler/bundler/stub_specification_spec.rb index 5521d83769..7495b5d661 100644 --- a/spec/bundler/bundler/stub_specification_spec.rb +++ b/spec/bundler/bundler/stub_specification_spec.rb @@ -13,12 +13,10 @@ RSpec.describe Bundler::StubSpecification do described_class.from_stub(gemspec) end - if Bundler.rubygems.provides?(">= 2.1") - describe "#from_stub" do - it "returns the same stub if already a Bundler::StubSpecification" do - stub = described_class.from_stub(with_bundler_stub_spec) - expect(stub).to be(with_bundler_stub_spec) - end + describe "#from_stub" do + it "returns the same stub if already a Bundler::StubSpecification" do + stub = described_class.from_stub(with_bundler_stub_spec) + expect(stub).to be(with_bundler_stub_spec) end end end diff --git a/spec/bundler/bundler/ui/shell_spec.rb b/spec/bundler/bundler/ui/shell_spec.rb index 951a446aff..23a7670dd1 100644 --- a/spec/bundler/bundler/ui/shell_spec.rb +++ b/spec/bundler/bundler/ui/shell_spec.rb @@ -21,11 +21,7 @@ RSpec.describe Bundler::UI::Shell do describe "#warn" do before { subject.level = "warn" } - it "prints to stdout", :bundler => "< 2" do - expect { subject.warn("warning") }.to output("warning\n").to_stdout - end - - it "prints to stderr", :bundler => "2" do + it "prints to stderr" do expect { subject.warn("warning") }.to output("warning\n").to_stderr end @@ -46,11 +42,7 @@ RSpec.describe Bundler::UI::Shell do describe "#error" do before { subject.level = "error" } - it "prints to stdout", :bundler => "< 2" do - expect { subject.error("error!!!") }.to output("error!!!\n").to_stdout - end - - it "prints to stderr", :bundler => "2" do + it "prints to stderr" do expect { subject.error("error!!!") }.to output("error!!!\n").to_stderr end diff --git a/spec/bundler/bundler/ui_spec.rb b/spec/bundler/bundler/ui_spec.rb index 6ef8729277..6df0d2e290 100644 --- a/spec/bundler/bundler/ui_spec.rb +++ b/spec/bundler/bundler/ui_spec.rb @@ -2,7 +2,7 @@ RSpec.describe Bundler::UI do describe Bundler::UI::Silent do - it "has the same instance methods as Shell", :ruby => ">= 1.9" do + it "has the same instance methods as Shell" do shell = Bundler::UI::Shell methods = proc do |cls| cls.instance_methods.map do |i| @@ -13,7 +13,7 @@ RSpec.describe Bundler::UI do expect(methods.call(described_class)).to eq(methods.call(shell)) end - it "has the same instance class as Shell", :ruby => ">= 1.9" do + it "has the same instance class as Shell" do shell = Bundler::UI::Shell methods = proc do |cls| cls.methods.map do |i| diff --git a/spec/bundler/bundler/vendored_persistent_spec.rb b/spec/bundler/bundler/vendored_persistent_spec.rb index 338431c4a6..c760c067e0 100644 --- a/spec/bundler/bundler/vendored_persistent_spec.rb +++ b/spec/bundler/bundler/vendored_persistent_spec.rb @@ -1,6 +1,5 @@ # frozen_string_literal: true -require "spec_helper" require "bundler/vendored_persistent" RSpec.describe Bundler::PersistentHTTP do @@ -13,7 +12,7 @@ RSpec.describe Bundler::PersistentHTTP do before do allow(connection).to receive(:use_ssl?).and_return(!tls_version.nil?) - allow(socket).to receive(:io).and_return(socket_io) + allow(socket).to receive(:io).and_return(socket_io) if socket connection.instance_variable_set(:@socket, socket) if tls_version diff --git a/spec/bundler/bundler/version_ranges_spec.rb b/spec/bundler/bundler/version_ranges_spec.rb index ccbb9285d5..bca044b0c0 100644 --- a/spec/bundler/bundler/version_ranges_spec.rb +++ b/spec/bundler/bundler/version_ranges_spec.rb @@ -25,9 +25,12 @@ RSpec.describe Bundler::VersionRanges do include_examples "empty?", false, ">= 1.0.0", "< 2.0.0" include_examples "empty?", false, "~> 1" include_examples "empty?", false, "~> 2.0", "~> 2.1" + include_examples "empty?", true, ">= 4.1.0", "< 5.0", "= 5.2.1" + include_examples "empty?", true, "< 5.0", "< 5.3", "< 6.0", "< 6", "= 5.2.0", "> 2", ">= 3.0", ">= 3.1", ">= 3.2", ">= 4.0.0", ">= 4.1.0", ">= 4.2.0", ">= 4.2", ">= 4" include_examples "empty?", true, "!= 1", "< 2", "> 2" include_examples "empty?", true, "!= 1", "<= 1", ">= 1" include_examples "empty?", true, "< 2", "> 2" + include_examples "empty?", true, "< 2", "> 2", "= 2" include_examples "empty?", true, "= 1", "!= 1" include_examples "empty?", true, "= 1", "= 2" include_examples "empty?", true, "= 1", "~> 2" diff --git a/spec/bundler/cache/cache_path_spec.rb b/spec/bundler/cache/cache_path_spec.rb index 69d3809964..a4572af11e 100644 --- a/spec/bundler/cache/cache_path_spec.rb +++ b/spec/bundler/cache/cache_path_spec.rb @@ -17,7 +17,7 @@ RSpec.describe "bundle package" do context "with config cache_path" do it "caches gems at given path" do - bundle "config cache_path vendor/cache-foo" + bundle "config set cache_path vendor/cache-foo" bundle :package expect(bundled_app("vendor/cache-foo/rack-1.0.0.gem")).to exist end diff --git a/spec/bundler/cache/gems_spec.rb b/spec/bundler/cache/gems_spec.rb index 4a0b953830..4fc43a50a0 100644 --- a/spec/bundler/cache/gems_spec.rb +++ b/spec/bundler/cache/gems_spec.rb @@ -74,16 +74,16 @@ RSpec.describe "bundle cache" do end context "using system gems" do - before { bundle! "config path.system true" } + before { bundle! "config set path.system true" } it_behaves_like "when there are only gemsources" end context "installing into a local path" do - before { bundle! "config path ./.bundle" } + before { bundle! "config set path ./.bundle" } it_behaves_like "when there are only gemsources" end - describe "when there is a built-in gem", :ruby => "2.0" do + describe "when there is a built-in gem" do before :each do build_repo2 do build_gem "builtin_gem", "1.0.2" @@ -97,7 +97,7 @@ RSpec.describe "bundle cache" do end it "uses builtin gems when installing to system gems" do - bundle! "config path.system true" + bundle! "config set path.system true" install_gemfile %(gem 'builtin_gem', '1.0.2') expect(the_bundle).to include_gems("builtin_gem 1.0.2") end @@ -129,7 +129,7 @@ RSpec.describe "bundle cache" do end it "errors if the builtin gem isn't available to cache" do - bundle! "config path.system true" + bundle! "config set path.system true" install_gemfile <<-G gem 'builtin_gem', '1.0.2' @@ -137,7 +137,7 @@ RSpec.describe "bundle cache" do bundle :cache expect(exitstatus).to_not eq(0) if exitstatus - expect(out).to include("builtin_gem-1.0.2 is built in to Ruby, and can't be cached") + expect(err).to include("builtin_gem-1.0.2 is built in to Ruby, and can't be cached") end end @@ -196,7 +196,7 @@ RSpec.describe "bundle cache" do it "adds and removes when gems are updated" do update_repo2 - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(cached_gem("rack-1.2")).to exist expect(cached_gem("rack-1.0.0")).not_to exist end diff --git a/spec/bundler/cache/git_spec.rb b/spec/bundler/cache/git_spec.rb index 33387dbbb2..55a24ff118 100644 --- a/spec/bundler/cache/git_spec.rb +++ b/spec/bundler/cache/git_spec.rb @@ -81,7 +81,7 @@ end ref = git.ref_for("master", 11) expect(ref).not_to eq(old_ref) - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true bundle! "#{cmd}", forgotten_command_line_options([:all, :cache_all] => true) expect(bundled_app("vendor/cache/foo-1.0-#{ref}")).to exist @@ -127,7 +127,7 @@ end gem "foo", :git => '#{lib_path("foo-invalid")}', :branch => :master G - bundle %(config local.foo #{lib_path("foo-1.0")}) + bundle %(config set local.foo #{lib_path("foo-1.0")}) bundle "install" bundle "#{cmd}", forgotten_command_line_options([:all, :cache_all] => true) @@ -168,7 +168,7 @@ end expect(the_bundle).to include_gems "has_submodule 1.0" end - it "displays warning message when detecting git repo in Gemfile", :bundler => "< 2" do + it "displays warning message when detecting git repo in Gemfile", :bundler => "< 3" do build_git "foo" install_gemfile <<-G @@ -177,7 +177,7 @@ end bundle "#{cmd}" - expect(out).to include("Your Gemfile contains path and git dependencies.") + expect(err).to include("Your Gemfile contains path and git dependencies.") end it "does not display warning message if cache_all is set in bundle config" do @@ -190,7 +190,7 @@ end bundle cmd, forgotten_command_line_options([:all, :cache_all] => true) bundle cmd - expect(out).not_to include("Your Gemfile contains path and git dependencies.") + expect(err).not_to include("Your Gemfile contains path and git dependencies.") end it "caches pre-evaluated gemspecs" do diff --git a/spec/bundler/cache/path_spec.rb b/spec/bundler/cache/path_spec.rb index 12be2dbcf8..0d7b154a37 100644 --- a/spec/bundler/cache/path_spec.rb +++ b/spec/bundler/cache/path_spec.rb @@ -94,7 +94,7 @@ G bundle cmd - expect(out).to match(/please pass the \-\-all flag/) + expect(err).to match(/please pass the \-\-all flag/) expect(bundled_app("vendor/cache/foo-1.0")).not_to exist end diff --git a/spec/bundler/cache/platform_spec.rb b/spec/bundler/cache/platform_spec.rb index c0622a3c94..b3c4643ef5 100644 --- a/spec/bundler/cache/platform_spec.rb +++ b/spec/bundler/cache/platform_spec.rb @@ -41,7 +41,7 @@ RSpec.describe "bundle cache with multiple platforms" do end it "ensures that a successful bundle update does not delete gems for other platforms" do - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true expect(bundled_app("vendor/cache/rack-1.0.0.gem")).to exist expect(bundled_app("vendor/cache/activesupport-2.3.5.gem")).to exist diff --git a/spec/bundler/commands/add_spec.rb b/spec/bundler/commands/add_spec.rb index 9f11adbcf8..dac1d0f6b9 100644 --- a/spec/bundler/commands/add_spec.rb +++ b/spec/bundler/commands/add_spec.rb @@ -106,23 +106,23 @@ RSpec.describe "bundle add" do it "shows error message when version is not formatted correctly" do bundle "add 'foo' -v='~>1 . 0'" - expect(out).to match("Invalid gem requirement pattern '~>1 . 0'") + expect(err).to match("Invalid gem requirement pattern '~>1 . 0'") end it "shows error message when gem cannot be found" do bundle "add 'werk_it'" - expect(out).to match("Could not find gem 'werk_it' in") + expect(err).to match("Could not find gem 'werk_it' in") bundle "add 'werk_it' -s='file://#{gem_repo2}'" - expect(out).to match("Could not find gem 'werk_it' in rubygems repository") + expect(err).to match("Could not find gem 'werk_it' in rubygems repository") end it "shows error message when source cannot be reached" do bundle "add 'baz' --source='http://badhostasdf'" - expect(out).to include("Could not reach host badhostasdf. Check your network connection and try again.") + expect(err).to include("Could not reach host badhostasdf. Check your network connection and try again.") bundle "add 'baz' --source='file://does/not/exist'" - expect(out).to include("Could not fetch specs from file://does/not/exist/") + expect(err).to include("Could not fetch specs from file://does/not/exist/") end describe "with --optimistic" do @@ -153,7 +153,7 @@ RSpec.describe "bundle add" do it "throws error" do bundle "add 'foo' --strict --optimistic" - expect(out).to include("You can not specify `--strict` and `--optimistic` at the same time") + expect(err).to include("You can not specify `--strict` and `--optimistic` at the same time") end end @@ -168,8 +168,8 @@ RSpec.describe "bundle add" do it "throws error if any of the specified gems are present in the gemfile with different version" do bundle "add weakling bar" - expect(out).to include("You cannot specify the same gem twice with different version requirements") - expect(out).to include("You specified: weakling (~> 0.0.1) and weakling (>= 0).") + expect(err).to include("You cannot specify the same gem twice with different version requirements") + expect(err).to include("You specified: weakling (~> 0.0.1) and weakling (>= 0).") end end @@ -182,8 +182,8 @@ RSpec.describe "bundle add" do bundle "add 'rack' --version=1.1" - expect(out).to include("You cannot specify the same gem twice with different version requirements") - expect(out).to include("If you want to update the gem version, run `bundle update rack`. You may also need to change the version requirement specified in the Gemfile if it's too restrictive") + expect(err).to include("You cannot specify the same gem twice with different version requirements") + expect(err).to include("If you want to update the gem version, run `bundle update rack`. You may also need to change the version requirement specified in the Gemfile if it's too restrictive") end it "shows error when added without version requirements" do @@ -194,9 +194,9 @@ RSpec.describe "bundle add" do bundle "add 'rack'" - expect(out).to include("Gem already added.") - expect(out).to include("You cannot specify the same gem twice with different version requirements") - expect(out).not_to include("If you want to update the gem version, run `bundle update rack`. You may also need to change the version requirement specified in the Gemfile if it's too restrictive") + expect(err).to include("Gem already added.") + expect(err).to include("You cannot specify the same gem twice with different version requirements") + expect(err).not_to include("If you want to update the gem version, run `bundle update rack`. You may also need to change the version requirement specified in the Gemfile if it's too restrictive") end end @@ -209,9 +209,9 @@ RSpec.describe "bundle add" do bundle "add 'rack' --version=1.1" - expect(out).to include("You cannot specify the same gem twice with different version requirements") - expect(out).to include("If you want to update the gem version, run `bundle update rack`.") - expect(out).not_to include("You may also need to change the version requirement specified in the Gemfile if it's too restrictive") + expect(err).to include("You cannot specify the same gem twice with different version requirements") + expect(err).to include("If you want to update the gem version, run `bundle update rack`.") + expect(err).not_to include("You may also need to change the version requirement specified in the Gemfile if it's too restrictive") end end end diff --git a/spec/bundler/commands/binstubs_spec.rb b/spec/bundler/commands/binstubs_spec.rb index 7f2e81c099..3f62f17b45 100644 --- a/spec/bundler/commands/binstubs_spec.rb +++ b/spec/bundler/commands/binstubs_spec.rb @@ -59,7 +59,7 @@ RSpec.describe "bundle binstubs <gem>" do bundle "binstubs" expect(exitstatus).to eq(1) if exitstatus - expect(out).to include("`bundle binstubs` needs at least one gem to run.") + expect(err).to include("`bundle binstubs` needs at least one gem to run.") end it "displays an error when used with --all and gems" do @@ -124,54 +124,16 @@ RSpec.describe "bundle binstubs <gem>" do bundle! "binstubs bundler rack prints_loaded_gems" end - # When environment has a same version of bundler as default gems. - # `system_gems "bundler-x.y.z"` will detect system binstub. - # We need to avoid it by virtual version of bundler. - let(:system_bundler_version) { Gem::Version.new(Bundler::VERSION).bump.to_s } + let(:system_bundler_version) { Bundler::VERSION } - context "when system bundler was used" do - # Support master branch of bundler - if ENV["BUNDLER_SPEC_SUB_VERSION"] - let(:system_bundler_version) { Bundler::VERSION } - end - - before do - gemfile <<-G - source "file:///Users/colby/Projects/bundler/tmp/gems/remote2" - gem "rack" - gem "prints_loaded_gems" - G - - lockfile <<-G - GEM - remote: file:///Users/colby/Projects/bundler/tmp/gems/remote2/ - specs: - prints_loaded_gems (1.0) - rack (1.2) - - PLATFORMS - ruby - - DEPENDENCIES - prints_loaded_gems - rack - - BUNDLED WITH - #{system_bundler_version} - G - end - - it "runs bundler" do - sys_exec! "#{bundled_app("bin/bundle")} install" - expect(out).to eq %(system bundler #{system_bundler_version}\n["install"]) - end + it "runs bundler" do + sys_exec! "#{bundled_app("bin/bundle")} install" + expect(out).to eq %(system bundler #{system_bundler_version}\n["install"]) end context "when BUNDLER_VERSION is set" do - let(:system_bundler_version) { Bundler::VERSION } - it "runs the correct version of bundler" do - sys_exec "BUNDLER_VERSION='999.999.999' #{bundled_app("bin/bundle")} install" + 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:"). and include("To install the version of bundler this project requires, run `gem install bundler -v '999.999.999'`") @@ -179,8 +141,6 @@ RSpec.describe "bundle binstubs <gem>" do end context "when a lockfile exists with a locked bundler version" do - let(:system_bundler_version) { Bundler::VERSION } - it "runs the correct version of bundler when the version is newer" do lockfile lockfile.gsub(system_bundler_version, "999.999.999") sys_exec "#{bundled_app("bin/bundle")} install" @@ -236,13 +196,7 @@ RSpec.describe "bundle binstubs <gem>" do let(:system_bundler_version) { :bundler } it "loads all gems" do sys_exec! bundled_app("bin/print_loaded_gems").to_s - # RG < 2.0.14 didn't have a `Gem::Specification#default_gem?` - # This is dirty detection for old RG versions. - if File.dirname(Bundler.load.specs["bundler"][0].loaded_from) =~ %r{specifications/default} - expect(out).to eq %(["prints_loaded_gems-1.0", "rack-1.2"]) - else - expect(out).to eq %(["bundler-#{Bundler::VERSION}", "prints_loaded_gems-1.0", "rack-1.2"]) - end + expect(out).to eq %(["bundler-#{Bundler::VERSION}", "prints_loaded_gems-1.0", "rack-1.2"]) end context "when requesting a different bundler version" do @@ -324,7 +278,7 @@ RSpec.describe "bundle binstubs <gem>" do bundle "binstubs doesnt_exist" expect(exitstatus).to eq(7) if exitstatus - expect(out).to include("Could not find gem 'doesnt_exist'.") + expect(err).to include("Could not find gem 'doesnt_exist'.") end end @@ -396,8 +350,8 @@ RSpec.describe "bundle binstubs <gem>" do expect(bundled_app("bin/rackup")).to exist expect(File.read(bundled_app("bin/rackup"))).to eq("OMG") - expect(out).to include("Skipped rackup") - expect(out).to include("overwrite skipped stubs, use --force") + expect(err).to include("Skipped rackup") + expect(err).to include("overwrite skipped stubs, use --force") end context "when using --force" do @@ -428,8 +382,8 @@ RSpec.describe "bundle binstubs <gem>" do G bundle "binstubs rack-obama" - expect(out).to include("rack-obama has no executables") - expect(out).to include("rack has: rackup") + expect(err).to include("rack-obama has no executables") + expect(err).to include("rack has: rackup") end it "works if child gems don't have bins" do @@ -439,7 +393,7 @@ RSpec.describe "bundle binstubs <gem>" do G bundle "binstubs actionpack" - expect(out).to include("no executables for the gem actionpack") + expect(err).to include("no executables for the gem actionpack") end it "works if the gem has development dependencies" do @@ -449,7 +403,7 @@ RSpec.describe "bundle binstubs <gem>" do G bundle "binstubs with_development_dependency" - expect(out).to include("no executables for the gem with_development_dependency") + expect(err).to include("no executables for the gem with_development_dependency") end end @@ -460,7 +414,7 @@ RSpec.describe "bundle binstubs <gem>" do gem "rack" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle "binstubs rack" expect(out).to include("Installing rack 1.0.0") expect(the_bundle).to include_gems "rack 1.0.0" @@ -472,7 +426,7 @@ RSpec.describe "bundle binstubs <gem>" do gem "rack" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle "binstubs rack", :env => { "BUNDLE_INSTALL" => 1 } expect(out).not_to include("Installing rack 1.0.0") end diff --git a/spec/bundler/commands/check_spec.rb b/spec/bundler/commands/check_spec.rb index 890f4b1356..7114610644 100644 --- a/spec/bundler/commands/check_spec.rb +++ b/spec/bundler/commands/check_spec.rb @@ -58,7 +58,7 @@ RSpec.describe "bundle check" do G bundle :check - expect(out).to include("Bundler can't satisfy your Gemfile's dependencies.") + expect(err).to include("Bundler can't satisfy your Gemfile's dependencies.") end it "prints a generic error if a Gemfile.lock does not exist and a toplevel dependency does not exist" do @@ -69,7 +69,7 @@ RSpec.describe "bundle check" do bundle :check expect(exitstatus).to be > 0 if exitstatus - expect(out).to include("Bundler can't satisfy your Gemfile's dependencies.") + expect(err).to include("Bundler can't satisfy your Gemfile's dependencies.") end it "prints a generic message if you changed your lockfile" do @@ -89,7 +89,7 @@ RSpec.describe "bundle check" do G bundle :check - expect(out).to include("Bundler can't satisfy your Gemfile's dependencies.") + expect(err).to include("Bundler can't satisfy your Gemfile's dependencies.") end it "remembers --without option from install", :bundler => "< 3" do @@ -106,7 +106,7 @@ RSpec.describe "bundle check" do end it "uses the without setting" do - bundle! "config without foo" + bundle! "config set without foo" install_gemfile! <<-G source "file://#{gem_repo1}" group :foo do @@ -132,7 +132,7 @@ RSpec.describe "bundle check" do G bundle "check" - expect(out).to include("* rack (1.0.0)") + expect(err).to include("* rack (1.0.0)") expect(exitstatus).to eq(1) if exitstatus end @@ -201,13 +201,13 @@ RSpec.describe "bundle check" do it "outputs an error when the default Gemfile is not found" do bundle :check expect(exitstatus).to eq(10) if exitstatus - expect(out).to include("Could not locate Gemfile") + expect(err).to include("Could not locate Gemfile") end it "does not output fatal error message" do bundle :check expect(exitstatus).to eq(10) if exitstatus - expect(out).not_to include("Unfortunately, a fatal error has occurred. ") + expect(err).not_to include("Unfortunately, a fatal error has occurred. ") end it "should not crash when called multiple times on a new machine" do @@ -269,7 +269,7 @@ RSpec.describe "bundle check" do bundle "check --path vendor/bundle" expect(exitstatus).to eq(1) if exitstatus - expect(out).to match(/The following gems are missing/) + expect(err).to match(/The following gems are missing/) end end @@ -292,8 +292,8 @@ RSpec.describe "bundle check" do it "shows what is missing with the current Gemfile if it is not satisfied" do simulate_new_machine bundle :check - expect(out).to match(/The following gems are missing/) - expect(out).to include("* rack (1.0") + expect(err).to match(/The following gems are missing/) + expect(err).to include("* rack (1.0") end end diff --git a/spec/bundler/commands/clean_spec.rb b/spec/bundler/commands/clean_spec.rb index e1f007fc35..0053947c85 100644 --- a/spec/bundler/commands/clean_spec.rb +++ b/spec/bundler/commands/clean_spec.rb @@ -142,7 +142,7 @@ RSpec.describe "bundle clean" do bundle :clean digest = Digest(:SHA1).hexdigest(git_path.to_s) - cache_path = Bundler.bundler_major_version < 3 ? vendored_gems("cache/bundler/git/foo-1.0-#{digest}") : home(".bundle/cache/git/foo-1.0-#{digest}") + cache_path = Bundler::VERSION.start_with?("2.") ? vendored_gems("cache/bundler/git/foo-1.0-#{digest}") : home(".bundle/cache/git/foo-1.0-#{digest}") expect(cache_path).to exist end @@ -201,7 +201,7 @@ RSpec.describe "bundle clean" do update_git "foo", :path => lib_path("foo-bar") revision2 = revision_for(lib_path("foo-bar")) - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true bundle! :clean expect(out).to include("Removing foo-bar (#{revision[0..11]})") @@ -276,7 +276,7 @@ RSpec.describe "bundle clean" do end it "displays an error when used without --path" do - bundle! "config path.system true" + bundle! "config set path.system true" install_gemfile <<-G source "file://#{gem_repo1}" @@ -286,7 +286,7 @@ RSpec.describe "bundle clean" do bundle :clean expect(exitstatus).to eq(15) if exitstatus - expect(out).to include("--force") + expect(err).to include("--force") end # handling bundle clean upgrade path from the pre's @@ -320,9 +320,7 @@ RSpec.describe "bundle clean" do end it "does not call clean automatically when using system gems" do - bundle! "config path.system true" - - bundle! :config + bundle! "config set path.system true" install_gemfile! <<-G source "file://#{gem_repo1}" @@ -331,8 +329,6 @@ RSpec.describe "bundle clean" do gem "rack" G - bundle! "info thin" - install_gemfile! <<-G source "file://#{gem_repo1}" @@ -378,7 +374,7 @@ RSpec.describe "bundle clean" do build_gem "foo", "1.0.1" end - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true should_have_gems "foo-1.0.1" should_not_have_gems "foo-1.0" @@ -441,12 +437,12 @@ RSpec.describe "bundle clean" do build_gem "foo", "1.0.1" end - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true should_have_gems "foo-1.0", "foo-1.0.1" end it "does not clean on bundle update when using --system" do - bundle! "config path.system true" + bundle! "config set path.system true" build_repo2 @@ -460,7 +456,7 @@ RSpec.describe "bundle clean" do update_repo2 do build_gem "foo", "1.0.1" end - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true gem = ruby_core? ? ENV["BUNDLE_GEM"] : "gem" sys_exec! "#{gem} list" @@ -468,7 +464,7 @@ RSpec.describe "bundle clean" do end it "cleans system gems when --force is used" do - bundle! "config path.system true" + bundle! "config set path.system true" gemfile <<-G source "file://#{gem_repo1}" @@ -519,8 +515,8 @@ RSpec.describe "bundle clean" do bundle :clean, :force => true - expect(out).to include(system_gem_path.to_s) - expect(out).to include("grant write permissions") + expect(err).to include(system_gem_path.to_s) + expect(err).to include("grant write permissions") gem = ruby_core? ? ENV["BUNDLE_GEM"] : "gem" sys_exec "#{gem} list" @@ -560,7 +556,7 @@ RSpec.describe "bundle clean" do end it "when using --force on system gems, it doesn't remove binaries" do - bundle! "config path.system true" + bundle! "config set path.system true" build_repo2 update_repo2 do @@ -650,8 +646,6 @@ RSpec.describe "bundle clean" do bundle :install - bundle "configuration --delete path" - bundle "clean --dry-run" expect(out).not_to include("Removing foo (1.0)") @@ -671,7 +665,7 @@ RSpec.describe "bundle clean" do G bundle "install", forgotten_command_line_options(:path => "vendor/bundle", :clean => false) - bundle "config dry_run false" + bundle "config set dry_run false" gemfile <<-G source "file://#{gem_repo1}" @@ -709,14 +703,14 @@ RSpec.describe "bundle clean" do gem "weakling" G - bundle! "config auto_install 1" + bundle! "config set auto_install 1" bundle! :clean expect(out).to include("Installing weakling 0.0.3") should_have_gems "thin-1.0", "rack-1.0.0", "weakling-0.0.3" should_not_have_gems "foo-1.0" end - it "doesn't remove extensions artifacts from bundled git gems after clean", :ruby_repo, :rubygems => "2.2" do + it "doesn't remove extensions artifacts from bundled git gems after clean", :ruby_repo do build_git "very_simple_git_binary", &:add_c_extension revision = revision_for(lib_path("very_simple_git_binary-1.0")) @@ -738,7 +732,7 @@ RSpec.describe "bundle clean" do expect(vendored_gems("bundler/gems/very_simple_git_binary-1.0-#{revision[0..11]}")).to exist end - it "removes extension directories", :ruby_repo, :rubygems => "2.2" do + it "removes extension directories", :ruby_repo do gemfile <<-G source "file://#{gem_repo1}" @@ -772,4 +766,43 @@ RSpec.describe "bundle clean" do expect(very_simple_binary_extensions_dir).not_to exist expect(simple_binary_extensions_dir).to exist end + + it "removes git extension directories", :ruby_repo do + build_git "very_simple_git_binary", &:add_c_extension + + revision = revision_for(lib_path("very_simple_git_binary-1.0")) + short_revision = revision[0..11] + + gemfile <<-G + source "file://#{gem_repo1}" + + gem "thin" + gem "very_simple_git_binary", :git => "#{lib_path("very_simple_git_binary-1.0")}", :ref => "#{revision}" + G + + bundle! "install", forgotten_command_line_options(:path => "vendor/bundle") + + very_simple_binary_extensions_dir = + Pathname.glob("#{vendored_gems}/bundler/gems/extensions/*/*/very_simple_git_binary-1.0-#{short_revision}").first + + expect(very_simple_binary_extensions_dir).to exist + + gemfile <<-G + gem "very_simple_git_binary", :git => "#{lib_path("very_simple_git_binary-1.0")}", :ref => "#{revision}" + G + + bundle! "install" + bundle! :clean + expect(out).to include("Removing thin (1.0)") + expect(very_simple_binary_extensions_dir).to exist + + gemfile <<-G + G + + bundle! "install" + bundle! :clean + expect(out).to eq("Removing very_simple_git_binary-1.0 (#{short_revision})") + + expect(very_simple_binary_extensions_dir).not_to exist + end end diff --git a/spec/bundler/commands/config_spec.rb b/spec/bundler/commands/config_spec.rb index 9e49357465..84f882b410 100644 --- a/spec/bundler/commands/config_spec.rb +++ b/spec/bundler/commands/config_spec.rb @@ -1,18 +1,11 @@ # frozen_string_literal: true RSpec.describe ".bundle/config" do - before :each do - gemfile <<-G - source "file://#{gem_repo1}" - gem "rack", "1.0.0" - G - end - describe "config" do - before { bundle "config foo bar" } + before { bundle "config set foo bar" } it "prints a detailed report of local and user configuration" do - bundle "config" + bundle "config list" expect(out).to include("Settings are listed in order of priority. The top value will be used") expect(out).to include("foo\nSet for the current user") @@ -21,28 +14,35 @@ RSpec.describe ".bundle/config" do context "given --parseable flag" do it "prints a minimal report of local and user configuration" do - bundle "config --parseable" + bundle "config list --parseable" expect(out).to include("foo=bar") end context "with global config" do it "prints config assigned to local scope" do - bundle "config --local foo bar2" - bundle "config --parseable" + bundle "config set --local foo bar2" + bundle "config list --parseable" expect(out).to include("foo=bar2") end end context "with env overwrite" do it "prints config with env" do - bundle "config --parseable", :env => { "BUNDLE_FOO" => "bar3" } + bundle "config list --parseable", :env => { "BUNDLE_FOO" => "bar3" } expect(out).to include("foo=bar3") end end end end - describe "BUNDLE_APP_CONFIG" do + describe "location" do + before :each do + gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + G + end + it "can be moved with an environment variable" do ENV["BUNDLE_APP_CONFIG"] = tmp("foo/bar").to_s bundle "install", forgotten_command_line_options(:path => "vendor/bundle") @@ -66,24 +66,29 @@ RSpec.describe ".bundle/config" do end describe "global" do - before(:each) { bundle :install } + before(:each) do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + G + end it "is the default" do - bundle "config foo global" + bundle "config set foo global" run "puts Bundler.settings[:foo]" expect(out).to eq("global") end it "can also be set explicitly" do - bundle! "config --global foo global" + bundle! "config set --global foo global" run! "puts Bundler.settings[:foo]" expect(out).to eq("global") end it "has lower precedence than local" do - bundle "config --local foo local" + bundle "config set --local foo local" - bundle "config --global foo global" + bundle "config set --global foo global" expect(out).to match(/Your application has set foo to "local"/) run "puts Bundler.settings[:foo]" @@ -94,7 +99,7 @@ RSpec.describe ".bundle/config" do begin ENV["BUNDLE_FOO"] = "env" - bundle "config --global foo global" + bundle "config set --global foo global" expect(out).to match(/You have a bundler environment variable for foo set to "env"/) run "puts Bundler.settings[:foo]" @@ -105,16 +110,16 @@ RSpec.describe ".bundle/config" do end it "can be deleted" do - bundle "config --global foo global" - bundle "config --delete foo" + bundle "config set --global foo global" + bundle "config unset foo" run "puts Bundler.settings[:foo] == nil" expect(out).to eq("true") end it "warns when overriding" do - bundle "config --global foo previous" - bundle "config --global foo global" + bundle "config set --global foo previous" + bundle "config set --global foo global" expect(out).to match(/You are replacing the current global value of foo/) run "puts Bundler.settings[:foo]" @@ -122,8 +127,8 @@ RSpec.describe ".bundle/config" do end it "does not warn when using the same value twice" do - bundle "config --global foo value" - bundle "config --global foo value" + bundle "config set --global foo value" + bundle "config set --global foo value" expect(out).not_to match(/You are replacing the current global value of foo/) run "puts Bundler.settings[:foo]" @@ -131,22 +136,22 @@ RSpec.describe ".bundle/config" do end it "expands the path at time of setting" do - bundle "config --global local.foo .." + bundle "config set --global local.foo .." run "puts Bundler.settings['local.foo']" expect(out).to eq(File.expand_path(Dir.pwd + "/..")) end it "saves with parseable option" do - bundle "config --global --parseable foo value" + bundle "config set --global --parseable foo value" expect(out).to eq("foo=value") run "puts Bundler.settings['foo']" expect(out).to eq("value") end context "when replacing a current value with the parseable flag" do - before { bundle "config --global foo value" } + before { bundle "config set --global foo value" } it "prints the current value in a parseable format" do - bundle "config --global --parseable foo value2" + bundle "config set --global --parseable foo value2" expect(out).to eq "foo=value2" run "puts Bundler.settings['foo']" expect(out).to eq("value2") @@ -155,10 +160,15 @@ RSpec.describe ".bundle/config" do end describe "local" do - before(:each) { bundle :install } + before(:each) do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + G + end it "can also be set explicitly" do - bundle "config --local foo local" + bundle "config set --local foo local" run "puts Bundler.settings[:foo]" expect(out).to eq("local") end @@ -166,7 +176,7 @@ RSpec.describe ".bundle/config" do it "has higher precedence than env" do begin ENV["BUNDLE_FOO"] = "env" - bundle "config --local foo local" + bundle "config set --local foo local" run "puts Bundler.settings[:foo]" expect(out).to eq("local") @@ -176,16 +186,16 @@ RSpec.describe ".bundle/config" do end it "can be deleted" do - bundle "config --local foo local" - bundle "config --delete foo" + bundle "config set --local foo local" + bundle "config unset foo" run "puts Bundler.settings[:foo] == nil" expect(out).to eq("true") end it "warns when overriding" do - bundle "config --local foo previous" - bundle "config --local foo local" + bundle "config set --local foo previous" + bundle "config set --local foo local" expect(out).to match(/You are replacing the current local value of foo/) run "puts Bundler.settings[:foo]" @@ -193,14 +203,14 @@ RSpec.describe ".bundle/config" do end it "expands the path at time of setting" do - bundle "config --local local.foo .." + bundle "config set --local local.foo .." run "puts Bundler.settings['local.foo']" expect(out).to eq(File.expand_path(Dir.pwd + "/..")) end it "can be deleted with parseable option" do - bundle "config --local foo value" - bundle "config --delete --parseable foo" + bundle "config set --local foo value" + bundle "config unset --parseable foo" expect(out).to eq "" run "puts Bundler.settings['foo'] == nil" expect(out).to eq("true") @@ -208,7 +218,12 @@ RSpec.describe ".bundle/config" do end describe "env" do - before(:each) { bundle :install } + before(:each) do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + G + end it "can set boolean properties via the environment" do ENV["BUNDLE_FROZEN"] = "true" @@ -247,39 +262,44 @@ RSpec.describe ".bundle/config" do describe "parseable option" do it "prints an empty string" do - bundle "config foo --parseable" + bundle "config get foo --parseable" expect(out).to eq "" end it "only prints the value of the config" do - bundle "config foo local" - bundle "config foo --parseable" + bundle "config set foo local" + bundle "config get foo --parseable" expect(out).to eq "foo=local" end it "can print global config" do - bundle "config --global bar value" - bundle "config bar --parseable" + bundle "config set --global bar value" + bundle "config get bar --parseable" expect(out).to eq "bar=value" end it "prefers local config over global" do - bundle "config --local bar value2" - bundle "config --global bar value" - bundle "config bar --parseable" + bundle "config set --local bar value2" + bundle "config set --global bar value" + bundle "config get bar --parseable" expect(out).to eq "bar=value2" end end describe "gem mirrors" do - before(:each) { bundle :install } + before(:each) do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + G + end it "configures mirrors using keys with `mirror.`" do - bundle "config --local mirror.http://gems.example.org http://gem-mirror.example.org" + bundle "config set --local mirror.http://gems.example.org http://gem-mirror.example.org" run(<<-E) Bundler.settings.gem_mirrors.each do |k, v| puts "\#{k} => \#{v}" @@ -297,26 +317,26 @@ E end it "saves quotes" do - bundle "config foo something\\'" + bundle "config set foo something\\'" run "puts Bundler.settings[:foo]" expect(out).to eq("something'") end - it "doesn't return quotes around values", :ruby => "1.9" do - bundle "config foo '1'" + it "doesn't return quotes around values" do + bundle "config set foo '1'" run "puts Bundler.settings.send(:global_config_file).read" expect(out).to include('"1"') run "puts Bundler.settings[:foo]" expect(out).to eq("1") end - it "doesn't duplicate quotes around values", :if => (RUBY_VERSION >= "2.1") do + it "doesn't duplicate quotes around values" do bundled_app(".bundle").mkpath File.open(bundled_app(".bundle/config"), "w") do |f| f.write 'BUNDLE_FOO: "$BUILD_DIR"' end - bundle "config bar baz" + bundle "config set bar baz" run "puts Bundler.settings.send(:local_config_file).read" # Starting in Ruby 2.1, YAML automatically adds double quotes @@ -325,12 +345,12 @@ E end it "doesn't duplicate quotes around long wrapped values" do - bundle "config foo #{long_string}" + bundle "config set foo #{long_string}" run "puts Bundler.settings[:foo]" expect(out).to eq(long_string) - bundle "config bar baz" + bundle "config set bar baz" run "puts Bundler.settings[:foo]" expect(out).to eq(long_string) @@ -338,7 +358,12 @@ E end describe "very long lines" do - before(:each) { bundle :install } + before(:each) do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + G + end let(:long_string) do "--with-xml2-include=/usr/pkg/include/libxml2 --with-xml2-lib=/usr/pkg/lib " \ @@ -351,17 +376,103 @@ E end it "doesn't wrap values" do - bundle "config foo #{long_string}" + bundle "config set foo #{long_string}" run "puts Bundler.settings[:foo]" expect(out).to match(long_string) end it "can read wrapped unquoted values" do - bundle "config foo #{long_string_without_special_characters}" + bundle "config set foo #{long_string_without_special_characters}" run "puts Bundler.settings[:foo]" expect(out).to match(long_string_without_special_characters) end end + + describe "subcommands" do + it "list" 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\"" + + bundle! "config list", :parseable => true + expect(last_command.stdout).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`" + + ENV["BUNDLE_FOO"] = "foo_val" + + bundle! "config get foo --parseable" + expect(last_command.stdout).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\"" + end + + it "set" do + bundle! "config set foo 1" + expect(last_command.stdout).to eq "" + + bundle! "config set --local foo 2" + expect(last_command.stdout).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" + + bundle! "config set --parseable --local foo 4" + expect(last_command.stdout).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\"" + + 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." + end + + it "unset" do + bundle! "config unset foo" + expect(last_command.stdout).to eq "" + + bundle! "config set foo 1" + bundle! "config unset foo --parseable" + expect(last_command.stdout).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(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(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(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(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(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." + end + end end RSpec.describe "setting gemfile via config" do @@ -374,10 +485,10 @@ RSpec.describe "setting gemfile via config" do G end - bundle "config --local gemfile #{bundled_app("NotGemfile")}" + bundle "config set --local gemfile #{bundled_app("NotGemfile")}" expect(File.exist?(".bundle/config")).to eq(true) - bundle "config" + bundle "config list" expect(out).to include("NotGemfile") end end diff --git a/spec/bundler/commands/console_spec.rb b/spec/bundler/commands/console_spec.rb index 05b0a6c1e4..cba618db80 100644 --- a/spec/bundler/commands/console_spec.rb +++ b/spec/bundler/commands/console_spec.rb @@ -31,7 +31,7 @@ RSpec.describe "bundle console", :bundler => "< 3" do source "file://#{gem_repo1}" gem "pry" G - bundle "config console pry" + bundle "config set console pry" bundle "console" do |input, _, _| input.puts("__method__") @@ -41,7 +41,7 @@ RSpec.describe "bundle console", :bundler => "< 3" do end it "falls back to IRB if the other REPL isn't available" do - bundle "config console pry" + bundle "config set console pry" # make sure pry isn't there bundle "console" do |input, _, _| @@ -94,7 +94,7 @@ RSpec.describe "bundle console", :bundler => "< 3" do gem "foo" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle :console do |input, _, _| input.puts("puts 'hello'") input.puts("exit") diff --git a/spec/bundler/commands/exec_spec.rb b/spec/bundler/commands/exec_spec.rb index 2e3cb6621e..a95383ee97 100644 --- a/spec/bundler/commands/exec_spec.rb +++ b/spec/bundler/commands/exec_spec.rb @@ -38,7 +38,7 @@ RSpec.describe "bundle exec" do gem "rack" G - bundle "exec 'cd #{tmp("gems")} && rackup'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec 'cd #{tmp("gems")} && rackup'" expect(out).to include("1.0.0") end @@ -51,7 +51,7 @@ RSpec.describe "bundle exec" do it "works when exec'ing to ruby" do install_gemfile 'gem "rack"' - bundle "exec ruby -e 'puts %{hi}'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec ruby -e 'puts %{hi}'" expect(out).to eq("hi") end @@ -79,30 +79,23 @@ RSpec.describe "bundle exec" do require 'tempfile' io = Tempfile.new("io-test-fd") args = %W[#{Gem.ruby} -I#{lib} #{bindir.join("bundle")} exec --keep-file-descriptors #{Gem.ruby} #{command.path} \#{io.to_i}] - args << { io.to_i => io } if RUBY_VERSION >= "2.0" + args << { io.to_i => io } exec(*args) end G install_gemfile "" - with_env_vars "RUBYOPT" => "-r#{spec_dir.join("support/hax")}" do - sys_exec "#{Gem.ruby} #{command.path}" - end - - if Bundler.current_ruby.ruby_2? - expect(out).to eq("") - else - expect(out).to eq("Ruby version #{RUBY_VERSION} defaults to keeping non-standard file descriptors on Kernel#exec.") - end + sys_exec "#{Gem.ruby} #{command.path}" - expect(err).to lack_errors + expect(out).to eq("") + expect(last_command.stderr).to be_empty end it "accepts --keep-file-descriptors" do install_gemfile "" bundle "exec --keep-file-descriptors echo foobar" - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end it "can run a command named --verbose" do @@ -147,6 +140,112 @@ RSpec.describe "bundle exec" do end end + context "with default gems" do + let(:system_gems_to_install) { [] } + + let(:default_irb_version) { ruby "gem 'irb', '< 999999'; require 'irb'; puts IRB::VERSION" } + + context "when not specified in Gemfile" do + before do + skip "irb isn't a default gem" if default_irb_version.empty? + + install_gemfile "" + end + + it "uses version provided by ruby" do + bundle! "exec irb --version" + + expect(out).to include(default_irb_version) + expect(last_command.stderr).to be_empty + end + end + + context "when specified in Gemfile directly" do + let(:specified_irb_version) { "0.9.6" } + + before do + skip "irb isn't a default gem" if default_irb_version.empty? + + build_repo2 do + build_gem "irb", specified_irb_version do |s| + s.executables = "irb" + end + end + + install_gemfile <<-G + source "file://#{gem_repo2}" + gem "irb", "#{specified_irb_version}" + G + end + + it "uses version specified" do + bundle! "exec irb --version" + + expect(out).to include(specified_irb_version) + expect(last_command.stderr).to be_empty + end + end + + context "when specified in Gemfile indirectly" do + let(:indirect_irb_version) { "0.9.6" } + + before do + skip "irb isn't a default gem" if default_irb_version.empty? + + build_repo2 do + build_gem "irb", indirect_irb_version do |s| + s.executables = "irb" + end + + build_gem "gem_depending_on_old_irb" do |s| + s.add_dependency "irb", indirect_irb_version + end + end + + install_gemfile <<-G + source "file://#{gem_repo2}" + gem "gem_depending_on_old_irb" + G + + bundle! "exec irb --version" + end + + it "uses resolved version" do + expect(out).to include(indirect_irb_version) + expect(last_command.stderr).to be_empty + end + end + end + + it "warns about executable conflicts" do + build_repo2 do + build_gem "rack_two", "1.0.0" do |s| + s.executables = "rackup" + end + end + + bundle "config set path.system true" + + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack", "0.9.1" + G + + Dir.chdir bundled_app2 do + install_gemfile bundled_app2("Gemfile"), <<-G + source "file://#{gem_repo2}" + gem "rack_two", "1.0.0" + G + end + + bundle! "exec rackup" + + expect(last_command.stderr).to eq( + "Bundler is using a binstub that was created for a different gem (rack).\n" \ + "You should run `bundle binstub rack_two` to work around a system/bundle conflict." + ) + end + it "handles gems installed with --without" do install_gemfile <<-G, forgotten_command_line_options(:without => "middleware") source "file://#{gem_repo1}" @@ -201,8 +300,8 @@ RSpec.describe "bundle exec" do bundle "exec foobarbaz" expect(exitstatus).to eq(127) if exitstatus - expect(out).to include("bundler: command not found: foobarbaz") - expect(out).to include("Install missing gem executables with `bundle install`") + expect(err).to include("bundler: command not found: foobarbaz") + expect(err).to include("Install missing gem executables with `bundle install`") end it "errors nicely when the argument is not executable" do @@ -213,7 +312,7 @@ RSpec.describe "bundle exec" do bundle "exec touch foo" bundle "exec ./foo" expect(exitstatus).to eq(126) if exitstatus - expect(out).to include("bundler: not executable: ./foo") + expect(err).to include("bundler: not executable: ./foo") end it "errors nicely when no arguments are passed" do @@ -223,36 +322,22 @@ RSpec.describe "bundle exec" do bundle "exec" expect(exitstatus).to eq(128) if exitstatus - expect(out).to include("bundler: exec needs a command to run") + expect(err).to include("bundler: exec needs a command to run") end - it "raises a helpful error when exec'ing to something outside of the bundle", :ruby_repo, :rubygems => ">= 2.5.2" do - bundle! "config clean false" # want to keep the rackup binstub + it "raises a helpful error when exec'ing to something outside of the bundle", :ruby_repo do + bundle! "config set clean false" # want to keep the rackup binstub install_gemfile! <<-G source "file://#{gem_repo1}" gem "with_license" G [true, false].each do |l| - bundle! "config disable_exec_load #{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?" end end - # Different error message on old RG versions (before activate_bin_path) because they - # called `Kernel#gem` directly - it "raises a helpful error when exec'ing to something outside of the bundle", :rubygems => "< 2.5.2" do - install_gemfile! <<-G - source "file://#{gem_repo1}" - gem "with_license" - G - [true, false].each do |l| - bundle! "config disable_exec_load #{l}" - bundle "exec rackup", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } - expect(last_command.stderr).to include "rack is not part of the bundle. Add it to your Gemfile." - end - end - describe "with help flags" do each_prefix = proc do |string, &blk| 1.upto(string.length) {|l| blk.call(string[0, l]) } @@ -350,14 +435,14 @@ RSpec.describe "bundle exec" do end it "works when unlocked" do - bundle "exec 'cd #{tmp("gems")} && rackup'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec 'cd #{tmp("gems")} && rackup'" expect(out).to eq("1.0.0") expect(out).to include("1.0.0") end it "works when locked" do expect(the_bundle).to be_locked - bundle "exec 'cd #{tmp("gems")} && rackup'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec 'cd #{tmp("gems")} && rackup'" expect(out).to include("1.0.0") end end @@ -440,13 +525,13 @@ RSpec.describe "bundle exec" do gem "foo" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle "exec rackup" expect(out).to include("Installing foo 1.0") end describe "with gems bundled via :path with invalid gemspecs", :ruby_repo do - it "outputs the gemspec validation errors", :rubygems => ">= 1.7.2" do + it "outputs the gemspec validation errors" do build_lib "foo" gemspec = lib_path("foo-1.0").join("foo.gemspec").to_s @@ -467,8 +552,8 @@ RSpec.describe "bundle exec" do bundle "exec irb" - 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') + 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') end end @@ -483,7 +568,7 @@ RSpec.describe "bundle exec" do Bundler.rubygems.extend(Monkey) G bundle "install --deployment" - bundle "exec ruby -e '`#{bindir.join("bundler")} -v`; puts $?.success?'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec ruby -e '`#{bindir.join("bundler")} -v`; puts $?.success?'" expect(out).to match("true") end end @@ -516,14 +601,14 @@ RSpec.describe "bundle exec" do let(:rack) { "RACK: 1.0.0" } let(:process) do title = "PROCESS: #{path}" - title += " arg1 arg2" if RUBY_VERSION >= "2.1" + title += " arg1 arg2" title end let(:exit_code) { 0 } let(:expected) { [exec, args, rack, process].join("\n") } let(:expected_err) { "" } - subject { bundle "exec #{path} arg1 arg2", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } } + subject { bundle "exec #{path} arg1 arg2" } shared_examples_for "it runs" do it "like a normally executed executable" do @@ -553,15 +638,10 @@ RSpec.describe "bundle exec" do let(:executable) do ex = super() ex << "\n" - if LessThanProc.with(RUBY_VERSION).call("1.9") - # Ruby < 1.9 needs a flush for a exit by signal, later - # rubies do not - ex << "STDOUT.flush\n" - end ex << "raise SignalException, 'SIGTERM'\n" ex end - let(:expected_err) { ENV["TRAVIS"] ? "Terminated" : "" } + let(:expected_err) { "" } let(:exit_code) do # signal mask 128 + plus signal 15 -> TERM # this is specified by C99 @@ -612,7 +692,8 @@ RSpec.describe "bundle exec" do end let(:exit_code) { Bundler::GemNotFound.new.status_code } - let(:expected) { <<-EOS.strip } + let(:expected) { "" } + let(:expected_err) { <<-EOS.strip } \e[31mCould not find gem 'rack (= 2)' in any of the gem sources listed in your Gemfile.\e[0m \e[33mRun `bundle install` to install missing gems.\e[0m EOS @@ -629,7 +710,8 @@ RSpec.describe "bundle exec" do end let(:exit_code) { Bundler::GemNotFound.new.status_code } - let(:expected) { <<-EOS.strip } + let(:expected) { "" } + let(:expected_err) { <<-EOS.strip } \e[31mCould not find gem 'rack (= 2)' in locally installed gems. The source contains 'rack' at: 1.0.0\e[0m \e[33mRun `bundle install` to install missing gems.\e[0m @@ -650,7 +732,7 @@ The source contains 'rack' at: 1.0.0\e[0m let(:process) { "PROCESS: ruby #{path} arg1 arg2" } before do - bundle "config disable_exec_load true" + bundle "config set disable_exec_load true" end it_behaves_like "it runs" @@ -674,21 +756,13 @@ __FILE__: #{path.to_s.inspect} context "when the path is relative" do let(:path) { super().relative_path_from(bundled_app) } - if LessThanProc.with(RUBY_VERSION).call("1.9") - pending "relative paths have ./ __FILE__" - else - it_behaves_like "it runs" - end + it_behaves_like "it runs" end context "when the path is relative with a leading ./" do let(:path) { Pathname.new("./#{super().relative_path_from(Pathname.pwd)}") } - if LessThanProc.with(RUBY_VERSION).call("< 1.9") - pending "relative paths with ./ have absolute __FILE__" - else - it_behaves_like "it runs" - end + pending "relative paths with ./ have absolute __FILE__" end end @@ -716,7 +790,7 @@ __FILE__: #{path.to_s.inspect} end RUBY - it "receives the signal", :ruby => ">= 1.9.3" do + it "receives the signal" do bundle!("exec #{path}") do |_, o, thr| o.gets # Consumes 'Started' and ensures that thread has started Process.kill("INT", thr.pid) @@ -762,9 +836,7 @@ __FILE__: #{path.to_s.inspect} bundle :install, :system_bundler => true, :path => "vendor/bundler" end - it "overrides disable_shared_gems so bundler can be found" do - skip "bundler 1.16.x is not support with Ruby 2.6 on Travis CI" if RUBY_VERSION >= "2.6" - + it "overrides disable_shared_gems so bundler can be found", :rubygems => ">= 2.6.2" do system_gems :bundler file = bundled_app("file_that_bundle_execs.rb") create_file(file, <<-RB) @@ -809,10 +881,7 @@ __FILE__: #{path.to_s.inspect} expect(bundle!("exec #{file}", :artifice => nil)).to eq(expected) expect(bundle!("exec bundle exec #{file}", :artifice => nil)).to eq(expected) expect(bundle!("exec ruby #{file}", :artifice => nil)).to eq(expected) - # Ignore expectaion for default bundler gem conflict. - unless ENV["BUNDLER_SPEC_SUB_VERSION"] - expect(run!(file.read, :artifice => nil)).to eq(expected) - end + expect(run!(file.read, :artifice => nil)).to eq(expected) end # sanity check that we get the newer, custom version without bundler diff --git a/spec/bundler/commands/help_spec.rb b/spec/bundler/commands/help_spec.rb index 56b1b6f722..f4f90b9347 100644 --- a/spec/bundler/commands/help_spec.rb +++ b/spec/bundler/commands/help_spec.rb @@ -1,15 +1,6 @@ # frozen_string_literal: true RSpec.describe "bundle help" do - # RubyGems 1.4+ no longer load gem plugins so this test is no longer needed - it "complains if older versions of bundler are installed", :rubygems => "< 1.4" do - system_gems "bundler-0.8.1" - - bundle "help" - expect(err).to include("older than 0.9") - expect(err).to include("running `gem cleanup bundler`.") - end - it "uses mann when available" do with_fake_man do bundle "help gemfile" @@ -81,7 +72,7 @@ RSpec.describe "bundle help" do with_fake_man do bundle "instill -h" end - expect(out).to include('Could not find command "instill".') + expect(err).to include('Could not find command "instill".') end it "is called when only using the --help flag" do diff --git a/spec/bundler/commands/info_spec.rb b/spec/bundler/commands/info_spec.rb index a9ab8fc210..fc1d97b1da 100644 --- a/spec/bundler/commands/info_spec.rb +++ b/spec/bundler/commands/info_spec.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true RSpec.describe "bundle info" do - context "info from specific gem in gemfile" do + context "with a standard Gemfile" do before do install_gemfile <<-G source "file://#{gem_repo1}" @@ -9,23 +9,39 @@ RSpec.describe "bundle info" do G end - it "prints information about the current gem" do + it "creates a Gemfile.lock when invoked with a gem name" do + FileUtils.rm("Gemfile.lock") + + bundle "info rails" + + expect(bundled_app("Gemfile.lock")).to exist + end + + it "prints information if gem exists in bundle" do bundle "info rails" expect(out).to include "* rails (2.3.2) \tSummary: This is just a fake gem for testing -\tHomepage: http://example.com" - expect(out).to match(%r{Path\: .*\/rails\-2\.3\.2}) +\tHomepage: http://example.com +\tPath: #{default_bundle_path("gems", "rails-2.3.2")}" end - context "given a gem that is not installed" do - it "prints missing gem error" do - bundle "info foo" - expect(out).to eq "Could not find gem 'foo'." - end + it "prints path if gem exists in bundle" do + bundle "info rails --path" + expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s) + end + + it "prints the path to the running bundler" do + bundle "info bundler --path" + expect(out).to eq(root.to_s) + end + + it "complains if gem not in bundle" do + bundle "info missing" + expect(err).to eq("Could not find gem 'missing'.") end context "given a default gem shippped in ruby", :ruby_repo do - it "prints information about the default gem", :if => (RUBY_VERSION >= "2.0") do + it "prints information about the default gem" do bundle "info rdoc" expect(out).to include("* rdoc") expect(out).to include("Default Gem: yes") @@ -34,7 +50,7 @@ RSpec.describe "bundle info" do context "when gem does not have homepage" do before do - build_repo1 do + build_repo2 do build_gem "rails", "2.3.2" do |s| s.executables = "rails" s.summary = "Just another test gem" @@ -46,12 +62,84 @@ RSpec.describe "bundle info" do expect(out).to_not include("Homepage:") end end + end + + context "with a git repo in the Gemfile" do + before :each do + @git = build_git "foo", "1.0" + end + + it "prints out git info" do + install_gemfile <<-G + gem "foo", :git => "#{lib_path("foo-1.0")}" + G + expect(the_bundle).to include_gems "foo 1.0" + + bundle "info foo" + expect(out).to include("foo (1.0 #{@git.ref_for("master", 6)}") + end - context "given --path option" do - it "prints the path to the gem" do - bundle "info rails" - expect(out).to match(%r{.*\/rails\-2\.3\.2}) + it "prints out branch names other than master" do + update_git "foo", :branch => "omg" do |s| + s.write "lib/foo.rb", "FOO = '1.0.omg'" end + @revision = revision_for(lib_path("foo-1.0"))[0...6] + + install_gemfile <<-G + gem "foo", :git => "#{lib_path("foo-1.0")}", :branch => "omg" + G + expect(the_bundle).to include_gems "foo 1.0.omg" + + bundle "info foo" + expect(out).to include("foo (1.0 #{@git.ref_for("omg", 6)}") + end + + it "doesn't print the branch when tied to a ref" do + sha = revision_for(lib_path("foo-1.0")) + install_gemfile <<-G + gem "foo", :git => "#{lib_path("foo-1.0")}", :ref => "#{sha}" + G + + bundle "info foo" + expect(out).to include("foo (1.0 #{sha[0..6]})") + end + + it "handles when a version is a '-' prerelease", :rubygems => "2.1" do + @git = build_git("foo", "1.0.0-beta.1", :path => lib_path("foo")) + install_gemfile <<-G + gem "foo", "1.0.0-beta.1", :git => "#{lib_path("foo")}" + G + expect(the_bundle).to include_gems "foo 1.0.0.pre.beta.1" + + bundle! "info foo" + expect(out).to include("foo (1.0.0.pre.beta.1") + end + end + + context "with a valid regexp for gem name" do + it "presents alternatives" do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack" + gem "rack-obama" + G + + bundle "info rac" + expect(out).to eq "1 : rack\n2 : rack-obama\n0 : - exit -\n>" + end + end + + context "with an invalid regexp for gem name" do + it "does not find the gem" do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rails" + G + + invalid_regexp = "[]" + + bundle "info #{invalid_regexp}" + expect(err).to include("Could not find gem '#{invalid_regexp}'.") end end end diff --git a/spec/bundler/commands/init_spec.rb b/spec/bundler/commands/init_spec.rb index 8a8f0effa0..64849beeb9 100644 --- a/spec/bundler/commands/init_spec.rb +++ b/spec/bundler/commands/init_spec.rb @@ -1,19 +1,13 @@ # frozen_string_literal: true RSpec.describe "bundle init" do - it "generates a Gemfile", :bundler => "< 3" do + it "generates a Gemfile" do bundle! :init expect(out).to include("Writing new Gemfile") expect(bundled_app("Gemfile")).to be_file end - it "generates a gems.rb", :bundler => "3" do - bundle! :init - expect(out).to include("Writing new gems.rb") - expect(bundled_app("gems.rb")).to be_file - end - - context "when a Gemfile already exists", :bundler => "< 3" do + context "when a Gemfile already exists" do before do create_file "Gemfile", <<-G gem "rails" @@ -26,28 +20,11 @@ RSpec.describe "bundle init" do it "notifies the user that an existing Gemfile already exists" do bundle :init - expect(out).to include("Gemfile already exists") + expect(err).to include("Gemfile already exists") end end - context "when gems.rb already exists", :bundler => ">= 3" do - before do - create_file("gems.rb", <<-G) - gem "rails" - G - end - - it "does not change existing Gemfiles" do - expect { bundle :init }.not_to change { File.read(bundled_app("gems.rb")) } - end - - it "notifies the user that an existing gems.rb already exists" do - bundle :init - expect(out).to include("gems.rb already exists") - end - end - - context "when a Gemfile exists in a parent directory", :bundler => "< 3" do + context "when a Gemfile exists in a parent directory" do let(:subdir) { "child_dir" } it "lets users generate a Gemfile in a child directory" do @@ -77,29 +54,12 @@ RSpec.describe "bundle init" do bundle :init end - expect(out).to include("directory is not writable") + expect(err).to include("directory is not writable") expect(Dir[bundled_app("#{subdir}/*")]).to be_empty end end - context "when a gems.rb file exists in a parent directory", :bundler => ">= 3" do - let(:subdir) { "child_dir" } - - it "lets users generate a Gemfile in a child directory" do - bundle! :init - - FileUtils.mkdir bundled_app(subdir) - - Dir.chdir bundled_app(subdir) do - bundle! :init - end - - expect(out).to include("Writing new gems.rb") - expect(bundled_app("#{subdir}/gems.rb")).to be_file - end - end - - context "given --gemspec option", :bundler => "< 3" do + context "given --gemspec option" do let(:spec_file) { tmp.join("test.gemspec") } it "should generate from an existing gemspec" do @@ -115,11 +75,7 @@ RSpec.describe "bundle init" do bundle :init, :gemspec => spec_file - gemfile = if Bundler::VERSION[0, 2].to_i < 3 - bundled_app("Gemfile").read - else - bundled_app("gems.rb").read - end + gemfile = bundled_app("Gemfile").read expect(gemfile).to match(%r{source 'https://rubygems.org'}) expect(gemfile.scan(/gem "rack", "= 1.0.1"/).size).to eq(1) expect(gemfile.scan(/gem "rspec", "= 1.2"/).size).to eq(1) @@ -144,9 +100,49 @@ RSpec.describe "bundle init" do end context "when init_gems_rb setting is enabled" do - before { bundle "config init_gems_rb true" } + before { bundle "config set init_gems_rb true" } + + it "generates a gems.rb" do + bundle! :init + expect(out).to include("Writing new gems.rb") + expect(bundled_app("gems.rb")).to be_file + end + + context "when gems.rb already exists" do + before do + create_file("gems.rb", <<-G) + gem "rails" + G + end + + it "does not change existing Gemfiles" do + expect { bundle :init }.not_to change { File.read(bundled_app("gems.rb")) } + end + + it "notifies the user that an existing gems.rb already exists" do + bundle :init + expect(err).to include("gems.rb already exists") + end + end + + context "when a gems.rb file exists in a parent directory" do + let(:subdir) { "child_dir" } + + it "lets users generate a Gemfile in a child directory" do + bundle! :init + + FileUtils.mkdir bundled_app(subdir) + + Dir.chdir bundled_app(subdir) do + bundle! :init + end + + expect(out).to include("Writing new gems.rb") + expect(bundled_app("#{subdir}/gems.rb")).to be_file + end + end - context "given --gemspec option", :bundler => "< 3" do + context "given --gemspec option" do let(:spec_file) { tmp.join("test.gemspec") } before do diff --git a/spec/bundler/commands/inject_spec.rb b/spec/bundler/commands/inject_spec.rb index d091e01380..da31849be7 100644 --- a/spec/bundler/commands/inject_spec.rb +++ b/spec/bundler/commands/inject_spec.rb @@ -37,14 +37,14 @@ RSpec.describe "bundle inject", :bundler => "< 3" do context "with injected gems already in the Gemfile" do it "doesn't add existing gems" do bundle "inject 'rack' '> 0'" - expect(out).to match(/cannot specify the same gem twice/i) + expect(err).to match(/cannot specify the same gem twice/i) end end context "incorrect arguments" do it "fails when more than 2 arguments are passed" do bundle "inject gem_name 1 v" - expect(out).to eq(<<-E.strip) + expect(err).to eq(<<-E.strip) ERROR: "bundle inject" was called with arguments ["gem_name", "1", "v"] Usage: "bundle inject GEM VERSION" E @@ -80,9 +80,9 @@ Usage: "bundle inject GEM VERSION" before do bundle "install" if Bundler.feature_flag.bundler_3_mode? - bundle! "config --local deployment true" + bundle! "config set --local deployment true" else - bundle! "config --local frozen true" + bundle! "config set --local frozen true" end end @@ -109,7 +109,7 @@ Usage: "bundle inject GEM VERSION" gem "rack-obama" G bundle "inject 'rack' '> 0'" - expect(out).to match(/trying to install in deployment mode after changing/) + expect(err).to match(/trying to install in deployment mode after changing/) expect(bundled_app("Gemfile.lock").read).not_to match(/rack-obama/) end diff --git a/spec/bundler/commands/install_spec.rb b/spec/bundler/commands/install_spec.rb index 326f98161e..21157dd309 100644 --- a/spec/bundler/commands/install_spec.rb +++ b/spec/bundler/commands/install_spec.rb @@ -8,7 +8,7 @@ RSpec.describe "bundle install with gem sources" do G bundle :install - expect(out).to match(/no dependencies/) + expect(err).to match(/no dependencies/) end it "does not make a lockfile if the install fails" do @@ -311,7 +311,7 @@ RSpec.describe "bundle install with gem sources" do G bundle :install - expect(out).to include("Your Gemfile has no gem server sources") + expect(err).to include("Your Gemfile has no gem server sources") end it "creates a Gemfile.lock on a blank Gemfile" do @@ -329,9 +329,9 @@ RSpec.describe "bundle install with gem sources" do gem "rack" G - expect(out).to include("Your Gemfile lists the gem rack (>= 0) more than once.") - expect(out).to include("Remove any duplicate entries and specify the gem only once (per group).") - expect(out).to include("While it's not a problem now, it could cause errors if you change the version of one of them later.") + expect(err).to include("Your Gemfile lists the gem rack (>= 0) more than once.") + expect(err).to include("Remove any duplicate entries and specify the gem only once (per group).") + expect(err).to include("While it's not a problem now, it could cause errors if you change the version of one of them later.") end it "with same versions" do @@ -341,9 +341,9 @@ RSpec.describe "bundle install with gem sources" do gem "rack", "1.0" G - expect(out).to include("Your Gemfile lists the gem rack (= 1.0) more than once.") - expect(out).to include("Remove any duplicate entries and specify the gem only once (per group).") - expect(out).to include("While it's not a problem now, it could cause errors if you change the version of one of them later.") + expect(err).to include("Your Gemfile lists the gem rack (= 1.0) more than once.") + expect(err).to include("Remove any duplicate entries and specify the gem only once (per group).") + expect(err).to include("While it's not a problem now, it could cause errors if you change the version of one of them later.") end end @@ -355,8 +355,8 @@ RSpec.describe "bundle install with gem sources" do gem "rack", "1.0" G - expect(out).to include("You cannot specify the same gem twice with different version requirements") - expect(out).to include("You specified: rack (>= 0) and rack (= 1.0).") + expect(err).to include("You cannot specify the same gem twice with different version requirements") + expect(err).to include("You specified: rack (>= 0) and rack (= 1.0).") end it "when different versions of both dependencies are specified" do @@ -366,25 +366,25 @@ RSpec.describe "bundle install with gem sources" do gem "rack", "1.1" G - expect(out).to include("You cannot specify the same gem twice with different version requirements") - expect(out).to include("You specified: rack (= 1.0) and rack (= 1.1).") + expect(err).to include("You cannot specify the same gem twice with different version requirements") + expect(err).to include("You specified: rack (= 1.0) and rack (= 1.1).") end end it "gracefully handles error when rubygems server is unavailable" do install_gemfile <<-G, :artifice => nil source "file://#{gem_repo1}" - source "http://localhost:9384" do + source "http://0.0.0.0:9384" do gem 'foo' end G bundle :install, :artifice => nil - expect(out).to include("Could not fetch specs from http://localhost:9384/") - expect(out).not_to include("file://") + expect(err).to include("Could not fetch specs from http://0.0.0.0:9384/") + expect(err).not_to include("file://") end - it "fails gracefully when downloading an invalid specification from the full index", :rubygems => "2.5" do + it "fails gracefully when downloading an invalid specification from the full index" do build_repo2 do build_gem "ajp-rails", "0.0.0", :gemspec => false, :skip_validation => true do |s| bad_deps = [["ruby-ajp", ">= 0.2.0"], ["rails", ">= 0.14"]] @@ -442,7 +442,7 @@ RSpec.describe "bundle install with gem sources" do ::RUBY_VERSION = '2.0.1' ruby '~> 2.2' G - expect(out).to include("Your Ruby version is 2.0.1, but your Gemfile specified ~> 2.2") + expect(err).to include("Your Ruby version is 2.0.1, but your Gemfile specified ~> 2.2") end end @@ -529,8 +529,8 @@ RSpec.describe "bundle install with gem sources" do G bundle :install, :quiet => true - expect(out).to include("Could not find gem 'rack'") - expect(out).to_not include("Your Gemfile has no gem server sources") + expect(err).to include("Could not find gem 'rack'") + expect(err).to_not include("Your Gemfile has no gem server sources") end end @@ -547,8 +547,8 @@ RSpec.describe "bundle install with gem sources" do FileUtils.chmod(0o500, bundled_app("vendor")) bundle :install, forgotten_command_line_options(:path => "vendor") - expect(out).to include(bundled_app("vendor").to_s) - expect(out).to include("grant write permissions") + expect(err).to include(bundled_app("vendor").to_s) + expect(err).to include("grant write permissions") end end @@ -577,10 +577,10 @@ RSpec.describe "bundle install with gem sources" do G end - it "should display a helpful messag explaining how to fix it" do + it "should display a helpful message explaining how to fix it" do bundle :install, :env => { "BUNDLE_RUBYGEMS__ORG" => "user:pass{word" } expect(exitstatus).to eq(17) if exitstatus - expect(out).to eq("Please CGI escape your usernames and passwords before " \ + expect(err).to eq("Please CGI escape your usernames and passwords before " \ "setting them for authentication.") end end diff --git a/spec/bundler/commands/licenses_spec.rb b/spec/bundler/commands/licenses_spec.rb index d61d3492f3..21fd8eaf2f 100644 --- a/spec/bundler/commands/licenses_spec.rb +++ b/spec/bundler/commands/licenses_spec.rb @@ -12,14 +12,7 @@ RSpec.describe "bundle licenses" do it "prints license information for all gems in the bundle" do bundle "licenses" - loaded_bundler_spec = Bundler.load.specs["bundler"] - expected = if !loaded_bundler_spec.empty? - loaded_bundler_spec[0].license - else - "Unknown" - end - - expect(out).to include("bundler: #{expected}") + expect(err).to include("bundler: Unknown") expect(out).to include("with_license: MIT") end @@ -31,7 +24,7 @@ RSpec.describe "bundle licenses" do gem "foo" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle :licenses expect(out).to include("Installing foo 1.0") end diff --git a/spec/bundler/commands/list_spec.rb b/spec/bundler/commands/list_spec.rb index ba4bb9b040..346b47517e 100644 --- a/spec/bundler/commands/list_spec.rb +++ b/spec/bundler/commands/list_spec.rb @@ -1,20 +1,11 @@ # frozen_string_literal: true -RSpec.describe "bundle list", :bundler => "3" do - before do - install_gemfile <<-G - source "file://#{gem_repo1}" - - gem "rack" - gem "rspec", :group => [:test] - G - end - +RSpec.describe "bundle list" do context "with name-only and paths option" do it "raises an error" do bundle "list --name-only --paths" - expect(out).to eq "The `--name-only` and `--paths` options cannot be used together" + expect(err).to eq "The `--name-only` and `--paths` options cannot be used together" end end @@ -22,11 +13,20 @@ RSpec.describe "bundle list", :bundler => "3" do it "raises an error" do bundle "list --without-group dev --only-group test" - expect(out).to eq "The `--only-group` and `--without-group` options cannot be used together" + expect(err).to eq "The `--only-group` and `--without-group` options cannot be used together" end end describe "with without-group option" do + before do + install_gemfile <<-G + source "file://#{gem_repo1}" + + gem "rack" + gem "rspec", :group => [:test] + G + end + context "when group is present" do it "prints the gems not in the specified group" do bundle! "list --without-group test" @@ -40,12 +40,21 @@ RSpec.describe "bundle list", :bundler => "3" do it "raises an error" do bundle "list --without-group random" - expect(out).to eq "`random` group could not be found." + expect(err).to eq "`random` group could not be found." end end end describe "with only-group option" do + before do + install_gemfile <<-G + source "file://#{gem_repo1}" + + gem "rack" + gem "rspec", :group => [:test] + G + end + context "when group is present" do it "prints the gems in the specified group" do bundle! "list --only-group default" @@ -59,12 +68,21 @@ RSpec.describe "bundle list", :bundler => "3" do it "raises an error" do bundle "list --only-group random" - expect(out).to eq "`random` group could not be found." + expect(err).to eq "`random` group could not be found." end end end context "with name-only option" do + before do + install_gemfile <<-G + source "file://#{gem_repo1}" + + gem "rack" + gem "rspec", :group => [:test] + G + end + it "prints only the name of the gems in the bundle" do bundle "list --name-only" @@ -82,7 +100,6 @@ RSpec.describe "bundle list", :bundler => "3" do build_git "git_test", "1.0.0", :path => lib_path("git_test") build_lib("gemspec_test", :path => tmp.join("gemspec_test")) do |s| - s.write("Gemfile", "source :rubygems\ngemspec") s.add_dependency "bar", "=1.0.0" end @@ -93,8 +110,6 @@ RSpec.describe "bundle list", :bundler => "3" do gem "git_test", :git => "#{lib_path("git_test")}" gemspec :path => "#{tmp.join("gemspec_test")}" G - - bundle! "install" end it "prints the path of each gem in the bundle" do @@ -119,13 +134,35 @@ RSpec.describe "bundle list", :bundler => "3" do end end - it "lists gems installed in the bundle" do - bundle "list" - expect(out).to include(" * rack (1.0.0)") + context "without options" do + before do + install_gemfile <<-G + source "file://#{gem_repo1}" + + gem "rack" + gem "rspec", :group => [:test] + G + end + + it "lists gems installed in the bundle" do + bundle "list" + expect(out).to include(" * rack (1.0.0)") + end end - it "aliases the ls command to list" do - bundle "ls" - expect(out).to include("Gems included by the bundle") + context "when using the ls alias" do + before do + install_gemfile <<-G + source "file://#{gem_repo1}" + + gem "rack" + gem "rspec", :group => [:test] + G + end + + it "runs the list command" do + bundle "ls" + expect(out).to include("Gems included by the bundle") + end end end diff --git a/spec/bundler/commands/lock_spec.rb b/spec/bundler/commands/lock_spec.rb index 0b77605f01..f876d719cc 100644 --- a/spec/bundler/commands/lock_spec.rb +++ b/spec/bundler/commands/lock_spec.rb @@ -38,8 +38,8 @@ RSpec.describe "bundle lock" do actionpack (= 2.3.2) activerecord (= 2.3.2) activeresource (= 2.3.2) - rake (= 10.0.2) - rake (10.0.2) + rake (= 12.3.2) + rake (12.3.2) with_license (1.0) PLATFORMS @@ -86,14 +86,41 @@ RSpec.describe "bundle lock" do it "does not fetch remote specs when using the --local option" do bundle "lock --update --local" - expect(out).to match(/sources listed in your Gemfile|installed locally/) + expect(err).to match(/sources listed in your Gemfile|installed locally/) + end + + it "works with --gemfile flag" do + create_file "CustomGemfile", <<-G + source "file://localhost#{repo}" + gem "foo" + G + lockfile = strip_lockfile(normalize_uri_file(<<-L)) + GEM + remote: file://localhost#{repo}/ + specs: + foo (1.0) + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + foo + + BUNDLED WITH + #{Bundler::VERSION} + L + bundle "lock --gemfile CustomGemfile" + + expect(out).to match(/Writing lockfile to.+CustomGemfile\.lock/) + expect(read_lockfile("CustomGemfile.lock")).to eq(lockfile) + expect { read_lockfile }.to raise_error(Errno::ENOENT) end it "writes to a custom location using --lockfile" do bundle "lock --lockfile=lock" expect(out).to match(/Writing lockfile to.+lock/) - expect(read_lockfile "lock").to eq(@lockfile) + expect(read_lockfile("lock")).to eq(@lockfile) expect { read_lockfile }.to raise_error(Errno::ENOENT) end @@ -106,7 +133,7 @@ RSpec.describe "bundle lock" do end it "update specific gems using --update" do - lockfile @lockfile.gsub("2.3.2", "2.3.1").gsub("10.0.2", "10.0.1") + lockfile @lockfile.gsub("2.3.2", "2.3.1").gsub("12.3.2", "10.0.1") bundle "lock --update rails rake" @@ -117,11 +144,24 @@ RSpec.describe "bundle lock" do lockfile @lockfile bundle "lock --update blahblah" - expect(out).to eq("Could not find gem 'blahblah'.") + expect(err).to eq("Could not find gem 'blahblah'.") expect(read_lockfile).to eq(@lockfile) end + it "can lock without downloading gems" do + gemfile <<-G + source "file://#{gem_repo1}" + + gem "thin" + gem "rack_middleware", :group => "test" + G + bundle! "config set without test" + bundle! "config set path .bundle" + bundle! "lock" + expect(bundled_app(".bundle")).not_to exist + end + # see update_spec for more coverage on same options. logic is shared so it's not necessary # to repeat coverage here. context "conservative updates" do @@ -185,7 +225,7 @@ RSpec.describe "bundle lock" do it "warns when adding an unknown platform" do bundle "lock --add-platform foobarbaz" - expect(out).to include("The platform `foobarbaz` is unknown to RubyGems and adding it will likely lead to resolution errors") + expect(err).to include("The platform `foobarbaz` is unknown to RubyGems and adding it will likely lead to resolution errors") end it "allows removing platforms" do diff --git a/spec/bundler/commands/newgem_spec.rb b/spec/bundler/commands/newgem_spec.rb index e6d6e19122..0d1058ad11 100644 --- a/spec/bundler/commands/newgem_spec.rb +++ b/spec/bundler/commands/newgem_spec.rb @@ -6,18 +6,8 @@ RSpec.describe "bundle gem" do global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false" end - def remove_push_guard(gem_name) - # Remove exception that prevents public pushes on older RubyGems versions - if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.0") - path = "#{gem_name}/#{gem_name}.gemspec" - content = File.read(path).sub(/raise "RubyGems 2\.0 or newer.*/, "") - File.open(path, "w") {|f| f.write(content) } - end - end - - def execute_bundle_gem(gem_name, flag = "", to_remove_push_guard = true) + def execute_bundle_gem(gem_name, flag = "") bundle! "gem #{gem_name} #{flag}" - remove_push_guard(gem_name) if to_remove_push_guard # reset gemspec cache for each test because of commit 3d4163a Bundler.clear_gemspec_cache end @@ -96,7 +86,7 @@ RSpec.describe "bundle gem" do shared_examples_for "--coc flag" do before do - execute_bundle_gem(gem_name, "--coc", false) + execute_bundle_gem(gem_name, "--coc") end it "generates a gem skeleton with MIT license" do gem_skeleton_assertions(gem_name) @@ -113,7 +103,7 @@ RSpec.describe "bundle gem" do shared_examples_for "--no-coc flag" do before do - execute_bundle_gem(gem_name, "--no-coc", false) + execute_bundle_gem(gem_name, "--no-coc") end it "generates a gem skeleton without Code of Conduct" do gem_skeleton_assertions(gem_name) @@ -149,7 +139,6 @@ RSpec.describe "bundle gem" do reset! in_app_root bundle "gem #{gem_name}" - remove_push_guard(gem_name) end it "contribute URL set to [USERNAME]" do @@ -173,7 +162,7 @@ RSpec.describe "bundle gem" do load_paths = [lib, spec] load_path_str = "-I#{load_paths.join(File::PATH_SEPARATOR)}" - sys_exec "PATH=\"\" #{Gem.ruby} #{load_path_str} #{bindir.join("bundle")} gem #{gem_name}" + sys_exec "#{Gem.ruby} #{load_path_str} #{bindir.join("bundle")} gem #{gem_name}", "PATH" => "" end it "creates the gem without the need for git" do @@ -202,16 +191,13 @@ RSpec.describe "bundle gem" do line.gsub(/\=.*$/, "= %q{A short summary of my new gem.}") when /spec\.description/ line.gsub(/\=.*$/, "= %q{A longer description of my new gem.}") - # Remove exception that prevents public pushes on older RubyGems versions - when /raise "RubyGems 2.0 or newer/ - line.gsub(/.*/, "") if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.0") else line end end Dir.chdir(bundled_app("newgem")) do - gems = ["rake-10.0.2", :bundler] + gems = ["rake-12.3.2", :bundler] # for Ruby core repository, Ruby 2.6+ has bundler as standard library. gems.delete(:bundler) if ruby_core? system_gems gems, :path => :bundle_path @@ -298,13 +284,12 @@ RSpec.describe "bundle gem" do reset! in_app_root bundle "gem #{gem_name}" - remove_push_guard(gem_name) end it_should_behave_like "git config is absent" end - it "sets gemspec metadata['allowed_push_host']", :rubygems => "2.0" do + it "sets gemspec metadata['allowed_push_host']" do expect(generated_gem.gemspec.metadata["allowed_push_host"]). to match(/mygemserver\.com/) end @@ -318,7 +303,7 @@ RSpec.describe "bundle gem" do end it "runs rake without problems" do - system_gems ["rake-10.0.2"] + system_gems ["rake-12.3.2"] rakefile = strip_whitespace <<-RAKEFILE task :default do @@ -396,8 +381,7 @@ RSpec.describe "bundle gem" do expect(bundled_app("test_gem/spec/spec_helper.rb")).to exist end - it "depends on a specific version of rspec", :rubygems => ">= 1.8.1" do - remove_push_guard(gem_name) + it "depends on a specific version of rspec" do rspec_dep = generated_gem.gemspec.development_dependencies.find {|d| d.name == "rspec" } expect(rspec_dep).to be_specific end @@ -415,7 +399,7 @@ RSpec.describe "bundle gem" do before do reset! in_app_root - bundle "config gem.test rspec" + bundle "config set gem.test rspec" bundle "gem #{gem_name}" end @@ -430,7 +414,7 @@ RSpec.describe "bundle gem" do before do reset! in_app_root - bundle "config gem.test rspec" + bundle "config set gem.test rspec" bundle "gem #{gem_name} --test=minitest" end @@ -447,8 +431,7 @@ RSpec.describe "bundle gem" do bundle "gem #{gem_name} --test=minitest" end - it "depends on a specific version of minitest", :rubygems => ">= 1.8.1" do - remove_push_guard(gem_name) + it "depends on a specific version of minitest" do rspec_dep = generated_gem.gemspec.development_dependencies.find {|d| d.name == "minitest" } expect(rspec_dep).to be_specific end @@ -475,7 +458,7 @@ RSpec.describe "bundle gem" do before do reset! in_app_root - bundle "config gem.test minitest" + bundle "config set gem.test minitest" bundle "gem #{gem_name}" end @@ -592,7 +575,6 @@ RSpec.describe "bundle gem" do reset! in_app_root bundle "gem #{gem_name}" - remove_push_guard(gem_name) end it_should_behave_like "git config is absent" @@ -603,7 +585,7 @@ RSpec.describe "bundle gem" do end it "runs rake without problems" do - system_gems ["rake-10.0.2"] + system_gems ["rake-12.3.2"] rakefile = strip_whitespace <<-RAKEFILE task :default do @@ -820,22 +802,22 @@ Usage: "bundle gem NAME [OPTIONS]" context "with an existing const name" do subject { "gem" } - it { expect(out).to include("Invalid gem name #{subject}") } + it { expect(err).to include("Invalid gem name #{subject}") } end context "with an existing hyphenated const name" do subject { "gem-specification" } - it { expect(out).to include("Invalid gem name #{subject}") } + it { expect(err).to include("Invalid gem name #{subject}") } end context "starting with an existing const name" do subject { "gem-somenewconstantname" } - it { expect(out).not_to include("Invalid gem name #{subject}") } + it { expect(err).not_to include("Invalid gem name #{subject}") } end context "ending with an existing const name" do subject { "somenewconstantname-gem" } - it { expect(out).not_to include("Invalid gem name #{subject}") } + it { expect(err).not_to include("Invalid gem name #{subject}") } end end @@ -868,7 +850,7 @@ Usage: "bundle gem NAME [OPTIONS]" it "asks about MIT license" do global_config "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false" - bundle :config + bundle "config list" bundle "gem foobar" do |input, _, _| input.puts "yes" diff --git a/spec/bundler/commands/open_spec.rb b/spec/bundler/commands/open_spec.rb index 5cab846fb5..659445da33 100644 --- a/spec/bundler/commands/open_spec.rb +++ b/spec/bundler/commands/open_spec.rb @@ -30,7 +30,7 @@ RSpec.describe "bundle open" do it "complains if gem not in bundle" do bundle "open missing", :env => { "EDITOR" => "echo editor", "VISUAL" => "", "BUNDLER_EDITOR" => "" } - expect(out).to match(/could not find gem 'missing'/i) + expect(err).to match(/could not find gem 'missing'/i) end it "does not blow up if the gem to open does not have a Gemfile" do @@ -48,7 +48,7 @@ RSpec.describe "bundle open" do it "suggests alternatives for similar-sounding gems" do bundle "open Rails", :env => { "EDITOR" => "echo editor", "VISUAL" => "", "BUNDLER_EDITOR" => "" } - expect(out).to match(/did you mean rails\?/i) + expect(err).to match(/did you mean rails\?/i) end it "opens the gem with short words" do @@ -80,7 +80,7 @@ RSpec.describe "bundle open" do gem "foo" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle "open rails", :env => { "EDITOR" => "echo editor", "VISUAL" => "", "BUNDLER_EDITOR" => "" } expect(out).to include("Installing foo 1.0") end diff --git a/spec/bundler/commands/outdated_spec.rb b/spec/bundler/commands/outdated_spec.rb index c9d3ac1de4..843bebf6e0 100644 --- a/spec/bundler/commands/outdated_spec.rb +++ b/spec/bundler/commands/outdated_spec.rb @@ -135,6 +135,17 @@ RSpec.describe "bundle outdated" do expect(out).to include("activesupport") expect(out).to include("duradura") end + + 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("terranova (") + + expect(out).to include("===== Group development, test =====") + expect(out).to include("activesupport") + expect(out).to include("duradura") + end end describe "with --groups option" do @@ -191,7 +202,7 @@ RSpec.describe "bundle outdated" do build_gem "activesupport", "2.3.4" end - bundle! "config clean false" + bundle! "config set clean false" install_gemfile <<-G source "file://#{gem_repo2}" @@ -302,14 +313,15 @@ RSpec.describe "bundle outdated" do end end - describe "with --strict option" do + filter_strict_option = Bundler.feature_flag.bundler_2_mode? ? :"filter-strict" : :strict + describe "with --#{filter_strict_option} option" do it "only reports gems that have a newer version that matches the specified dependency version requirements" do update_repo2 do build_gem "activesupport", "3.0" build_gem "weakling", "0.0.5" end - bundle "outdated --strict" + bundle :outdated, filter_strict_option => true expect(out).to_not include("activesupport (newest") expect(out).to include("(newest 0.0.5, installed 0.0.3, requested ~> 0.0.1)") @@ -321,7 +333,7 @@ RSpec.describe "bundle outdated" do gem "rack_middleware", "1.0" G - bundle "outdated --strict" + bundle :outdated, filter_strict_option => true expect(out).to_not include("rack (1.2") end @@ -339,7 +351,7 @@ RSpec.describe "bundle outdated" do build_gem "weakling", "0.0.5" end - bundle "outdated --strict --filter-patch" + bundle :outdated, filter_strict_option => true, "filter-patch" => true expect(out).to_not include("activesupport (newest") expect(out).to include("(newest 0.0.5, installed 0.0.3") @@ -357,7 +369,7 @@ RSpec.describe "bundle outdated" do build_gem "weakling", "0.1.5" end - bundle "outdated --strict --filter-minor" + bundle :outdated, filter_strict_option => true, "filter-minor" => true expect(out).to_not include("activesupport (newest") expect(out).to include("(newest 0.1.5, installed 0.0.3") @@ -375,7 +387,7 @@ RSpec.describe "bundle outdated" do build_gem "weakling", "1.1.5" end - bundle "outdated --strict --filter-major" + bundle :outdated, filter_strict_option => true, "filter-major" => true expect(out).to_not include("activesupport (newest") expect(out).to include("(newest 1.1.5, installed 0.0.3") @@ -386,7 +398,7 @@ RSpec.describe "bundle outdated" do describe "with invalid gem name" do it "returns could not find gem name" do bundle "outdated invalid_gem_name" - expect(out).to include("Could not find gem 'invalid_gem_name'.") + expect(err).to include("Could not find gem 'invalid_gem_name'.") end it "returns non-zero exit code" do @@ -402,7 +414,7 @@ RSpec.describe "bundle outdated" do gem "foo" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle :outdated expect(out).to include("Installing foo 1.0") end @@ -422,14 +434,14 @@ RSpec.describe "bundle outdated" do bundle "outdated" expect(last_command).to be_failure - expect(out).to include("You are trying to check outdated gems in deployment mode.") - expect(out).to include("Run `bundle outdated` elsewhere.") - expect(out).to include("If this is a development machine, remove the ") - expect(out).to include("Gemfile freeze\nby running `bundle install --no-deployment`.") + expect(err).to include("You are trying to check outdated gems in deployment mode.") + expect(err).to include("Run `bundle outdated` elsewhere.") + expect(err).to include("If this is a development machine, remove the ") + expect(err).to include("Gemfile freeze\nby running `bundle install --no-deployment`.") end end - context "after bundle config deployment true" do + context "after bundle config set deployment true" do before do install_gemfile <<-G source "file://#{gem_repo2}" @@ -437,7 +449,7 @@ RSpec.describe "bundle outdated" do gem "rack" gem "foo" G - bundle! "config deployment true" + bundle! "config set deployment true" end it "outputs a helpful message about being in deployment mode" do @@ -445,10 +457,10 @@ RSpec.describe "bundle outdated" do bundle "outdated" expect(last_command).to be_failure - expect(out).to include("You are trying to check outdated gems in deployment mode.") - expect(out).to include("Run `bundle outdated` elsewhere.") - expect(out).to include("If this is a development machine, remove the ") - expect(out).to include("Gemfile freeze\nby running `bundle config --delete deployment`.") + expect(err).to include("You are trying to check outdated gems in deployment mode.") + expect(err).to include("Run `bundle outdated` elsewhere.") + expect(err).to include("If this is a development machine, remove the ") + expect(err).to include("Gemfile freeze\nby running `bundle config unset deployment`.") end end diff --git a/spec/bundler/commands/package_spec.rb b/spec/bundler/commands/package_spec.rb index a8426e6322..6cd8e3f85a 100644 --- a/spec/bundler/commands/package_spec.rb +++ b/spec/bundler/commands/package_spec.rb @@ -179,10 +179,22 @@ RSpec.describe "bundle package" do expect(the_bundle).to include_gems "rack 1.0.0" end + + it "does not prevent installing gems with bundle update" do + gemfile <<-D + source "file://#{gem_repo1}" + gem "rack", "1.0.0" + D + + bundle! "package --no-install" + bundle! "update --all" + + expect(the_bundle).to include_gems "rack 1.0.0" + end end context "with --all-platforms" do - it "puts the gems in vendor/cache even for other rubies", :ruby => "2.1" do + it "puts the gems in vendor/cache even for other rubies" do gemfile <<-D source "file://#{gem_repo1}" gem 'rack', :platforms => :ruby_19 @@ -205,7 +217,7 @@ RSpec.describe "bundle package" do subject { bundle :package, forgotten_command_line_options(:frozen => true) } it "tries to install with frozen" do - bundle! "config deployment true" + bundle! "config set deployment true" gemfile <<-G source "file://#{gem_repo1}" gem "rack" @@ -213,9 +225,9 @@ RSpec.describe "bundle package" do G subject expect(exitstatus).to eq(16) if exitstatus - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile") - expect(out).to include("* rack-obama") + expect(err).to include("deployment mode") + expect(err).to include("You have added to the Gemfile") + expect(err).to include("* rack-obama") bundle "env" expect(out).to include("frozen").or include("deployment") end @@ -266,7 +278,7 @@ RSpec.describe "bundle install with gem sources" do end bundle :install - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(the_bundle).to include_gems "rack 1.0" end diff --git a/spec/bundler/commands/pristine_spec.rb b/spec/bundler/commands/pristine_spec.rb index d8761bba26..93eb81f2af 100644 --- a/spec/bundler/commands/pristine_spec.rb +++ b/spec/bundler/commands/pristine_spec.rb @@ -42,7 +42,7 @@ RSpec.describe "bundle pristine", :ruby_repo do expect(changes_txt).to_not be_file end - it "does not delete the bundler gem" do + it "does not delete the bundler gem", :rubygems => ">= 2.6.2" do ENV["BUNDLER_SPEC_KEEP_DEFAULT_BUNDLER_GEM"] = "true" system_gems :bundler bundle! "install" @@ -95,7 +95,7 @@ RSpec.describe "bundle pristine", :ruby_repo do bundle "pristine" expect(File.read(changed_file)).to include(diff) - expect(out).to include("Cannot pristine #{spec.name} (#{spec.version}#{spec.git_version}). Gem is sourced from local path.") + expect(err).to include("Cannot pristine #{spec.name} (#{spec.version}#{spec.git_version}). Gem is sourced from local path.") end it "reinstall gemspec dependency" do @@ -118,7 +118,7 @@ RSpec.describe "bundle pristine", :ruby_repo do FileUtils.touch(changes_txt) expect(changes_txt).to be_file bundle "pristine" - expect(out).to include("Cannot pristine #{spec.name} (#{spec.version}#{spec.git_version}). Gem is sourced from local path.") + expect(err).to include("Cannot pristine #{spec.name} (#{spec.version}#{spec.git_version}). Gem is sourced from local path.") expect(changes_txt).to be_file end end @@ -142,8 +142,8 @@ RSpec.describe "bundle pristine", :ruby_repo do bundle! "pristine foo bar weakling" - expect(out).to include("Cannot pristine bar (1.0). Gem is sourced from local path."). - and include("Installing weakling 1.0") + expect(err).to include("Cannot pristine bar (1.0). Gem is sourced from local path.") + expect(out).to include("Installing weakling 1.0") expect(weakling_changes_txt).not_to be_file expect(foo_changes_txt).not_to be_file @@ -152,7 +152,7 @@ RSpec.describe "bundle pristine", :ruby_repo do it "raises when one of them is not in the lockfile" do bundle "pristine abcabcabc" - expect(out).to include("Could not find gem 'abcabcabc'.") + expect(err).to include("Could not find gem 'abcabcabc'.") end end @@ -160,7 +160,7 @@ RSpec.describe "bundle pristine", :ruby_repo do let(:very_simple_binary) { Bundler.definition.specs["very_simple_binary"].first } let(:c_ext_dir) { Pathname.new(very_simple_binary.full_gem_path).join("ext") } let(:build_opt) { "--with-ext-lib=#{c_ext_dir}" } - before { bundle "config build.very_simple_binary -- #{build_opt}" } + before { bundle "config set build.very_simple_binary -- #{build_opt}" } # This just verifies that the generated Makefile from the c_ext gem makes # use of the build_args from the bundle config @@ -177,7 +177,7 @@ RSpec.describe "bundle pristine", :ruby_repo do let(:git_with_ext) { Bundler.definition.specs["git_with_ext"].first } let(:c_ext_dir) { Pathname.new(git_with_ext.full_gem_path).join("ext") } let(:build_opt) { "--with-ext-lib=#{c_ext_dir}" } - before { bundle "config build.git_with_ext -- #{build_opt}" } + before { bundle "config set build.git_with_ext -- #{build_opt}" } # This just verifies that the generated Makefile from the c_ext gem makes # use of the build_args from the bundle config diff --git a/spec/bundler/commands/remove_spec.rb b/spec/bundler/commands/remove_spec.rb index faeb654b14..7695d2a881 100644 --- a/spec/bundler/commands/remove_spec.rb +++ b/spec/bundler/commands/remove_spec.rb @@ -9,7 +9,7 @@ RSpec.describe "bundle remove" do bundle "remove" - expect(out).to include("Please specify gems to remove.") + expect(err).to include("Please specify gems to remove.") end end @@ -54,7 +54,7 @@ RSpec.describe "bundle remove" do bundle "remove rack" - expect(out).to include("`rack` is not specified in #{bundled_app("Gemfile")} so it could not be removed.") + expect(err).to include("`rack` is not specified in #{bundled_app("Gemfile")} so it could not be removed.") end end end @@ -91,7 +91,7 @@ RSpec.describe "bundle remove" do bundle "remove rails rack minitest" - expect(out).to include("`rack` is not specified in #{bundled_app("Gemfile")} so it could not be removed.") + expect(err).to include("`rack` is not specified in #{bundled_app("Gemfile")} so it could not be removed.") gemfile_should_be <<-G source "file://#{gem_repo1}" @@ -140,6 +140,30 @@ RSpec.describe "bundle remove" do end end + context "when gem to be removed is outside block" do + it "does not modify group" do + gemfile <<-G + source "file://#{gem_repo1}" + + gem "rack" + group :test do + gem "coffee-script-source" + end + G + + bundle! "remove rack" + + expect(out).to include("rack was removed.") + gemfile_should_be <<-G + source "file://#{gem_repo1}" + + group :test do + gem "coffee-script-source" + end + G + end + end + context "when an empty block is also present" do it "removes all empty blocks" do gemfile <<-G @@ -294,11 +318,7 @@ RSpec.describe "bundle remove" do bundle "remove rails" - if Gem::VERSION >= "1.6.0" - expect(out).to include("Gems could not be removed. rack (>= 0) would also have been removed.") - else - expect(out).to include("Gems could not be removed. rack (>= 0, runtime) would also have been removed.") - end + expect(err).to include("Gems could not be removed. rack (>= 0) would also have been removed.") gemfile_should_be <<-G source "file://#{gem_repo1}" gem "rack"; gem "rails" @@ -416,7 +436,7 @@ RSpec.describe "bundle remove" do bundle "remove rack" - expect(out).to include("`rack` is not specified in #{bundled_app("Gemfile")} so it could not be removed.") + expect(err).to include("`rack` is not specified in #{bundled_app("Gemfile")} so it could not be removed.") end end @@ -436,7 +456,7 @@ RSpec.describe "bundle remove" do bundle "remove rack" expect(out).to include("rack was removed.") - expect(out).to include("`rack` is not specified in #{bundled_app("Gemfile-other")} so it could not be removed.") + expect(err).to include("`rack` is not specified in #{bundled_app("Gemfile-other")} so it could not be removed.") gemfile_should_be <<-G source "file://#{gem_repo1}" @@ -461,11 +481,7 @@ RSpec.describe "bundle remove" do bundle "remove rack" expect(out).to include("rack was removed.") - if Gem::VERSION >= "1.6.0" - expect(out).to include("Gems could not be removed. rails (>= 0) would also have been removed.") - else - expect(out).to include("Gems could not be removed. rails (>= 0, runtime) would also have been removed.") - end + expect(err).to include("Gems could not be removed. rails (>= 0) would also have been removed.") gemfile_should_be <<-G source "file://#{gem_repo1}" @@ -489,11 +505,7 @@ RSpec.describe "bundle remove" do bundle "remove rack" - if Gem::VERSION >= "1.6.0" - expect(out).to include("Gems could not be removed. rails (>= 0) would also have been removed.") - else - expect(out).to include("Gems could not be removed. rails (>= 0, runtime) would also have been removed.") - end + expect(err).to include("Gems could not be removed. rails (>= 0) would also have been removed.") expect(bundled_app("Gemfile-other").read).to include("gem \"rack\"") gemfile_should_be <<-G source "file://#{gem_repo1}" diff --git a/spec/bundler/commands/show_spec.rb b/spec/bundler/commands/show_spec.rb index a5c6beec1a..8fb6631f82 100644 --- a/spec/bundler/commands/show_spec.rb +++ b/spec/bundler/commands/show_spec.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do +RSpec.describe "bundle show", :bundler => "< 3" do context "with a standard Gemfile" do before :each do install_gemfile <<-G @@ -30,46 +30,9 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s) end - context "when show command deprecation is enabled" do - before { bundle "config major_deprecations yes" } - - it "prints path if gem exists in bundle" do - bundle "show rails" - expect(out).to eq( - "[DEPRECATED FOR 3.0] use `bundle info rails` instead of `bundle show rails`\n" + - default_bundle_path("gems", "rails-2.3.2").to_s - ) - end - - it "prints the path to the running bundler" do - bundle "show bundler" - expect(out).to eq( - "[DEPRECATED FOR 3.0] use `bundle info bundler` instead of `bundle show bundler`\n" + - root.to_s - ) - end - - it "prints path if gem exists in bundle (with --paths option)" do - bundle "show rails --paths" - expect(out).to eq( - "[DEPRECATED FOR 3.0] use `bundle info rails --path` instead of `bundle show rails --paths`\n" + - default_bundle_path("gems", "rails-2.3.2").to_s - ) - end - - it "prints path of all gems in bundle sorted by name" do - bundle "show --paths" - - expect(out).to include(default_bundle_path("gems", "rake-10.0.2").to_s) - expect(out).to include(default_bundle_path("gems", "rails-2.3.2").to_s) - - out_lines = out.split("\n") - expect(out_lines[0]).to eq("[DEPRECATED FOR 3.0] use `bundle list` instead of `bundle show --paths`") - - # Gem names are the last component of their path. - gem_list = out_lines[1..-1].map {|p| p.split("/").last } - expect(gem_list).to eq(gem_list.sort) - 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 @@ -77,13 +40,18 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do 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")) bundle "show rails" - expect(out).to match(/has been deleted/i). - and include(default_bundle_path("gems", "rails-2.3.2").to_s) + expect(err).to match(/has been deleted/i) + expect(err).to match(default_bundle_path("gems", "rails-2.3.2").to_s) end it "prints the path to the running bundler" do @@ -91,15 +59,19 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" 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(out).to match(/could not find gem 'missing'/i) + expect(err).to match(/could not find gem 'missing'/i) end it "prints path of all gems in bundle sorted by name" do bundle "show --paths" - expect(out).to include(default_bundle_path("gems", "rake-10.0.2").to_s) + expect(out).to include(default_bundle_path("gems", "rake-12.3.2").to_s) expect(out).to include(default_bundle_path("gems", "rails-2.3.2").to_s) # Gem names are the last component of their path. @@ -107,19 +79,18 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do expect(gem_list).to eq(gem_list.sort) end + it "prints a deprecation when called with the --paths option" do + bundle "show --paths" + + expect(err).to eq("[DEPRECATED] use `bundle list` instead of `bundle show --paths`") + end + it "prints summary of gems" do bundle "show --verbose" - loaded_bundler_spec = Bundler.load.specs["bundler"] - expected = if !loaded_bundler_spec.empty? - loaded_bundler_spec[0].homepage - else - "No website available." - end - 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: #{expected}") + expect(out).to include("\tHomepage: No website available.") expect(out).to include("\tStatus: Up to date") end end @@ -164,7 +135,7 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do expect(out).to include("foo (1.0 #{sha[0..6]})") end - it "handles when a version is a '-' prerelease", :rubygems => "2.1" do + it "handles when a version is a '-' prerelease" do @git = build_git("foo", "1.0.0-beta.1", :path => lib_path("foo")) install_gemfile <<-G gem "foo", "1.0.0-beta.1", :git => "#{lib_path("foo")}" @@ -186,7 +157,7 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do it "does not output git errors" do bundle :show - expect(err).to lack_errors + expect(err_without_deprecations).to be_empty end end @@ -196,11 +167,24 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do gem "foo" G - bundle "config auto_install 1" + bundle "config set auto_install 1" bundle :show expect(out).to include("Installing foo 1.0") end + context "with a valid regexp for gem name" do + it "presents alternatives" do + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack" + gem "rack-obama" + G + + bundle "show rac" + expect(out).to eq "1 : rack\n2 : rack-obama\n0 : - exit -\n>" + end + end + context "with an invalid regexp for gem name" do it "does not find the gem" do install_gemfile <<-G @@ -211,7 +195,7 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do invalid_regexp = "[]" bundle "show #{invalid_regexp}" - expect(out).to include("Could not find gem '#{invalid_regexp}'.") + expect(err).to include("Could not find gem '#{invalid_regexp}'.") end end @@ -242,3 +226,7 @@ RSpec.describe "bundle show", :bundler => "< 3", :ruby => ">= 2.0" do end end end + +RSpec.describe "bundle show", :bundler => "3" do + pending "shows a friendly error about the command removal" +end diff --git a/spec/bundler/commands/update_spec.rb b/spec/bundler/commands/update_spec.rb index 1effba6526..46c208db6c 100644 --- a/spec/bundler/commands/update_spec.rb +++ b/spec/bundler/commands/update_spec.rb @@ -8,6 +8,7 @@ RSpec.describe "bundle update" do source "file://#{gem_repo2}" gem "activesupport" gem "rack-obama" + gem "platform_specific" G end @@ -64,25 +65,25 @@ RSpec.describe "bundle update" do gem "rack", "1.0" G - bundle! "update --gemfile OmgFile", :all => bundle_update_requires_all? + bundle! "update --gemfile OmgFile", :all => true expect(bundled_app("OmgFile.lock")).to exist end end context "when update_requires_all_flag is set" do - before { bundle! "config update_requires_all_flag true" } + before { bundle! "config set update_requires_all_flag true" } it "errors when passed nothing" do install_gemfile! "" bundle :update - expect(out).to eq("To update everything, pass the `--all` flag.") + expect(err).to eq("To update everything, pass the `--all` flag.") end it "errors when passed --all and another option" do install_gemfile! "" bundle "update --all foo" - expect(out).to eq("Cannot specify --all along with specific options.") + expect(err).to eq("Cannot specify --all along with specific options.") end it "updates everything when passed --all" do @@ -113,11 +114,11 @@ RSpec.describe "bundle update" do describe "with an unknown dependency" do it "should inform the user" do bundle "update halting-problem-solver" - expect(out).to include "Could not find gem 'halting-problem-solver'" + expect(err).to include "Could not find gem 'halting-problem-solver'" end it "should suggest alternatives" do - bundle "update active-support" - expect(out).to include "Did you mean activesupport?" + bundle "update platformspecific" + expect(err).to include "Did you mean platform_specific?" end end @@ -132,7 +133,7 @@ RSpec.describe "bundle update" do describe "when a possible resolve requires an older version of a locked gem" do context "and only_update_to_newer_versions is set" do before do - bundle! "config only_update_to_newer_versions true" + bundle! "config set only_update_to_newer_versions true" end it "does not go to an older version" do @@ -166,7 +167,7 @@ RSpec.describe "bundle update" do end end - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true expect(the_bundle).to include_gems("slim 3.0.9", "slim-rails 3.1.3", "slim_lint 0.16.1") end @@ -281,25 +282,25 @@ RSpec.describe "bundle update" do describe "in a frozen bundle" do it "should fail loudly", :bundler => "< 3" do bundle! "install --deployment" - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(last_command).to be_failure - expect(out).to match(/You are trying to install in deployment mode after changing.your Gemfile/m) - expect(out).to match(/freeze \nby running `bundle install --no-deployment`./m) + expect(err).to match(/You are trying to install in deployment mode after changing.your Gemfile/m) + expect(err).to match(/freeze \nby running `bundle install --no-deployment`./m) end it "should suggest different command when frozen is set globally", :bundler => "< 3" do - bundle! "config --global frozen 1" - bundle "update", :all => bundle_update_requires_all? - expect(out).to match(/You are trying to install in deployment mode after changing.your Gemfile/m). - and match(/freeze \nby running `bundle config --delete frozen`./m) + bundle! "config set --global frozen 1" + bundle "update", :all => true + expect(err).to match(/You are trying to install in deployment mode after changing.your Gemfile/m). + and match(/freeze \nby running `bundle config unset frozen`./m) end it "should suggest different command when frozen is set globally", :bundler => "3" do - bundle! "config --global deployment true" - bundle "update", :all => bundle_update_requires_all? - expect(out).to match(/You are trying to install in deployment mode after changing.your Gemfile/m). - and match(/freeze \nby running `bundle config --delete deployment`./m) + bundle! "config set --global deployment true" + bundle "update", :all => true + expect(err).to match(/You are trying to install in deployment mode after changing.your Gemfile/m). + and match(/freeze \nby running `bundle config unset deployment`./m) end end @@ -327,7 +328,7 @@ RSpec.describe "bundle update" do end context "with unlock_source_unlocks_spec set to false" do - before { bundle! "config unlock_source_unlocks_spec false" } + before { bundle! "config set unlock_source_unlocks_spec false" } it "should not update gems not included in the source that happen to have the same name" do install_gemfile <<-G @@ -541,7 +542,7 @@ RSpec.describe "bundle update without a Gemfile.lock" do gem "rack", "1.0" G - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(the_bundle).to include_gems "rack 1.0.0" end @@ -562,7 +563,7 @@ RSpec.describe "bundle update when a gem depends on a newer version of bundler" end it "should explain that bundler conflicted", :bundler => "< 3" do - bundle "update", :all => bundle_update_requires_all? + 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). and match(/perhaps you need to update bundler/i) @@ -585,19 +586,19 @@ RSpec.describe "bundle update" do gem "activesupport" G - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(out).to include("Using activesupport 2.3.5") update_repo2 do build_gem "activesupport", "3.0" end - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(out).to include("Installing activesupport 3.0 (was 2.3.5)") end context "with suppress_install_using_messages set" do - before { bundle! "config suppress_install_using_messages true" } + before { bundle! "config set suppress_install_using_messages true" } it "only prints `Using` for versions that have changed" do build_repo4 do @@ -611,7 +612,7 @@ RSpec.describe "bundle update" do gem "foo" G - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true out.gsub!(/RubyGems [\d\.]+ is not threadsafe.*\n?/, "") expect(out).to include "Resolving dependencies...\nBundle updated!" @@ -619,7 +620,7 @@ RSpec.describe "bundle update" do build_gem "foo", "2.0" end - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true out.sub!("Removing foo (1.0)\n", "") out.gsub!(/RubyGems [\d\.]+ is not threadsafe.*\n?/, "") expect(out).to include strip_whitespace(<<-EOS).strip @@ -638,7 +639,7 @@ RSpec.describe "bundle update" do G bundle "update nonexisting" - expect(out).to include("This Bundle hasn't been installed yet. Run `bundle install` to update and install the bundled gems.") + expect(err).to include("This Bundle hasn't been installed yet. Run `bundle install` to update and install the bundled gems.") expect(exitstatus).to eq(22) if exitstatus end end @@ -718,7 +719,7 @@ RSpec.describe "bundle update --ruby" do it "shows a helpful error message" do bundle "update --ruby" - expect(out).to include("Your Ruby version is 2.2.2, but your Gemfile specified ~> 2.1.0") + expect(err).to include("Your Ruby version is 2.2.2, but your Gemfile specified ~> 2.1.0") end end @@ -808,6 +809,15 @@ RSpec.describe "bundle update conservative" do G end + context "with patch set as default update level in config" do + it "should do a patch level update" do + bundle! "config set --local prefer_patch true" + bundle! "update foo" + + expect(the_bundle).to include_gems "foo 1.4.5", "bar 2.1.1", "qux 1.0.0" + end + end + context "patch preferred" do it "single gem updates dependent gem to minor" do bundle! "update --patch foo" @@ -816,7 +826,7 @@ RSpec.describe "bundle update conservative" do end it "update all" do - bundle! "update --patch", :all => bundle_update_requires_all? + bundle! "update --patch", :all => true expect(the_bundle).to include_gems "foo 1.4.5", "bar 2.1.1", "qux 1.0.1" end @@ -838,7 +848,7 @@ RSpec.describe "bundle update conservative" do end it "minor preferred" do - bundle! "update --minor --strict", :all => bundle_update_requires_all? + bundle! "update --minor --strict", :all => true expect(the_bundle).to include_gems "foo 1.5.0", "bar 2.1.1", "qux 1.1.0" end @@ -935,7 +945,7 @@ RSpec.describe "bundle update conservative" do end it "raises if too many flags are provided" do - bundle "update --patch --minor", :all => bundle_update_requires_all? + bundle "update --patch --minor", :all => true expect(last_command.bundler_err).to eq "Provide only one of the following options: minor, patch" end diff --git a/spec/bundler/commands/viz_spec.rb b/spec/bundler/commands/viz_spec.rb index 61414956a9..96cc21b5f7 100644 --- a/spec/bundler/commands/viz_spec.rb +++ b/spec/bundler/commands/viz_spec.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -RSpec.describe "bundle viz", :ruby => "1.9.3", :bundler => "< 3", :if => Bundler.which("dot") do +RSpec.describe "bundle viz", :bundler => "< 3", :if => Bundler.which("dot") do let(:ruby_graphviz) do graphviz_glob = base_system_gems.join("cache/ruby-graphviz*") Pathname.glob(graphviz_glob).first diff --git a/spec/bundler/install/allow_offline_install_spec.rb b/spec/bundler/install/allow_offline_install_spec.rb index d4bb595771..8af88b7efe 100644 --- a/spec/bundler/install/allow_offline_install_spec.rb +++ b/spec/bundler/install/allow_offline_install_spec.rb @@ -2,7 +2,7 @@ RSpec.describe "bundle install with :allow_offline_install" do before do - bundle "config allow_offline_install true" + bundle "config set allow_offline_install true" end context "with no cached data locally" do @@ -19,7 +19,7 @@ RSpec.describe "bundle install with :allow_offline_install" do source "http://testgemserver.local" gem "rack-obama" G - expect(out).to include("Could not reach host testgemserver.local.") + expect(err).to include("Could not reach host testgemserver.local.") expect(the_bundle).to_not be_locked end end @@ -28,7 +28,7 @@ RSpec.describe "bundle install with :allow_offline_install" do it "will install from the compact index" do system_gems ["rack-1.0.0"], :path => :bundle_path - bundle! "config clean false" + bundle! "config set clean false" install_gemfile! <<-G, :artifice => "compact_index" source "http://testgemserver.local" gem "rack-obama" @@ -77,7 +77,7 @@ RSpec.describe "bundle install with :allow_offline_install" do G break_git_remote_ops! { bundle! :update, :all => true } - expect(out).to include("Using cached git data because of network errors") + expect(err).to include("Using cached git data because of network errors") expect(the_bundle).to be_locked break_git_remote_ops! do @@ -85,7 +85,7 @@ RSpec.describe "bundle install with :allow_offline_install" do gem "a", :git => #{git.path.to_s.dump}, :branch => "new_branch" G end - expect(out).to include("Using cached git data because of network errors") + expect(err).to include("Using cached git data because of network errors") expect(the_bundle).to be_locked end end diff --git a/spec/bundler/install/binstubs_spec.rb b/spec/bundler/install/binstubs_spec.rb index f04d3fe654..daa20693c7 100644 --- a/spec/bundler/install/binstubs_spec.rb +++ b/spec/bundler/install/binstubs_spec.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -RSpec.describe "bundle install", :bundler => "< 3" do +RSpec.describe "bundle install" do describe "when system_bindir is set" do # On OS X, Gem.bindir defaults to /usr/bin, so system_bindir is useful if # you want to avoid sudo installs for system gems with OS X's default ruby @@ -20,7 +20,7 @@ RSpec.describe "bundle install", :bundler => "< 3" do end end - describe "when multiple gems contain the same exe", :bundler => "< 3" do + describe "when multiple gems contain the same exe" do before do build_repo2 do build_gem "fake", "14" do |s| @@ -28,16 +28,25 @@ RSpec.describe "bundle install", :bundler => "< 3" do end end - install_gemfile <<-G, :binstubs => true + install_gemfile <<-G source "file://#{gem_repo2}" gem "fake" gem "rack" G end - it "loads the correct spec's executable" do - gembin("rackup") - expect(out).to eq("1.2") + it "warns about the situation" do + bundle! "exec rackup" + + expect(last_command.stderr).to include( + "The `rackup` executable in the `fake` gem is being loaded, but it's also present in other gems (rack).\n" \ + "If you meant to run the executable for another gem, make sure you use a project specific binstub (`bundle binstub <gem_name>`).\n" \ + "If you plan to use multiple conflicting executables, generate binstubs for them and disambiguate their names." + ).or include( + "The `rackup` executable in the `rack` gem is being loaded, but it's also present in other gems (fake).\n" \ + "If you meant to run the executable for another gem, make sure you use a project specific binstub (`bundle binstub <gem_name>`).\n" \ + "If you plan to use multiple conflicting executables, generate binstubs for them and disambiguate their names." + ) end end end diff --git a/spec/bundler/install/bundler_spec.rb b/spec/bundler/install/bundler_spec.rb index 42863ed89b..3347988cdd 100644 --- a/spec/bundler/install/bundler_spec.rb +++ b/spec/bundler/install/bundler_spec.rb @@ -125,8 +125,8 @@ RSpec.describe "bundle install" do expect(last_command.bundler_err).to include(nice_error) end - it "can install dependencies with newer bundler version with system gems", :ruby => "> 2" do - bundle! "config path.system true" + it "can install dependencies with newer bundler version with system gems" do + bundle! "config set path.system true" install_gemfile! <<-G source "file://#{gem_repo2}" gem "rails", "3.0" @@ -138,9 +138,9 @@ RSpec.describe "bundle install" do expect(out).to include("The Gemfile's dependencies are satisfied") end - it "can install dependencies with newer bundler version with a local path", :ruby => "> 2" do - bundle! "config path .bundle" - bundle! "config global_path_appends_ruby_scope true" + 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" @@ -153,7 +153,7 @@ RSpec.describe "bundle install" do end context "with allow_bundler_dependency_conflicts set" do - before { bundle! "config allow_bundler_dependency_conflicts true" } + before { bundle! "config set allow_bundler_dependency_conflicts true" } it "are forced to the current bundler version with warnings when no compatible version is found" do build_repo4 do @@ -167,7 +167,7 @@ RSpec.describe "bundle install" do gem "requires_nonexistant_bundler" G - expect(out).to include "requires_nonexistant_bundler (1.0) has dependency bundler (= 99.99.99.99), " \ + expect(err).to include "requires_nonexistant_bundler (1.0) has dependency bundler (= 99.99.99.99), " \ "which is unsatisfied by the current bundler version #{Bundler::VERSION}, so the dependency is being ignored" expect(the_bundle).to include_gems "bundler #{Bundler::VERSION}", "requires_nonexistant_bundler 1.0" diff --git a/spec/bundler/install/deploy_spec.rb b/spec/bundler/install/deploy_spec.rb index ec72ff69fc..918dbabfbe 100644 --- a/spec/bundler/install/deploy_spec.rb +++ b/spec/bundler/install/deploy_spec.rb @@ -11,26 +11,26 @@ RSpec.describe "install with --deployment or --frozen" do context "with CLI flags", :bundler => "< 3" do it "fails without a lockfile and says that --deployment requires a lock" do bundle "install --deployment" - expect(out).to include("The --deployment flag requires a Gemfile.lock") + expect(err).to include("The --deployment flag requires a Gemfile.lock") end it "fails without a lockfile and says that --frozen requires a lock" do bundle "install --frozen" - expect(out).to include("The --frozen flag requires a Gemfile.lock") + expect(err).to include("The --frozen flag requires a Gemfile.lock") end it "disallows --deployment --system" do bundle "install --deployment --system" - expect(out).to include("You have specified both --deployment") - expect(out).to include("Please choose only one option") + expect(err).to include("You have specified both --deployment") + expect(err).to include("Please choose only one option") expect(exitstatus).to eq(15) if exitstatus end it "disallows --deployment --path --system" do bundle "install --deployment --path . --system" - expect(out).to include("You have specified both --path") - expect(out).to include("as well as --system") - expect(out).to include("Please choose only one option") + expect(err).to include("You have specified both --path") + expect(err).to include("as well as --system") + expect(err).to include("Please choose only one option") expect(exitstatus).to eq(15) if exitstatus end @@ -129,11 +129,11 @@ RSpec.describe "install with --deployment or --frozen" do G bundle :install, forgotten_command_line_options(:deployment => true) - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile") - expect(out).to include("* rack-obama") - expect(out).not_to include("You have deleted from the Gemfile") - expect(out).not_to include("You have changed in the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have added to the Gemfile") + expect(err).to include("* rack-obama") + expect(err).not_to include("You have deleted from the Gemfile") + expect(err).not_to include("You have changed in the Gemfile") end it "works if a path gem is missing but is in a without group" do @@ -162,7 +162,7 @@ RSpec.describe "install with --deployment or --frozen" do FileUtils.rm_r lib_path("path_gem-1.0") bundle :install, forgotten_command_line_options(:path => ".bundle", :deployment => true) - expect(out).to include("The path `#{lib_path("path_gem-1.0")}` does not exist.") + expect(err).to include("The path `#{lib_path("path_gem-1.0")}` does not exist.") end it "can have --frozen set via an environment variable", :bundler => "< 3" do @@ -174,11 +174,11 @@ RSpec.describe "install with --deployment or --frozen" do ENV["BUNDLE_FROZEN"] = "1" bundle "install" - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile") - expect(out).to include("* rack-obama") - expect(out).not_to include("You have deleted from the Gemfile") - expect(out).not_to include("You have changed in the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have added to the Gemfile") + expect(err).to include("* rack-obama") + expect(err).not_to include("You have deleted from the Gemfile") + expect(err).not_to include("You have changed in the Gemfile") end it "can have --deployment set via an environment variable" do @@ -190,11 +190,11 @@ RSpec.describe "install with --deployment or --frozen" do ENV["BUNDLE_DEPLOYMENT"] = "true" bundle "install" - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile") - expect(out).to include("* rack-obama") - expect(out).not_to include("You have deleted from the Gemfile") - expect(out).not_to include("You have changed in the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have added to the Gemfile") + expect(err).to include("* rack-obama") + expect(err).not_to include("You have deleted from the Gemfile") + expect(err).not_to include("You have changed in the Gemfile") end it "can have --frozen set to false via an environment variable" do @@ -212,21 +212,6 @@ RSpec.describe "install with --deployment or --frozen" do expect(out).not_to include("* rack-obama") end - it "explodes with the --frozen flag if you make a change and don't check in the lockfile", :bundler => "< 2" do - gemfile <<-G - source "file://#{gem_repo1}" - gem "rack" - gem "rack-obama", "1.1" - G - - bundle :install, forgotten_command_line_options(:frozen => true) - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile") - expect(out).to include("* rack-obama (= 1.1)") - expect(out).not_to include("You have deleted from the Gemfile") - expect(out).not_to include("You have changed in the Gemfile") - end - it "explodes if you remove a gem and don't check in the lockfile" do gemfile <<-G source "file://#{gem_repo1}" @@ -234,10 +219,10 @@ RSpec.describe "install with --deployment or --frozen" do G bundle :install, forgotten_command_line_options(:deployment => true) - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile:\n* activesupport\n\n") - expect(out).to include("You have deleted from the Gemfile:\n* rack") - expect(out).not_to include("You have changed in the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have added to the Gemfile:\n* activesupport\n\n") + expect(err).to include("You have deleted from the Gemfile:\n* rack") + expect(err).not_to include("You have changed in the Gemfile") end it "explodes if you add a source" do @@ -247,9 +232,9 @@ RSpec.describe "install with --deployment or --frozen" do G bundle :install, forgotten_command_line_options(:deployment => true) - expect(out).to include("deployment mode") - expect(out).to include("You have added to the Gemfile:\n* source: git://hubz.com (at master)") - expect(out).not_to include("You have changed in the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have added to the Gemfile:\n* source: git://hubz.com (at master)") + expect(err).not_to include("You have changed in the Gemfile") end it "explodes if you unpin a source" do @@ -266,10 +251,10 @@ RSpec.describe "install with --deployment or --frozen" do G bundle :install, forgotten_command_line_options(:deployment => true) - expect(out).to include("deployment mode") - expect(out).to include("You have deleted from the Gemfile:\n* source: #{lib_path("rack-1.0")} (at master@#{revision_for(lib_path("rack-1.0"))[0..6]}") - expect(out).not_to include("You have added to the Gemfile") - expect(out).not_to include("You have changed in the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have deleted from the Gemfile:\n* source: #{lib_path("rack-1.0")} (at master@#{revision_for(lib_path("rack-1.0"))[0..6]}") + expect(err).not_to include("You have added to the Gemfile") + expect(err).not_to include("You have changed in the Gemfile") end it "explodes if you unpin a source, leaving it pinned somewhere else" do @@ -289,19 +274,15 @@ RSpec.describe "install with --deployment or --frozen" do G bundle :install, forgotten_command_line_options(:deployment => true) - expect(out).to include("deployment mode") - expect(out).to include("You have changed in the Gemfile:\n* rack from `no specified source` to `#{lib_path("rack")} (at master@#{revision_for(lib_path("rack"))[0..6]})`") - expect(out).not_to include("You have added to the Gemfile") - expect(out).not_to include("You have deleted from the Gemfile") + expect(err).to include("deployment mode") + expect(err).to include("You have changed in the Gemfile:\n* rack from `no specified source` to `#{lib_path("rack")} (at master@#{revision_for(lib_path("rack"))[0..6]})`") + expect(err).not_to include("You have added to the Gemfile") + expect(err).not_to include("You have deleted from the Gemfile") end context "when replacing a host with the same host with credentials" do let(:success_message) do - if Bundler.bundler_major_version < 3 - "Could not reach host localgemserver.test" - else - "Bundle complete!" - end + "Bundle complete!" end before do @@ -322,31 +303,33 @@ RSpec.describe "install with --deployment or --frozen" do DEPENDENCIES rack G + + bundle! "config set --local deployment true" end it "prevents the replace by default" do - bundle :install, forgotten_command_line_options(:deployment => true) + bundle :install - expect(out).to match(/The list of sources changed/) + expect(err).to match(/The list of sources changed/) end context "when allow_deployment_source_credential_changes is true" do - before { bundle! "config allow_deployment_source_credential_changes true" } + before { bundle! "config set allow_deployment_source_credential_changes true" } it "allows the replace" do - bundle :install, forgotten_command_line_options(:deployment => true) + bundle :install expect(out).to match(/#{success_message}/) end end context "when allow_deployment_source_credential_changes is false" do - before { bundle! "config allow_deployment_source_credential_changes false" } + before { bundle! "config set allow_deployment_source_credential_changes false" } it "prevents the replace" do - bundle :install, forgotten_command_line_options(:deployment => true) + bundle :install - expect(out).to match(/The list of sources changed/) + expect(err).to match(/The list of sources changed/) end end @@ -354,7 +337,7 @@ RSpec.describe "install with --deployment or --frozen" do before { ENV["BUNDLE_ALLOW_DEPLOYMENT_SOURCE_CREDENTIAL_CHANGES"] = "true" } it "allows the replace" do - bundle :install, forgotten_command_line_options(:deployment => true) + bundle :install expect(out).to match(/#{success_message}/) end @@ -364,9 +347,9 @@ RSpec.describe "install with --deployment or --frozen" do before { ENV["BUNDLE_ALLOW_DEPLOYMENT_SOURCE_CREDENTIAL_CHANGES"] = "false" } it "prevents the replace" do - bundle :install, forgotten_command_line_options(:deployment => true) + bundle :install - expect(out).to match(/The list of sources changed/) + expect(err).to match(/The list of sources changed/) end end end @@ -374,7 +357,7 @@ RSpec.describe "install with --deployment or --frozen" do it "remembers that the bundle is frozen at runtime" do bundle! :lock - bundle! "config deployment true" + bundle! "config set --local deployment true" gemfile <<-G source "file://#{gem_repo1}" @@ -383,7 +366,7 @@ RSpec.describe "install with --deployment or --frozen" do G expect(the_bundle).not_to include_gems "rack 1.0.0" - expect(err).to include strip_whitespace(<<-E).strip + expect(last_command.stderr).to include strip_whitespace(<<-E).strip The dependencies in your gemfile changed You have added to the Gemfile: @@ -412,7 +395,8 @@ You have deleted from the Gemfile: expect(out).to include("Updating files in vendor/cache") simulate_new_machine - bundle! "install --verbose", forgotten_command_line_options(:deployment => true) + bundle! "config set --local deployment true" + bundle! "install --verbose" expect(out).not_to include("You are trying to install in deployment mode after changing your Gemfile") expect(out).not_to include("You have added to the Gemfile") expect(out).not_to include("You have deleted from the Gemfile") diff --git a/spec/bundler/install/failure_spec.rb b/spec/bundler/install/failure_spec.rb index b4cdf13857..49e2771dca 100644 --- a/spec/bundler/install/failure_spec.rb +++ b/spec/bundler/install/failure_spec.rb @@ -121,5 +121,24 @@ In Gemfile: activesupport M end + + context "because the downloaded .gem was invalid" do + before do + build_repo4 do + build_gem "a" + end + + gem_repo4("gems", "a-1.0.gem").open("w") {|f| f << "<html></html>" } + end + + it "removes the downloaded .gem" do + install_gemfile <<-G + source "file:#{gem_repo4}" + gem "a" + G + + expect(default_bundle_path("cache", "a-1.0.gem")).not_to exist + end + end end end diff --git a/spec/bundler/install/gemfile/gemspec_spec.rb b/spec/bundler/install/gemfile/gemspec_spec.rb index bbb56da5a4..0bec2e9d96 100644 --- a/spec/bundler/install/gemfile/gemspec_spec.rb +++ b/spec/bundler/install/gemfile/gemspec_spec.rb @@ -117,7 +117,7 @@ RSpec.describe "bundle install from an existing gemspec" do build_lib("foo", :path => tmp.join("foo")) do |s| s.write("Gemfile", "source 'file://#{gem_repo1}'\ngemspec") s.add_dependency "actionpack", "=2.3.2" - s.add_development_dependency "rake", "=10.0.2" + s.add_development_dependency "rake", "=12.3.2" end Dir.chdir(tmp.join("foo")) do @@ -239,7 +239,7 @@ RSpec.describe "bundle install from an existing gemspec" do expect(the_bundle).to include_gems "foo 1.0.0" end - it "does not break Gem.finish_resolve with conflicts", :rubygems => ">= 2" do + it "does not break Gem.finish_resolve with conflicts" do build_lib("foo", :path => tmp.join("foo")) do |s| s.version = "1.0.0" s.add_dependency "bar", "= 1.0.0" @@ -263,6 +263,20 @@ RSpec.describe "bundle install from an existing gemspec" do expect(out).to eq("WIN") end + it "works with only_update_to_newer_versions" do + build_lib "omg", "2.0", :path => lib_path("omg") + + install_gemfile <<-G + gemspec :path => "#{lib_path("omg")}" + G + + build_lib "omg", "1.0", :path => lib_path("omg") + + bundle! :install, :env => { "BUNDLE_BUNDLE_ONLY_UPDATE_TO_NEWER_VERSIONS" => "true" } + + expect(the_bundle).to include_gems "omg 1.0" + end + context "in deployment mode" do context "when the lockfile was not updated after a change to the gemspec's dependencies" do it "reports that installation failed" do @@ -283,7 +297,7 @@ RSpec.describe "bundle install from an existing gemspec" do bundle :install, forgotten_command_line_options(:deployment => true) - expect(out).to include("changed") + expect(err).to include("changed") end end end @@ -433,7 +447,7 @@ RSpec.describe "bundle install from an existing gemspec" do end end - context "on ruby", :bundler => "< 3" do + context "on ruby" do before do simulate_platform("ruby") bundle :install @@ -533,107 +547,6 @@ RSpec.describe "bundle install from an existing gemspec" do end end end - - context "on ruby", :bundler => "3" do - before do - simulate_platform("ruby") - bundle :install - end - - context "as a runtime dependency" do - it "keeps java dependencies in the lockfile" do - expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 RUBY" - expect(lockfile).to eq normalize_uri_file(strip_whitespace(<<-L)) - GEM - remote: file://localhost#{gem_repo2}/ - specs: - platform_specific (1.0) - platform_specific (1.0-java) - - PATH - remote: . - specs: - foo (1.0) - platform_specific - - PLATFORMS - java - ruby - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - L - end - end - - context "as a development dependency" do - let(:platform_specific_type) { :development } - - it "keeps java dependencies in the lockfile" do - expect(the_bundle).to include_gems "foo 1.0", "platform_specific 1.0 RUBY" - expect(lockfile).to eq normalize_uri_file(strip_whitespace(<<-L)) - GEM - remote: file://localhost#{gem_repo2}/ - specs: - platform_specific (1.0) - platform_specific (1.0-java) - - PATH - remote: . - specs: - foo (1.0) - - PLATFORMS - java - ruby - - DEPENDENCIES - foo! - platform_specific - - BUNDLED WITH - #{Bundler::VERSION} - L - end - end - - context "with an indirect platform-specific development dependency" do - let(:platform_specific_type) { :development } - let(:dependency) { "indirect_platform_specific" } - - it "keeps java dependencies in the lockfile" do - expect(the_bundle).to include_gems "foo 1.0", "indirect_platform_specific 1.0", "platform_specific 1.0 RUBY" - expect(lockfile).to eq normalize_uri_file(strip_whitespace(<<-L)) - GEM - remote: file://localhost#{gem_repo2}/ - specs: - indirect_platform_specific (1.0) - platform_specific - platform_specific (1.0) - platform_specific (1.0-java) - - PATH - remote: . - specs: - foo (1.0) - - PLATFORMS - java - ruby - - DEPENDENCIES - foo! - indirect_platform_specific - - BUNDLED WITH - #{Bundler::VERSION} - L - end - end - end end end diff --git a/spec/bundler/install/gemfile/git_spec.rb b/spec/bundler/install/gemfile/git_spec.rb index fe396c7a0f..f208853041 100644 --- a/spec/bundler/install/gemfile/git_spec.rb +++ b/spec/bundler/install/gemfile/git_spec.rb @@ -32,7 +32,7 @@ RSpec.describe "bundle install with git sources" do it "caches the git repo globally" do simulate_new_machine - bundle! "config global_gem_cache true" + bundle! "config set global_gem_cache true" bundle! :install expect(Dir["#{home}/.bundle/cache/git/foo-1.0-*"]).to have_attributes :size => 1 end @@ -87,7 +87,7 @@ RSpec.describe "bundle install with git sources" do gem "foo", "1.1", :git => "#{lib_path("foo-1.0")}" G - expect(out).to include("The source contains 'foo' at: 1.0") + expect(err).to include("The source contains 'foo' at: 1.0") end it "complains with version and platform if pinned specs don't exist in the git repo" do @@ -103,7 +103,7 @@ RSpec.describe "bundle install with git sources" do end G - expect(out).to include("The source contains 'only_java' at: 1.0 java") + expect(err).to include("The source contains 'only_java' at: 1.0 java") end it "complains with multiple versions and platforms if pinned specs don't exist in the git repo" do @@ -124,7 +124,7 @@ RSpec.describe "bundle install with git sources" do end G - expect(out).to include("The source contains 'only_java' at: 1.0 java, 1.1 java") + expect(err).to include("The source contains 'only_java' at: 1.0 java, 1.1 java") end it "still works after moving the application directory" do @@ -204,7 +204,7 @@ RSpec.describe "bundle install with git sources" do gem "foo" end G - expect(err).to lack_errors + expect(last_command.stderr).to be_empty run <<-RUBY require 'foo' @@ -221,7 +221,7 @@ RSpec.describe "bundle install with git sources" do end Dir.chdir(lib_path("foo-1.0")) do - `git update-ref -m 'Bundler Spec!' refs/bundler/1 master~1` + `git update-ref -m "Bundler Spec!" refs/bundler/1 master~1` end # want to ensure we don't fallback to HEAD @@ -234,7 +234,7 @@ RSpec.describe "bundle install with git sources" do gem "foo" end G - expect(err).to lack_errors + expect(last_command.stderr).to be_empty run! <<-RUBY require 'foo' @@ -257,7 +257,7 @@ RSpec.describe "bundle install with git sources" do end Dir.chdir(lib_path("foo-1.0")) do - `git update-ref -m 'Bundler Spec!' refs/bundler/1 master~1` + `git update-ref -m "Bundler Spec!" refs/bundler/1 master~1` end # want to ensure we don't fallback to HEAD @@ -270,7 +270,7 @@ RSpec.describe "bundle install with git sources" do gem "foo" end G - expect(err).to lack_errors + expect(last_command.stderr).to be_empty run! <<-RUBY require 'foo' @@ -282,10 +282,10 @@ RSpec.describe "bundle install with git sources" do it "does not download random non-head refs" do Dir.chdir(lib_path("foo-1.0")) do - sys_exec!("git update-ref -m 'Bundler Spec!' refs/bundler/1 master~1") + sys_exec!('git update-ref -m "Bundler Spec!" refs/bundler/1 master~1') end - bundle! "config global_gem_cache true" + bundle! "config set global_gem_cache true" install_gemfile! <<-G git "#{lib_path("foo-1.0")}" do @@ -294,7 +294,7 @@ RSpec.describe "bundle install with git sources" do G # ensure we also git fetch after cloning - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true Dir.chdir(Dir[home(".bundle/cache/git/foo-*")].first) do sys_exec("git ls-remote .") @@ -406,7 +406,7 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle! %(config local.rack #{lib_path("local-rack")}) + bundle! %(config set local.rack #{lib_path("local-rack")}) bundle! :install run "require 'rack'" @@ -427,7 +427,7 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) run "require 'rack'" expect(out).to eq("LOCAL") end @@ -447,7 +447,7 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle! %(config local.rack #{lib_path("local-rack")}) + bundle! %(config set local.rack #{lib_path("local-rack")}) bundle! :install run! "require 'rack'" expect(out).to eq("LOCAL") @@ -470,7 +470,7 @@ RSpec.describe "bundle install with git sources" do s.add_dependency "nokogiri", "1.4.2" end - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) run "require 'rack'" lockfile1 = File.read(bundled_app("Gemfile.lock")) @@ -490,14 +490,14 @@ RSpec.describe "bundle install with git sources" do FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack")) update_git "rack", "0.8", :path => lib_path("local-rack") - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle :install lockfile1 = File.read(bundled_app("Gemfile.lock")) expect(lockfile1).not_to eq(lockfile0) end - it "explodes if given path does not exist on install" do + it "explodes and gives correct solution if given path does not exist on install" do build_git "rack", "0.8" install_gemfile <<-G @@ -505,12 +505,20 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle :install - expect(out).to match(/Cannot use local override for rack-0.8 because #{Regexp.escape(lib_path('local-rack').to_s)} does not exist/) + expect(err).to match(/Cannot use local override for rack-0.8 because #{Regexp.escape(lib_path('local-rack').to_s)} does not exist/) + + solution = "config unset local.rack" + expect(err).to match(/Run `bundle #{solution}` to remove the local override/) + + bundle solution + bundle :install + + expect(last_command.stderr).to be_empty end - it "explodes if branch is not given on install" do + it "explodes and gives correct solution if branch is not given on install" do build_git "rack", "0.8" FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack")) @@ -519,9 +527,17 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) + bundle :install + expect(err).to match(/Cannot use local override for rack-0.8 at #{Regexp.escape(lib_path('local-rack').to_s)} because :branch is not specified in Gemfile/) + + solution = "config unset local.rack" + expect(err).to match(/Specify a branch or run `bundle #{solution}` to remove the local override/) + + bundle solution bundle :install - expect(out).to match(/cannot use local override/i) + + expect(last_command.stderr).to be_empty end it "does not explode if disable_local_branch_check is given" do @@ -533,8 +549,8 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}" G - bundle %(config local.rack #{lib_path("local-rack")}) - bundle %(config disable_local_branch_check true) + bundle %(config set local.rack #{lib_path("local-rack")}) + bundle %(config set disable_local_branch_check true) bundle :install expect(out).to match(/Bundle complete!/) end @@ -553,9 +569,9 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle :install - expect(out).to match(/is using branch another but Gemfile specifies master/) + expect(err).to match(/is using branch another but Gemfile specifies master/) end it "explodes on invalid revision on install" do @@ -570,9 +586,9 @@ RSpec.describe "bundle install with git sources" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle :install - expect(out).to match(/The Gemfile lock is pointing to revision \w+/) + expect(err).to match(/The Gemfile lock is pointing to revision \w+/) end end @@ -709,7 +725,7 @@ RSpec.describe "bundle install with git sources" do build_lib "bar", :path => lib_path("foo/bar"), :gemspec => false do |s| s.write lib_path("foo/bar/lib/version.rb"), %(BAR_VERSION = '1.0') s.write "bar.gemspec", <<-G - $:.unshift Dir.pwd # For 1.9 + $:.unshift Dir.pwd require 'lib/version' Gem::Specification.new do |s| s.name = 'bar' @@ -769,7 +785,7 @@ RSpec.describe "bundle install with git sources" do bundle :install - expect(out).to include("Git error:") + expect(err).to include("Git error:") expect(err).to include("fatal") expect(err).to include("omgomg") end @@ -798,14 +814,14 @@ RSpec.describe "bundle install with git sources" do s.write "lib/forced.rb", "FORCED = '1.1'" end - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(the_bundle).to include_gems "forced 1.1" Dir.chdir(lib_path("forced-1.0")) do `git reset --hard HEAD^` end - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(the_bundle).to include_gems "forced 1.0" end @@ -824,7 +840,7 @@ RSpec.describe "bundle install with git sources" do gem "has_submodule" end G - expect(out).to match(/could not find gem 'submodule/i) + expect(err).to match(/could not find gem 'submodule/i) expect(the_bundle).not_to include_gems "has_submodule 1.0" end @@ -910,7 +926,7 @@ RSpec.describe "bundle install with git sources" do G expect(exitstatus).to_not eq(0) if exitstatus - expect(out).to include("Bundler could not install a gem because it " \ + expect(err).to include("Bundler could not install a gem because it " \ "needs to create a directory, but a file exists " \ "- #{default_bundle_path("bundler")}") end @@ -922,12 +938,11 @@ RSpec.describe "bundle install with git sources" do build_git "foo", :path => lib_path("nested") build_git "bar", :path => lib_path("nested") - gemfile <<-G + install_gemfile <<-G gem "foo", :git => "#{lib_path("nested")}" gem "bar", :git => "#{lib_path("nested")}" G - bundle "install" expect(File.read(bundled_app("Gemfile.lock")).scan("GIT").size).to eq(1) end @@ -1010,14 +1025,12 @@ RSpec.describe "bundle install with git sources" do install_gemfile <<-G gem "foo", :git => "file://#{lib_path("foo-1.0")}", :ref => "#{revision}" G - bundle "install" expect(out).to_not match(/Revision.*does not exist/) install_gemfile <<-G gem "foo", :git => "file://#{lib_path("foo-1.0")}", :ref => "deadbeef" G - bundle "install" - expect(out).to include("Revision deadbeef does not exist in the repository") + expect(err).to include("Revision deadbeef does not exist in the repository") end end @@ -1054,7 +1067,7 @@ RSpec.describe "bundle install with git sources" do bundle :install, :requires => [lib_path("install_hooks.rb")] - expect(err).to eq_err("Ran pre-install hook: foo-1.0") + expect(err_without_deprecations).to eq("Ran pre-install hook: foo-1.0") end it "runs post-install hooks" do @@ -1074,7 +1087,7 @@ RSpec.describe "bundle install with git sources" do bundle :install, :requires => [lib_path("install_hooks.rb")] - expect(err).to eq_err("Ran post-install hook: foo-1.0") + expect(err_without_deprecations).to eq("Ran post-install hook: foo-1.0") end it "complains if the install hook fails" do @@ -1094,7 +1107,7 @@ RSpec.describe "bundle install with git sources" do bundle :install, :requires => [lib_path("install_hooks.rb")] - expect(out).to include("failed for foo-1.0") + expect(err).to include("failed for foo-1.0") end end @@ -1150,7 +1163,7 @@ RSpec.describe "bundle install with git sources" do void Init_foo() { rb_define_global_function("foo", &foo, 0); } C end - `git commit -m 'commit for iteration #{i}' ext/foo.c` + `git commit -m "commit for iteration #{i}" ext/foo.c` end git_commit_sha = git_reader.ref_for("HEAD") @@ -1193,7 +1206,48 @@ In Gemfile: expect(out).not_to include("gem install foo") end - it "does not reinstall the extension", :ruby_repo, :rubygems => ">= 2.3.0" do + it "does not reinstall the extension", :ruby_repo do + build_git "foo" do |s| + s.add_dependency "rake" + s.extensions << "Rakefile" + s.write "Rakefile", <<-RUBY + task :default do + path = File.expand_path("../lib", __FILE__) + FileUtils.mkdir_p(path) + cur_time = Time.now.to_f.to_s + File.open("\#{path}/foo.rb", "w") do |f| + f.puts "FOO = \#{cur_time}" + end + end + RUBY + end + + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "foo", :git => "#{lib_path("foo-1.0")}" + G + + run! <<-R + require 'foo' + puts FOO + R + + installed_time = out + expect(installed_time).to match(/\A\d+\.\d+\z/) + + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "foo", :git => "#{lib_path("foo-1.0")}" + G + + run! <<-R + require 'foo' + puts FOO + R + expect(out).to eq(installed_time) + end + + it "does not reinstall the extension when changing another gem" do build_git "foo" do |s| s.add_dependency "rake" s.extensions << "Rakefile" @@ -1211,6 +1265,7 @@ In Gemfile: install_gemfile <<-G source "file://#{gem_repo1}" + gem "rack", "0.9.1" gem "foo", :git => "#{lib_path("foo-1.0")}" G @@ -1224,6 +1279,7 @@ In Gemfile: install_gemfile <<-G source "file://#{gem_repo1}" + gem "rack", "1.0.0" gem "foo", :git => "#{lib_path("foo-1.0")}" G @@ -1233,6 +1289,60 @@ In Gemfile: R expect(out).to eq(installed_time) end + + it "does reinstall the extension when changing refs" do + build_git "foo" do |s| + s.add_dependency "rake" + s.extensions << "Rakefile" + s.write "Rakefile", <<-RUBY + task :default do + path = File.expand_path("../lib", __FILE__) + FileUtils.mkdir_p(path) + cur_time = Time.now.to_f.to_s + File.open("\#{path}/foo.rb", "w") do |f| + f.puts "FOO = \#{cur_time}" + end + end + RUBY + end + + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "foo", :git => "#{lib_path("foo-1.0")}" + G + + run! <<-R + require 'foo' + puts FOO + R + + update_git("foo", :branch => "branch2") + + installed_time = out + expect(installed_time).to match(/\A\d+\.\d+\z/) + + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "foo", :git => "#{lib_path("foo-1.0")}", :branch => "branch2" + G + + run! <<-R + require 'foo' + puts FOO + R + expect(out).not_to eq(installed_time) + + installed_time = out + + update_git("foo") + bundle! "update foo" + + run! <<-R + require 'foo' + puts FOO + R + expect(out).not_to eq(installed_time) + end end it "ignores git environment variables" do @@ -1268,7 +1378,7 @@ In Gemfile: G with_path_as("") do - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true end expect(last_command.bundler_err). to include("You need to install git to be able to use gems from git repositories. For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git") @@ -1292,7 +1402,7 @@ In Gemfile: describe "when the git source is overridden with a local git repo" do before do - bundle! "config --global local.foo #{lib_path("foo")}" + bundle! "config set --global local.foo #{lib_path("foo")}" end describe "and git output is colorized" do @@ -1326,7 +1436,6 @@ In Gemfile: end G - bundle :install expect(last_command.stdboth).to_not include("password1") expect(last_command.stdout).to include("Fetching https://[email protected]/company/private-repo") end @@ -1342,7 +1451,6 @@ In Gemfile: end G - bundle :install expect(last_command.stdboth).to_not include("oauth_token") expect(last_command.stdout).to include("Fetching https://[email protected]/company/private-repo") end diff --git a/spec/bundler/install/gemfile/groups_spec.rb b/spec/bundler/install/gemfile/groups_spec.rb index 45395e606f..f836499148 100644 --- a/spec/bundler/install/gemfile/groups_spec.rb +++ b/spec/bundler/install/gemfile/groups_spec.rb @@ -25,7 +25,7 @@ RSpec.describe "bundle install with groups" do puts ACTIVESUPPORT R - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end it "installs gems with inline :groups into those groups" do @@ -36,7 +36,7 @@ RSpec.describe "bundle install with groups" do puts THIN R - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end it "sets up everything if Bundler.setup is used with no groups" do @@ -57,7 +57,7 @@ RSpec.describe "bundle install with groups" do puts THIN RUBY - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end it "sets up old groups when they have previously been removed" do @@ -207,7 +207,7 @@ RSpec.describe "bundle install with groups" do it "errors out when passing a group to with and without via CLI flags", :bundler => "< 3" do bundle :install, forgotten_command_line_options(:with => "emo debugging", :without => "emo") expect(last_command).to be_failure - expect(out).to include("The offending groups are: emo") + expect(err).to include("The offending groups are: emo") end it "allows the BUNDLE_WITH setting to override BUNDLE_WITHOUT" do diff --git a/spec/bundler/install/gemfile/lockfile_spec.rb b/spec/bundler/install/gemfile/lockfile_spec.rb index dc1baca6ea..96cd5067be 100644 --- a/spec/bundler/install/gemfile/lockfile_spec.rb +++ b/spec/bundler/install/gemfile/lockfile_spec.rb @@ -16,7 +16,7 @@ RSpec.describe "bundle install with a lockfile present" do context "with plugins disabled" do before do - bundle! "config plugins false" + bundle! "config set plugins false" subject end diff --git a/spec/bundler/install/gemfile/path_spec.rb b/spec/bundler/install/gemfile/path_spec.rb index a508c971ad..54a41b576f 100644 --- a/spec/bundler/install/gemfile/path_spec.rb +++ b/spec/bundler/install/gemfile/path_spec.rb @@ -66,8 +66,8 @@ RSpec.describe "bundle install with explicit source paths" do install_gemfile <<-G gem 'foo', :path => "~#{username}/#{relative_path}" G - expect(out).to match("There was an error while trying to use the path `~#{username}/#{relative_path}`.") - expect(out).to match("user #{username} doesn't exist") + expect(err).to match("There was an error while trying to use the path `~#{username}/#{relative_path}`.") + expect(err).to match("user #{username} doesn't exist") end it "expands paths relative to Bundler.root" do @@ -132,6 +132,20 @@ RSpec.describe "bundle install with explicit source paths" do expect(the_bundle).to include_gems "foo 1.0" end + it "works with only_update_to_newer_versions" do + build_lib "omg", "2.0", :path => lib_path("omg") + + install_gemfile <<-G + gem "omg", :path => "#{lib_path("omg")}" + G + + build_lib "omg", "1.0", :path => lib_path("omg") + + bundle! :install, :env => { "BUNDLE_BUNDLE_ONLY_UPDATE_TO_NEWER_VERSIONS" => "true" } + + expect(the_bundle).to include_gems "omg 1.0" + end + it "prefers gemspecs closer to the path root" do build_lib "premailer", "1.0.0", :path => lib_path("premailer") do |s| s.write "gemfiles/ruby187.gemspec", <<-G @@ -153,7 +167,7 @@ RSpec.describe "bundle install with explicit source paths" do expect(the_bundle).to include_gems "premailer 1.0.0" end - it "warns on invalid specs", :rubygems => "1.7" do + it "warns on invalid specs" do build_lib "foo" gemspec = lib_path("foo-1.0").join("foo.gemspec").to_s @@ -169,11 +183,11 @@ RSpec.describe "bundle install with explicit source paths" do gem "foo", :path => "#{lib_path("foo-1.0")}" G - expect(out).to_not include("ERROR REPORT") - expect(out).to_not include("Your Gemfile has no gem server sources.") - expect(out).to match(/is not valid. Please fix this gemspec./) - expect(out).to match(/The validation error was 'missing value for attribute version'/) - expect(out).to match(/You have one or more invalid gemspecs that need to be fixed/) + expect(err).to_not include("ERROR REPORT") + expect(err).to_not include("Your Gemfile has no gem server sources.") + expect(err).to match(/is not valid. Please fix this gemspec./) + expect(err).to match(/The validation error was 'missing value for attribute version'/) + expect(err).to match(/You have one or more invalid gemspecs that need to be fixed/) end it "supports gemspec syntax" do @@ -260,7 +274,7 @@ RSpec.describe "bundle install with explicit source paths" do G expect(exitstatus).to eq(15) if exitstatus - expect(out).to match(/There are multiple gemspecs/) + expect(err).to match(/There are multiple gemspecs/) end it "allows :name to be specified to resolve ambiguity" do @@ -299,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(err).to lack_errors + expect(last_command.stderr).to be_empty end it "removes the .gem file after installing" do @@ -561,7 +575,7 @@ RSpec.describe "bundle install with explicit source paths" do bundle :install, :requires => [lib_path("install_hooks.rb")] - expect(err).to eq_err("Ran pre-install hook: foo-1.0") + expect(err_without_deprecations).to eq("Ran pre-install hook: foo-1.0") end it "runs post-install hooks" do @@ -581,7 +595,7 @@ RSpec.describe "bundle install with explicit source paths" do bundle :install, :requires => [lib_path("install_hooks.rb")] - expect(err).to eq_err("Ran post-install hook: foo-1.0") + expect(err_without_deprecations).to eq("Ran post-install hook: foo-1.0") end it "complains if the install hook fails" do @@ -601,7 +615,7 @@ RSpec.describe "bundle install with explicit source paths" do bundle :install, :requires => [lib_path("install_hooks.rb")] - expect(out).to include("failed for foo-1.0") + expect(err).to include("failed for foo-1.0") end it "loads plugins from the path gem" do diff --git a/spec/bundler/install/gemfile/platform_spec.rb b/spec/bundler/install/gemfile/platform_spec.rb index b5dbc41a33..891f766cc0 100644 --- a/spec/bundler/install/gemfile/platform_spec.rb +++ b/spec/bundler/install/gemfile/platform_spec.rb @@ -248,9 +248,9 @@ RSpec.describe "bundle install across platforms" do gem "facter" G - expect(out).to include "Unable to use the platform-specific (universal-darwin) version of facter (2.4.6) " \ + expect(err).to include "Unable to use the platform-specific (universal-darwin) version of facter (2.4.6) " \ "because it has different dependencies from the ruby version. " \ - "To use the platform-specific version of the gem, run `bundle config specific_platform true` and install again." + "To use the platform-specific version of the gem, run `bundle config set specific_platform true` and install again." expect(the_bundle).to include_gem "facter 2.4.6" expect(the_bundle).not_to include_gem "CFPropertyList" @@ -265,8 +265,7 @@ RSpec.describe "bundle install across platforms" do bundle! :install, forgotten_command_line_options(:path => "vendor/bundle") - new_version = Gem::ConfigMap[:ruby_version] == "1.8" ? "1.9.1" : "1.8" - FileUtils.mv(vendored_gems, bundled_app("vendor/bundle", Gem.ruby_engine, new_version)) + FileUtils.mv(vendored_gems, bundled_app("vendor/bundle", Gem.ruby_engine, "1.8")) bundle! :install expect(vendored_gems("gems/rack-1.0.0")).to exist @@ -385,13 +384,13 @@ RSpec.describe "bundle install with platform conditionals" do bundle! "install" - expect(out).to include <<-O.strip + expect(err).to include <<-O.strip The dependency #{Gem::Dependency.new("rack", ">= 0")} will be unused by any of the platforms Bundler is installing for. Bundler is installing for ruby but the dependency is only for x86-mingw32, x86-mswin32, x64-mingw32, java. To add those platforms to the bundle, run `bundle lock --add-platform x86-mingw32 x86-mswin32 x64-mingw32 java`. O end context "when disable_platform_warnings is true" do - before { bundle! "config disable_platform_warnings true" } + before { bundle! "config set disable_platform_warnings true" } it "does not print the warning when a dependency is unused on any platform" do simulate_platform "ruby" diff --git a/spec/bundler/install/gemfile/ruby_spec.rb b/spec/bundler/install/gemfile/ruby_spec.rb index 24fe021fa3..3373c9bd3e 100644 --- a/spec/bundler/install/gemfile/ruby_spec.rb +++ b/spec/bundler/install/gemfile/ruby_spec.rb @@ -103,6 +103,6 @@ RSpec.describe "ruby requirement" do gem "rack" G - expect(out).to include("There was an error parsing") # i.e. DSL error, not error template + expect(err).to include("There was an error parsing") # i.e. DSL error, not error template end end diff --git a/spec/bundler/install/gemfile/sources_spec.rb b/spec/bundler/install/gemfile/sources_spec.rb index efe6ccce7f..8e1205dfa3 100644 --- a/spec/bundler/install/gemfile/sources_spec.rb +++ b/spec/bundler/install/gemfile/sources_spec.rb @@ -15,7 +15,7 @@ RSpec.describe "bundle install with gems on multiple sources" do end end - context "with multiple toplevel sources" do + context "with multiple toplevel sources", :bundler => "< 3" do let(:repo3_rack_version) { "1.0.0" } before do @@ -25,27 +25,24 @@ RSpec.describe "bundle install with gems on multiple sources" do gem "rack-obama" gem "rack" G - bundle "config major_deprecations true" end - it "warns about ambiguous gems, but installs anyway, prioritizing sources last to first", :bundler => "< 3" do + it "warns about ambiguous gems, but installs anyway, prioritizing sources last to first", :bundler => "2" do bundle :install - expect(out).to have_major_deprecation a_string_including("Your Gemfile contains multiple primary sources.") - expect(out).to include("Warning: the gem 'rack' was found in multiple sources.") - expect(out).to include(normalize_uri_file("Installed from: file://localhost#{gem_repo1}")) + expect(err).to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).to include(normalize_uri_file("Installed from: file://localhost#{gem_repo1}")) expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0", :source => "remote1") end - it "errors when disable_multisource is set" do - bundle "config disable_multisource true" + it "fails", :bundler => "3" do bundle :install - expect(out).to include("Each source after the first must include a block") + expect(err).to include("Each source after the first must include a block") expect(exitstatus).to eq(4) if exitstatus end end - context "when different versions of the same gem are in multiple sources" do + context "when different versions of the same gem are in multiple sources", :bundler => "< 3" do let(:repo3_rack_version) { "1.2" } before do @@ -55,17 +52,20 @@ RSpec.describe "bundle install with gems on multiple sources" do gem "rack-obama" gem "rack", "1.0.0" # force it to install the working version in repo1 G - bundle "config major_deprecations true" - end - it "warns about ambiguous gems, but installs anyway", :bundler => "< 3" do bundle :install + end - expect(out).to have_major_deprecation a_string_including("Your Gemfile contains multiple primary sources.") - expect(out).to include("Warning: the gem 'rack' was found in multiple sources.") - expect(out).to include(normalize_uri_file("Installed from: file://localhost#{gem_repo1}")) + it "warns about ambiguous gems, but installs anyway", :bundler => "2" do + expect(err).to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).to include(normalize_uri_file("Installed from: file://localhost#{gem_repo1}")) expect(the_bundle).to include_gems("rack-obama 1.0.0", "rack 1.0.0", :source => "remote1") end + + it "fails", :bundler => "3" do + expect(err).to include("Each source after the first must include a block") + expect(exitstatus).to eq(4) if exitstatus + end end end @@ -187,10 +187,9 @@ RSpec.describe "bundle install with gems on multiple sources" do end end - context "when lockfile_uses_separate_rubygems_sources is set" do + context "when disable_multisource is set" do before do - bundle! "config lockfile_uses_separate_rubygems_sources true" - bundle! "config disable_multisource true" + bundle! "config set disable_multisource true" end it "installs from the same source without any warning" do @@ -237,7 +236,7 @@ RSpec.describe "bundle install with gems on multiple sources" do end end - context "and in yet another source" do + context "and in yet another source", :bundler => "< 3" do before do gemfile <<-G source "file://localhost#{gem_repo1}" @@ -246,19 +245,23 @@ RSpec.describe "bundle install with gems on multiple sources" do gem "depends_on_rack" end G - end - it "installs from the other source and warns about ambiguous gems", :bundler => "< 3" do - bundle "config major_deprecations true" bundle :install - expect(out).to have_major_deprecation a_string_including("Your Gemfile contains multiple primary sources.") - expect(out).to include("Warning: the gem 'rack' was found in multiple sources.") - expect(out).to include(normalize_uri_file("Installed from: file://localhost#{gem_repo2}")) + end + + it "installs from the other source and warns about ambiguous gems", :bundler => "2" do + expect(err).to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).to include(normalize_uri_file("Installed from: file://localhost#{gem_repo2}")) expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0") end + + it "fails", :bundler => "3" do + expect(err).to include("Each source after the first must include a block") + expect(exitstatus).to eq(4) if exitstatus + end end - context "and only the dependency is pinned" do + context "and only the dependency is pinned", :bundler => "< 3" do before do # need this to be broken to check for correct source ordering build_repo gem_repo2 do @@ -276,10 +279,10 @@ RSpec.describe "bundle install with gems on multiple sources" do G end - it "installs the dependency from the pinned source without warning", :bundler => "< 3" do + it "installs the dependency from the pinned source without warning", :bundler => "2" do bundle :install - expect(out).not_to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).not_to include("Warning: the gem 'rack' was found in multiple sources.") expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0") # In https://github.com/bundler/bundler/issues/3585 this failed @@ -287,18 +290,23 @@ RSpec.describe "bundle install with gems on multiple sources" do system_gems [] bundle :install - expect(out).not_to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).not_to include("Warning: the gem 'rack' was found in multiple sources.") expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0") end + + it "fails", :bundler => "3" do + bundle :install + expect(err).to include("Each source after the first must include a block") + expect(exitstatus).to eq(4) if exitstatus + end end end end context "when a top-level gem has an indirect dependency" do - context "when lockfile_uses_separate_rubygems_sources is set" do + context "when disable_multisource is set" do before do - bundle! "config lockfile_uses_separate_rubygems_sources true" - bundle! "config disable_multisource true" + bundle! "config set disable_multisource true" end before do @@ -332,7 +340,7 @@ RSpec.describe "bundle install with gems on multiple sources" do it "installs all gems without warning" do bundle :install - expect(out).not_to include("Warning") + expect(err).not_to include("Warning") expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0", "unrelated_gem 1.0.0") end end @@ -348,7 +356,7 @@ RSpec.describe "bundle install with gems on multiple sources" do it "does not find the dependency" do bundle :install - expect(out).to include("Could not find gem 'rack', which is required by gem 'depends_on_rack', in any of the relevant sources") + expect(err).to include("Could not find gem 'rack', which is required by gem 'depends_on_rack', in any of the relevant sources") end end @@ -367,7 +375,7 @@ RSpec.describe "bundle install with gems on multiple sources" do it "installs the dependency from the top-level source without warning" do bundle :install - expect(out).not_to include("Warning") + expect(err).not_to include("Warning") expect(the_bundle).to include_gems("depends_on_rack 1.0.1", "rack 1.0.0", "unrelated_gem 1.0.0") end end @@ -388,7 +396,7 @@ RSpec.describe "bundle install with gems on multiple sources" do it "does not install the gem" do bundle :install - expect(out).to include("Could not find gem 'not_in_repo1'") + expect(err).to include("Could not find gem 'not_in_repo1'") end end @@ -437,7 +445,7 @@ RSpec.describe "bundle install with gems on multiple sources" do it "does not unlock the non-path gem after install" do bundle! :install - bundle! %(exec ruby -e 'puts "OK"'), :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle! %(exec ruby -e 'puts "OK"') expect(out).to include("OK") end @@ -456,7 +464,7 @@ RSpec.describe "bundle install with gems on multiple sources" do it "installs the gems without any warning" do bundle :install - expect(out).not_to include("Warning") + expect(err).not_to include("Warning") expect(the_bundle).to include_gems("rack 1.0.0") end end @@ -544,7 +552,7 @@ RSpec.describe "bundle install with gems on multiple sources" do end it "does not re-resolve" do - bundle :install, :verbose => true + bundle! :install, :verbose => true expect(out).to include("using resolution from the lockfile") expect(out).not_to include("re-resolving dependencies") end @@ -616,4 +624,63 @@ RSpec.describe "bundle install with gems on multiple sources" do end end end + + describe "source changed to one containing a higher version of a dependency" do + before do + install_gemfile! <<-G + source "file://#{gem_repo1}" + + gem "rack" + G + + build_repo2 do + build_gem "bar" + end + + build_lib("gemspec_test", :path => tmp.join("gemspec_test")) do |s| + s.add_dependency "bar", "=1.0.0" + end + + install_gemfile <<-G + source "file://#{gem_repo2}" + gem "rack" + gemspec :path => "#{tmp.join("gemspec_test")}" + G + end + + it "keeps the old version", :bundler => "2" do + expect(the_bundle).to include_gems("rack 1.0.0") + end + + it "installs the higher version in the new repo", :bundler => "3" do + expect(the_bundle).to include_gems("rack 1.2") + end + end + + context "when a gem is available from multiple ambiguous sources", :bundler => "3" do + it "raises, suggesting a source block" do + build_repo4 do + build_gem "depends_on_rack" do |s| + s.add_dependency "rack" + end + build_gem "rack" + end + + install_gemfile <<-G + source "file://localhost#{gem_repo4}" + source "file://localhost#{gem_repo1}" do + gem "thin" + end + gem "depends_on_rack" + G + expect(last_command).to be_failure + expect(err).to eq normalize_uri_file(strip_whitespace(<<-EOS).strip) + The gem 'rack' was found in multiple relevant sources. + * rubygems repository file://localhost#{gem_repo1}/ or installed locally + * rubygems repository file://localhost#{gem_repo4}/ or installed locally + You must add this gem to the source block for the source you wish it to be installed from. + EOS + expect(the_bundle).not_to be_locked + end + end end diff --git a/spec/bundler/install/gemfile/specific_platform_spec.rb b/spec/bundler/install/gemfile/specific_platform_spec.rb index 9c725416d5..2c482b7ad4 100644 --- a/spec/bundler/install/gemfile/specific_platform_spec.rb +++ b/spec/bundler/install/gemfile/specific_platform_spec.rb @@ -2,7 +2,7 @@ RSpec.describe "bundle install with specific_platform enabled" do before do - bundle "config specific_platform true" + bundle "config set specific_platform true" build_repo2 do build_gem("google-protobuf", "3.0.0.alpha.5.0.5.1") diff --git a/spec/bundler/install/gemfile_spec.rb b/spec/bundler/install/gemfile_spec.rb index e74c5ffe59..c26fbd74e7 100644 --- a/spec/bundler/install/gemfile_spec.rb +++ b/spec/bundler/install/gemfile_spec.rb @@ -1,4 +1,3 @@ -# encoding: utf-8 # frozen_string_literal: true RSpec.describe "bundle install" do @@ -8,7 +7,7 @@ RSpec.describe "bundle install" do gem 'rails', '~> 4.0.0' gem 'rails', '~> 4.0.0' G - expect(out).to include("more than once") + expect(err).to include("more than once") end end @@ -35,7 +34,7 @@ RSpec.describe "bundle install" do gem 'rack' G - bundle "config --local gemfile #{bundled_app("NotGemfile")}" + bundle "config set --local gemfile #{bundled_app("NotGemfile")}" end it "uses the gemfile to install" do bundle "install" @@ -65,23 +64,7 @@ RSpec.describe "bundle install" do G bundle :install - expect(out).to match(/You passed :lib as an option for gem 'rack', but it is invalid/) - end - end - - context "with prefer_gems_rb set" do - before { bundle! "config prefer_gems_rb true" } - - it "prefers gems.rb to Gemfile" do - create_file("gems.rb", "gem 'bundler'") - create_file("Gemfile", "raise 'wrong Gemfile!'") - - bundle! :install - - expect(bundled_app("gems.rb")).to be_file - expect(bundled_app("Gemfile.lock")).not_to be_file - - expect(the_bundle).to include_gem "bundler #{Bundler::VERSION}" + expect(err).to match(/You passed :lib as an option for gem 'rack', but it is invalid/) end end @@ -116,8 +99,6 @@ RSpec.describe "bundle install" do context "with a Gemfile containing non-US-ASCII characters" do it "reads the Gemfile with the UTF-8 encoding by default" do - skip "Ruby 1.8 has no encodings" if RUBY_VERSION < "1.9" - install_gemfile <<-G str = "Il était une fois ..." puts "The source encoding is: " + str.encoding.name @@ -129,8 +110,6 @@ RSpec.describe "bundle install" do end it "respects the magic encoding comment" do - skip "Ruby 1.8 has no encodings" if RUBY_VERSION < "1.9" - # NOTE: This works thanks to #eval interpreting the magic encoding comment install_gemfile <<-G # encoding: iso-8859-1 diff --git a/spec/bundler/install/gems/compact_index_spec.rb b/spec/bundler/install/gems/compact_index_spec.rb index 2acade1166..b94b68dbd9 100644 --- a/spec/bundler/install/gems/compact_index_spec.rb +++ b/spec/bundler/install/gems/compact_index_spec.rb @@ -22,7 +22,7 @@ RSpec.describe "compact index api" do G bundle :install, :artifice => "compact_index" - expect(out).to include("' sinatra' is not a valid gem name because it contains whitespace.") + expect(err).to include("' sinatra' is not a valid gem name because it contains whitespace.") end it "should handle nested dependencies" do @@ -226,7 +226,7 @@ The checksum of /versions does not match the checksum provided by the server! So G bundle :install, :artifice => "compact_index_redirects" - expect(out).to match(/Too many redirects/) + expect(err).to match(/Too many redirects/) end context "when --full-index is specified" do @@ -247,7 +247,7 @@ The checksum of /versions does not match the checksum provided by the server! So gem "rack" G - bundle! "update --full-index", :artifice => "compact_index", :all => bundle_update_requires_all? + bundle! "update --full-index", :artifice => "compact_index", :all => true expect(out).to include("Fetching source index from #{source_uri}") expect(the_bundle).to include_gems "rack 1.0.0" end @@ -255,7 +255,7 @@ The checksum of /versions does not match the checksum provided by the server! So it "does not double check for gems that are only installed locally" do system_gems %w[rack-1.0.0 thin-1.0 net_a-1.0] - bundle! "config --local path.system true" + bundle! "config set --local path.system true" ENV["BUNDLER_SPEC_ALL_REQUESTS"] = strip_whitespace(<<-EOS).strip #{source_uri}/versions #{source_uri}/info/rack @@ -628,8 +628,8 @@ The checksum of /versions does not match the checksum provided by the server! So G bundle! :install, :artifice => "compact_index_basic_authentication" - expect(out).to include("Warning: the gem 'rack' was found in multiple sources.") - expect(out).not_to include("#{user}:#{password}") + expect(err).to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).not_to include("#{user}:#{password}") expect(the_bundle).to include_gems "rack 1.0.0" end @@ -652,7 +652,7 @@ The checksum of /versions does not match the checksum provided by the server! So end it "reads authentication details by host name from bundle config" do - bundle "config #{source_hostname} #{user}:#{password}" + bundle "config set #{source_hostname} #{user}:#{password}" bundle! :install, :artifice => "compact_index_strict_basic_authentication" @@ -662,7 +662,7 @@ The checksum of /versions does not match the checksum provided by the server! So it "reads authentication details by full url from bundle config" do # The trailing slash is necessary here; Fetcher canonicalizes the URI. - bundle "config #{source_uri}/ #{user}:#{password}" + bundle "config set #{source_uri}/ #{user}:#{password}" bundle! :install, :artifice => "compact_index_strict_basic_authentication" @@ -671,7 +671,7 @@ The checksum of /versions does not match the checksum provided by the server! So end it "should use the API" do - bundle "config #{source_hostname} #{user}:#{password}" + bundle "config set #{source_hostname} #{user}:#{password}" bundle! :install, :artifice => "compact_index_strict_basic_authentication" expect(out).to include("Fetching gem metadata from #{source_uri}") expect(the_bundle).to include_gems "rack 1.0.0" @@ -683,7 +683,7 @@ The checksum of /versions does not match the checksum provided by the server! So gem "rack" G - bundle "config #{source_hostname} otheruser:wrong" + bundle "config set #{source_hostname} otheruser:wrong" bundle! :install, :artifice => "compact_index_strict_basic_authentication" expect(the_bundle).to include_gems "rack 1.0.0" @@ -691,14 +691,14 @@ The checksum of /versions does not match the checksum provided by the server! So it "shows instructions if auth is not provided for the source" do bundle :install, :artifice => "compact_index_strict_basic_authentication" - expect(out).to include("bundle config #{source_hostname} username:password") + expect(err).to include("bundle config set #{source_hostname} username:password") end it "fails if authentication has already been provided, but failed" do - bundle "config #{source_hostname} #{user}:wrong" + bundle "config set #{source_hostname} #{user}:wrong" bundle :install, :artifice => "compact_index_strict_basic_authentication" - expect(out).to include("Bad username or password") + expect(err).to include("Bad username or password") end end @@ -737,7 +737,7 @@ The checksum of /versions does not match the checksum provided by the server! So G bundle :install, :env => { "RUBYOPT" => "-I#{bundled_app("broken_ssl")}" } - expect(out).to include("OpenSSL") + expect(err).to include("OpenSSL") end end @@ -757,7 +757,7 @@ The checksum of /versions does not match the checksum provided by the server! So G bundle :install - expect(out).to match(/could not verify the SSL certificate/i) + expect(err).to match(/could not verify the SSL certificate/i) end end @@ -858,12 +858,12 @@ The checksum of /versions does not match the checksum provided by the server! So gem "rack" G expect(exitstatus).to eq(15) if exitstatus - expect(out).to end_with(<<-E.strip) + expect(err).to end_with(<<-E.strip) The request uri `htps://index.rubygems.org/versions` has an invalid scheme (`htps`). Did you mean `http` or `https`? E end - describe "checksum validation", :rubygems => ">= 2.3.0" do + describe "checksum validation" do it "raises when the checksum does not match" do install_gemfile <<-G, :artifice => "compact_index_wrong_gem_checksum" source "#{source_uri}" @@ -871,7 +871,7 @@ The checksum of /versions does not match the checksum provided by the server! So G expect(exitstatus).to eq(19) if exitstatus - expect(out). + expect(err). to include("Bundler cannot continue installing rack (1.0.0)."). and include("The checksum for the downloaded `rack-1.0.0.gem` does not match the checksum given by the server."). and include("This means the contents of the downloaded gem is different from what was uploaded to the server, and could be a potential security issue."). @@ -879,7 +879,7 @@ The checksum of /versions does not match the checksum provided by the server! So and include("1. delete the downloaded gem located at: `#{default_bundle_path}/gems/rack-1.0.0/rack-1.0.0.gem`"). and include("2. run `bundle install`"). and include("If you wish to continue installing the downloaded gem, and are certain it does not pose a security issue despite the mismatching checksum, do the following:"). - and include("1. run `bundle config disable_checksum_validation true` to turn off checksum verification"). + and include("1. run `bundle config set disable_checksum_validation true` to turn off checksum verification"). and include("2. run `bundle install`"). and match(/\(More info: The expected SHA256 checksum was "#{"ab" * 22}", but the checksum for the downloaded gem was ".+?"\.\)/) end @@ -890,11 +890,11 @@ The checksum of /versions does not match the checksum provided by the server! So gem "rack" G expect(exitstatus).to eq(5) if exitstatus - expect(out).to include("The given checksum for rack-1.0.0 (\"checksum!\") is not a valid SHA256 hexdigest nor base64digest") + expect(err).to include("The given checksum for rack-1.0.0 (\"checksum!\") is not a valid SHA256 hexdigest nor base64digest") end it "does not raise when disable_checksum_validation is set" do - bundle! "config disable_checksum_validation true" + bundle! "config set disable_checksum_validation true" install_gemfile! <<-G, :artifice => "compact_index_wrong_gem_checksum" source "#{source_uri}" gem "rack" @@ -915,7 +915,7 @@ The checksum of /versions does not match the checksum provided by the server! So source "#{source_uri}" gem "rails" G - deps = [Gem::Dependency.new("rake", "= 10.0.2"), + deps = [Gem::Dependency.new("rake", "= 12.3.2"), Gem::Dependency.new("actionpack", "= 2.3.2"), Gem::Dependency.new("activerecord", "= 2.3.2"), Gem::Dependency.new("actionmailer", "= 2.3.2"), diff --git a/spec/bundler/install/gems/dependency_api_spec.rb b/spec/bundler/install/gems/dependency_api_spec.rb index 3cb98db1eb..0dc1ee87f2 100644 --- a/spec/bundler/install/gems/dependency_api_spec.rb +++ b/spec/bundler/install/gems/dependency_api_spec.rb @@ -22,7 +22,7 @@ RSpec.describe "gemcutter's dependency API" do G bundle :install, :artifice => "endpoint" - expect(out).to include("' sinatra' is not a valid gem name because it contains whitespace.") + expect(err).to include("' sinatra' is not a valid gem name because it contains whitespace.") end it "should handle nested dependencies" do @@ -216,7 +216,7 @@ RSpec.describe "gemcutter's dependency API" do G bundle :install, :artifice => "endpoint_redirect" - expect(out).to match(/Too many redirects/) + expect(err).to match(/Too many redirects/) end context "when --full-index is specified" do @@ -237,7 +237,7 @@ RSpec.describe "gemcutter's dependency API" do gem "rack" G - bundle! "update --full-index", :artifice => "endpoint", :all => bundle_update_requires_all? + bundle! "update --full-index", :artifice => "endpoint", :all => true expect(out).to include("Fetching source index from #{source_uri}") expect(the_bundle).to include_gems "rack 1.0.0" end @@ -602,8 +602,8 @@ RSpec.describe "gemcutter's dependency API" do G bundle :install, :artifice => "endpoint_basic_authentication" - expect(out).to include("Warning: the gem 'rack' was found in multiple sources.") - expect(out).not_to include("#{user}:#{password}") + expect(err).to include("Warning: the gem 'rack' was found in multiple sources.") + expect(err).not_to include("#{user}:#{password}") expect(the_bundle).to include_gems "rack 1.0.0" end @@ -626,7 +626,7 @@ RSpec.describe "gemcutter's dependency API" do end it "reads authentication details by host name from bundle config" do - bundle "config #{source_hostname} #{user}:#{password}" + bundle "config set #{source_hostname} #{user}:#{password}" bundle :install, :artifice => "endpoint_strict_basic_authentication" @@ -636,7 +636,7 @@ RSpec.describe "gemcutter's dependency API" do it "reads authentication details by full url from bundle config" do # The trailing slash is necessary here; Fetcher canonicalizes the URI. - bundle "config #{source_uri}/ #{user}:#{password}" + bundle "config set #{source_uri}/ #{user}:#{password}" bundle :install, :artifice => "endpoint_strict_basic_authentication" @@ -645,7 +645,7 @@ RSpec.describe "gemcutter's dependency API" do end it "should use the API" do - bundle "config #{source_hostname} #{user}:#{password}" + bundle "config set #{source_hostname} #{user}:#{password}" bundle :install, :artifice => "endpoint_strict_basic_authentication" expect(out).to include("Fetching gem metadata from #{source_uri}") expect(the_bundle).to include_gems "rack 1.0.0" @@ -657,7 +657,7 @@ RSpec.describe "gemcutter's dependency API" do gem "rack" G - bundle "config #{source_hostname} otheruser:wrong" + bundle "config set #{source_hostname} otheruser:wrong" bundle :install, :artifice => "endpoint_strict_basic_authentication" expect(the_bundle).to include_gems "rack 1.0.0" @@ -665,14 +665,14 @@ RSpec.describe "gemcutter's dependency API" do it "shows instructions if auth is not provided for the source" do bundle :install, :artifice => "endpoint_strict_basic_authentication" - expect(out).to include("bundle config #{source_hostname} username:password") + expect(err).to include("bundle config set #{source_hostname} username:password") end it "fails if authentication has already been provided, but failed" do - bundle "config #{source_hostname} #{user}:wrong" + bundle "config set #{source_hostname} #{user}:wrong" bundle :install, :artifice => "endpoint_strict_basic_authentication" - expect(out).to include("Bad username or password") + expect(err).to include("Bad username or password") end end @@ -711,7 +711,7 @@ RSpec.describe "gemcutter's dependency API" do G bundle :install, :env => { "RUBYOPT" => "-I#{bundled_app("broken_ssl")}" } - expect(out).to include("OpenSSL") + expect(err).to include("OpenSSL") end end @@ -731,7 +731,7 @@ RSpec.describe "gemcutter's dependency API" do G bundle :install - expect(out).to match(/could not verify the SSL certificate/i) + expect(err).to match(/could not verify the SSL certificate/i) end end diff --git a/spec/bundler/install/gems/flex_spec.rb b/spec/bundler/install/gems/flex_spec.rb index 736f418ec7..aeb83d6573 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(err).to match(/could not find gem 'rack-obama/i) + expect(last_command.stderr).to match(/could not find gem 'rack-obama/i) end it "suggests bundle update when the Gemfile requires different versions than the lock" do @@ -233,9 +233,9 @@ RSpec.describe "bundle flex_install" do bundle "install" end.not_to change { File.read(bundled_app("Gemfile.lock")) } - expect(out).to include("rack = 0.9.1") - expect(out).to include("locked at 1.0.0") - expect(out).to include("bundle update rack") + expect(err).to include("rack = 0.9.1") + expect(err).to include("locked at 1.0.0") + expect(err).to include("bundle update rack") end it "should work when you update" do @@ -264,7 +264,7 @@ RSpec.describe "bundle flex_install" do rack (1.0.0) PLATFORMS - ruby + #{lockfile_platforms} DEPENDENCIES rack @@ -345,7 +345,7 @@ RSpec.describe "bundle flex_install" do gem "capybara", "0.3.9" G - expect(out).to include("Gemfile.lock") + expect(err).to include("Gemfile.lock") end end end diff --git a/spec/bundler/install/gems/mirror_spec.rb b/spec/bundler/install/gems/mirror_spec.rb index 4c35b8f206..ffa6116127 100644 --- a/spec/bundler/install/gems/mirror_spec.rb +++ b/spec/bundler/install/gems/mirror_spec.rb @@ -8,7 +8,7 @@ RSpec.describe "bundle install with a mirror configured" do gem "rack" G - bundle "config --local mirror.http://gems.example.org http://gem-mirror.example.org" + bundle "config set --local mirror.http://gems.example.org http://gem-mirror.example.org" end it "installs from the normal location" do @@ -26,7 +26,7 @@ RSpec.describe "bundle install with a mirror configured" do gem "rack" G - bundle "config --local mirror.file://localhost#{gem_repo2} file://localhost#{gem_repo1}" + bundle "config set --local mirror.file://localhost#{gem_repo2} file://localhost#{gem_repo1}" end it "installs the gem from the mirror" do diff --git a/spec/bundler/install/gems/native_extensions_spec.rb b/spec/bundler/install/gems/native_extensions_spec.rb index ea616f60d3..9176a07084 100644 --- a/spec/bundler/install/gems/native_extensions_spec.rb +++ b/spec/bundler/install/gems/native_extensions_spec.rb @@ -37,7 +37,7 @@ RSpec.describe "installing a gem with native extensions", :ruby_repo do gem "c_extension" G - bundle "config build.c_extension --with-c_extension=hello" + bundle "config set build.c_extension --with-c_extension=hello" bundle "install" expect(out).not_to include("extconf.rb failed") @@ -76,7 +76,48 @@ RSpec.describe "installing a gem with native extensions", :ruby_repo do C end - bundle! "config build.c_extension --with-c_extension=hello" + bundle! "config set build.c_extension --with-c_extension=hello" + + install_gemfile! <<-G + gem "c_extension", :git => #{lib_path("c_extension-1.0").to_s.dump} + G + + expect(out).not_to include("extconf.rb failed") + + run! "Bundler.require; puts CExtension.new.its_true" + expect(out).to eq("true") + end + + it "install with multiple build flags" do + build_git "c_extension" do |s| + s.extensions = ["ext/extconf.rb"] + s.write "ext/extconf.rb", <<-E + require "mkmf" + name = "c_extension_bundle" + dir_config(name) + raise "OMG" unless with_config("c_extension") == "hello" && with_config("c_extension_bundle-dir") == "hola" + create_makefile(name) + E + + s.write "ext/c_extension.c", <<-C + #include "ruby.h" + + VALUE c_extension_true(VALUE self) { + return Qtrue; + } + + void Init_c_extension_bundle() { + VALUE c_Extension = rb_define_class("CExtension", rb_cObject); + rb_define_method(c_Extension, "its_true", c_extension_true, 0); + } + C + + s.write "lib/c_extension.rb", <<-C + require "c_extension_bundle" + C + end + + bundle! "config set build.c_extension --with-c_extension=hello --with-c_extension_bundle-dir=hola" install_gemfile! <<-G gem "c_extension", :git => #{lib_path("c_extension-1.0").to_s.dump} diff --git a/spec/bundler/install/gems/post_install_spec.rb b/spec/bundler/install/gems/post_install_spec.rb index c6e348fb65..a6894fbc14 100644 --- a/spec/bundler/install/gems/post_install_spec.rb +++ b/spec/bundler/install/gems/post_install_spec.rb @@ -127,7 +127,7 @@ RSpec.describe "bundle install" do gem "rack" G - bundle "config ignore_messages.rack true" + bundle "config set ignore_messages.rack true" bundle :install expect(out).not_to include("Post-install message") @@ -141,7 +141,7 @@ RSpec.describe "bundle install" do gem "rack" G - bundle "config ignore_messages true" + bundle "config set ignore_messages true" bundle :install expect(out).not_to include("Post-install message") diff --git a/spec/bundler/install/gems/resolving_spec.rb b/spec/bundler/install/gems/resolving_spec.rb index 01c03ac793..cf3aaa719e 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(err).to include("Creating possibility state for net_c") + expect(last_command.stderr).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(err).to include(" net_b"). + expect(last_command.stderr).to include(" net_b"). and include("Starting resolution"). and include("Finished resolution"). and include("Attempting to activate") @@ -117,6 +117,26 @@ RSpec.describe "bundle install with install-time dependencies" do expect(out).to_not include("rack-9001.0.0 requires ruby version > 9000") expect(the_bundle).to include_gems("rack 1.2") end + + it "installs the older version under rate limiting conditions" do + build_repo4 do + build_gem "rack", "9001.0.0" do |s| + s.required_ruby_version = "> 9000" + end + build_gem "rack", "1.2" + build_gem "foo1", "1.0" + end + + install_gemfile <<-G, :artifice => "compact_index_rate_limited", :env => { "BUNDLER_SPEC_GEM_REPO" => gem_repo4 } + ruby "#{RUBY_VERSION}" + source "http://localgemserver.test/" + gem 'rack' + gem 'foo1' + G + + expect(out).to_not include("rack-9001.0.0 requires ruby version > 9000") + expect(the_bundle).to include_gems("rack 1.2") + end end context "allows no gems" do @@ -142,15 +162,14 @@ RSpec.describe "bundle install with install-time dependencies" do expect(out).to_not include("Gem::InstallError: require_ruby requires Ruby version > 9000") nice_error = strip_whitespace(<<-E).strip - Bundler could not find compatible versions for gem "ruby\0": + Bundler found conflicting requirements for the Ruby\0 version: In Gemfile: - ruby\0 (#{error_message_requirement}) + Ruby\0 (#{error_message_requirement}) require_ruby was resolved to 1.0, which depends on - ruby\0 (> 9000) + Ruby\0 (> 9000) - Could not find gem 'ruby\0 (> 9000)', which is required by gem 'require_ruby', in any of the relevant sources: - the local ruby installation + 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) end @@ -188,8 +207,8 @@ RSpec.describe "bundle install with install-time dependencies" do gem 'require_rubygems' G - expect(out).to_not include("Gem::InstallError: require_rubygems requires RubyGems version > 9000") - expect(out).to include("require_rubygems-1.0 requires rubygems version > 9000, which is incompatible with the current version, #{Gem::VERSION}") + expect(err).to_not include("Gem::InstallError: require_rubygems requires RubyGems version > 9000") + expect(err).to include("require_rubygems-1.0 requires rubygems version > 9000, which is incompatible with the current version, #{Gem::VERSION}") end end end diff --git a/spec/bundler/install/gems/standalone_spec.rb b/spec/bundler/install/gems/standalone_spec.rb index fa7a3bdc27..e2cfe5ec4c 100644 --- a/spec/bundler/install/gems/standalone_spec.rb +++ b/spec/bundler/install/gems/standalone_spec.rb @@ -75,7 +75,7 @@ RSpec.shared_examples "bundle install --standalone" do G end - it "generates a bundle/bundler/setup.rb with the proper paths", :rubygems => "2.4" do + it "generates a bundle/bundler/setup.rb with the proper paths" do expected_path = bundled_app("bundle/bundler/setup.rb") extension_line = File.read(expected_path).each_line.find {|line| line.include? "/extensions/" }.strip expect(extension_line).to start_with '$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/' @@ -108,8 +108,8 @@ RSpec.shared_examples "bundle install --standalone" do end it "outputs a helpful error message" do - expect(out).to include("You have one or more invalid gemspecs that need to be fixed.") - expect(out).to include("bar 1.0 has an invalid gemspec") + expect(err).to include("You have one or more invalid gemspecs that need to be fixed.") + expect(err).to include("bar 1.0 has an invalid gemspec") end end diff --git a/spec/bundler/install/gems/sudo_spec.rb b/spec/bundler/install/gems/sudo_spec.rb index 1781451c98..fb41f63a07 100644 --- a/spec/bundler/install/gems/sudo_spec.rb +++ b/spec/bundler/install/gems/sudo_spec.rb @@ -4,7 +4,7 @@ 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 before do - bundle! "config path.system true" + bundle! "config set path.system true" subdir = system_gem_path("cache") subdir.mkpath sudo "chmod u-w #{subdir}" @@ -25,7 +25,7 @@ RSpec.describe "when using sudo", :sudo => true do describe "and GEM_HOME is owned by root" do before :each do - bundle! "config path.system true" + bundle! "config set path.system true" chown_system_gems_to_root end @@ -52,7 +52,7 @@ RSpec.describe "when using sudo", :sudo => true do end it "installs when BUNDLE_PATH is owned by root" do - bundle! "config global_path_appends_ruby_scope false" # consistency in tests between 1.x and 2.x modes + 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 @@ -70,7 +70,7 @@ RSpec.describe "when using sudo", :sudo => true do end it "installs when BUNDLE_PATH does not exist" do - bundle! "config global_path_appends_ruby_scope false" # consistency in tests between 1.x and 2.x modes + 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 @@ -88,7 +88,7 @@ RSpec.describe "when using sudo", :sudo => true do expect(the_bundle).to include_gems "rack 1.0" end - it "installs extensions/ compiled by RubyGems 2.2", :rubygems => "2.2" do + it "installs extensions/" do install_gemfile <<-G source "file://#{gem_repo1}" gem "very_simple_binary" @@ -133,7 +133,7 @@ RSpec.describe "when using sudo", :sudo => true do describe "and GEM_HOME is not writable" do it "installs" do - bundle! "config path.system true" + bundle! "config set path.system true" gem_home = tmp("sudo_gem_home") sudo "mkdir -p #{gem_home}" sudo "chmod ugo-w #{gem_home}" @@ -158,20 +158,20 @@ RSpec.describe "when using sudo", :sudo => true do it "warns against that" do bundle :install, :sudo => true - expect(out).to include(warning) + expect(err).to include(warning) end context "when ENV['BUNDLE_SILENCE_ROOT_WARNING'] is set" do it "skips the warning" do bundle :install, :sudo => :preserve_env, :env => { "BUNDLE_SILENCE_ROOT_WARNING" => true } - expect(out).to_not include(warning) + expect(err).to_not include(warning) end end context "when silence_root_warning = false" do it "warns against that" do bundle :install, :sudo => true, :env => { "BUNDLE_SILENCE_ROOT_WARNING" => "false" } - expect(out).to include(warning) + expect(err).to include(warning) end end end diff --git a/spec/bundler/install/gemspecs_spec.rb b/spec/bundler/install/gemspecs_spec.rb index 666707b295..c9878ccae8 100644 --- a/spec/bundler/install/gemspecs_spec.rb +++ b/spec/bundler/install/gemspecs_spec.rb @@ -1,4 +1,3 @@ -# encoding: utf-8 # frozen_string_literal: true RSpec.describe "bundle install" do @@ -15,7 +14,7 @@ RSpec.describe "bundle install" do gem "yaml_spec" G bundle :install - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end it "still installs correctly when using path" do @@ -24,7 +23,7 @@ RSpec.describe "bundle install" do install_gemfile <<-G gem 'yaml_spec', :path => "#{lib_path("yaml_spec-1.0")}" G - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end end @@ -48,11 +47,11 @@ RSpec.describe "bundle install" do end it "does not hang when gemspec has incompatible encoding" do - create_file "foo.gemspec", <<-G + create_file("foo.gemspec", <<-G) Gem::Specification.new do |gem| gem.name = "pry-byebug" gem.version = "3.4.2" - gem.author = "David Rodriguez" + gem.author = "David RodrÃguez" gem.summary = "Good stuff" end G @@ -65,8 +64,6 @@ RSpec.describe "bundle install" do end it "reads gemspecs respecting their encoding" do - skip "Unicode is not supported on Ruby 1.x without extra work" if RUBY_VERSION < "2.0" - create_file "version.rb", <<-RUBY module Persistent💎 VERSION = "0.0.1" @@ -129,8 +126,8 @@ RSpec.describe "bundle install" do gemspec G - expect(out).to include("Ruby patchlevel") - expect(out).to include("but your Gemfile specified") + expect(err).to include("Ruby patchlevel") + expect(err).to include("but your Gemfile specified") expect(exitstatus).to eq(18) if exitstatus end @@ -146,8 +143,8 @@ RSpec.describe "bundle install" do gemspec G - expect(out).to include("Ruby version") - expect(out).to include("but your Gemfile specified") + expect(err).to include("Ruby version") + expect(err).to include("but your Gemfile specified") expect(exitstatus).to eq(18) if exitstatus end end diff --git a/spec/bundler/install/git_spec.rb b/spec/bundler/install/git_spec.rb index 48086a86c7..68b2f47c10 100644 --- a/spec/bundler/install/git_spec.rb +++ b/spec/bundler/install/git_spec.rb @@ -31,7 +31,7 @@ RSpec.describe "bundle install" do update_git "foo", "4.0", :path => lib_path("foo"), :gemspec => true - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true expect(out).to include("Using foo 2.0 (was 1.0) from #{lib_path("foo")} (at master~2@#{rev2})") expect(the_bundle).to include_gems "foo 2.0", :source => "git@#{lib_path("foo")}" end diff --git a/spec/bundler/install/global_cache_spec.rb b/spec/bundler/install/global_cache_spec.rb index e41e7e0157..345ad86db8 100644 --- a/spec/bundler/install/global_cache_spec.rb +++ b/spec/bundler/install/global_cache_spec.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true RSpec.describe "global gem caching" do - before { bundle! "config global_gem_cache true" } + before { bundle! "config set global_gem_cache true" } describe "using the cross-application user cache" do let(:source) { "http://localgemserver.test" } @@ -112,7 +112,7 @@ RSpec.describe "global gem caching" do expect(source_global_cache("rack-1.0.0.gem")).to exist expect(source2_global_cache("rack-0.9.1.gem")).to exist bundle :install, :artifice => "compact_index_no_gem" - expect(out).to include("Internal Server Error 500") + expect(err).to include("Internal Server Error 500") # rack 1.0.0 is not installed and rack 0.9.1 is not expect(the_bundle).not_to include_gems "rack 1.0.0" expect(the_bundle).not_to include_gems "rack 0.9.1" @@ -125,7 +125,7 @@ RSpec.describe "global gem caching" do expect(source_global_cache("rack-1.0.0.gem")).to exist expect(source2_global_cache("rack-0.9.1.gem")).to exist bundle :install, :artifice => "compact_index_no_gem" - expect(out).to include("Internal Server Error 500") + expect(err).to include("Internal Server Error 500") # rack 0.9.1 is not installed and rack 1.0.0 is not expect(the_bundle).not_to include_gems "rack 0.9.1" expect(the_bundle).not_to include_gems "rack 1.0.0" @@ -187,7 +187,7 @@ RSpec.describe "global gem caching" do end end - describe "extension caching", :ruby_repo, :rubygems => "2.2" do + describe "extension caching", :ruby_repo do it "works" do build_git "very_simple_git_binary", &:add_c_extension build_lib "very_simple_path_binary", &:add_c_extension @@ -220,7 +220,7 @@ RSpec.describe "global gem caching" do gem_binary_cache.join("very_simple_binary_c.rb").open("w") {|f| f << "puts File.basename(__FILE__)" } git_binary_cache.join("very_simple_git_binary_c.rb").open("w") {|f| f << "puts File.basename(__FILE__)" } - bundle! "config --local path different_path" + bundle! "config set --local path different_path" bundle! :install expect(Dir[home(".bundle", "cache", "extensions", "**", "*binary_c*")]).to all(end_with(".rb")) diff --git a/spec/bundler/install/path_spec.rb b/spec/bundler/install/path_spec.rb index 94f38c9290..0947ed9539 100644 --- a/spec/bundler/install/path_spec.rb +++ b/spec/bundler/install/path_spec.rb @@ -37,7 +37,7 @@ RSpec.describe "bundle install" do it "disallows --path vendor/bundle --system", :bundler => "< 3" do bundle "install --path vendor/bundle --system" - expect(out).to include("Please choose only one option.") + expect(err).to include("Please choose only one option.") expect(exitstatus).to eq(15) if exitstatus end @@ -51,7 +51,7 @@ RSpec.describe "bundle install" do end context "with path_relative_to_cwd set to true" do - before { bundle! "config path_relative_to_cwd true" } + before { bundle! "config set path_relative_to_cwd true" } it "installs the bundle relatively to current working directory", :bundler => "< 3" do Dir.chdir(bundled_app.parent) do @@ -98,7 +98,7 @@ RSpec.describe "bundle install" do if type == :env ENV["BUNDLE_PATH"] = location elsif type == :global - bundle! "config path #{location}", "no-color" => nil + bundle! "config set path #{location}", "no-color" => nil end end @@ -116,7 +116,7 @@ RSpec.describe "bundle install" do context "with global_path_appends_ruby_scope set", :bundler => "3" do it "installs gems to ." do set_bundle_path(type, ".") - bundle! "config --global disable_shared_gems true" + bundle! "config set --global disable_shared_gems true" bundle! :install @@ -150,7 +150,7 @@ RSpec.describe "bundle install" do context "with global_path_appends_ruby_scope unset", :bundler => "< 3" do it "installs gems to ." do set_bundle_path(type, ".") - bundle! "config --global disable_shared_gems true" + bundle! "config set --global disable_shared_gems true" bundle! :install @@ -207,7 +207,7 @@ RSpec.describe "bundle install" do expect(the_bundle).to include_gems "rack 1.0.0" end - it "re-installs gems whose extensions have been deleted", :ruby_repo, :rubygems => ">= 2.3" do + it "re-installs gems whose extensions have been deleted", :ruby_repo do build_lib "very_simple_binary", "1.0.0", :to_system => true do |s| s.write "lib/very_simple_binary.rb", "raise 'FAIL'" end @@ -226,7 +226,7 @@ RSpec.describe "bundle install" do vendored_gems("extensions").rmtree run "require 'very_simple_binary_c'" - expect(err).to include("Bundler::GemNotFound") + expect(last_command.stderr).to include("Bundler::GemNotFound") bundle :install, forgotten_command_line_options(:path => "./vendor/bundle") @@ -250,7 +250,7 @@ RSpec.describe "bundle install" do G bundle :install, forgotten_command_line_options(:path => "bundle") - expect(out).to include("file already exists") + expect(err).to include("file already exists") end end end diff --git a/spec/bundler/install/post_bundle_message_spec.rb b/spec/bundler/install/post_bundle_message_spec.rb index 394134f523..1efd0b8146 100644 --- a/spec/bundler/install/post_bundle_message_spec.rb +++ b/spec/bundler/install/post_bundle_message_spec.rb @@ -107,7 +107,7 @@ RSpec.describe "post bundle message" do gem "rack" gem "not-a-gem", :group => :development G - expect(out).to include("Could not find gem 'not-a-gem' in any of the gem sources listed in your Gemfile.") + expect(err).to include("Could not find gem 'not-a-gem' in any of the gem sources listed in your Gemfile.") end it "should report a helpful error message", :bundler => "3" do @@ -116,7 +116,7 @@ RSpec.describe "post bundle message" do gem "rack" gem "not-a-gem", :group => :development G - expect(out).to include normalize_uri_file(<<-EOS.strip) + expect(err).to include normalize_uri_file(<<-EOS.strip) Could not find gem 'not-a-gem' in rubygems repository file://localhost#{gem_repo1}/ or installed locally. The source does not contain any versions of 'not-a-gem' EOS @@ -134,7 +134,7 @@ The source does not contain any versions of 'not-a-gem' gem "rack" gem "not-a-gem", :group => :development G - expect(out).to include("Could not find gem 'not-a-gem' in"). + expect(err).to include("Could not find gem 'not-a-gem' in"). and include("or in gems cached in vendor/cache.") end end @@ -177,28 +177,28 @@ The source does not contain any versions of 'not-a-gem' describe "for bundle update" do it "without any options" do - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true expect(out).not_to include("Gems in the groups") expect(out).to include(bundle_updated_message) end it "with --without one group" do bundle! :install, forgotten_command_line_options(:without => "emo") - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true expect(out).to include("Gems in the group emo were not installed") 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 => bundle_update_requires_all? + bundle! :update, :all => true expect(out).to include("Gems in the groups emo and test were not installed") 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 => bundle_update_requires_all? + bundle! :update, :all => true expect(out).to include("Gems in the groups emo, obama and test were not installed") expect(out).to include(bundle_updated_message) end diff --git a/spec/bundler/install/process_lock_spec.rb b/spec/bundler/install/process_lock_spec.rb index be8fd04fdd..df1e9c6350 100644 --- a/spec/bundler/install/process_lock_spec.rb +++ b/spec/bundler/install/process_lock_spec.rb @@ -21,7 +21,7 @@ RSpec.describe "process lock spec" do expect(the_bundle).to include_gems "rack 1.0" end - context "when creating a lock raises Errno::ENOTSUP", :ruby => ">= 1.9" do + context "when creating a lock raises Errno::ENOTSUP" do before { allow(File).to receive(:open).and_raise(Errno::ENOTSUP) } it "skips creating the lock file and yields" do diff --git a/spec/bundler/install/redownload_spec.rb b/spec/bundler/install/redownload_spec.rb index f9caeed58a..2a0cdc9473 100644 --- a/spec/bundler/install/redownload_spec.rb +++ b/spec/bundler/install/redownload_spec.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -RSpec.describe "bundle install", :bundler => "< 3", :ruby => ">= 2.0" do +RSpec.describe "bundle install" do before :each do gemfile <<-G source "file://#{gem_repo1}" @@ -8,8 +8,6 @@ RSpec.describe "bundle install", :bundler => "< 3", :ruby => ">= 2.0" do G end - before { bundle "config major_deprecations yes" } - shared_examples_for "an option to force redownloading gems" do it "re-installs installed gems" do rack_lib = default_bundle_path("gems/rack-1.0.0/lib/rack.rb") @@ -58,19 +56,19 @@ RSpec.describe "bundle install", :bundler => "< 3", :ruby => ">= 2.0" do end end - describe "with --force" do + describe "with --force", :bundler => 2 do it_behaves_like "an option to force redownloading gems" do let(:flag) { "force" } end it "shows a deprecation when single flag passed" do bundle! "install --force" - expect(out).to include "[DEPRECATED FOR 3.0] The `--force` option has been renamed to `--redownload`" + expect(err).to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end it "shows a deprecation when multiple flags passed" do bundle! "install --no-color --force" - expect(out).to include "[DEPRECATED FOR 3.0] The `--force` option has been renamed to `--redownload`" + expect(err).to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end end @@ -81,12 +79,12 @@ RSpec.describe "bundle install", :bundler => "< 3", :ruby => ">= 2.0" do it "does not show a deprecation when single flag passed" do bundle! "install --redownload" - expect(out).not_to include "[DEPRECATED FOR 2.0] The `--force` option has been renamed to `--redownload`" + expect(err).not_to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end it "does not show a deprecation when single multiple flags passed" do bundle! "install --no-color --redownload" - expect(out).not_to include "[DEPRECATED FOR 2.0] The `--force` option has been renamed to `--redownload`" + expect(err).not_to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end end end diff --git a/spec/bundler/install/security_policy_spec.rb b/spec/bundler/install/security_policy_spec.rb index 7be09d6bd4..ad76162aac 100644 --- a/spec/bundler/install/security_policy_spec.rb +++ b/spec/bundler/install/security_policy_spec.rb @@ -24,18 +24,17 @@ RSpec.describe "policies with unsigned gems" do it "will fail when given invalid security policy" do bundle "install --trust-policy=InvalidPolicyName" - expect(out).to include("RubyGems doesn't know about trust policy") + expect(err).to include("RubyGems doesn't know about trust policy") end it "will fail with High Security setting due to presence of unsigned gem" do bundle "install --trust-policy=HighSecurity" - expect(out).to include("security policy didn't allow") + expect(err).to include("security policy didn't allow") end - # This spec will fail on RubyGems 2 rc1 due to a bug in policy.rb. the bug is fixed in rc3. - it "will fail with Medium Security setting due to presence of unsigned gem", :unless => ENV["RGV"] == "v2.0.0.rc.1" do + it "will fail with Medium Security setting due to presence of unsigned gem" do bundle "install --trust-policy=MediumSecurity" - expect(out).to include("security policy didn't allow") + expect(err).to include("security policy didn't allow") end it "will succeed with no policy" do @@ -55,12 +54,12 @@ RSpec.describe "policies with signed gems and no CA" do it "will fail with High Security setting, gem is self-signed" do bundle "install --trust-policy=HighSecurity" - expect(out).to include("security policy didn't allow") + expect(err).to include("security policy didn't allow") end it "will fail with Medium Security setting, gem is self-signed" do bundle "install --trust-policy=MediumSecurity" - expect(out).to include("security policy didn't allow") + expect(err).to include("security policy didn't allow") end it "will succeed with Low Security setting, low security accepts self signed gem" do diff --git a/spec/bundler/install/yanked_spec.rb b/spec/bundler/install/yanked_spec.rb index 7c4b98bfdf..3e6f6a3bcd 100644 --- a/spec/bundler/install/yanked_spec.rb +++ b/spec/bundler/install/yanked_spec.rb @@ -27,7 +27,7 @@ RSpec.context "when installing a bundle that includes yanked gems" do gem "foo", "10.0.0" G - expect(out).to include("Your bundle is locked to foo (10.0.0)") + expect(err).to include("Your bundle is locked to foo (10.0.0)") end it "throws the original error when only the Gemfile specifies a gem version that doesn't exist" do @@ -36,8 +36,8 @@ RSpec.context "when installing a bundle that includes yanked gems" do gem "foo", "10.0.0" G - expect(out).not_to include("Your bundle is locked to foo (10.0.0)") - expect(out).to include("Could not find gem 'foo (= 10.0.0)' in") + expect(err).not_to include("Your bundle is locked to foo (10.0.0)") + expect(err).to include("Could not find gem 'foo (= 10.0.0)' in") end end @@ -63,9 +63,9 @@ RSpec.context "when using gem before installing" do bundle :list - expect(out).to include("Could not find rack-0.9.1 in any of the sources") - expect(out).to_not include("Your bundle is locked to rack (0.9.1), but that version could not be found in any of the sources listed in your Gemfile.") - expect(out).to_not include("If you haven't changed sources, that means the author of rack (0.9.1) has removed it.") - expect(out).to_not include("You'll need to update your bundle to a different version of rack (0.9.1) that hasn't been removed in order to install.") + expect(err).to include("Could not find rack-0.9.1 in any of the sources") + expect(err).to_not include("Your bundle is locked to rack (0.9.1), but that version could not be found in any of the sources listed in your Gemfile.") + expect(err).to_not include("If you haven't changed sources, that means the author of rack (0.9.1) has removed it.") + expect(err).to_not include("You'll need to update your bundle to a different version of rack (0.9.1) that hasn't been removed in order to install.") end end diff --git a/spec/bundler/lock/lockfile_bundler_1_spec.rb b/spec/bundler/lock/lockfile_bundler_1_spec.rb deleted file mode 100644 index e89c5078d9..0000000000 --- a/spec/bundler/lock/lockfile_bundler_1_spec.rb +++ /dev/null @@ -1,1386 +0,0 @@ -# frozen_string_literal: true - -RSpec.describe "the lockfile format", :bundler => "< 3" do - include Bundler::GemHelpers - - before { ENV["BUNDLER_SPEC_IGNORE_COMPATIBILITY_GUARD"] = "TRUE" } - - it "generates a simple lockfile for a single source, gem" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "updates the lockfile's bundler version if current ver. is newer" do - lockfile <<-L - GIT - remote: git://github.com/nex3/haml.git - revision: 8a2271f - specs: - - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - omg! - rack - - BUNDLED WITH - 1.8.2 - L - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not update the lockfile's bundler version if nothing changed during bundle install", :ruby_repo do - version = "#{Bundler::VERSION.split(".").first}.0.0.0.a" - - lockfile normalize_uri_file(<<-L) - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - #{version} - L - - install_gemfile normalize_uri_file(<<-G) - source "file://localhost#{gem_repo1}" - - gem "rack" - G - - lockfile_should_be normalize_uri_file(<<-G) - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - #{version} - G - end - - it "updates the lockfile's bundler version if not present" do - lockfile <<-L - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - L - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack", "> 0" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack (> 0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "outputs a warning if the current is older than lockfile's bundler version" do - lockfile <<-L - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - 9999999.1.0 - L - - simulate_bundler_version "9999999.0.0" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack" - G - end - - warning_message = "the running version of Bundler (9999999.0.0) is older " \ - "than the version that created the lockfile (9999999.1.0)" - expect(out.scan(warning_message).size).to eq(1) - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - #{specific_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - 9999999.1.0 - G - end - - it "errors if the current is a major version older than lockfile's bundler version" do - lockfile <<-L - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - 9999999.0.0 - L - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack" - G - - expect(exitstatus > 0) if exitstatus - expect(out).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(exitstatus > 0) if exitstatus - expect(out).to include("You must use Bundler 9999999 or greater with this lockfile.") - end - - it "warns when updating bundler major version" 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(out).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 - #{generic_local_platform} - #{specific_local_platform} - - DEPENDENCIES - rack - - BUNDLED WITH - 9999999.0.0 - G - end - - it "generates a simple lockfile for a single source, gem with dependencies" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack-obama" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - rack-obama (1.0) - rack - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack-obama - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "generates a simple lockfile for a single source, gem with a version requirement" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack-obama", ">= 1.0" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - rack-obama (1.0) - rack - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack-obama (>= 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "generates a lockfile wihout credentials for a configured source" do - bundle "config http://localgemserver.test/ user:pass" - - install_gemfile(<<-G, :artifice => "endpoint_strict_basic_authentication", :quiet => true) - source "http://localgemserver.test/" - source "http://user:[email protected]/" - - gem "rack-obama", ">= 1.0" - G - - lockfile_should_be <<-G - GEM - remote: http://localgemserver.test/ - remote: http://user:[email protected]/ - specs: - rack (1.0.0) - rack-obama (1.0) - rack - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack-obama (>= 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "generates lockfiles with multiple requirements" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "net-sftp" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - net-sftp (1.1.1) - net-ssh (>= 1.0.0, < 1.99.0) - net-ssh (1.0) - - PLATFORMS - ruby - - DEPENDENCIES - net-sftp - - BUNDLED WITH - #{Bundler::VERSION} - G - - expect(the_bundle).to include_gems "net-sftp 1.1.1", "net-ssh 1.0.0" - end - - it "generates a simple lockfile for a single pinned source, gem with a version requirement" do - git = build_git "foo" - - install_gemfile <<-G - gem "foo", :git => "#{lib_path("foo-1.0")}" - G - - lockfile_should_be <<-G - GIT - remote: #{lib_path("foo-1.0")} - revision: #{git.ref_for("master")} - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not asplode when a platform specific dependency is present and the Gemfile has not been resolved on that platform" do - build_lib "omg", :path => lib_path("omg") - - gemfile <<-G - source "file://localhost#{gem_repo1}" - - platforms :#{not_local_tag} do - gem "omg", :path => "#{lib_path("omg")}" - end - - gem "rack" - G - - lockfile <<-L - GIT - remote: git://github.com/nex3/haml.git - revision: 8a2271f - specs: - - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{not_local} - - DEPENDENCIES - omg! - rack - - BUNDLED WITH - #{Bundler::VERSION} - L - - bundle "install" - expect(the_bundle).to include_gems "rack 1.0.0" - end - - it "serializes global git sources" do - git = build_git "foo" - - install_gemfile <<-G - git "#{lib_path("foo-1.0")}" do - gem "foo" - end - G - - lockfile_should_be <<-G - GIT - remote: #{lib_path("foo-1.0")} - revision: #{git.ref_for("master")} - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "generates a lockfile with a ref for a single pinned source, git gem with a branch requirement" do - git = build_git "foo" - update_git "foo", :branch => "omg" - - install_gemfile <<-G - gem "foo", :git => "#{lib_path("foo-1.0")}", :branch => "omg" - G - - lockfile_should_be <<-G - GIT - remote: #{lib_path("foo-1.0")} - revision: #{git.ref_for("omg")} - branch: omg - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "generates a lockfile with a ref for a single pinned source, git gem with a tag requirement" do - git = build_git "foo" - update_git "foo", :tag => "omg" - - install_gemfile <<-G - gem "foo", :git => "#{lib_path("foo-1.0")}", :tag => "omg" - G - - lockfile_should_be <<-G - GIT - remote: #{lib_path("foo-1.0")} - revision: #{git.ref_for("omg")} - tag: omg - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "serializes pinned path sources to the lockfile" do - build_lib "foo" - - install_gemfile <<-G - gem "foo", :path => "#{lib_path("foo-1.0")}" - G - - lockfile_should_be <<-G - PATH - remote: #{lib_path("foo-1.0")} - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "serializes pinned path sources to the lockfile even when packaging" do - build_lib "foo" - - install_gemfile! <<-G - gem "foo", :path => "#{lib_path("foo-1.0")}" - G - - bundle! :package, forgotten_command_line_options([:all, :cache_all] => true) - bundle! :install, :local => true - - lockfile_should_be <<-G - PATH - remote: #{lib_path("foo-1.0")} - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "sorts serialized sources by type" do - build_lib "foo" - bar = build_git "bar" - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack" - gem "foo", :path => "#{lib_path("foo-1.0")}" - gem "bar", :git => "#{lib_path("bar-1.0")}" - G - - lockfile_should_be <<-G - GIT - remote: #{lib_path("bar-1.0")} - revision: #{bar.ref_for("master")} - specs: - bar (1.0) - - PATH - remote: #{lib_path("foo-1.0")} - specs: - foo (1.0) - - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - bar! - foo! - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "lists gems alphabetically" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "thin" - gem "actionpack" - gem "rack-obama" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - actionpack (2.3.2) - activesupport (= 2.3.2) - activesupport (2.3.2) - rack (1.0.0) - rack-obama (1.0) - rack - thin (1.0) - rack - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - actionpack - rack-obama - thin - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "orders dependencies' dependencies in alphabetical order" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rails" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - actionmailer (2.3.2) - activesupport (= 2.3.2) - actionpack (2.3.2) - activesupport (= 2.3.2) - activerecord (2.3.2) - activesupport (= 2.3.2) - activeresource (2.3.2) - activesupport (= 2.3.2) - activesupport (2.3.2) - rails (2.3.2) - actionmailer (= 2.3.2) - actionpack (= 2.3.2) - activerecord (= 2.3.2) - activeresource (= 2.3.2) - rake (= 10.0.2) - rake (10.0.2) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rails - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "orders dependencies by version" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem 'double_deps' - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - double_deps (1.0) - net-ssh - net-ssh (>= 1.0.0) - net-ssh (1.0) - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - double_deps - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not add the :require option to the lockfile" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack-obama", ">= 1.0", :require => "rack/obama" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - rack-obama (1.0) - rack - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack-obama (>= 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not add the :group option to the lockfile" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack-obama", ">= 1.0", :group => :test - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - rack-obama (1.0) - rack - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - rack-obama (>= 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "stores relative paths when the path is provided in a relative fashion and in Gemfile dir" do - build_lib "foo", :path => bundled_app("foo") - - install_gemfile <<-G - path "foo" - gem "foo" - G - - lockfile_should_be <<-G - PATH - remote: foo - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "stores relative paths when the path is provided in a relative fashion and is above Gemfile dir" do - build_lib "foo", :path => bundled_app(File.join("..", "foo")) - - install_gemfile <<-G - path "../foo" - gem "foo" - G - - lockfile_should_be <<-G - PATH - remote: ../foo - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "stores relative paths when the path is provided in an absolute fashion but is relative" do - build_lib "foo", :path => bundled_app("foo") - - install_gemfile <<-G - path File.expand_path("../foo", __FILE__) - gem "foo" - G - - lockfile_should_be <<-G - PATH - remote: foo - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "stores relative paths when the path is provided for gemspec" do - build_lib("foo", :path => tmp.join("foo")) - - install_gemfile <<-G - gemspec :path => "../foo" - G - - lockfile_should_be <<-G - PATH - remote: ../foo - specs: - foo (1.0) - - GEM - specs: - - PLATFORMS - #{generic_local_platform} - - DEPENDENCIES - foo! - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "keeps existing platforms in the lockfile" do - lockfile <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - java - - DEPENDENCIES - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - - gem "rack" - G - - platforms = ["java", generic_local_platform.to_s].sort - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - #{platforms[0]} - #{platforms[1]} - - DEPENDENCIES - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "persists the spec's platform to the lockfile" do - build_gem "platform_specific", "1.0.0", :to_system => true do |s| - s.platform = Gem::Platform.new("universal-java-16") - end - - simulate_platform "universal-java-16" - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "platform_specific" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - platform_specific (1.0-java) - - PLATFORMS - java - - DEPENDENCIES - platform_specific - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not add duplicate gems" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack" - G - - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack" - gem "activesupport" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - activesupport (2.3.5) - rack (1.0.0) - - PLATFORMS - ruby - - DEPENDENCIES - activesupport - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not add duplicate dependencies" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack" - gem "rack" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - ruby - - DEPENDENCIES - rack - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not add duplicate dependencies with versions" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack", "1.0" - gem "rack", "1.0" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - ruby - - DEPENDENCIES - rack (= 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "does not add duplicate dependencies in different groups" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack", "1.0", :group => :one - gem "rack", "1.0", :group => :two - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - - PLATFORMS - ruby - - DEPENDENCIES - rack (= 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "raises if two different versions are used" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack", "1.0" - gem "rack", "1.1" - G - - expect(bundled_app("Gemfile.lock")).not_to exist - expect(out).to include "rack (= 1.0) and rack (= 1.1)" - end - - it "raises if two different sources are used" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack" - gem "rack", :git => "git://hubz.com" - G - - expect(bundled_app("Gemfile.lock")).not_to exist - expect(out).to include "rack (>= 0) should come from an unspecified source and git://hubz.com (at master)" - end - - it "works correctly with multiple version dependencies" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "rack", "> 0.9", "< 1.0" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (0.9.1) - - PLATFORMS - ruby - - DEPENDENCIES - rack (> 0.9, < 1.0) - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - it "captures the Ruby version in the lockfile" do - install_gemfile <<-G - source "file://localhost#{gem_repo1}" - ruby '#{RUBY_VERSION}' - gem "rack", "> 0.9", "< 1.0" - G - - lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (0.9.1) - - PLATFORMS - ruby - - DEPENDENCIES - rack (> 0.9, < 1.0) - - RUBY VERSION - ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} - - BUNDLED WITH - #{Bundler::VERSION} - G - end - - # Some versions of the Bundler 1.1 RC series introduced corrupted - # lockfiles. There were two major problems: - # - # * multiple copies of the same GIT section appeared in the lockfile - # * when this happened, those sections got multiple copies of gems - # in those sections. - it "fixes corrupted lockfiles" do - build_git "omg", :path => lib_path("omg") - revision = revision_for(lib_path("omg")) - - gemfile <<-G - source "file://localhost#{gem_repo1}" - gem "omg", :git => "#{lib_path("omg")}", :branch => 'master' - G - - bundle "install --path vendor" - expect(the_bundle).to include_gems "omg 1.0" - - # Create a Gemfile.lock that has duplicate GIT sections - lockfile <<-L - GIT - remote: #{lib_path("omg")} - revision: #{revision} - branch: master - specs: - omg (1.0) - - GIT - remote: #{lib_path("omg")} - revision: #{revision} - branch: master - specs: - omg (1.0) - - GEM - remote: file://localhost#{gem_repo1}/ - specs: - - PLATFORMS - #{local} - - DEPENDENCIES - omg! - - BUNDLED WITH - #{Bundler::VERSION} - L - - FileUtils.rm_rf(bundled_app("vendor")) - bundle "install" - expect(the_bundle).to include_gems "omg 1.0" - - # Confirm that duplicate specs do not appear - lockfile_should_be(<<-L) - GIT - remote: #{lib_path("omg")} - revision: #{revision} - branch: master - specs: - omg (1.0) - - GEM - remote: file://localhost#{gem_repo1}/ - specs: - - PLATFORMS - #{local} - - DEPENDENCIES - omg! - - BUNDLED WITH - #{Bundler::VERSION} - L - end - - it "raises a helpful error message when the lockfile is missing deps" do - lockfile <<-L - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack_middleware (1.0) - - PLATFORMS - #{local} - - DEPENDENCIES - rack_middleware - L - - install_gemfile <<-G - source "file:#{gem_repo1}" - gem "rack_middleware" - G - - expect(out).to include("Downloading rack_middleware-1.0 revealed dependencies not in the API or the lockfile (#{Gem::Dependency.new("rack", "= 0.9.1")})."). - and include("Either installing with `--full-index` or running `bundle update rack_middleware` should fix the problem.") - end - - describe "a line ending" do - def set_lockfile_mtime_to_known_value - time = Time.local(2000, 1, 1, 0, 0, 0) - File.utime(time, time, bundled_app("Gemfile.lock")) - end - before(:each) do - build_repo2 - - install_gemfile <<-G - source "file://localhost#{gem_repo2}" - gem "rack" - G - set_lockfile_mtime_to_known_value - end - - it "generates Gemfile.lock with \\n line endings" do - expect(File.read(bundled_app("Gemfile.lock"))).not_to match("\r\n") - expect(the_bundle).to include_gems "rack 1.0" - end - - context "during updates" do - it "preserves Gemfile.lock \\n line endings" do - update_repo2 - - expect { bundle "update", :all => true }.to change { File.mtime(bundled_app("Gemfile.lock")) } - expect(File.read(bundled_app("Gemfile.lock"))).not_to match("\r\n") - expect(the_bundle).to include_gems "rack 1.2" - end - - it "preserves Gemfile.lock \\n\\r line endings" do - update_repo2 - win_lock = File.read(bundled_app("Gemfile.lock")).gsub(/\n/, "\r\n") - File.open(bundled_app("Gemfile.lock"), "wb") {|f| f.puts(win_lock) } - set_lockfile_mtime_to_known_value - - expect { bundle "update", :all => true }.to change { File.mtime(bundled_app("Gemfile.lock")) } - expect(File.read(bundled_app("Gemfile.lock"))).to match("\r\n") - expect(the_bundle).to include_gems "rack 1.2" - end - end - - context "when nothing changes" do - it "preserves Gemfile.lock \\n line endings" do - expect do - ruby <<-RUBY - require 'rubygems' - require 'bundler' - Bundler.setup - RUBY - end.not_to change { File.mtime(bundled_app("Gemfile.lock")) } - end - - it "preserves Gemfile.lock \\n\\r line endings" do - win_lock = File.read(bundled_app("Gemfile.lock")).gsub(/\n/, "\r\n") - File.open(bundled_app("Gemfile.lock"), "wb") {|f| f.puts(win_lock) } - set_lockfile_mtime_to_known_value - - expect do - ruby <<-RUBY - require 'rubygems' - require 'bundler' - Bundler.setup - RUBY - end.not_to change { File.mtime(bundled_app("Gemfile.lock")) } - end - end - end - - it "refuses to install if Gemfile.lock contains conflict markers" do - lockfile <<-L - GEM - remote: file://localhost#{gem_repo1}/ - specs: - <<<<<<< - rack (1.0.0) - ======= - rack (1.0.1) - >>>>>>> - - PLATFORMS - ruby - - DEPENDENCIES - rack - - BUNDLED WITH - #{Bundler::VERSION} - L - - install_gemfile(<<-G) - source "file://localhost#{gem_repo1}" - 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) - end -end diff --git a/spec/bundler/lock/lockfile_spec.rb b/spec/bundler/lock/lockfile_spec.rb index 9e2fb3b2dd..5ee44bf779 100644 --- a/spec/bundler/lock/lockfile_spec.rb +++ b/spec/bundler/lock/lockfile_spec.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -RSpec.describe "the lockfile format", :bundler => "3" do +RSpec.describe "the lockfile format" do include Bundler::GemHelpers before { ENV["BUNDLER_SPEC_IGNORE_COMPATIBILITY_GUARD"] = "TRUE" } @@ -76,7 +76,7 @@ RSpec.describe "the lockfile format", :bundler => "3" do end it "does not update the lockfile's bundler version if nothing changed during bundle install" do - version = "#{Bundler::VERSION.split(".").first}.0.0.0.a" + version = "#{Bundler::VERSION.split(".").first}.0.0.a" lockfile <<-L GEM @@ -180,8 +180,10 @@ RSpec.describe "the lockfile format", :bundler => "3" do end warning_message = "the running version of Bundler (9999999.0.0) is older " \ - "than the version that created the lockfile (9999999.1.0)" - expect(last_command.bundler_err).to include warning_message + "than the version that created the lockfile (9999999.1.0). " \ + "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_should_be <<-G GEM @@ -190,7 +192,8 @@ RSpec.describe "the lockfile format", :bundler => "3" do rack (1.0.0) PLATFORMS - #{lockfile_platforms} + #{generic_local_platform} + #{specific_local_platform} DEPENDENCIES rack @@ -200,7 +203,7 @@ RSpec.describe "the lockfile format", :bundler => "3" do G end - it "errors if the current is a major version older than lockfile's bundler version" do + it "errors if the current is a major version older than lockfile's bundler version", :bundler => "3" do lockfile <<-L GEM remote: file://localhost#{gem_repo1}/ @@ -262,10 +265,10 @@ RSpec.describe "the lockfile format", :bundler => "3" do G expect(last_command).to be_failure - expect(out).to include("You must use Bundler 9999999 or greater with this lockfile.") + expect(err).to include("You must use Bundler 9999999 or greater with this lockfile.") end - it "warns when updating bundler major version" do + it "warns when updating bundler major version", :bundler => "< 3" do lockfile <<-L GEM remote: file://localhost#{gem_repo1}/ @@ -290,8 +293,10 @@ RSpec.describe "the lockfile format", :bundler => "3" do G end - expect(out).to include("Warning: the lockfile is being updated to Bundler " \ - "9999999, after which you will be unable to return to Bundler 1.") + 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 @@ -300,7 +305,8 @@ RSpec.describe "the lockfile format", :bundler => "3" do rack (1.0.0) PLATFORMS - #{lockfile_platforms} + #{generic_local_platform} + #{specific_local_platform} DEPENDENCIES rack @@ -310,6 +316,53 @@ RSpec.describe "the lockfile format", :bundler => "3" do 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 + end + it "generates a simple lockfile for a single source, gem with dependencies" do install_gemfile <<-G source "file://localhost#{gem_repo1}/" @@ -362,8 +415,41 @@ RSpec.describe "the lockfile format", :bundler => "3" do G end - it "generates a lockfile without credentials for a configured source" do - bundle "config http://localgemserver.test/ user:pass" + it "generates a lockfile without credentials for a configured source", :bundler => "< 3" do + bundle "config set http://localgemserver.test/ user:pass" + + install_gemfile(<<-G, :artifice => "endpoint_strict_basic_authentication", :quiet => true) + source "http://localgemserver.test/" do + + end + + source "http://user:[email protected]/" do + gem "rack-obama", ">= 1.0" + end + G + + lockfile_should_be <<-G + GEM + remote: http://localgemserver.test/ + remote: http://user:[email protected]/ + specs: + rack (1.0.0) + rack-obama (1.0) + rack + + PLATFORMS + #{lockfile_platforms} + + DEPENDENCIES + rack-obama (>= 1.0)! + + BUNDLED WITH + #{Bundler::VERSION} + G + end + + it "generates a lockfile without credentials for a configured source", :bundler => "3" do + bundle "config set http://localgemserver.test/ user:pass" install_gemfile(<<-G, :artifice => "endpoint_strict_basic_authentication", :quiet => true) source "http://localgemserver.test/" do @@ -464,15 +550,15 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - GIT remote: #{lib_path("foo-1.0")} revision: #{git.ref_for("master")} specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -533,15 +619,15 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - GIT remote: #{lib_path("foo-1.0")} revision: #{git.ref_for("master")} specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -562,9 +648,6 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - GIT remote: #{lib_path("foo-1.0")} revision: #{git.ref_for("omg")} @@ -572,6 +655,9 @@ RSpec.describe "the lockfile format", :bundler => "3" do specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -592,9 +678,6 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - GIT remote: #{lib_path("foo-1.0")} revision: #{git.ref_for("omg")} @@ -602,6 +685,9 @@ RSpec.describe "the lockfile format", :bundler => "3" do specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -621,14 +707,14 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - PATH remote: #{lib_path("foo-1.0")} specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -651,14 +737,14 @@ RSpec.describe "the lockfile format", :bundler => "3" do bundle! :install, :local => true lockfile_should_be <<-G - GEM - specs: - PATH remote: #{lib_path("foo-1.0")} specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -683,11 +769,6 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo1}/ - specs: - rack (1.0.0) - GIT remote: #{lib_path("bar-1.0")} revision: #{bar.ref_for("master")} @@ -699,6 +780,11 @@ RSpec.describe "the lockfile format", :bundler => "3" do specs: foo (1.0) + GEM + remote: file://localhost#{gem_repo1}/ + specs: + rack (1.0.0) + PLATFORMS #{lockfile_platforms} @@ -772,8 +858,8 @@ RSpec.describe "the lockfile format", :bundler => "3" do actionpack (= 2.3.2) activerecord (= 2.3.2) activeresource (= 2.3.2) - rake (= 10.0.2) - rake (10.0.2) + rake (= 12.3.2) + rake (12.3.2) PLATFORMS #{lockfile_platforms} @@ -874,14 +960,14 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - PATH remote: foo specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -903,14 +989,14 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - PATH remote: ../foo specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -932,14 +1018,14 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - PATH remote: foo specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -959,14 +1045,14 @@ RSpec.describe "the lockfile format", :bundler => "3" do G lockfile_should_be <<-G - GEM - specs: - PATH remote: ../foo specs: foo (1.0) + GEM + specs: + PLATFORMS #{lockfile_platforms} @@ -978,7 +1064,48 @@ RSpec.describe "the lockfile format", :bundler => "3" do G end - it "keeps existing platforms in the lockfile" do + it "keeps existing platforms in the lockfile", :bundler => "< 3" do + lockfile <<-G + GEM + remote: file://localhost#{gem_repo1}/ + specs: + rack (1.0.0) + + PLATFORMS + java + + DEPENDENCIES + rack + + BUNDLED WITH + #{Bundler::VERSION} + G + + install_gemfile <<-G + source "file://localhost#{gem_repo1}/" + + gem "rack" + G + + lockfile_should_be <<-G + GEM + remote: file://localhost#{gem_repo1}/ + specs: + rack (1.0.0) + + PLATFORMS + java + #{generic_local_platform} + + DEPENDENCIES + rack + + BUNDLED WITH + #{Bundler::VERSION} + G + end + + it "keeps existing platforms in the lockfile", :bundler => "3" do lockfile <<-G GEM remote: file://localhost#{gem_repo1}/ @@ -1008,7 +1135,9 @@ RSpec.describe "the lockfile format", :bundler => "3" do rack (1.0.0) PLATFORMS - #{lockfile_platforms "java", generic_local_platform, specific_local_platform} + java + #{generic_local_platform} + #{specific_local_platform} DEPENDENCIES rack @@ -1018,7 +1147,38 @@ RSpec.describe "the lockfile format", :bundler => "3" do G end - it "persists the spec's platform to the lockfile" do + it "persists the spec's platform to the lockfile", :bundler => "< 3" do + build_repo2 do + build_gem "platform_specific", "1.0" do |s| + s.platform = Gem::Platform.new("universal-java-16") + end + end + + simulate_platform "universal-java-16" + + install_gemfile! <<-G + source "file://localhost#{gem_repo2}" + gem "platform_specific" + G + + lockfile_should_be <<-G + GEM + remote: file://localhost#{gem_repo2}/ + specs: + platform_specific (1.0-java) + + PLATFORMS + java + + DEPENDENCIES + platform_specific + + BUNDLED WITH + #{Bundler::VERSION} + G + end + + it "persists the spec's platform and specific platform to the lockfile", :bundler => "3" do build_repo2 do build_gem "platform_specific", "1.0" do |s| s.platform = Gem::Platform.new("universal-java-16") @@ -1162,7 +1322,7 @@ RSpec.describe "the lockfile format", :bundler => "3" do G expect(bundled_app("Gemfile.lock")).not_to exist - expect(out).to include "rack (= 1.0) and rack (= 1.1)" + expect(err).to include "rack (= 1.0) and rack (= 1.1)" end it "raises if two different sources are used" do @@ -1173,7 +1333,7 @@ RSpec.describe "the lockfile format", :bundler => "3" do G expect(bundled_app("Gemfile.lock")).not_to exist - expect(out).to include "rack (>= 0) should come from an unspecified source and git://hubz.com (at master)" + expect(err).to include "rack (>= 0) should come from an unspecified source and git://hubz.com (at master)" end it "works correctly with multiple version dependencies" do @@ -1246,10 +1406,6 @@ RSpec.describe "the lockfile format", :bundler => "3" do # Create a Gemfile.lock that has duplicate GIT sections lockfile <<-L - GEM - remote: file://localhost#{gem_repo1}/ - specs: - GIT remote: #{lib_path("omg")} revision: #{revision} @@ -1264,6 +1420,10 @@ RSpec.describe "the lockfile format", :bundler => "3" do specs: omg (1.0) + GEM + remote: file://localhost#{gem_repo1}/ + specs: + PLATFORMS #{lockfile_platforms} @@ -1280,10 +1440,6 @@ RSpec.describe "the lockfile format", :bundler => "3" do # Confirm that duplicate specs do not appear lockfile_should_be(<<-L) - GEM - remote: file://localhost#{gem_repo1}/ - specs: - GIT remote: #{lib_path("omg")} revision: #{revision} @@ -1291,6 +1447,10 @@ RSpec.describe "the lockfile format", :bundler => "3" do specs: omg (1.0) + GEM + remote: file://localhost#{gem_repo1}/ + specs: + PLATFORMS #{lockfile_platforms} @@ -1321,7 +1481,7 @@ RSpec.describe "the lockfile format", :bundler => "3" do gem "rack_middleware" G - expect(out).to include("Downloading rack_middleware-1.0 revealed dependencies not in the API or the lockfile (#{Gem::Dependency.new("rack", "= 0.9.1")})."). + expect(err).to include("Downloading rack_middleware-1.0 revealed dependencies not in the API or the lockfile (#{Gem::Dependency.new("rack", "= 0.9.1")})."). and include("Either installing with `--full-index` or running `bundle update rack_middleware` should fix the problem.") end diff --git a/spec/bundler/other/bundle_ruby_spec.rb b/spec/bundler/other/bundle_ruby_spec.rb deleted file mode 100644 index fbca31d0a0..0000000000 --- a/spec/bundler/other/bundle_ruby_spec.rb +++ /dev/null @@ -1,155 +0,0 @@ -# frozen_string_literal: true - -RSpec.describe "bundle_ruby", :bundler => "< 3" do - context "without patchlevel" do - it "returns the ruby version" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.9.3", :engine => 'ruby', :engine_version => '1.9.3' - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 1.9.3") - end - - it "engine defaults to MRI" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.9.3" - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 1.9.3") - end - - it "handles jruby" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.8.7", :engine => 'jruby', :engine_version => '1.6.5' - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 1.8.7 (jruby 1.6.5)") - end - - it "handles rbx" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.8.7", :engine => 'rbx', :engine_version => '1.2.4' - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 1.8.7 (rbx 1.2.4)") - end - - it "handles truffleruby", :rubygems => ">= 2.1.0" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "2.5.1", :engine => 'truffleruby', :engine_version => '1.0.0-rc6' - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 2.5.1 (truffleruby 1.0.0-rc6)") - end - - it "raises an error if engine is used but engine version is not" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.8.7", :engine => 'rbx' - - gem "foo" - G - - bundle_ruby - expect(exitstatus).not_to eq(0) if exitstatus - - bundle_ruby - expect(out).to include("Please define :engine_version") - end - - it "raises an error if engine_version is used but engine is not" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.8.7", :engine_version => '1.2.4' - - gem "foo" - G - - bundle_ruby - expect(exitstatus).not_to eq(0) if exitstatus - - bundle_ruby - expect(out).to include("Please define :engine") - end - - it "raises an error if engine version doesn't match ruby version for MRI" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.8.7", :engine => 'ruby', :engine_version => '1.2.4' - - gem "foo" - G - - bundle_ruby - expect(exitstatus).not_to eq(0) if exitstatus - - bundle_ruby - expect(out).to include("ruby_version must match the :engine_version for MRI") - end - - it "should print if no ruby version is specified" do - gemfile <<-G - source "file://#{gem_repo1}" - - gem "foo" - G - - bundle_ruby - - expect(out).to include("No ruby version specified") - end - end - - context "when using patchlevel" do - it "returns the ruby version" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.9.3", :patchlevel => '429', :engine => 'ruby', :engine_version => '1.9.3' - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 1.9.3p429") - end - - it "handles an engine" do - gemfile <<-G - source "file://#{gem_repo1}" - ruby "1.9.3", :patchlevel => '392', :engine => 'jruby', :engine_version => '1.7.4' - - gem "foo" - G - - bundle_ruby - - expect(out).to include("ruby 1.9.3p392 (jruby 1.7.4)") - end - end -end diff --git a/spec/bundler/other/cli_dispatch_spec.rb b/spec/bundler/other/cli_dispatch_spec.rb index d17819b394..67127fc6e0 100644 --- a/spec/bundler/other/cli_dispatch_spec.rb +++ b/spec/bundler/other/cli_dispatch_spec.rb @@ -19,7 +19,7 @@ RSpec.describe "bundle command names" do end context "when cache_command_is_package is set" do - before { bundle! "config cache_command_is_package true" } + before { bundle! "config set cache_command_is_package true" } it "dispatches `bundle cache` to the package command" do bundle "cache --verbose" diff --git a/spec/bundler/other/compatibility_guard_spec.rb b/spec/bundler/other/compatibility_guard_spec.rb index ac05ebd918..c72842eab5 100644 --- a/spec/bundler/other/compatibility_guard_spec.rb +++ b/spec/bundler/other/compatibility_guard_spec.rb @@ -12,14 +12,5 @@ RSpec.describe "bundler compatibility guard" do expect(err).to eq("Bundler 2 requires Ruby 2.3 or later. Either install bundler 1 or update to a supported Ruby version.") end end - - context "when running on RubyGems < 2.5", :ruby => ">= 2.5" do - before { simulate_rubygems_version "1.3.6" } - - it "raises a friendly error" do - bundle :version - expect(err).to eq("Bundler 2 requires RubyGems 2.5 or later. Either install bundler 1 or update to a supported RubyGems version.") - end - end end end diff --git a/spec/bundler/other/ext_spec.rb b/spec/bundler/other/ext_spec.rb index 3f6f8b4928..bc8c781c5d 100644 --- a/spec/bundler/other/ext_spec.rb +++ b/spec/bundler/other/ext_spec.rb @@ -54,13 +54,8 @@ RSpec.describe "Gem::SourceIndex#refresh!" do G end - it "does not explode when called", :rubygems => "1.7" do + it "does not explode when called" do run "Gem.source_index.refresh!" run "Gem::SourceIndex.new([]).refresh!" end - - it "does not explode when called", :rubygems => "< 1.7" do - run "Gem.source_index.refresh!" - run "Gem::SourceIndex.from_gems_in([]).refresh!" - end end diff --git a/spec/bundler/other/major_deprecation_spec.rb b/spec/bundler/other/major_deprecation_spec.rb index 50800dbb0c..83944e4075 100644 --- a/spec/bundler/other/major_deprecation_spec.rb +++ b/spec/bundler/other/major_deprecation_spec.rb @@ -1,126 +1,235 @@ # frozen_string_literal: true -RSpec.describe "major deprecations", :bundler => "< 3" do - let(:warnings) { last_command.bundler_err } # change to err in 2.0 - let(:warnings_without_version_messages) { warnings.gsub(/#{Spec::Matchers::MAJOR_DEPRECATION}Bundler will only support ruby(gems)? >= .*/, "") } +RSpec.describe "major deprecations" do + let(:warnings) { err } - context "in a .99 version" do + describe "Bundler" do before do - simulate_bundler_version "1.99.1" - bundle "config --delete major_deprecations" + install_gemfile! <<-G + source "file:#{gem_repo1}" + gem "rack" + G end - it "prints major deprecations without being configured" do - ruby <<-R - require "bundler" - Bundler::SharedHelpers.major_deprecation(Bundler::VERSION) - R + describe ".clean_env" do + before do + source = "Bundler.clean_env" + bundle "exec ruby -e #{source.dump}" + end + + it "is deprecated in favor of .unbundled_env", :bundler => "2" do + expect(deprecations).to include \ + "`Bundler.clean_env` has been deprecated in favor of `Bundler.unbundled_env`. " \ + "If you instead want the environment before bundler was originally loaded, use `Bundler.original_env`" + end - expect(warnings).to have_major_deprecation("1.99.1") + pending "is removed and shows a helpful error message about it", :bundler => "3" end - end - before do - bundle "config major_deprecations true" + describe ".with_clean_env" do + before do + source = "Bundler.with_clean_env {}" + bundle "exec ruby -e #{source.dump}" + end - create_file "gems.rb", <<-G - source "file:#{gem_repo1}" - ruby #{RUBY_VERSION.dump} - gem "rack" - G - bundle! "install" - end + it "is deprecated in favor of .unbundled_env", :bundler => "2" do + expect(deprecations).to include( + "`Bundler.with_clean_env` has been deprecated in favor of `Bundler.with_unbundled_env`. " \ + "If you instead want the environment before bundler was originally loaded, use `Bundler.with_original_env`" + ) + end - describe "bundle_ruby" do - it "prints a deprecation" do - bundle_ruby - warnings.gsub! "\nruby #{RUBY_VERSION}", "" - expect(warnings).to have_major_deprecation "the bundle_ruby executable has been removed in favor of `bundle platform --ruby`" + pending "is removed and shows a helpful error message about it", :bundler => "3" end - end - describe "Bundler" do - describe ".clean_env" do - it "is deprecated in favor of .original_env" do - source = "Bundler.clean_env" + describe ".clean_system" do + before do + source = "Bundler.clean_system('ls')" bundle "exec ruby -e #{source.dump}" - expect(warnings).to have_major_deprecation "`Bundler.clean_env` has weird edge cases, use `.original_env` instead" end + + it "is deprecated in favor of .unbundled_system", :bundler => "2" do + expect(deprecations).to include( + "`Bundler.clean_system` has been deprecated in favor of `Bundler.unbundled_system`. " \ + "If you instead want to run the command in the environment before bundler was originally loaded, use `Bundler.original_system`" + ) + end + + pending "is removed and shows a helpful error message about it", :bundler => "3" + end + + describe ".clean_exec" do + before do + source = "Bundler.clean_exec('ls')" + bundle "exec ruby -e #{source.dump}" + end + + it "is deprecated in favor of .unbundled_exec", :bundler => "2" do + expect(deprecations).to include( + "`Bundler.clean_exec` has been deprecated in favor of `Bundler.unbundled_exec`. " \ + "If you instead want to exec to a command in the environment before bundler was originally loaded, use `Bundler.original_exec`" + ) + end + + pending "is removed and shows a helpful error message about it", :bundler => "3" end describe ".environment" do - it "is deprecated in favor of .load" do + before do source = "Bundler.environment" bundle "exec ruby -e #{source.dump}" - expect(warnings).to have_major_deprecation "Bundler.environment has been removed in favor of Bundler.load" end + + it "is deprecated in favor of .load", :bundler => "2" do + expect(deprecations).to include "Bundler.environment has been removed in favor of Bundler.load" + end + + pending "is removed and shows a helpful error message about it", :bundler => "3" end + end - shared_examples_for "environmental deprecations" do |trigger| - describe "ruby version", :ruby => "< 2.0" do - it "requires a newer ruby version" do - instance_eval(&trigger) - expect(warnings).to have_major_deprecation "Bundler will only support ruby >= 2.0, you are running #{RUBY_VERSION}" - end + describe "bundle update --quiet" do + it "does not print any deprecations" do + bundle :update, :quiet => true + expect(deprecations).to be_empty + end + end + + describe "bundle config" do + describe "old list interface" do + before do + bundle! "config" end - describe "rubygems version", :rubygems => "< 2.0" do - it "requires a newer rubygems version" do - instance_eval(&trigger) - expect(warnings).to have_major_deprecation "Bundler will only support rubygems >= 2.0, you are running #{Gem::VERSION}" - end + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config list` instead.") end + + pending "fails with a helpful error", :bundler => "3" end - describe "-rbundler/setup" do - it_behaves_like "environmental deprecations", proc { ruby "require 'bundler/setup'" } + describe "old get interface" do + before do + bundle! "config waka" + end + + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config get waka` instead.") + end + + pending "fails with a helpful error", :bundler => "3" end - describe "Bundler.setup" do - it_behaves_like "environmental deprecations", proc { ruby "require 'bundler'; Bundler.setup" } + describe "old set interface" do + before do + bundle! "config waka wakapun" + end + + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config set waka wakapun` instead.") + end + + pending "fails with a helpful error", :bundler => "3" end - describe "bundle check" do - it_behaves_like "environmental deprecations", proc { bundle :check } + describe "old set interface with --local" do + before do + bundle! "config --local waka wakapun" + end + + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config set --local waka wakapun` instead.") + end + + pending "fails with a helpful error", :bundler => "3" end - describe "bundle update --quiet" do - it "does not print any deprecations" do - bundle :update, :quiet => true - expect(warnings_without_version_messages).not_to have_major_deprecation + describe "old set interface with --global" do + before do + bundle! "config --global waka wakapun" end + + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config set --global waka wakapun` instead.") + end + + pending "fails with a helpful error", :bundler => "3" end - describe "bundle update" do + describe "old unset interface" do before do - create_file("gems.rb", "") - bundle! "install" + bundle! "config --delete waka" end - it "warns when no options are given" do - bundle! "update" - expect(warnings).to have_major_deprecation a_string_including("Pass --all to `bundle update` to update everything") + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config unset waka` instead.") end - it "does not warn when --all is passed" do - bundle! "update --all" - expect(warnings_without_version_messages).not_to have_major_deprecation + pending "fails with a helpful error", :bundler => "3" + end + + describe "old unset interface with --local" do + before do + bundle! "config --delete --local waka" + end + + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config unset --local waka` instead.") end + + pending "fails with a helpful error", :bundler => "3" end - describe "bundle install --binstubs" do - it "should output a deprecation warning" do - gemfile <<-G - gem 'rack' - G + describe "old unset interface with --global" do + before do + bundle! "config --delete --global waka" + end - bundle :install, :binstubs => true - expect(warnings).to have_major_deprecation a_string_including("The --binstubs option will be removed") + it "warns", :bundler => "2" do + expect(deprecations).to include("Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle config unset --global waka` instead.") end + + pending "fails with a helpful error", :bundler => "3" + end + end + + describe "bundle update" do + before do + install_gemfile <<-G + source "file:#{gem_repo1}" + gem "rack" + G + end + + it "warns when no options are given", :bundler => "2" do + bundle! "update" + expect(deprecations).to include("Pass --all to `bundle update` to update everything") + end + + pending "fails with a helpful error when no options are given", :bundler => "3" + + it "does not warn when --all is passed" do + bundle! "update --all" + expect(deprecations).to be_empty + end + end + + describe "bundle install --binstubs" do + before do + install_gemfile <<-G, :binstubs => true + source "file:#{gem_repo1}" + gem "rack" + G + end + + it "should output a deprecation warning", :bundler => "2" do + expect(deprecations).to include("The --binstubs option will be removed in favor of `bundle binstubs`") end + + pending "fails with a helpful error", :bundler => "3" end - context "when bundle is run" do + context "bundle install with both gems.rb and Gemfile present" do it "should not warn about gems.rb" do create_file "gems.rb", <<-G source "file://#{gem_repo1}" @@ -128,36 +237,92 @@ RSpec.describe "major deprecations", :bundler => "< 3" do G bundle :install - expect(warnings_without_version_messages).not_to have_major_deprecation + expect(deprecations).to be_empty end - it "should print a Gemfile deprecation warning" do + it "should print a proper warning, and use gems.rb" do create_file "gems.rb" install_gemfile! <<-G source "file://#{gem_repo1}" gem "rack" G - expect(the_bundle).to include_gem "rack 1.0" - expect(warnings).to have_major_deprecation a_string_including("gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock.") + expect(warnings).to include( + "Multiple gemfiles (gems.rb and Gemfile) detected. Make sure you remove Gemfile and Gemfile.lock since bundler is ignoring them in favor of gems.rb and gems.rb.locked." + ) + + expect(the_bundle).not_to include_gem "rack 1.0" end + end - context "with flags" do - it "should print a deprecation warning about autoremembering flags" do - install_gemfile <<-G, :path => "vendor/bundle" - source "file://#{gem_repo1}" - gem "rack" - G + context "bundle install with flags" do + before do + bundle "config set --local path vendor/bundle" - expect(warnings).to have_major_deprecation a_string_including( - "flags passed to commands will no longer be automatically remembered." - ) + install_gemfile <<-G + source "file://#{gem_repo1}" + gem "rack" + G + end + + { + :clean => true, + :deployment => true, + :frozen => true, + :"no-cache" => true, + :"no-prune" => true, + :path => "vendor/bundle", + :shebang => "ruby27", + :system => true, + :without => "development", + :with => "development", + }.each do |name, value| + flag_name = "--#{name}" + + context "with the #{flag_name} flag" do + before do + bundle "install" # to create a lockfile, which deployment or frozen need + bundle "install #{flag_name} #{value}" + end + + it "should print a deprecation warning", :bundler => "2" do + expect(deprecations).to include( + "The `#{flag_name}` flag is deprecated because it relies on " \ + "being remembered accross bundler invokations, which bundler " \ + "will no longer do in future versions. Instead please use " \ + "`bundle config #{name} '#{value}'`, and stop using this flag" + ) + end + + pending "should fail with a helpful error", :bundler => "3" end end end + context "bundle install with multiple sources" do + before do + install_gemfile <<-G + source "file://localhost#{gem_repo3}" + source "file://localhost#{gem_repo1}" + G + end + + it "shows a deprecation", :bundler => "2" do + expect(deprecations).to include( + "Your Gemfile contains multiple primary sources. " \ + "Using `source` more than once without a block is a security risk, and " \ + "may result in installing unexpected gems. To resolve this warning, use " \ + "a block to indicate which gems should come from the secondary source. " \ + "To upgrade this warning to an error, run `bundle config set " \ + "disable_multisource true`." + ) + end + + pending "should fail with a helpful error", :bundler => "3" + end + context "when Bundler.setup is run in a ruby script" do - it "should print a single deprecation warning" do + before do create_file "gems.rb" install_gemfile! <<-G source "file://#{gem_repo1}" @@ -173,52 +338,57 @@ RSpec.describe "major deprecations", :bundler => "< 3" do Bundler.setup Bundler.setup RUBY + end - expect(warnings_without_version_messages).to have_major_deprecation("gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock.") + it "should print a single deprecation warning" do + expect(warnings).to include( + "Multiple gemfiles (gems.rb and Gemfile) detected. Make sure you remove Gemfile and Gemfile.lock since bundler is ignoring them in favor of gems.rb and gems.rb.locked." + ) end end context "when `bundler/deployment` is required in a ruby script" do - it "should print a capistrano deprecation warning" do + before do ruby(<<-RUBY) require 'bundler/deployment' RUBY + end - expect(warnings).to have_major_deprecation("Bundler no longer integrates " \ + it "should print a capistrano deprecation warning", :bundler => "2" do + expect(deprecations).to include("Bundler no longer integrates " \ "with Capistrano, but Capistrano provides " \ "its own integration with Bundler via the " \ "capistrano-bundler gem. Use it instead.") end + + pending "should fail with a helpful error", :bundler => "3" 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" do - msg = <<-EOS -The :github git source is deprecated, and will be removed in Bundler 3.0. Change any "reponame" :github sources to "username/reponame". Add this code to the top of your Gemfile to ensure it continues to work: - - git_source(:github) {|repo_name| "https://github.com/\#{repo_name}.git" } - - EOS + 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 "upgrades to https on request" do - Bundler.settings.temporary "github.https" => true - msg = <<-EOS -The :github git source is deprecated, and will be removed in Bundler 3.0. Change any "reponame" :github sources to "username/reponame". Add this code to the top of your Gemfile to ensure it continues to work: - - git_source(:github) {|repo_name| "https://github.com/\#{repo_name}.git" } - - EOS + it "upgrades to https by default", :bundler => "2" do expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, msg) - expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, "The `github.https` setting will be removed") subject.gem("sparks", :github => "indirect/sparks") github_uri = "https://github.com/indirect/sparks.git" expect(subject.dependencies.first.source.uri).to eq(github_uri) @@ -229,7 +399,7 @@ The :github git source is deprecated, and will be removed in Bundler 3.0. Change it "warns about removal" do allow(Bundler.ui).to receive(:deprecate) msg = <<-EOS -The :bitbucket git source is deprecated, and will be removed in Bundler 3.0. Add this code to the top of your Gemfile to ensure it continues to work: +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: git_source(:bitbucket) do |repo_name| user_name, repo_name = repo_name.split("/") @@ -246,10 +416,12 @@ The :bitbucket git source is deprecated, and will be removed in Bundler 3.0. Add context "with gist gems" do it "warns about removal" do allow(Bundler.ui).to receive(:deprecate) - msg = "The :gist git source is deprecated, and will be removed " \ - "in Bundler 3.0. Add this code to the top of your Gemfile to ensure it " \ - "continues to work:\n\n git_source(:gist) {|repo_name| " \ - "\"https://gist.github.com/\#{repo_name}.git\" }\n\n" + 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: + + git_source(:gist) {|repo_name| "https://gist.github.com/\#{repo_name}.git" } + + EOS expect(Bundler::SharedHelpers).to receive(:major_deprecation).with(3, msg) subject.gem("not-really-a-gem", :gist => "1234") end @@ -257,26 +429,91 @@ The :bitbucket git source is deprecated, and will be removed in Bundler 3.0. Add end context "bundle show" do - it "prints a deprecation warning" do + before do install_gemfile! <<-G source "file://#{gem_repo1}" gem "rack" G + end - bundle! :show + context "without flags" do + before do + bundle! :show + end - warnings.gsub!(/gems included.*?\[DEPRECATED/im, "[DEPRECATED") + it "prints a deprecation warning recommending `bundle list`", :bundler => "2" do + expect(deprecations).to include("use `bundle list` instead of `bundle show`") + end - expect(warnings).to have_major_deprecation a_string_including("use `bundle list` instead of `bundle show`") + pending "fails with a helpful message", :bundler => "3" end + + context "with --outdated flag" do + before do + bundle! "show --outdated" + end + + it "prints a deprecation warning informing about its removal", :bundler => "2" do + expect(deprecations).to include("the `--outdated` flag to `bundle show` was undocumented and will be removed without replacement") + end + + pending "fails with a helpful message", :bundler => "3" + end + + context "with --verbose flag" do + before do + bundle! "show --verbose" + end + + it "prints a deprecation warning informing about its removal", :bundler => "2" do + expect(deprecations).to include("the `--verbose` flag to `bundle show` was undocumented and will be removed without replacement") + end + + pending "fails with a helpful message", :bundler => "3" + end + + context "with a gem argument" do + before do + bundle! "show rack" + end + + 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 + end + + pending "fails with a helpful message", :bundler => "3" end context "bundle console" do - it "prints a deprecation warning" do + before do bundle "console" + end - expect(warnings).to have_major_deprecation \ - a_string_including("bundle console will be replaced by `bin/console` generated by `bundle gem <name>`") + it "prints a deprecation warning", :bundler => "2" do + expect(deprecations).to include \ + "bundle console will be replaced by `bin/console` generated by `bundle gem <name>`" end + + pending "fails with a helpful message", :bundler => "3" + end + + context "bundle viz" do + let(:ruby_graphviz) do + graphviz_glob = base_system_gems.join("cache/ruby-graphviz*") + Pathname.glob(graphviz_glob).first + end + + before do + system_gems ruby_graphviz + create_file "gems.rb" + bundle "viz" + end + + it "prints a deprecation warning", :bundler => "2" do + expect(deprecations).to include "The `viz` command has been moved to the `bundle-viz` gem, see https://github.com/bundler/bundler-viz" + end + + pending "fails with a helpful message", :bundler => "3" end end diff --git a/spec/bundler/other/platform_spec.rb b/spec/bundler/other/platform_spec.rb index 6c59fd893c..9c62904286 100644 --- a/spec/bundler/other/platform_spec.rb +++ b/spec/bundler/other/platform_spec.rb @@ -149,7 +149,7 @@ G expect(out).to eq("ruby 1.8.7 (rbx 1.2.4)") end - it "handles truffleruby", :rubygems => ">= 2.1.0" do + it "handles truffleruby" do gemfile <<-G source "file://#{gem_repo1}" ruby "2.5.1", :engine => 'truffleruby', :engine_version => '1.0.0-rc6' @@ -268,27 +268,27 @@ G def should_be_ruby_version_incorrect expect(exitstatus).to eq(18) if exitstatus - expect(out).to be_include("Your Ruby version is #{RUBY_VERSION}, but your Gemfile specified #{not_local_ruby_version}") + expect(err).to be_include("Your Ruby version is #{RUBY_VERSION}, but your Gemfile specified #{not_local_ruby_version}") end def should_be_engine_incorrect expect(exitstatus).to eq(18) if exitstatus - expect(out).to be_include("Your Ruby engine is #{local_ruby_engine}, but your Gemfile specified #{not_local_tag}") + expect(err).to be_include("Your Ruby engine is #{local_ruby_engine}, but your Gemfile specified #{not_local_tag}") end def should_be_engine_version_incorrect expect(exitstatus).to eq(18) if exitstatus - expect(out).to be_include("Your #{local_ruby_engine} version is #{local_engine_version}, but your Gemfile specified #{local_ruby_engine} #{not_local_engine_version}") + expect(err).to be_include("Your #{local_ruby_engine} version is #{local_engine_version}, but your Gemfile specified #{local_ruby_engine} #{not_local_engine_version}") end def should_be_patchlevel_incorrect expect(exitstatus).to eq(18) if exitstatus - expect(out).to be_include("Your Ruby patchlevel is #{RUBY_PATCHLEVEL}, but your Gemfile specified #{not_local_patchlevel}") + expect(err).to be_include("Your Ruby patchlevel is #{RUBY_PATCHLEVEL}, but your Gemfile specified #{not_local_patchlevel}") end def should_be_patchlevel_fixnum expect(exitstatus).to eq(18) if exitstatus - expect(out).to be_include("The Ruby patchlevel in your Gemfile must be a string") + expect(err).to be_include("The Ruby patchlevel in your Gemfile must be a string") end context "bundle install" do @@ -511,7 +511,7 @@ G build_gem "activesupport", "3.0" end - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(the_bundle).to include_gems "rack 1.2", "rack-obama 1.0", "activesupport 3.0" end @@ -528,7 +528,7 @@ G build_gem "activesupport", "3.0" end - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(the_bundle).to include_gems "rack 1.2", "rack-obama 1.0", "activesupport 3.0" end end @@ -545,7 +545,7 @@ G build_gem "activesupport", "3.0" end - bundle :update, :all => bundle_update_requires_all? + bundle :update, :all => true should_be_ruby_version_incorrect end @@ -561,7 +561,7 @@ G build_gem "activesupport", "3.0" end - bundle :update, :all => bundle_update_requires_all? + bundle :update, :all => true should_be_engine_incorrect end @@ -578,7 +578,7 @@ G build_gem "activesupport", "3.0" end - bundle :update, :all => bundle_update_requires_all? + bundle :update, :all => true should_be_engine_version_incorrect end end @@ -594,7 +594,7 @@ G build_gem "activesupport", "3.0" end - bundle :update, :all => bundle_update_requires_all? + bundle :update, :all => true should_be_patchlevel_incorrect end end @@ -863,7 +863,7 @@ G G bundle "exec rackup" - expect(out).to eq("0.9.1") + expect(out).to include("0.9.1") end it "activates the correct gem when ruby version matches any engine" do @@ -876,7 +876,7 @@ G G bundle "exec rackup" - expect(out).to eq("0.9.1") + expect(out).to include("0.9.1") end end diff --git a/spec/bundler/other/ssl_cert_spec.rb b/spec/bundler/other/ssl_cert_spec.rb deleted file mode 100644 index 6d957276fc..0000000000 --- a/spec/bundler/other/ssl_cert_spec.rb +++ /dev/null @@ -1,18 +0,0 @@ -# frozen_string_literal: true - -require "bundler/ssl_certs/certificate_manager" - -RSpec.describe "SSL Certificates", :rubygems_master do - hosts = %w[ - rubygems.org - index.rubygems.org - rubygems.global.ssl.fastly.net - staging.rubygems.org - ] - - hosts.each do |host| - it "can securely connect to #{host}", :realworld do - Bundler::SSLCerts::CertificateManager.new.connect_to(host) - end - end -end diff --git a/spec/bundler/plugins/command_spec.rb b/spec/bundler/plugins/command_spec.rb index 999d8b722b..53d34f7acc 100644 --- a/spec/bundler/plugins/command_spec.rb +++ b/spec/bundler/plugins/command_spec.rb @@ -73,8 +73,8 @@ RSpec.describe "command plugins" do expect(out).not_to include("Installed plugin copycat") - expect(out).to include("Failed to install plugin") + expect(err).to include("Failed to install plugin") - expect(out).to include("Command(s) `mahcommand` declared by copycat are already registered.") + expect(err).to include("Command(s) `mahcommand` declared by copycat are already registered.") end end diff --git a/spec/bundler/plugins/install_spec.rb b/spec/bundler/plugins/install_spec.rb index 9304d78062..afc6087c1b 100644 --- a/spec/bundler/plugins/install_spec.rb +++ b/spec/bundler/plugins/install_spec.rb @@ -11,7 +11,7 @@ RSpec.describe "bundler plugin install" do it "shows proper message when gem in not found in the source" do bundle "plugin install no-foo --source file://#{gem_repo1}" - expect(out).to include("Could not find") + expect(err).to include("Could not find") plugin_should_not_be_installed("no-foo") end @@ -22,6 +22,18 @@ RSpec.describe "bundler plugin install" do plugin_should_be_installed("foo") end + context "plugin is already installed" do + before do + bundle "plugin install foo --source file://#{gem_repo2}" + end + + it "doesn't install plugin again" do + bundle "plugin install foo --source file://#{gem_repo2}" + expect(out).not_to include("Installing plugin foo") + expect(out).not_to include("Installed plugin foo") + end + end + it "installs multiple plugins" do bundle "plugin install foo kung-foo --source file://#{gem_repo2}" @@ -86,7 +98,7 @@ RSpec.describe "bundler plugin install" do bundle "plugin install charlie --source file://#{gem_repo2}" - expect(out).to include("plugins.rb was not found") + expect(err).to include("plugins.rb was not found") expect(global_plugin_gem("charlie-1.0")).not_to be_directory @@ -122,6 +134,24 @@ RSpec.describe "bundler plugin install" do expect(out).to include("Installed plugin foo") plugin_should_be_installed("foo") end + + it "installs form a local git source" do + build_git "foo" do |s| + s.write "plugins.rb" + end + + bundle "plugin install foo --local_git #{lib_path("foo-1.0")}" + + expect(out).to include("Installed plugin foo") + plugin_should_be_installed("foo") + end + + it "raises an error when both git and local git sources are specified" do + bundle "plugin install foo --local_git /phony/path/project --git [email protected]:/repo/project" + + expect(exitstatus).not_to eq(0) if exitstatus + expect(err).to eq("Remote and local plugin git sources can't be both specified") + end end context "Gemfile eval" do @@ -147,7 +177,7 @@ RSpec.describe "bundler plugin install" do build_plugin "foo", "1.1.0" end - install_gemfile <<-G + gemfile <<-G source 'file://#{gem_repo2}' plugin 'foo', "1.0" G @@ -173,6 +203,28 @@ RSpec.describe "bundler plugin install" do expect(out).to include("Installed plugin ga-plugin") plugin_should_be_installed("ga-plugin") end + + context "in deployment mode" do + it "installs plugins" do + install_gemfile! <<-G + source 'file://#{gem_repo2}' + gem 'rack', "1.0.0" + G + + install_gemfile! <<-G, forgotten_command_line_options(:deployment => true) + source 'file://#{gem_repo2}' + plugin 'foo' + gem 'rack', "1.0.0" + G + + expect(out).to include("Installed plugin foo") + + expect(out).to include("Bundle complete!") + + expect(the_bundle).to include_gems("rack 1.0.0") + plugin_should_be_installed("foo") + end + end end context "inline gemfiles" do diff --git a/spec/bundler/plugins/list_spec.rb b/spec/bundler/plugins/list_spec.rb new file mode 100644 index 0000000000..7dc9d10c4b --- /dev/null +++ b/spec/bundler/plugins/list_spec.rb @@ -0,0 +1,60 @@ +# frozen_string_literal: true + +RSpec.describe "bundler plugin list" do + before do + build_repo2 do + build_plugin "foo" do |s| + s.write "plugins.rb", <<-RUBY + class Foo < Bundler::Plugin::API + command "shout" + + def exec(command, args) + puts "Foo shout" + end + end + RUBY + end + build_plugin "bar" do |s| + s.write "plugins.rb", <<-RUBY + class Bar < Bundler::Plugin::API + command "scream" + + def exec(command, args) + puts "Bar scream" + end + end + RUBY + end + end + end + + context "no plugins installed" do + it "shows proper no plugins installed message" do + bundle "plugin list" + + expect(out).to include("No plugins installed") + end + end + + context "single plugin installed" do + it "shows plugin name with commands list" do + bundle "plugin install foo --source file://#{gem_repo2}" + plugin_should_be_installed("foo") + bundle "plugin list" + + expected_output = "foo\n-----\n shout" + expect(out).to include(expected_output) + end + end + + context "multiple plugins installed" do + it "shows plugin names with commands list" do + bundle "plugin install foo bar --source file://#{gem_repo2}" + plugin_should_be_installed("foo", "bar") + bundle "plugin list" + + expected_output = "foo\n-----\n shout\n\nbar\n-----\n scream" + expect(out).to include(expected_output) + end + end +end diff --git a/spec/bundler/plugins/source/example_spec.rb b/spec/bundler/plugins/source/example_spec.rb index d9a3cd2b92..bc076c06bf 100644 --- a/spec/bundler/plugins/source/example_spec.rb +++ b/spec/bundler/plugins/source/example_spec.rb @@ -96,16 +96,16 @@ RSpec.describe "real source plugins" do bundle "install" lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo2}/ - specs: - PLUGIN SOURCE remote: #{lib_path("a-path-gem-1.0")} type: mpath specs: a-path-gem (1.0) + GEM + remote: file://localhost#{gem_repo2}/ + specs: + PLATFORMS #{lockfile_platforms} @@ -391,10 +391,6 @@ RSpec.describe "real source plugins" do bundle "install" lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo2}/ - specs: - PLUGIN SOURCE remote: file://#{lib_path("ma-gitp-gem-1.0")} type: gitp @@ -402,6 +398,10 @@ RSpec.describe "real source plugins" do specs: ma-gitp-gem (1.0) + GEM + remote: file://localhost#{gem_repo2}/ + specs: + PLATFORMS #{lockfile_platforms} diff --git a/spec/bundler/quality_es_spec.rb b/spec/bundler/quality_es_spec.rb new file mode 100644 index 0000000000..8fc653c45a --- /dev/null +++ b/spec/bundler/quality_es_spec.rb @@ -0,0 +1,70 @@ +# frozen_string_literal: true + +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") +end + +RSpec.describe "La biblioteca si misma" do + def check_for_expendable_words(filename) + failing_line_message = [] + useless_words = %w[ + básicamente + claramente + sólo + solamente + obvio + obviamente + fácil + fácilmente + sencillamente + simplemente + ] + pattern = /\b#{Regexp.union(useless_words)}\b/i + + File.readlines(filename).each_with_index do |line, number| + next unless word_found = pattern.match(line) + failing_line_message << "#{filename}:#{number.succ} contiene '#{word_found}'. Esta palabra tiene un significado subjetivo y es mejor obviarla en textos técnicos." + end + + failing_line_message unless failing_line_message.empty? + end + + def check_for_specific_pronouns(filename) + failing_line_message = [] + specific_pronouns = /\b(él|ella|ellos|ellas)\b/i + + File.readlines(filename).each_with_index do |line, number| + next unless word_found = specific_pronouns.match(line) + failing_line_message << "#{filename}:#{number.succ} contiene '#{word_found}'. Use pronombres más genéricos en la documentación." + end + + failing_line_message unless failing_line_message.empty? + end + + it "mantiene la calidad de lenguaje de la documentación" do + included = /ronn/ + error_messages = [] + Dir.chdir(root) do + `git ls-files -z -- man`.split("\x0").each do |filename| + next unless filename =~ included + error_messages << check_for_expendable_words(filename) + error_messages << check_for_specific_pronouns(filename) + end + end + expect(error_messages.compact).to be_well_formed + end + + it "mantiene la calidad de lenguaje de oraciones usadas en el código fuente" do + error_messages = [] + exempt = /vendor/ + Dir.chdir(root) do + `git ls-files -z -- lib`.split("\x0").each do |filename| + next if filename =~ exempt + error_messages << check_for_expendable_words(filename) + error_messages << check_for_specific_pronouns(filename) + end + end + expect(error_messages.compact).to be_well_formed + end +end diff --git a/spec/bundler/quality_spec.rb b/spec/bundler/quality_spec.rb index b24b42c542..f9c815aee1 100644 --- a/spec/bundler/quality_spec.rb +++ b/spec/bundler/quality_spec.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true if defined?(Encoding) && Encoding.default_external.name != "UTF-8" - # Poor man's ruby -E UTF-8, since it works on 1.8.7 + # An approximation of ruby -E UTF-8, since it works on 1.8.7 Encoding.default_external = Encoding.find("UTF-8") end @@ -96,16 +96,8 @@ RSpec.describe "The library itself" do failing_line_message unless failing_line_message.empty? end - RSpec::Matchers.define :be_well_formed do - match(&:empty?) - - failure_message do |actual| - actual.join("\n") - end - end - it "has no malformed whitespace" do - exempt = /\.gitmodules|\.marshal|fixtures|vendor|ssl_certs|LICENSE|vcr_cassettes/ + exempt = /\.gitmodules|\.marshal|fixtures|vendor|LICENSE|vcr_cassettes/ error_messages = [] Dir.chdir(root) do lib_files = ruby_core? ? `git ls-files -z -- lib/bundler lib/bundler.rb spec/bundler` : `git ls-files -z -- lib` @@ -175,16 +167,13 @@ RSpec.describe "The library itself" do exemptions = %w[ auto_config_jobs cache_command_is_package - console_command deployment_means_frozen forget_cli_options gem.coc gem.mit + github.https inline - lockfile_upgrade_warning - lockfile_uses_separate_rubygems_sources use_gem_version_promoter_for_major_updates - viz_command ] all_settings = Hash.new {|h, k| h[k] = [] } @@ -235,14 +224,10 @@ RSpec.describe "The library itself" do gem_command! :build, gemspec end - if Bundler.rubygems.provides?(">= 2.4") - # there's no way aroudn this warning - last_command.stderr.sub!(/^YAML safe loading.*/, "") + # there's no way around this warning + last_command.stderr.sub!(/^YAML safe loading.*/, "") - # older rubygems have weird warnings, and we won't actually be using them - # to build the gem for releases anyways - expect(last_command.stderr).to be_empty, "bundler should build as a gem without warnings, but\n#{err}" - end + expect(last_command.stderr).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") @@ -250,6 +235,18 @@ RSpec.describe "The library itself" do end end + it "ships the correct set of files" do + Dir.chdir(root) do + git_list = IO.popen("git ls-files -z", &:read).split("\x0").select {|f| f.match(%r{^(lib|exe)/}) } + git_list += %w[CHANGELOG.md LICENSE.md README.md bundler.gemspec] + git_list += Dir.glob("man/**/*") + + gem_list = Gem::Specification.load(gemspec.to_s).files + + expect(git_list.to_set).to eq(gem_list.to_set) + end + end + it "does not contain any warnings" do Dir.chdir(root) do exclusions = %w[ diff --git a/spec/bundler/realworld/dependency_api_spec.rb b/spec/bundler/realworld/dependency_api_spec.rb index 13527ce5d1..e7d11419cd 100644 --- a/spec/bundler/realworld/dependency_api_spec.rb +++ b/spec/bundler/realworld/dependency_api_spec.rb @@ -9,7 +9,7 @@ RSpec.describe "gemcutter's dependency API", :realworld => true do @server_uri = "http://127.0.0.1:#{port}" require File.expand_path("../../support/artifice/endpoint_timeout", __FILE__) - require "thread" + @t = Thread.new do server = Rack::Server.start(:app => EndpointTimeout, :Host => "0.0.0.0", @@ -22,7 +22,7 @@ RSpec.describe "gemcutter's dependency API", :realworld => true do @t.run wait_for_server("127.0.0.1", port) - bundle! "config timeout 1" + bundle! "config set timeout 1" end after do diff --git a/spec/bundler/realworld/double_check_spec.rb b/spec/bundler/realworld/double_check_spec.rb index 94ab49ba2a..6fee578a71 100644 --- a/spec/bundler/realworld/double_check_spec.rb +++ b/spec/bundler/realworld/double_check_spec.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true RSpec.describe "double checking sources", :realworld => true do - it "finds already-installed gems", :ruby => ">= 2.2" do + it "finds already-installed gems" do create_file("rails.gemspec", <<-RUBY) Gem::Specification.new do |s| s.name = "rails" diff --git a/spec/bundler/realworld/edgecases_spec.rb b/spec/bundler/realworld/edgecases_spec.rb index 1db5c0f9d6..a3662c91e7 100644 --- a/spec/bundler/realworld/edgecases_spec.rb +++ b/spec/bundler/realworld/edgecases_spec.rb @@ -19,63 +19,25 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do RUBY end - # there is no rbx-relative-require gem that will install on 1.9 - it "ignores extra gems with bad platforms", :ruby => "~> 1.8.7" do - gemfile <<-G - source "https://rubygems.org" - gem "linecache", "0.46" - G - bundle :lock - expect(err).to lack_errors - expect(exitstatus).to eq(0) if exitstatus - end - - # https://github.com/bundler/bundler/issues/1202 - it "bundle cache works with rubygems 1.3.7 and pre gems", - :ruby => "~> 1.8.7", :rubygems => "~> 1.3.7" do - install_gemfile <<-G - source "https://rubygems.org" - gem "rack", "1.3.0.beta2" - gem "will_paginate", "3.0.pre2" - G - bundle :cache - expect(out).not_to include("Removing outdated .gem files from vendor/cache") - end - - # https://github.com/bundler/bundler/issues/1486 - # this is a hash collision that only manifests on 1.8.7 - it "finds the correct child versions", :ruby => "~> 1.8.7" do - gemfile <<-G - source "https://rubygems.org" - - gem 'i18n', '~> 0.6.0' - gem 'activesupport', '~> 3.0.5' - gem 'activerecord', '~> 3.0.5' - gem 'builder', '~> 2.1.2' - G - bundle :lock - expect(lockfile).to include("activemodel (3.0.5)") - end - - it "resolves dependencies correctly", :ruby => "<= 1.9.3" do + it "resolves dependencies correctly" do gemfile <<-G source "https://rubygems.org" - gem 'rails', '~> 3.0' + gem 'rails', '~> 5.0' gem 'capybara', '~> 2.2.0' gem 'rack-cache', '1.2.0' # last version that works on Ruby 1.9 G bundle! :lock - expect(lockfile).to include(rubygems_version("rails", "~> 3.0")) + expect(lockfile).to include(rubygems_version("rails", "~> 5.0")) expect(lockfile).to include("capybara (2.2.1)") end - it "installs the latest version of gxapi_rails", :ruby => "<= 1.9.3" do + it "installs the latest version of gxapi_rails" do gemfile <<-G source "https://rubygems.org" gem "sass-rails" - gem "rails", "~> 3" + gem "rails", "~> 5" gem "gxapi_rails", "< 0.1.0" # 0.1.0 was released way after the test was written gem 'rack-cache', '1.2.0' # last version that works on Ruby 1.9 G @@ -97,7 +59,7 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do expect(lockfile).to include(rubygems_version("activesupport", "~> 3.0")) end - it "is able to update a top-level dependency when there is a conflict on a shared transitive child", :ruby => "2.1" do + it "is able to update a top-level dependency when there is a conflict on a shared transitive child" do # from https://github.com/bundler/bundler/issues/5031 gemfile <<-G @@ -239,9 +201,10 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do gem 'rack', '1.0.1' G - bundle! :install, forgotten_command_line_options(:path => "vendor/bundle") + bundle "config set --local path vendor/bundle" + bundle! :install expect(err).not_to include("Could not find rake") - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end it "checks out git repos when the lockfile is corrupted" do @@ -368,7 +331,7 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do L bundle! :lock - expect(last_command.stderr).to lack_errors + expect(last_command.stderr).to be_empty end it "outputs a helpful error message when gems have invalid gemspecs" do @@ -376,7 +339,7 @@ RSpec.describe "real world edgecases", :realworld => true, :sometimes => true do source 'https://rubygems.org' gem "resque-scheduler", "2.2.0" G - expect(out).to include("You have one or more invalid gemspecs that need to be fixed.") - expect(out).to include("resque-scheduler 2.2.0 has an invalid gemspec") + expect(err).to include("You have one or more invalid gemspecs that need to be fixed.") + expect(err).to include("resque-scheduler 2.2.0 has an invalid gemspec") end end diff --git a/spec/bundler/realworld/gemfile_source_header_spec.rb b/spec/bundler/realworld/gemfile_source_header_spec.rb index 59c1916874..eaefd0f03e 100644 --- a/spec/bundler/realworld/gemfile_source_header_spec.rb +++ b/spec/bundler/realworld/gemfile_source_header_spec.rb @@ -1,14 +1,12 @@ # frozen_string_literal: true -require "thread" - -RSpec.describe "fetching dependencies with a mirrored source", :realworld => true, :rubygems => ">= 2.0" do +RSpec.describe "fetching dependencies with a mirrored source", :realworld => true do let(:mirror) { "https://server.example.org" } let(:original) { "http://127.0.0.1:#{@port}" } before do setup_server - bundle "config --local mirror.#{mirror} #{original}" + bundle "config set --local mirror.#{mirror} #{original}" end after do diff --git a/spec/bundler/realworld/mirror_probe_spec.rb b/spec/bundler/realworld/mirror_probe_spec.rb index ab74886329..c5e95f3059 100644 --- a/spec/bundler/realworld/mirror_probe_spec.rb +++ b/spec/bundler/realworld/mirror_probe_spec.rb @@ -1,7 +1,5 @@ # frozen_string_literal: true -require "thread" - RSpec.describe "fetching dependencies with a not available mirror", :realworld => true do let(:mirror) { @mirror_uri } let(:original) { @server_uri } @@ -74,10 +72,10 @@ RSpec.describe "fetching dependencies with a not available mirror", :realworld = bundle :install, :artifice => nil expect(out).to include("Fetching source index from #{mirror}") - expect(out).to include("Retrying fetcher due to error (2/4): Bundler::HTTPError Could not fetch specs from #{mirror}") - expect(out).to include("Retrying fetcher due to error (3/4): Bundler::HTTPError Could not fetch specs from #{mirror}") - expect(out).to include("Retrying fetcher due to error (4/4): Bundler::HTTPError Could not fetch specs from #{mirror}") - expect(out).to include("Could not fetch specs from #{mirror}") + expect(err).to include("Retrying fetcher due to error (2/4): Bundler::HTTPError Could not fetch specs from #{mirror}") + expect(err).to include("Retrying fetcher due to error (3/4): Bundler::HTTPError Could not fetch specs from #{mirror}") + expect(err).to include("Retrying fetcher due to error (4/4): Bundler::HTTPError Could not fetch specs from #{mirror}") + expect(err).to include("Could not fetch specs from #{mirror}") end it "prints each error and warning on a new line" do @@ -112,10 +110,10 @@ Could not fetch specs from #{mirror}/ bundle :install, :artifice => nil expect(out).to include("Fetching source index from #{mirror}") - expect(out).to include("Retrying fetcher due to error (2/4): Bundler::HTTPError Could not fetch specs from #{mirror}") - expect(out).to include("Retrying fetcher due to error (3/4): Bundler::HTTPError Could not fetch specs from #{mirror}") - expect(out).to include("Retrying fetcher due to error (4/4): Bundler::HTTPError Could not fetch specs from #{mirror}") - expect(out).to include("Could not fetch specs from #{mirror}") + expect(err).to include("Retrying fetcher due to error (2/4): Bundler::HTTPError Could not fetch specs from #{mirror}") + expect(err).to include("Retrying fetcher due to error (3/4): Bundler::HTTPError Could not fetch specs from #{mirror}") + expect(err).to include("Retrying fetcher due to error (4/4): Bundler::HTTPError Could not fetch specs from #{mirror}") + expect(err).to include("Could not fetch specs from #{mirror}") end end diff --git a/spec/bundler/realworld/parallel_spec.rb b/spec/bundler/realworld/parallel_spec.rb index ed4430c68b..7738b46aac 100644 --- a/spec/bundler/realworld/parallel_spec.rb +++ b/spec/bundler/realworld/parallel_spec.rb @@ -11,11 +11,7 @@ RSpec.describe "parallel", :realworld => true, :sometimes => true do bundle :install, :jobs => 4, :env => { "DEBUG" => "1" } - if Bundler.rubygems.provides?(">= 2.1.0") - expect(out).to match(/[1-3]: /) - else - expect(out).to include("is not threadsafe") - end + expect(out).to match(/[1-3]: /) bundle "info activesupport --path" expect(out).to match(/activesupport/) @@ -38,13 +34,9 @@ RSpec.describe "parallel", :realworld => true, :sometimes => true do gem 'i18n', '~> 0.6.0' # Because 0.7+ requires Ruby 1.9.3+ G - bundle :update, :jobs => 4, :env => { "DEBUG" => "1" }, :all => bundle_update_requires_all? + bundle :update, :jobs => 4, :env => { "DEBUG" => "1" }, :all => true - if Bundler.rubygems.provides?(">= 2.1.0") - expect(out).to match(/[1-3]: /) - else - expect(out).to include("is not threadsafe") - end + expect(out).to match(/[1-3]: /) bundle "info activesupport --path" expect(out).to match(/activesupport-3\.2\.\d+/) diff --git a/spec/bundler/resolver/basic_spec.rb b/spec/bundler/resolver/basic_spec.rb index c023f5d7aa..57897f89b4 100644 --- a/spec/bundler/resolver/basic_spec.rb +++ b/spec/bundler/resolver/basic_spec.rb @@ -35,7 +35,7 @@ RSpec.describe "Resolving" do should_resolve_as %w[berkshelf-2.0.7 chef-10.26 chef_app-1.0.0 json-1.7.7] end - it "prefers expicitly requested dependencies when resolving an index which would otherwise be ambiguous" do + it "prefers explicitly requested dependencies when resolving an index which would otherwise be ambiguous" do @index = an_ambiguous_index dep "a" dep "b" @@ -169,10 +169,10 @@ Bundler could not find compatible versions for gem "a": s.required_ruby_version = "~> 2.0.0" end - gem "ruby\0", "1.8.7" + gem "Ruby\0", "1.8.7" end dep "foo" - dep "ruby\0", "1.8.7" + dep "Ruby\0", "1.8.7" deps = [] @deps.each do |d| @@ -226,7 +226,7 @@ Bundler could not find compatible versions for gem "a": # dependencies and since the dependency of the selected foo gem changes, the latest matching # dependency of "bar", "~> 2.1" -- bar-2.1.1 -- is selected. This is not a bug and follows # the long-standing documented Conservative Updating behavior of bundle install. - # http://bundler.io/v1.12/man/bundle-install.1.html#CONSERVATIVE-UPDATING + # https://bundler.io/v1.12/man/bundle-install.1.html#CONSERVATIVE-UPDATING should_conservative_resolve_and_include :patch, ["foo"], %w[foo-1.4.5 bar-2.1.1] end diff --git a/spec/bundler/runtime/executable_spec.rb b/spec/bundler/runtime/executable_spec.rb index 7ba510a509..b2d5b6c03f 100644 --- a/spec/bundler/runtime/executable_spec.rb +++ b/spec/bundler/runtime/executable_spec.rb @@ -129,23 +129,6 @@ RSpec.describe "Running bin/* commands" do expect(bundled_app("bin/rackup")).to exist end - it "rewrites bins on --binstubs (to maintain backwards compatibility)", :bundler => "< 2" do - gemfile <<-G - source "file://#{gem_repo1}" - gem "rack" - G - - bundle! :install, forgotten_command_line_options([:binstubs, :bin] => "bin") - - File.open(bundled_app("bin/rackup"), "wb") do |file| - file.print "OMG" - end - - bundle "install" - - expect(bundled_app("bin/rackup").read).to_not eq("OMG") - end - it "rewrites bins on binstubs (to maintain backwards compatibility)" do install_gemfile! <<-G source "file://#{gem_repo1}" diff --git a/spec/bundler/runtime/gem_tasks_spec.rb b/spec/bundler/runtime/gem_tasks_spec.rb index de72869dc3..3c69f8a800 100644 --- a/spec/bundler/runtime/gem_tasks_spec.rb +++ b/spec/bundler/runtime/gem_tasks_spec.rb @@ -22,7 +22,7 @@ RSpec.describe "require 'bundler/gem_tasks'", :ruby_repo do sys_exec "#{rake} -T" end - expect(err).to eq("") + expect(last_command.stderr).to eq("") expected_tasks = [ "rake build", "rake clean", diff --git a/spec/bundler/runtime/inline_spec.rb b/spec/bundler/runtime/inline_spec.rb index 18ca246199..96a3fa09ae 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(err).to include "Could not find gem 'eleven'" + expect(last_command.stderr).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(err).to lack_errors + expect(last_command.stderr).to be_empty expect(exitstatus).to be_zero if exitstatus end @@ -112,6 +112,19 @@ RSpec.describe "bundler/inline#gemfile" do expect(exitstatus).to be_zero if exitstatus end + it "has an option for quiet installation" do + script <<-RUBY, :artifice => "endpoint" + require 'bundler' + + gemfile(true, :quiet => true) do + source "https://notaserver.com" + gem "activesupport", :require => true + end + RUBY + + expect(out).to be_empty + end + it "raises an exception if passed unknown arguments" do script <<-RUBY gemfile(true, :arglebargle => true) do @@ -121,7 +134,7 @@ RSpec.describe "bundler/inline#gemfile" do puts "success" RUBY - expect(err).to include "Unknown options: arglebargle" + expect(last_command.stderr).to include "Unknown options: arglebargle" expect(out).not_to include "success" end @@ -152,7 +165,7 @@ RSpec.describe "bundler/inline#gemfile" do RUBY expect(out).to eq("1.0.0") - expect(err).to be_empty + expect(last_command.stderr).to be_empty expect(exitstatus).to be_zero if exitstatus end @@ -170,7 +183,7 @@ RSpec.describe "bundler/inline#gemfile" do RUBY expect(out).to eq("1.0.0\n2.0.0") - expect(err).to be_empty + expect(last_command.stderr).to be_empty expect(exitstatus).to be_zero if exitstatus end @@ -190,7 +203,7 @@ RSpec.describe "bundler/inline#gemfile" do RUBY expect(out).to eq("two\nfour") - expect(err).to be_empty + expect(last_command.stderr).to be_empty expect(exitstatus).to be_zero if exitstatus end @@ -227,7 +240,7 @@ RSpec.describe "bundler/inline#gemfile" do RUBY end - expect(err).to be_empty + expect(last_command.stderr).to be_empty expect(exitstatus).to be_zero if exitstatus end @@ -245,7 +258,7 @@ RSpec.describe "bundler/inline#gemfile" do RUBY end - expect(err).to be_empty + expect(last_command.stderr).to be_empty expect(exitstatus).to be_zero if exitstatus end diff --git a/spec/bundler/runtime/platform_spec.rb b/spec/bundler/runtime/platform_spec.rb index eecf162427..11fe16f499 100644 --- a/spec/bundler/runtime/platform_spec.rb +++ b/spec/bundler/runtime/platform_spec.rb @@ -93,7 +93,7 @@ RSpec.describe "Bundler.setup with multi platform stuff" do gem "platform_specific" G - bundle! "config force_ruby_platform true" + bundle! "config set force_ruby_platform true" bundle! "install" @@ -108,7 +108,7 @@ RSpec.describe "Bundler.setup with multi platform stuff" do gem "platform_specific" G - bundle! "config force_ruby_platform true" + bundle! "config set force_ruby_platform true" bundle! "install" diff --git a/spec/bundler/runtime/require_spec.rb b/spec/bundler/runtime/require_spec.rb index 0484e38845..c9cfa199d3 100644 --- a/spec/bundler/runtime/require_spec.rb +++ b/spec/bundler/runtime/require_spec.rb @@ -121,7 +121,7 @@ RSpec.describe "Bundler.require" do Bundler.require R - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end it "displays a helpful message if the required gem throws an error" do @@ -136,8 +136,8 @@ RSpec.describe "Bundler.require" do G run "Bundler.require" - expect(err).to match("error while trying to load the gem 'faulty'") - expect(err).to match("Gem Internal Error Message") + expect(last_command.stderr).to match("error while trying to load the gem 'faulty'") + expect(last_command.stderr).to match("Gem Internal Error Message") end it "doesn't swallow the error when the library has an unrelated error" do @@ -160,7 +160,7 @@ RSpec.describe "Bundler.require" do RUBY run(cmd) - expect(err).to eq_err("ZOMG LOAD ERROR: cannot load such file -- load-bar") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR: cannot load such file -- load-bar") end describe "with namespaced gems" do @@ -198,7 +198,7 @@ RSpec.describe "Bundler.require" do RUBY ruby(cmd) - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end it "does not mangle explicitly given requires" do @@ -211,7 +211,7 @@ RSpec.describe "Bundler.require" do load_error_run <<-R, "jquery-rails" Bundler.require R - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end it "handles the case where regex fails" do @@ -234,7 +234,7 @@ RSpec.describe "Bundler.require" do RUBY run(cmd) - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end it "doesn't swallow the error when the library has an unrelated error" do @@ -258,19 +258,19 @@ RSpec.describe "Bundler.require" do RUBY run(cmd) - expect(err).to eq_err("ZOMG LOAD ERROR: cannot load such file -- load-bar") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR: cannot load such file -- load-bar") end end describe "using bundle exec" do it "requires the locked gems" do - bundle "exec ruby -e 'Bundler.require'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec ruby -e 'Bundler.require'" expect(out).to eq("two") - bundle "exec ruby -e 'Bundler.require(:bar)'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec ruby -e 'Bundler.require(:bar)'" expect(out).to eq("baz\nqux") - bundle "exec ruby -e 'Bundler.require(:default, :bar)'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle "exec ruby -e 'Bundler.require(:default, :bar)'" expect(out).to eq("baz\nqux\ntwo") end end @@ -366,12 +366,12 @@ RSpec.describe "Bundler.require" do load_error_run <<-R, "no_such_file_omg" Bundler.require R - expect(err).to eq_err("ZOMG LOAD ERROR") + expect(err_without_deprecations).to eq("ZOMG LOAD ERROR") end end end - it "does not load rubygems gemspecs that are used", :rubygems => ">= 2.5.2" do + it "does not load rubygems gemspecs that are used" do install_gemfile! <<-G source "file://#{gem_repo1}" gem "rack" @@ -394,7 +394,7 @@ RSpec.describe "Bundler.require" do expect(out).to eq("WIN") end - it "does not load git gemspecs that are used", :rubygems => ">= 2.5.2" do + it "does not load git gemspecs that are used" do build_git "foo" install_gemfile! <<-G @@ -432,7 +432,7 @@ RSpec.describe "Bundler.require with platform specific dependencies" do G run "Bundler.require" - expect(err).to lack_errors + expect(last_command.stderr).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(err).to lack_errors + expect(last_command.stderr).to be_empty end end diff --git a/spec/bundler/runtime/setup_spec.rb b/spec/bundler/runtime/setup_spec.rb index f2f750a9ca..c81baa34ea 100644 --- a/spec/bundler/runtime/setup_spec.rb +++ b/spec/bundler/runtime/setup_spec.rb @@ -1,5 +1,8 @@ # frozen_string_literal: true +require "tmpdir" +require "tempfile" + RSpec.describe "Bundler.setup" do describe "with no arguments" do it "makes all groups available" do @@ -16,7 +19,7 @@ RSpec.describe "Bundler.setup" do require 'rack' puts RACK RUBY - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to eq("1.0.0") end end @@ -42,7 +45,7 @@ RSpec.describe "Bundler.setup" do puts "WIN" end RUBY - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to eq("WIN") end @@ -55,7 +58,7 @@ RSpec.describe "Bundler.setup" do require 'rack' puts RACK RUBY - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to eq("1.0.0") end @@ -69,7 +72,7 @@ RSpec.describe "Bundler.setup" do require 'rack' puts RACK RUBY - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to eq("1.0.0") end @@ -87,7 +90,7 @@ RSpec.describe "Bundler.setup" do puts "FAIL" end RUBY - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to match("WIN") end @@ -101,8 +104,8 @@ RSpec.describe "Bundler.setup" do puts "FAIL" RUBY - expect(err).to match("rack") - expect(err).to match("LoadError") + expect(last_command.stderr).to match("rack") + expect(last_command.stderr).to match("LoadError") expect(out).not_to match("FAIL") end end @@ -125,7 +128,7 @@ RSpec.describe "Bundler.setup" do gem "rack" G - ENV["RUBYOPT"] = "-Idash_i_dir" + ENV["RUBYOPT"] = "#{ENV["RUBYOPT"]} -Idash_i_dir" ENV["RUBYLIB"] = "rubylib_dir" ruby <<-RUBY @@ -138,9 +141,8 @@ RSpec.describe "Bundler.setup" do load_path = out.split("\n") rack_load_order = load_path.index {|path| path.include?("rack") } - expect(err).to eq("") - expect(load_path[1]).to include "dash_i_dir" - expect(load_path[2]).to include "rubylib_dir" + expect(last_command.stderr).to eq("") + expect(load_path).to include(a_string_ending_with("dash_i_dir"), "rubylib_dir") expect(rack_load_order).to be > 0 end @@ -159,10 +161,6 @@ RSpec.describe "Bundler.setup" do load_path = clean_load_path(out.split("\n")) - unless Bundler.load.specs["bundler"].empty? - load_path.delete_if {|path| path =~ /bundler/ } - end - expect(load_path).to start_with( "/gems/rails-2.3.2/lib", "/gems/activeresource-2.3.2/lib", @@ -170,7 +168,7 @@ RSpec.describe "Bundler.setup" do "/gems/actionpack-2.3.2/lib", "/gems/actionmailer-2.3.2/lib", "/gems/activesupport-2.3.2/lib", - "/gems/rake-10.0.2/lib" + "/gems/rake-12.3.2/lib" ) end @@ -366,7 +364,7 @@ RSpec.describe "Bundler.setup" do end R - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end it "replaces #gem but raises when the version is wrong" do @@ -392,7 +390,7 @@ RSpec.describe "Bundler.setup" do end R - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end end @@ -451,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(err).to match(/the git source #{lib_path('rack-1.0.0')} is not yet checked out. Please run `bundle install`/i) + 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) end it "does not hit the git binary if the lockfile is available and up to date" do @@ -532,12 +530,12 @@ RSpec.describe "Bundler.setup" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle! :install FileUtils.rm_rf(lib_path("local-rack")) run "require 'rack'" - expect(err).to match(/Cannot use local override for rack-0.8 because #{Regexp.escape(lib_path('local-rack').to_s)} does not exist/) + 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/) end it "explodes if branch is not given on runtime" do @@ -550,7 +548,7 @@ RSpec.describe "Bundler.setup" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle! :install gemfile <<-G @@ -559,7 +557,7 @@ RSpec.describe "Bundler.setup" do G run "require 'rack'" - expect(err).to match(/because :branch is not specified in Gemfile/) + expect(last_command.stderr).to match(/because :branch is not specified in Gemfile/) end it "explodes on different branches on runtime" do @@ -572,7 +570,7 @@ RSpec.describe "Bundler.setup" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle! :install gemfile <<-G @@ -581,7 +579,7 @@ RSpec.describe "Bundler.setup" do G run "require 'rack'" - expect(err).to match(/is using branch master but Gemfile specifies changed/) + expect(last_command.stderr).to match(/is using branch master but Gemfile specifies changed/) end it "explodes on refs with different branches on runtime" do @@ -599,9 +597,9 @@ RSpec.describe "Bundler.setup" do gem "rack", :git => "#{lib_path("rack-0.8")}", :ref => "master", :branch => "nonexistant" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) run "require 'rack'" - expect(err).to match(/is using branch master but Gemfile specifies nonexistant/) + expect(last_command.stderr).to match(/is using branch master but Gemfile specifies nonexistant/) end end @@ -655,62 +653,6 @@ RSpec.describe "Bundler.setup" do end end - # Unfortunately, gem_prelude does not record the information about - # activated gems, so this test cannot work on 1.9 :( - if RUBY_VERSION < "1.9" - describe "preactivated gems" do - it "raises an exception if a pre activated gem conflicts with the bundle" do - system_gems "thin-1.0", "rack-1.0.0" - build_gem "thin", "1.1", :to_system => true do |s| - s.add_dependency "rack" - end - - gemfile <<-G - gem "thin", "1.0" - G - - ruby <<-R - require 'rubygems' - gem "thin" - require 'bundler' - begin - Bundler.setup - puts "FAIL" - rescue Gem::LoadError => e - puts e.message - end - R - - expect(out).to eq("You have already activated thin 1.1, but your Gemfile requires thin 1.0. Prepending `bundle exec` to your command may solve this.") - end - - it "version_requirement is now deprecated in rubygems 1.4.0+" do - system_gems "thin-1.0", "rack-1.0.0" - build_gem "thin", "1.1", :to_system => true do |s| - s.add_dependency "rack" - end - - gemfile <<-G - gem "thin", "1.0" - G - - ruby <<-R - require 'rubygems' - gem "thin" - require 'bundler' - begin - Bundler.setup - puts "FAIL" - rescue Gem::LoadError => e - puts e.message - end - R - - expect(err).to lack_errors - end - end - end - # RubyGems returns loaded_from as a string it "has loaded_from as a string on all specs" do build_git "foo" @@ -732,7 +674,7 @@ RSpec.describe "Bundler.setup" do expect(out).to be_empty end - it "does not load all gemspecs", :rubygems => ">= 2.3" do + it "does not load all gemspecs" do install_gemfile! <<-G source "file://#{gem_repo1}" gem "rack" @@ -767,9 +709,9 @@ end G ENV["GEM_HOME"] = "" - bundle %(exec ruby -e "require 'set'"), :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } + bundle %(exec ruby -e "require 'set'") - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end describe "$MANPATH" do @@ -831,7 +773,7 @@ end it "should clean $LOAD_PATH properly", :ruby_repo do gem_name = "very_simple_binary" full_gem_name = gem_name + "-1.0" - ext_dir = File.join(tmp "extenstions", full_gem_name) + ext_dir = File.join(tmp("extensions", full_gem_name)) install_gem full_gem_name @@ -863,48 +805,41 @@ end context "with bundler is located in symlinked GEM_HOME" do let(:gem_home) { Dir.mktmpdir } - let(:symlinked_gem_home) { Tempfile.new("gem_home") } + let(:symlinked_gem_home) { Tempfile.new("gem_home").path } let(:bundler_dir) { ruby_core? ? File.expand_path("../../../..", __FILE__) : File.expand_path("../../..", __FILE__) } - let(:bundler_lib) { File.join(bundler_dir, "lib") } + let(:full_name) { "bundler-#{Bundler::VERSION}" } before do - FileUtils.ln_sf(gem_home, symlinked_gem_home.path) + FileUtils.ln_sf(gem_home, symlinked_gem_home) gems_dir = File.join(gem_home, "gems") specifications_dir = File.join(gem_home, "specifications") Dir.mkdir(gems_dir) Dir.mkdir(specifications_dir) - FileUtils.ln_s(bundler_dir, File.join(gems_dir, "bundler-#{Bundler::VERSION}")) + FileUtils.ln_s(bundler_dir, File.join(gems_dir, full_name)) gemspec_file = ruby_core? ? "#{bundler_dir}/lib/bundler/bundler.gemspec" : "#{bundler_dir}/bundler.gemspec" - gemspec = File.read(gemspec_file). + gemspec = File.binread(gemspec_file). sub("Bundler::VERSION", %("#{Bundler::VERSION}")) gemspec = gemspec.lines.reject {|line| line =~ %r{lib/bundler/version} }.join - File.open(File.join(specifications_dir, "bundler.gemspec"), "wb") do |f| + File.open(File.join(specifications_dir, "#{full_name}.gemspec"), "wb") do |f| f.write(gemspec) end end - # Can't make this pass on 2.6 since the ruby standard library has the same $LOAD_PATH - # entry as bundler (since it's a default gem) - it "should successfully require 'bundler/setup'", :ruby_repo, :ruby => "< 2.6" do + it "should not remove itself from the LOAD_PATH and require a different copy of 'bundler/setup'", :ruby_repo do install_gemfile "" - ENV["GEM_PATH"] = symlinked_gem_home.path - - ruby <<-R - if $LOAD_PATH.include?("#{bundler_lib}") - # We should use bundler from GEM_PATH for this test, so we should - # remove path to the bundler source tree - $LOAD_PATH.delete("#{bundler_lib}") - else - raise "We don't have #{bundler_lib} in $LOAD_PATH" + ruby <<-R, :env => { "GEM_PATH" => symlinked_gem_home }, :no_lib => true + TracePoint.trace(:class) do |tp| + puts "OMG" if tp.path.include?("bundler") && !tp.path.start_with?("#{File.expand_path("../..", __dir__)}") end - puts (require 'bundler/setup') + gem 'bundler', '#{Bundler::VERSION}' + require 'bundler/setup' R - expect(out).to eql("true") + expect(out).to be_empty end end @@ -943,7 +878,7 @@ end require 'foo' R end - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end it "should make sure the Bundler.root is really included in the path relative to the Gemfile" do @@ -968,7 +903,7 @@ end R end - expect(err).to lack_errors + expect(last_command.stderr).to be_empty end end @@ -1046,7 +981,7 @@ end describe "with system gems in the bundle" do before :each do - bundle! "config path.system true" + bundle! "config set path.system true" system_gems "rack-1.0.0" install_gemfile <<-G @@ -1099,9 +1034,9 @@ end end.ref_for("HEAD") bundle :install - expect(out.lines.map(&:chomp)).to include( + expect(err.lines.map(&:chomp)).to include( a_string_starting_with("[!] There was an error while loading `bar.gemspec`:"), - RUBY_VERSION >= "1.9" ? a_string_starting_with("Does it try to require a relative path? That's been removed in Ruby 1.9.") : "", + a_string_starting_with("Does it try to require a relative path? That's been removed in Ruby 1.9."), " # from #{default_bundle_path "bundler", "gems", "bar-1.0-#{ref[0, 12]}", "bar.gemspec"}:1", " > require 'foobarbaz'" ) @@ -1118,7 +1053,7 @@ end Bundler.load RUBY - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to eq("") end end @@ -1129,8 +1064,8 @@ end gem "bundler", :path => "#{File.expand_path("..", lib)}" G - bundle %(exec ruby -e "require 'bundler'; Bundler.setup"), :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } - expect(err).to lack_errors + bundle %(exec ruby -e "require 'bundler'; Bundler.setup") + expect(last_command.stderr).to be_empty end end @@ -1253,7 +1188,7 @@ end end describe "with gemified standard libraries" do - it "does not load Psych", :ruby => "~> 2.2" do + it "does not load Psych" do gemfile "" ruby <<-RUBY require 'bundler/setup' @@ -1279,7 +1214,7 @@ end describe "default gem activation" do let(:exemptions) do - if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("2.7") || ENV["RGV"] == "master" + if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("2.7") [] else %w[io-console openssl] @@ -1310,7 +1245,6 @@ end end let(:code) { strip_whitespace(<<-RUBY) } - require "bundler/setup" require "pp" loaded_specs = Gem.loaded_specs.dup #{exemptions.inspect}.each {|s| loaded_specs.delete(s) } @@ -1325,22 +1259,18 @@ end it "activates no gems with -rbundler/setup" do install_gemfile! "" - ruby! code, :env => { :RUBYOPT => activation_warning_hack_rubyopt } + ruby! code, :env => { :RUBYOPT => activation_warning_hack_rubyopt + " -rbundler/setup" } expect(last_command.stdout).to eq("{}") end it "activates no gems with bundle exec" do install_gemfile! "" - # ensure we clean out the default gems, bceause bundler's allowed to be activated create_file("script.rb", code) - bundle! "exec ruby ./script.rb", :env => { :RUBYOPT => activation_warning_hack_rubyopt + " -rbundler/setup" } + bundle! "exec ruby ./script.rb", :env => { :RUBYOPT => activation_warning_hack_rubyopt } expect(last_command.stdout).to eq("{}") end it "activates no gems with bundle exec that is loaded" do - # TODO: remove once https://github.com/erikhuda/thor/pull/539 is released - exemptions << "io-console" - install_gemfile! "" create_file("script.rb", "#!/usr/bin/env ruby\n\n#{code}") FileUtils.chmod(0o777, bundled_app("script.rb")) diff --git a/spec/bundler/runtime/with_clean_env_spec.rb b/spec/bundler/runtime/with_clean_env_spec.rb deleted file mode 100644 index da8e37b45d..0000000000 --- a/spec/bundler/runtime/with_clean_env_spec.rb +++ /dev/null @@ -1,151 +0,0 @@ -# frozen_string_literal: true - -RSpec.describe "Bundler.with_env helpers" do - def bundle_exec_ruby!(code, *args) - opts = args.last.is_a?(Hash) ? args.pop : {} - env = opts[:env] ||= {} - env[:RUBYOPT] ||= "-r#{spec_dir.join("support/hax")}" - args.push opts - bundle! "exec '#{Gem.ruby}' -e #{code}", *args - end - - describe "Bundler.original_env" do - before do - bundle "config path vendor/bundle" - gemfile "" - bundle "install" - end - - it "should return the PATH present before bundle was activated" do - code = "print Bundler.original_env['PATH']" - path = `getconf PATH`.strip + "#{File::PATH_SEPARATOR}/foo" - with_path_as(path) do - bundle_exec_ruby!(code.dump) - expect(last_command.stdboth).to eq(path) - end - end - - it "should return the GEM_PATH present before bundle was activated" do - code = "print Bundler.original_env['GEM_PATH']" - gem_path = ENV["GEM_PATH"] + ":/foo" - with_gem_path_as(gem_path) do - bundle_exec_ruby!(code.dump) - expect(last_command.stdboth).to eq(gem_path) - end - end - - it "works with nested bundle exec invocations", :ruby_repo do - create_file("exe.rb", <<-'RB') - count = ARGV.first.to_i - exit if count < 0 - STDERR.puts "#{count} #{ENV["PATH"].end_with?(":/foo")}" - if count == 2 - ENV["PATH"] = "#{ENV["PATH"]}:/foo" - end - exec(Gem.ruby, __FILE__, (count - 1).to_s) - RB - path = `getconf PATH`.strip + File::PATH_SEPARATOR + File.dirname(Gem.ruby) - with_path_as(path) do - bundle! "exec '#{Gem.ruby}' #{bundled_app("exe.rb")} 2", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } - end - expect(err).to eq <<-EOS.strip -2 false -1 true -0 true - EOS - end - - it "removes variables that bundler added", :ruby_repo do - original = ruby!('puts ENV.to_a.map {|e| e.join("=") }.sort.join("\n")', :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }) - code = 'puts Bundler.original_env.to_a.map {|e| e.join("=") }.sort.join("\n")' - bundle! "exec '#{Gem.ruby}' -e #{code.dump}", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" } - expect(out).to eq original - end - end - - describe "Bundler.clean_env", :bundler => "< 3" do - before do - bundle "config path vendor/bundle" - gemfile "" - bundle "install" - end - - it "should delete BUNDLE_PATH" do - code = "print Bundler.clean_env.has_key?('BUNDLE_PATH')" - ENV["BUNDLE_PATH"] = "./foo" - bundle_exec_ruby! code.dump - expect(last_command.stdboth).to eq "false" - end - - it "should remove '-rbundler/setup' from RUBYOPT" do - code = "print Bundler.clean_env['RUBYOPT']" - ENV["RUBYOPT"] = "-W2 -rbundler/setup" - bundle_exec_ruby! code.dump - expect(last_command.stdboth).not_to include("-rbundler/setup") - end - - it "should clean up RUBYLIB", :ruby_repo do - code = "print Bundler.clean_env['RUBYLIB']" - ENV["RUBYLIB"] = root.join("lib").to_s + File::PATH_SEPARATOR + "/foo" - bundle_exec_ruby! code.dump - expect(last_command.stdboth).to eq("/foo") - end - - it "should restore the original MANPATH" do - code = "print Bundler.clean_env['MANPATH']" - ENV["MANPATH"] = "/foo" - ENV["BUNDLER_ORIG_MANPATH"] = "/foo-original" - bundle_exec_ruby! code.dump - expect(last_command.stdboth).to eq("/foo-original") - end - end - - describe "Bundler.with_original_env" do - it "should set ENV to original_env in the block" do - expected = Bundler.original_env - actual = Bundler.with_original_env { ENV.to_hash } - expect(actual).to eq(expected) - end - - it "should restore the environment after execution" do - Bundler.with_original_env do - ENV["FOO"] = "hello" - end - - expect(ENV).not_to have_key("FOO") - end - end - - describe "Bundler.with_clean_env", :bundler => "< 3" do - it "should set ENV to clean_env in the block" do - expected = Bundler.clean_env - actual = Bundler.with_clean_env { ENV.to_hash } - expect(actual).to eq(expected) - end - - it "should restore the environment after execution" do - Bundler.with_clean_env do - ENV["FOO"] = "hello" - end - - expect(ENV).not_to have_key("FOO") - end - end - - describe "Bundler.clean_system", :ruby => ">= 1.9", :bundler => "< 3" do - it "runs system inside with_clean_env" do - Bundler.clean_system(%(echo 'if [ "$BUNDLE_PATH" = "" ]; then exit 42; else exit 1; fi' | /bin/sh)) - expect($?.exitstatus).to eq(42) - end - end - - describe "Bundler.clean_exec", :ruby => ">= 1.9", :bundler => "< 3" do - it "runs exec inside with_clean_env" do - pid = Kernel.fork do - Bundler.clean_exec(%(echo 'if [ "$BUNDLE_PATH" = "" ]; then exit 42; else exit 1; fi' | /bin/sh)) - end - Process.wait(pid) - expect($?.exitstatus).to eq(42) - end - end -end diff --git a/spec/bundler/runtime/with_unbundled_env_spec.rb b/spec/bundler/runtime/with_unbundled_env_spec.rb new file mode 100644 index 0000000000..b4503cba32 --- /dev/null +++ b/spec/bundler/runtime/with_unbundled_env_spec.rb @@ -0,0 +1,241 @@ +# frozen_string_literal: true + +RSpec.describe "Bundler.with_env helpers" do + def bundle_exec_ruby!(code) + build_bundler_context + bundle! "exec '#{Gem.ruby}' -e #{code}" + end + + def build_bundler_context + bundle "config set path vendor/bundle" + gemfile "" + bundle "install" + end + + describe "Bundler.original_env" do + it "should return the PATH present before bundle was activated" do + code = "print Bundler.original_env['PATH']" + path = `getconf PATH`.strip + "#{File::PATH_SEPARATOR}/foo" + with_path_as(path) do + bundle_exec_ruby!(code.dump) + expect(last_command.stdboth).to eq(path) + end + end + + it "should return the GEM_PATH present before bundle was activated" do + code = "print Bundler.original_env['GEM_PATH']" + gem_path = ENV["GEM_PATH"] + ":/foo" + with_gem_path_as(gem_path) do + bundle_exec_ruby!(code.dump) + expect(last_command.stdboth).to eq(gem_path) + end + end + + it "works with nested bundle exec invocations", :ruby_repo do + create_file("exe.rb", <<-'RB') + count = ARGV.first.to_i + exit if count < 0 + STDERR.puts "#{count} #{ENV["PATH"].end_with?(":/foo")}" + if count == 2 + ENV["PATH"] = "#{ENV["PATH"]}:/foo" + end + exec(Gem.ruby, __FILE__, (count - 1).to_s) + RB + path = `getconf PATH`.strip + File::PATH_SEPARATOR + File.dirname(Gem.ruby) + with_path_as(path) do + build_bundler_context + bundle! "exec '#{Gem.ruby}' #{bundled_app("exe.rb")} 2" + end + expect(last_command.stderr).to eq <<-EOS.strip +2 false +1 true +0 true + EOS + end + + it "removes variables that bundler added", :ruby_repo do + original = ruby!('puts ENV.to_a.map {|e| e.join("=") }.sort.join("\n")') + code = 'puts Bundler.original_env.to_a.map {|e| e.join("=") }.sort.join("\n")' + bundle_exec_ruby! code.dump + expect(out).to eq original + end + end + + shared_examples_for "an unbundling helper" do + it "should delete BUNDLE_PATH" do + code = "print #{modified_env}.has_key?('BUNDLE_PATH')" + ENV["BUNDLE_PATH"] = "./foo" + bundle_exec_ruby! code.dump + expect(last_command.stdboth).to include "false" + end + + it "should remove '-rbundler/setup' from RUBYOPT" do + code = "print #{modified_env}['RUBYOPT']" + ENV["RUBYOPT"] = "-W2 -rbundler/setup #{ENV["RUBYOPT"]}" + bundle_exec_ruby! code.dump + expect(last_command.stdboth).not_to include("-rbundler/setup") + end + + it "should clean up RUBYLIB", :ruby_repo do + code = "print #{modified_env}['RUBYLIB']" + ENV["RUBYLIB"] = root.join("lib").to_s + File::PATH_SEPARATOR + "/foo" + bundle_exec_ruby! code.dump + expect(last_command.stdboth).to include("/foo") + end + + it "should restore the original MANPATH" do + code = "print #{modified_env}['MANPATH']" + ENV["MANPATH"] = "/foo" + ENV["BUNDLER_ORIG_MANPATH"] = "/foo-original" + bundle_exec_ruby! code.dump + expect(last_command.stdboth).to include("/foo-original") + end + end + + describe "Bundler.unbundled_env" do + let(:modified_env) { "Bundler.unbundled_env" } + + it_behaves_like "an unbundling helper" + end + + describe "Bundler.clean_env", :bundler => 2 do + let(:modified_env) { "Bundler.clean_env" } + + it_behaves_like "an unbundling helper" + end + + describe "Bundler.with_original_env" do + it "should set ENV to original_env in the block" do + expected = Bundler.original_env + actual = Bundler.with_original_env { ENV.to_hash } + expect(actual).to eq(expected) + end + + it "should restore the environment after execution" do + Bundler.with_original_env do + ENV["FOO"] = "hello" + end + + expect(ENV).not_to have_key("FOO") + end + end + + describe "Bundler.with_clean_env", :bundler => 2 do + it "should set ENV to unbundled_env in the block" do + expected = Bundler.unbundled_env + actual = Bundler.with_clean_env { ENV.to_hash } + expect(actual).to eq(expected) + end + + it "should restore the environment after execution" do + Bundler.with_clean_env do + ENV["FOO"] = "hello" + end + + expect(ENV).not_to have_key("FOO") + end + end + + describe "Bundler.with_unbundled_env" do + it "should set ENV to unbundled_env in the block" do + expected = Bundler.unbundled_env + actual = Bundler.with_unbundled_env { ENV.to_hash } + expect(actual).to eq(expected) + end + + it "should restore the environment after execution" do + Bundler.with_unbundled_env do + ENV["FOO"] = "hello" + end + + expect(ENV).not_to have_key("FOO") + end + end + + describe "Bundler.original_system" do + 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) + end + end + + describe "Bundler.clean_system", :bundler => 2 do + 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) + end + end + + describe "Bundler.unbundled_system" do + 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) + end + end + + describe "Bundler.original_exec" do + let(:code) do + <<~RUBY + Process.fork do + exit Bundler.original_exec(%(test "\$BUNDLE_FOO" = "bar")) + end + + _, status = Process.wait2 + + exit(status.exitstatus) + RUBY + end + + it "runs exec inside with_original_env" do + lib = File.expand_path("../../lib", __dir__) + system({ "BUNDLE_FOO" => "bar" }, "ruby -I#{lib} -rbundler -e '#{code}'") + expect($?.exitstatus).to eq(0) + end + end + + describe "Bundler.clean_exec", :bundler => 2 do + let(:code) do + <<~RUBY + Process.fork do + exit Bundler.clean_exec(%(test "\$BUNDLE_FOO" = "bar")) + end + + _, status = Process.wait2 + + exit(status.exitstatus) + RUBY + end + + it "runs exec inside with_clean_env" do + lib = File.expand_path("../../lib", __dir__) + system({ "BUNDLE_FOO" => "bar" }, "ruby -I#{lib} -rbundler -e '#{code}'") + expect($?.exitstatus).to eq(1) + end + end + + describe "Bundler.unbundled_exec" do + let(:code) do + <<~RUBY + Process.fork do + exit Bundler.unbundled_exec(%(test "\$BUNDLE_FOO" = "bar")) + end + + _, status = Process.wait2 + + exit(status.exitstatus) + RUBY + end + + it "runs exec inside with_clean_env" do + lib = File.expand_path("../../lib", __dir__) + system({ "BUNDLE_FOO" => "bar" }, "ruby -I#{lib} -rbundler -e '#{code}'") + expect($?.exitstatus).to eq(1) + end + end +end diff --git a/spec/bundler/spec_helper.rb b/spec/bundler/spec_helper.rb index c7614e1c43..81c222ea6f 100644 --- a/spec/bundler/spec_helper.rb +++ b/spec/bundler/spec_helper.rb @@ -3,43 +3,11 @@ $:.unshift File.expand_path("..", __FILE__) $:.unshift File.expand_path("../../lib", __FILE__) -require "rubygems" -module Gem - if defined?(@path_to_default_spec_map) - @path_to_default_spec_map.delete_if do |_path, spec| - spec.name == "bundler" - end - end -end - -begin - require File.expand_path("../support/path.rb", __FILE__) - spec = Gem::Specification.load(Spec::Path.gemspec.to_s) - rspec = spec.dependencies.find {|d| d.name == "rspec" } - gem "rspec", rspec.requirement.to_s - require "rspec" - require "diff/lcs" -rescue LoadError - abort "Run rake spec:deps to install development dependencies" -end - require "bundler/psyched_yaml" require "bundler/vendored_fileutils" require "uri" require "digest" -# Delete the default copy of Bundler that RVM installs for us when running in CI -require "fileutils" -if ENV.select {|k, _v| k =~ /TRAVIS/ }.any? && Gem::Version.new(Gem::VERSION) > Gem::Version.new("2.0") - Dir.glob(File.join(Gem::Specification.default_specifications_dir, "bundler*.gemspec")).each do |file| - FileUtils.rm_rf(file) - end - - Dir.glob(File.join(RbConfig::CONFIG["sitelibdir"], "bundler*")).each do |file| - FileUtils.rm_rf(file) - end -end - if File.expand_path(__FILE__) =~ %r{([^\w/\.:\-])} abort "The bundler specs cannot be run from a path that contains special characters (particularly #{$1.inspect})" end @@ -53,9 +21,8 @@ end $debug = false -Spec::Manpages.setup +Spec::Manpages.setup unless Gem.win_platform? Spec::Rubygems.setup -FileUtils.rm_rf(Spec::Path.gem_repo1) ENV["RUBYOPT"] = "#{ENV["RUBYOPT"]} -r#{Spec::Path.spec_dir}/support/hax.rb" ENV["BUNDLE_SPEC_RUN"] = "true" @@ -104,13 +71,10 @@ 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 => LessThanProc.with(RUBY_VERSION) - config.filter_run_excluding :rubygems => LessThanProc.with(Gem::VERSION) - config.filter_run_excluding :git => LessThanProc.with(git_version) + config.filter_run_excluding :ruby => RequirementChecker.against(RUBY_VERSION) + config.filter_run_excluding :rubygems => RequirementChecker.against(Gem::VERSION) config.filter_run_excluding :rubygems_master => (ENV["RGV"] != "master") - config.filter_run_excluding :bundler => LessThanProc.with(Bundler::VERSION.split(".")[0, 2].join(".")) + config.filter_run_excluding :bundler => RequirementChecker.against(Bundler::VERSION.split(".")[0]) config.filter_run_excluding :ruby_repo => !(ENV["BUNDLE_RUBY"] && ENV["BUNDLE_GEM"]).nil? config.filter_run_when_matching :focus unless ENV["CI"] @@ -122,6 +86,10 @@ RSpec.configure do |config| c.syntax = :expect end + config.mock_with :rspec do |mocks| + mocks.allow_message_expectations_on_nil = false + end + config.around :each do |example| if ENV["BUNDLE_RUBY"] orig_ruby = Gem.ruby diff --git a/spec/bundler/support/artifice/compact_index.rb b/spec/bundler/support/artifice/compact_index.rb index 01e8eb7837..4f01690ae4 100644 --- a/spec/bundler/support/artifice/compact_index.rb +++ b/spec/bundler/support/artifice/compact_index.rb @@ -21,7 +21,7 @@ class CompactIndexAPI < Endpoint headers "Surrogate-Control" => "max-age=2592000, stale-while-revalidate=60" content_type "text/plain" requested_range_for(response_body) - rescue => e + rescue StandardError => e puts e puts e.backtrace raise @@ -57,11 +57,7 @@ class CompactIndexAPI < Endpoint end def slice_body(body, range) - if body.respond_to?(:byteslice) - body.byteslice(range) - else # pre-1.9.3 - body.unpack("@#{range.first}a#{range.end + 1}").first - end + body.byteslice(range) end def gems(gem_repo = GEM_REPO) @@ -82,8 +78,8 @@ class CompactIndexAPI < Endpoint CompactIndex::Dependency.new(d.name, reqs) end checksum = begin - Digest::SHA256.file("#{GEM_REPO}/gems/#{spec.original_name}.gem").base64digest - rescue + Digest(:SHA256).file("#{GEM_REPO}/gems/#{spec.original_name}.gem").base64digest + rescue StandardError nil end CompactIndex::GemVersion.new(spec.version.version, spec.platform.to_s, checksum, nil, diff --git a/spec/bundler/support/artifice/compact_index_api_missing.rb b/spec/bundler/support/artifice/compact_index_api_missing.rb index d4e68c38e8..94e6b73000 100644 --- a/spec/bundler/support/artifice/compact_index_api_missing.rb +++ b/spec/bundler/support/artifice/compact_index_api_missing.rb @@ -6,7 +6,7 @@ Artifice.deactivate class CompactIndexApiMissing < CompactIndexAPI get "/fetch/actual/gem/:id" do - $stderr.puts params[:id] + warn params[:id] if params[:id] == "rack-1.0.gemspec.rz" halt 404 else diff --git a/spec/bundler/support/artifice/compact_index_rate_limited.rb b/spec/bundler/support/artifice/compact_index_rate_limited.rb new file mode 100644 index 0000000000..d8f4fc941c --- /dev/null +++ b/spec/bundler/support/artifice/compact_index_rate_limited.rb @@ -0,0 +1,48 @@ +# frozen_string_literal: true + +require File.expand_path("../compact_index", __FILE__) + +Artifice.deactivate + +class CompactIndexRateLimited < CompactIndexAPI + class RequestCounter + def self.queue + @queue ||= Queue.new + end + + def self.size + @queue.size + end + + def self.enq(name) + @queue.enq(name) + end + + def self.deq + @queue.deq + end + end + + configure do + RequestCounter.queue + end + + get "/info/:name" do + RequestCounter.enq(params[:name]) + + begin + if RequestCounter.size == 1 + etag_response do + gem = gems.find {|g| g.name == params[:name] } + CompactIndex.info(gem ? gem.versions : []) + end + else + status 429 + end + ensure + RequestCounter.deq + end + end +end + +Artifice.activate_with(CompactIndexRateLimited) diff --git a/spec/bundler/support/artifice/endpoint.rb b/spec/bundler/support/artifice/endpoint.rb index 9a0cfae8a2..fcced6ea35 100644 --- a/spec/bundler/support/artifice/endpoint.rb +++ b/spec/bundler/support/artifice/endpoint.rb @@ -59,7 +59,7 @@ class Endpoint < Sinatra::Base :platform => spec.platform.to_s, :dependencies => spec.dependencies.select {|dep| dep.type == :runtime }.map do |dep| [dep.name, dep.requirement.requirements.map {|a| a.join(" ") }.join(", ")] - end + end, } end.compact end diff --git a/spec/bundler/support/artifice/endpoint_api_missing.rb b/spec/bundler/support/artifice/endpoint_api_missing.rb index 95db8e2a7e..2ada0dc553 100644 --- a/spec/bundler/support/artifice/endpoint_api_missing.rb +++ b/spec/bundler/support/artifice/endpoint_api_missing.rb @@ -6,7 +6,7 @@ Artifice.deactivate class EndpointApiMissing < Endpoint get "/fetch/actual/gem/:id" do - $stderr.puts params[:id] + warn params[:id] if params[:id] == "rack-1.0.gemspec.rz" halt 404 else diff --git a/spec/bundler/support/artifice/vcr.rb b/spec/bundler/support/artifice/vcr.rb index edd2f49a91..1e3809ff62 100644 --- a/spec/bundler/support/artifice/vcr.rb +++ b/spec/bundler/support/artifice/vcr.rb @@ -1,13 +1,6 @@ # frozen_string_literal: true require "net/http" -if RUBY_VERSION < "1.9" - begin - require "net/https" - rescue LoadError - nil # net/https or openssl - end -end # but only for 1.8 CASSETTE_PATH = File.expand_path("../vcr_cassettes", __FILE__) CASSETTE_NAME = ENV.fetch("BUNDLER_SPEC_VCR_CASSETTE_NAME") { "realworld" } diff --git a/spec/bundler/support/builders.rb b/spec/bundler/support/builders.rb index 97134a045a..33a81f6f65 100644 --- a/spec/bundler/support/builders.rb +++ b/spec/bundler/support/builders.rb @@ -40,7 +40,7 @@ module Spec build_gem "rails", "2.3.2" do |s| s.executables = "rails" - s.add_dependency "rake", "10.0.2" + s.add_dependency "rake", "12.3.2" s.add_dependency "actionpack", "2.3.2" s.add_dependency "activerecord", "2.3.2" s.add_dependency "actionmailer", "2.3.2" @@ -210,12 +210,7 @@ module Spec # The yard gem iterates over Gem.source_index looking for plugins build_gem "yard" do |s| s.write "lib/yard.rb", <<-Y - if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("1.8.10") - specs = Gem::Specification - else - specs = Gem.source_index.find_name('') - end - specs.sort_by(&:name).each do |gem| + Gem::Specification.sort_by(&:name).each do |gem| puts gem.full_name end Y @@ -653,7 +648,8 @@ module Spec `git add *` `git config user.email "[email protected]"` `git config user.name "lolwut"` - `git commit -m 'OMG INITIAL COMMIT'` + `git config commit.gpgsign false` + `git commit -m "OMG INITIAL COMMIT"` end end end diff --git a/spec/bundler/support/helpers.rb b/spec/bundler/support/helpers.rb index 89c67c45b7..09e7419a98 100644 --- a/spec/bundler/support/helpers.rb +++ b/spec/bundler/support/helpers.rb @@ -41,19 +41,25 @@ module Spec end def out - last_command.stdboth + last_command.stdout end def err - last_command.stderr + Bundler.feature_flag.error_on_stderr? ? last_command.stderr : last_command.stdout end - def exitstatus - last_command.exitstatus + MAJOR_DEPRECATION = /^\[DEPRECATED\]\s*/.freeze + + def err_without_deprecations + last_command.stderr.gsub(/#{MAJOR_DEPRECATION}.+[\n]?/, "") end - def bundle_update_requires_all? - Bundler::VERSION.start_with?("2.") ? nil : true + def deprecations + err.split("\n").select {|l| l =~ MAJOR_DEPRECATION }.join("\n").split(MAJOR_DEPRECATION) + end + + def exitstatus + last_command.exitstatus end def in_app_root(&blk) @@ -71,7 +77,7 @@ module Spec def run(cmd, *args) opts = args.last.is_a?(Hash) ? args.pop : {} groups = args.map(&:inspect).join(", ") - setup = "require 'rubygems' ; require 'bundler' ; Bundler.setup(#{groups})\n" + setup = "require 'bundler' ; Bundler.setup(#{groups})\n" ruby(setup + cmd, opts) end bang :run @@ -131,8 +137,6 @@ module Spec load_path << spec load_path_str = "-I#{load_path.join(File::PATH_SEPARATOR)}" - env = env.map {|k, v| "#{k}='#{v}'" }.join(" ") - args = options.map do |k, v| case v when nil @@ -146,13 +150,13 @@ module Spec end end.join - cmd = "#{env} #{sudo} #{Gem.ruby} #{load_path_str} #{requires_str} #{bundle_bin} #{cmd}#{args}" - sys_exec(cmd) {|i, o, thr| yield i, o, thr if block_given? } + cmd = "#{sudo} #{Gem.ruby} #{load_path_str} #{requires_str} #{bundle_bin} #{cmd}#{args}" + sys_exec(cmd, env) {|i, o, thr| yield i, o, thr if block_given? } end bang :bundle def forgotten_command_line_options(options) - remembered = Bundler.bundler_major_version < 3 + remembered = Bundler::VERSION.split(".", 2).first == "2" options = options.map do |k, v| k = Array(k)[remembered ? 0 : -1] v = '""' if v && v.to_s.empty? @@ -161,9 +165,9 @@ module Spec return Hash[options] if remembered options.each do |k, v| if v.nil? - bundle! "config --delete #{k}" + bundle! "config unset #{k}" else - bundle! "config --local #{k} #{v}" + bundle! "config set --local #{k} #{v}" end end {} @@ -174,11 +178,6 @@ module Spec bundle(cmd, options) end - def bundle_ruby(options = {}) - options["bundle_bin"] = bindir.join("bundle_ruby") - bundle("", options) - end - def ruby(ruby, options = {}) env = (options.delete(:env) || {}).map {|k, v| "#{k}='#{v}' " }.join ruby = ruby.gsub(/["`\$]/) {|m| "\\#{m}" } @@ -221,16 +220,18 @@ module Spec "#{Gem.ruby} -S #{ENV["GEM_PATH"]}/bin/rake" end - def sys_exec(cmd) + def sys_exec(cmd, env = {}) command_execution = CommandExecution.new(cmd.to_s, Dir.pwd) - Open3.popen3(cmd.to_s) do |stdin, stdout, stderr, wait_thr| + env = env.map {|k, v| [k.to_s, v.to_s] }.to_h # convert env keys and values to string + + Open3.popen3(env, cmd.to_s) do |stdin, stdout, stderr, wait_thr| yield stdin, stdout, wait_thr if block_given? stdin.close - command_execution.exitstatus = wait_thr && wait_thr.value.exitstatus command_execution.stdout = Thread.new { stdout.read }.value.strip command_execution.stderr = Thread.new { stderr.read }.value.strip + command_execution.exitstatus = wait_thr && wait_thr.value.exitstatus end (@command_executions ||= []) << command_execution @@ -263,18 +264,22 @@ module Spec end def gemfile(*args) - if args.empty? + contents = args.shift + + if contents.nil? File.open("Gemfile", "r", &:read) else - create_file("Gemfile", *args) + create_file("Gemfile", contents, *args) end end def lockfile(*args) - if args.empty? + contents = args.shift + + if contents.nil? File.open("Gemfile.lock", "r", &:read) else - create_file("Gemfile.lock", *args) + create_file("Gemfile.lock", normalize_uri_file(contents), *args) end end @@ -323,7 +328,7 @@ module Spec Dir.chdir(root) { gem_command! :build, gemspec.to_s } end bundler_path = root + "bundler-#{Bundler::VERSION}.gem" - elsif g.to_s =~ %r{\A/.*\.gem\z} + elsif g.to_s =~ %r{\A(?:[A-Z]:)?/.*\.gem\z} g else "#{gem_repo}/gems/#{g}.gem" @@ -331,11 +336,8 @@ module Spec raise "OMG `#{path}` does not exist!" unless File.exist?(path) - if Gem::VERSION < "2.0.0" - gem_command! :install, "--no-rdoc --no-ri --ignore-dependencies '#{path}'" - else - gem_command! :install, "--no-document --ignore-dependencies '#{path}'" - end + gem_command! :install, "--no-document --ignore-dependencies '#{path}'" + bundler_path && bundler_path.rmtree end end @@ -437,7 +439,7 @@ module Spec ENV["GEM_PATH"] = system_gem_path.to_s gems.each do |gem| - gem_command :install, "--no-rdoc --no-ri #{gem}" + gem_command! :install, "--no-document #{gem}" end return unless block_given? begin @@ -577,7 +579,7 @@ module Spec tries = 0 sleep 0.5 TCPSocket.new(host, port) - rescue => e + rescue StandardError => e raise(e) if tries > (seconds * 2) tries += 1 retry @@ -587,7 +589,7 @@ module Spec port = 21_453 begin port += 1 while TCPSocket.new("127.0.0.1", port) - rescue + rescue StandardError false end port diff --git a/spec/bundler/support/indexes.rb b/spec/bundler/support/indexes.rb index 69f8d9f679..b76f493d01 100644 --- a/spec/bundler/support/indexes.rb +++ b/spec/bundler/support/indexes.rb @@ -77,7 +77,7 @@ module Spec gem "rack-mount", %w[0.4 0.5 0.5.1 0.5.2 0.6] # --- Pre-release support - gem "rubygems\0", ["1.3.2"] + gem "RubyGems\0", ["1.3.2"] # --- Rails versions "1.2.3 2.2.3 2.3.5 3.0.0.beta 3.0.0.beta1" do |version| @@ -414,7 +414,7 @@ module Spec gem("b", %w[0.9.0 1.5.0 2.0.0.pre]) # --- Pre-release support - gem "rubygems\0", ["1.3.2"] + gem "RubyGems\0", ["1.3.2"] end end end diff --git a/spec/bundler/support/less_than_proc.rb b/spec/bundler/support/less_than_proc.rb deleted file mode 100644 index ddac5458b7..0000000000 --- a/spec/bundler/support/less_than_proc.rb +++ /dev/null @@ -1,20 +0,0 @@ -# frozen_string_literal: true - -class LessThanProc < Proc - attr_accessor :present - - def self.with(present) - provided = Gem::Version.new(present.dup) - new do |required| - if required =~ /[=><~]/ - !Gem::Requirement.new(required).satisfied_by?(provided) - else - provided < Gem::Version.new(required) - end - end.tap {|l| l.present = present } - end - - def inspect - "\"=< #{present}\"" - end -end diff --git a/spec/bundler/support/matchers.rb b/spec/bundler/support/matchers.rb index 8e17be3a02..f9efe32a38 100644 --- a/spec/bundler/support/matchers.rb +++ b/spec/bundler/support/matchers.rb @@ -60,36 +60,6 @@ module Spec end end - MAJOR_DEPRECATION = /^\[DEPRECATED FOR 2\.0\]\s*/ - - RSpec::Matchers.define :lack_errors do - diffable - match do |actual| - actual.gsub(/#{MAJOR_DEPRECATION}.+[\n]?/, "") == "" - end - end - - RSpec::Matchers.define :eq_err do |expected| - diffable - match do |actual| - actual.gsub(/#{MAJOR_DEPRECATION}.+[\n]?/, "") == expected - end - end - - RSpec::Matchers.define :have_major_deprecation do |expected| - diffable - match do |actual| - deprecations = actual.split(MAJOR_DEPRECATION) - - return !expected.nil? if deprecations.size <= 1 - return true if expected.nil? - - deprecations.any? do |d| - !d.empty? && values_match?(expected, d.strip) - end - end - end - RSpec::Matchers.define :have_dep do |*args| dep = Bundler::Dependency.new(*args) @@ -128,6 +98,14 @@ module Spec end end + RSpec::Matchers.define :be_well_formed do + match(&:empty?) + + failure_message do |actual| + actual.join("\n") + end + end + define_compound_matcher :read_as, [exist] do |file_contents| diffable @@ -152,10 +130,9 @@ module Spec version_const = name == "bundler" ? "Bundler::VERSION" : Spec::Builders.constantize(name) begin run! "require '#{name}.rb'; puts #{version_const}", *groups - rescue => e + rescue StandardError => e next "#{name} is not installed:\n#{indent(e)}" end - last_command.stdout.gsub!(/#{MAJOR_DEPRECATION}.*$/, "") actual_version, actual_platform = last_command.stdout.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}" @@ -167,10 +144,9 @@ module Spec begin source_const = "#{Spec::Builders.constantize(name)}_SOURCE" run! "require '#{name}/source'; puts #{source_const}", *groups - rescue + rescue StandardError next "#{name} does not have a source defined:\n#{indent(e)}" end - last_command.stdout.gsub!(/#{MAJOR_DEPRECATION}.*$/, "") unless last_command.stdout.strip == source next "Expected #{name} (#{version}) to be installed from `#{source}`, was actually from `#{out}`" end @@ -193,7 +169,7 @@ module Spec puts "WIN" end R - rescue => e + rescue StandardError => e next "checking for #{name} failed:\n#{e}" end next if last_command.stdout == "WIN" @@ -218,7 +194,7 @@ module Spec RSpec::Matchers.alias_matcher :include_gem, :include_gems def have_lockfile(expected) - read_as(strip_whitespace(expected)) + read_as(normalize_uri_file(strip_whitespace(expected))) end def plugin_should_be_installed(*names) @@ -236,7 +212,7 @@ module Spec end def lockfile_should_be(expected) - expect(bundled_app("Gemfile.lock")).to read_as(normalize_uri_file(strip_whitespace(expected))) + expect(bundled_app("Gemfile.lock")).to have_lockfile(expected) end def gemfile_should_be(expected) diff --git a/spec/bundler/support/path.rb b/spec/bundler/support/path.rb index 69efcba051..dc4b3bb6eb 100644 --- a/spec/bundler/support/path.rb +++ b/spec/bundler/support/path.rb @@ -99,7 +99,7 @@ module Spec end def bundler_path - Pathname.new(File.expand_path(root.join("lib"), __FILE__)) + root.join("lib") end def global_plugin_gem(*args) diff --git a/spec/bundler/support/platforms.rb b/spec/bundler/support/platforms.rb index 950311d20e..0a9e4a8cb6 100644 --- a/spec/bundler/support/platforms.rb +++ b/spec/bundler/support/platforms.rb @@ -100,9 +100,8 @@ module Spec 9999 end - def lockfile_platforms(*platforms) - platforms = local_platforms if platforms.empty? - platforms.map(&:to_s).sort.join("\n ") + def lockfile_platforms + local_platforms.map(&:to_s).sort.join("\n ") end def local_platforms diff --git a/spec/bundler/support/requirement_checker.rb b/spec/bundler/support/requirement_checker.rb new file mode 100644 index 0000000000..d8f5fd5e5f --- /dev/null +++ b/spec/bundler/support/requirement_checker.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +class RequirementChecker < Proc + def self.against(present) + provided = Gem::Version.new(present) + + new do |required| + !Gem::Requirement.new(required).satisfied_by?(provided) + end + end +end diff --git a/spec/bundler/support/rubygems_ext.rb b/spec/bundler/support/rubygems_ext.rb index 42f887f268..2f3d252865 100644 --- a/spec/bundler/support/rubygems_ext.rb +++ b/spec/bundler/support/rubygems_ext.rb @@ -1,31 +1,25 @@ # frozen_string_literal: true require "rubygems/user_interaction" -require "support/path" unless defined?(Spec::Path) +require "support/path" +require "fileutils" module Spec module Rubygems DEPS = begin - deps = { - # rack 2.x requires Ruby version >= 2.2.2. + { # artifice doesn't support rack 2.x now. - # TODO: revert to `< 2` once https://github.com/rack/rack/issues/1168 is - # addressed - "rack" => "1.6.6", - # rack-test 0.7.0 dropped 1.8.7 support - # https://github.com/rack-test/rack-test/issues/193#issuecomment-314230318 - "rack-test" => "< 0.7.0", + "rack" => "< 2.0", + "rack-test" => "~> 1.1", "artifice" => "~> 0.6.0", "compact_index" => "~> 0.11.0", "sinatra" => "~> 1.4.7", # Rake version has to be consistent for tests to pass - "rake" => "10.0.2", - # 3.0.0 breaks 1.9.2 specs - "builder" => "2.1.2", + "rake" => "12.3.2", + "builder" => "~> 3.2", + # ruby-graphviz is used by the viz tests + "ruby-graphviz" => nil, } - # ruby-graphviz is used by the viz tests - deps["ruby-graphviz"] = nil if RUBY_VERSION >= "1.9.3" - deps end def self.setup @@ -33,17 +27,17 @@ module Spec ENV["BUNDLE_PATH"] = nil ENV["GEM_HOME"] = ENV["GEM_PATH"] = Path.base_system_gems.to_s - ENV["PATH"] = [Path.bindir, "#{Path.system_gem_path}/bin", ENV["PATH"]].join(File::PATH_SEPARATOR) + ENV["PATH"] = [Path.bindir, Path.system_gem_path.join("bin"), ENV["PATH"]].join(File::PATH_SEPARATOR) manifest = DEPS.to_a.sort_by(&:first).map {|k, v| "#{k} => #{v}\n" } - manifest_path = "#{Path.base_system_gems}/manifest.txt" + manifest_path = Path.base_system_gems.join("manifest.txt") # it's OK if there are extra gems - if !File.exist?(manifest_path) || !(manifest - File.readlines(manifest_path)).empty? + if !manifest_path.file? || !(manifest - manifest_path.readlines).empty? FileUtils.rm_rf(Path.base_system_gems) FileUtils.mkdir_p(Path.base_system_gems) puts "installing gems for the tests to use..." install_gems(DEPS) - File.open(manifest_path, "w") {|f| f << manifest.join } + manifest_path.open("w") {|f| f << manifest.join } end ENV["HOME"] = Path.home.to_s @@ -54,17 +48,11 @@ module Spec def self.install_gems(gems) reqs, no_reqs = gems.partition {|_, req| !req.nil? && !req.split(" ").empty? } - # TODO: remove when we drop ruby 1.8.7-2.2.2 support - reqs = reqs.sort_by {|name, _| name == "rack" ? 0 : 1 }.sort_by {|name, _| name =~ /rack/ ? 0 : 1 } no_reqs.map!(&:first) reqs.map! {|name, req| "'#{name}:#{req}'" } deps = reqs.concat(no_reqs).join(" ") - gem = Spec::Path.ruby_core? ? ENV["BUNDLE_GEM"] : "gem" - cmd = if Gem::VERSION < "2.0.0" - "#{gem} install #{deps} --no-rdoc --no-ri --conservative" - else - "#{gem} install #{deps} --no-document --conservative" - end + gem = Spec::Path.ruby_core? ? ENV["BUNDLE_GEM"] : "#{Gem.ruby} -S gem" + cmd = "#{gem} install #{deps} --no-document --conservative" puts cmd system(cmd) || raise("Installing gems #{deps} for the tests to use failed!") end diff --git a/spec/bundler/update/gemfile_spec.rb b/spec/bundler/update/gemfile_spec.rb index f59f3a2d32..6c47c254cd 100644 --- a/spec/bundler/update/gemfile_spec.rb +++ b/spec/bundler/update/gemfile_spec.rb @@ -9,7 +9,7 @@ RSpec.describe "bundle update" do G bundle! :install, :gemfile => bundled_app("NotGemfile") - bundle! :update, :gemfile => bundled_app("NotGemfile"), :all => bundle_update_requires_all? + bundle! :update, :gemfile => bundled_app("NotGemfile"), :all => true # Specify BUNDLE_GEMFILE for `the_bundle` # to retrieve the proper Gemfile @@ -25,12 +25,12 @@ RSpec.describe "bundle update" do gem 'rack' G - bundle "config --local gemfile #{bundled_app("NotGemfile")}" + bundle "config set --local gemfile #{bundled_app("NotGemfile")}" bundle! :install end it "uses the gemfile to update" do - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true bundle "list" expect(out).to include("rack (1.0.0)") @@ -39,28 +39,11 @@ RSpec.describe "bundle update" do it "uses the gemfile while in a subdirectory" do bundled_app("subdir").mkpath Dir.chdir(bundled_app("subdir")) do - bundle! "update", :all => bundle_update_requires_all? + bundle! "update", :all => true bundle "list" expect(out).to include("rack (1.0.0)") end end end - - context "with prefer_gems_rb set" do - before { bundle! "config prefer_gems_rb true" } - - it "prefers gems.rb to Gemfile" do - create_file("gems.rb", "gem 'bundler'") - create_file("Gemfile", "raise 'wrong Gemfile!'") - - bundle! :install - bundle! :update, :all => bundle_update_requires_all? - - expect(bundled_app("gems.rb")).to be_file - expect(bundled_app("Gemfile.lock")).not_to be_file - - expect(the_bundle).to include_gem "bundler #{Bundler::VERSION}" - end - end end diff --git a/spec/bundler/update/gems/post_install_spec.rb b/spec/bundler/update/gems/post_install_spec.rb index 2fb3547806..f6b7f39d0b 100644 --- a/spec/bundler/update/gems/post_install_spec.rb +++ b/spec/bundler/update/gems/post_install_spec.rb @@ -10,7 +10,7 @@ RSpec.describe "bundle update" do gem 'thin' G - bundle! "config #{config}" if config + bundle! "config set #{config}" if config bundle! :install end @@ -52,7 +52,7 @@ RSpec.describe "bundle update" do gem 'thin' G - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true end it_behaves_like "a post-install message outputter" @@ -67,7 +67,7 @@ RSpec.describe "bundle update" do gem 'thin' G - bundle! :update, :all => bundle_update_requires_all? + bundle! :update, :all => true end it_behaves_like "a post-install message outputter" diff --git a/spec/bundler/update/git_spec.rb b/spec/bundler/update/git_spec.rb index d97760e84b..4fe22269e2 100644 --- a/spec/bundler/update/git_spec.rb +++ b/spec/bundler/update/git_spec.rb @@ -16,7 +16,7 @@ RSpec.describe "bundle update" do s.write "lib/foo.rb", "FOO = '1.1'" end - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(the_bundle).to include_gems "foo 1.1" end @@ -88,7 +88,7 @@ RSpec.describe "bundle update" do gem "foo", "1.0", :git => "#{lib_path("foo_two")}" G - expect(err).to lack_errors + expect(last_command.stderr).to be_empty expect(out).to include("Fetching #{lib_path}/foo_two") expect(out).to include("Bundle complete!") end @@ -111,7 +111,7 @@ RSpec.describe "bundle update" do gem 'foo', :git => "#{@remote.path}", :tag => "fubar" G - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(exitstatus).to eq(0) if exitstatus end @@ -191,7 +191,7 @@ RSpec.describe "bundle update" do lib_path("foo-1.0").join(".git").rmtree - bundle :update, :all => bundle_update_requires_all? + bundle :update, :all => true expect(last_command.bundler_err).to include(lib_path("foo-1.0").to_s). and match(/Git error: command `git fetch.+has failed/) end @@ -208,7 +208,7 @@ RSpec.describe "bundle update" do gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master" G - bundle %(config local.rack #{lib_path("local-rack")}) + bundle %(config set local.rack #{lib_path("local-rack")}) bundle "update rack" expect(out).to include("Bundle updated!") end @@ -233,7 +233,7 @@ RSpec.describe "bundle update" do rails! G - bundle "update", :all => bundle_update_requires_all? + bundle "update", :all => true expect(out).to include("Using rails 3.0 (was 2.3.2) from #{lib_path("rails")} (at master@#{revision_for(lib_path("rails"))[0..6]})") end end @@ -299,7 +299,7 @@ RSpec.describe "bundle update" do G end - it "the --source flag updates version of gems that were originally pulled in by the source", :bundler => "> 3" do + it "the --source flag updates version of gems that were originally pulled in by the source", :bundler => "< 3" do spec_lines = lib_path("bar/foo.gemspec").read.split("\n") spec_lines[5] = "s.version = '2.0'" @@ -348,17 +348,17 @@ RSpec.describe "bundle update" do bundle "update --source bar" lockfile_should_be <<-G - GEM - remote: file://localhost#{gem_repo2}/ - specs: - rack (1.0.0) - GIT remote: #{@git.path} revision: #{ref} specs: foo (2.0) + GEM + remote: file://localhost#{gem_repo2}/ + specs: + rack (1.0.0) + PLATFORMS #{lockfile_platforms} diff --git a/spec/bundler/update/redownload_spec.rb b/spec/bundler/update/redownload_spec.rb index 1bbc3a66fc..39edac0902 100644 --- a/spec/bundler/update/redownload_spec.rb +++ b/spec/bundler/update/redownload_spec.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -RSpec.describe "bundle update", :bundler => "< 3", :ruby => ">= 2.0" do +RSpec.describe "bundle update" do before :each do install_gemfile <<-G source "file://#{gem_repo1}" @@ -8,29 +8,27 @@ RSpec.describe "bundle update", :bundler => "< 3", :ruby => ">= 2.0" do G end - before { bundle "config major_deprecations yes" } - describe "with --force" do - it "shows a deprecation when single flag passed" do + it "shows a deprecation when single flag passed", :bundler => 2 do bundle! "update rack --force" - expect(out).to include "[DEPRECATED FOR 3.0] The `--force` option has been renamed to `--redownload`" + expect(err).to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end - it "shows a deprecation when multiple flags passed" do + it "shows a deprecation when multiple flags passed", :bundler => 2 do bundle! "update rack --no-color --force" - expect(out).to include "[DEPRECATED FOR 3.0] The `--force` option has been renamed to `--redownload`" + expect(err).to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end end describe "with --redownload" do it "does not show a deprecation when single flag passed" do bundle! "update rack --redownload" - expect(out).not_to include "[DEPRECATED FOR 3.0] The `--force` option has been renamed to `--redownload`" + expect(err).not_to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end it "does not show a deprecation when single multiple flags passed" do bundle! "update rack --no-color --redownload" - expect(out).not_to include "[DEPRECATED FOR 3.0] The `--force` option has been renamed to `--redownload`" + expect(err).not_to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`" end end end |