end

context "with no arguments" do

bundle ""

expect(err).to be_empty

expect(out).to include("Bundler version #{Bundler::VERSION}").

end

RSpec.describe "bundler executable" do

bundler "--version"

expect(out).to eq("Bundler version #{Bundler::VERSION}")

end

bundler "--version"

expect(out).to eq(Bundler::VERSION)

end

end

describe "Deprecated platform" do

expect(Bundler.ui).to receive(:warn).with(/`CurrentRuby#maglev\?` is deprecated with no replacement./)

Bundler.current_ruby.maglev?

end

expect(Bundler.ui).to receive(:warn).with(/`CurrentRuby#maglev_31\?` is deprecated with no replacement./)

Bundler.current_ruby.maglev_31?

end

end

end

)

end

it "converts :github to URI using https" do

subject.gem("sparks", github: "indirect/sparks")

github_uri = "https://github.com/indirect/sparks.git"

expect(bundled_app("vendor/cache/foo-1.0")).not_to exist

end

build_lib "foo"

install_gemfile <<-G

expect(bundled_app("vendor/cache/foo-1.0")).not_to exist

end

build_lib "foo"

install_gemfile <<-G

expect(bundled_app("exec/myrackup")).to exist

end

install_gemfile <<-G

source "https://gem.repo1"

gem "myrack"

end

end

it "sets root directory for gems" do

gemfile <<-D

source "https://gem.repo1"

expect(bundled_app("vendor/cache/myrack-1.0.0.gem")).to exist

end

gemfile <<-D

source "https://gem.repo1"

gem 'myrack', :platforms => [:ruby_20, :x64_mingw_20]

expect(bundled_app("vendor/cache/myrack-1.0.0.gem")).to exist

end

gemfile <<-D

source "https://gem.repo1"

gem 'myrack', :platforms => [:ruby_20, :x64_mingw_20]

expect(err).to include("Bundler can't satisfy your Gemfile's dependencies.")

end

gemfile <<-G

source "https://gem.repo1"

group :foo do

expect(last_command).to be_failure

end

context "after installing gems in the proper directory" do

before do

gemfile <<-G

expect(out).to include("myrack (1.0.0)").and include("thin (1.0)")

end

gemfile <<-G

source "https://gem.repo1"

should_not_have_gems "thin-1.0"

end

build_repo2

gemfile <<-G

should_not_have_gems "foo-1.0"

end

build_repo2

install_gemfile <<-G

end

end

context "`load`ing a ruby file instead of `exec`ing" do

let(:path) { bundled_app("ruby_executable") }

let(:shebang) { "#!/usr/bin/env ruby" }

# frozen_string_literal: true

before :each do

gemfile <<-G

source "https://gem.repo1"

context "when frozen" do

before do

bundle "install"

bundle "config set --local deployment true"

else

bundle "config set --local frozen true"

expect(bundled_app_lock).to exist

end

gemfile <<-G

source "https://gem.repo1"

gem "myrack"

expect(the_bundle).to include_gems "myrack 1.0"

end

bundle "install --path vendor"

bundle "install --system"

FileUtils.rm_r(bundled_app("vendor"))

expect(the_bundle).to include_gems "myrack 1.0"

end

bundle "install --path vendor"

FileUtils.rm_r(bundled_app("vendor"))

bundle "install --system"

end

end

build_repo2 do

build_gem "myrack", "1.2" do |s|

s.executables = "myrackup"

end

shared_examples_for "--rubocop flag" do

before do

global_config "BUNDLE_GEM__LINTER" => nil

bundle "gem #{gem_name} --rubocop"

end

shared_examples_for "--no-rubocop flag" do

define_negated_matcher :exclude, :include

before do

end

end

before do

global_config "BUNDLE_GEM__LINTER" => nil

bundle "config set gem.rubocop true"

include_examples "generating a gem"

context "--ext parameter with no value" do

it "prints deprecation when used after gem name" do

bundle ["gem", "--ext", gem_name].compact.join(" ")

expect(err).to include "[DEPRECATED]"

end

end

before do

build_repo2 do

build_gem "dotenv", "2.7.6"

expect(out).to include("Installing foo 1.0")

end

before do

build_repo2

expect(out).to eq(default_bundle_path("gems", "rails-2.3.2").to_s)

end

gemfile <<-G

source "https://gem.repo1"

gem "rails"

should_be_ruby_version_incorrect

end

gemfile <<-G

source "https://gem.repo1"

gem "rails"

should_be_engine_incorrect

end

gemfile <<-G

source "https://gem.repo1"

gem "rails"

should_be_engine_version_incorrect

end

gemfile <<-G

source "https://gem.repo1"

gem "myrack"

end

end

it "without any options" do

2.times { bundle :install }

expect(out).to include(bundle_show_message)

end

end

it "removes gems from .bundle" do

gemfile <<-G

source "https://gem.repo1"

# frozen_string_literal: true

context "with a standard Gemfile" do

before :each do

install_gemfile <<-G

end

end

pending "shows a friendly error about the command removal"

end

G

end

bundle "install --deployment"

bundle "update", all: true, raise_on_error: false

end

end

before do

build_repo2 do

build_gem "dotenv", "2.7.6"

G

lockfile lockfile.sub(/(^\s*)#{Bundler::VERSION}($)/, "2.99.9")

expect(out).to include("Updating bundler to 999.0.0")

expect(out).to include("Running `bundle update --bundler \"> 0.a\" --verbose` with bundler 999.0.0")

end

context "with -v" do

bundle "-v"

expect(out).to eq("Bundler version #{Bundler::VERSION}")

end

bundle "-v"

expect(out).to eq(Bundler::VERSION)

end

end

context "with --version" do

bundle "--version"

expect(out).to eq("Bundler version #{Bundler::VERSION}")

end

bundle "--version"

expect(out).to eq(Bundler::VERSION)

end

end

context "with version" do

bundle "version"

expect(out).to match(/\ABundler version #{Regexp.escape(Bundler::VERSION)} \(\d{4}-\d{2}-\d{2} commit #{COMMIT_HASH}\)\z/)

end

bundle "version"

expect(out).to match(/\A#{Regexp.escape(Bundler::VERSION)} \(\d{4}-\d{2}-\d{2} commit #{COMMIT_HASH}\)\z/)

end

# frozen_string_literal: true

before do

realworld_system_gems "ruby-graphviz --version 1.2.5"

end

G

end

it "fails without a lockfile and says that --deployment requires a lock" do

bundle "install --deployment", raise_on_error: false

expect(err).to include("The --deployment flag requires a lockfile")

expect(out).to eq("WIN")

end

it "handles downgrades" do

build_lib "omg", "2.0", path: lib_path("omg")

expect(out).to eq("WIN")

end

expect(Dir["#{default_bundle_path}/cache/bundler/git/foo-1.0-*"]).to have_attributes size: 1

end

expect(out).to include("Set for the current user (#{home(".bundle/config")}): [:emo]")

end

bundle "config set without emo"

bundle :install

bundle "exec ruby -e 'puts 42'", env: { "BUNDLE_USER_HOME" => tmp("new_home").to_s }

expect(the_bundle).not_to include_gems "activesupport 2.3.5", groups: [:default]

end

bundle "install --without emo"

expect(the_bundle).not_to include_gems "activesupport 2.3.5"

bundle :install

ENV["BUNDLE_WITHOUT"] = nil

end

bundle "install --without emo"

bundle "install --without ''"

expect(the_bundle).to include_gems "activesupport 2.3.5"

end

bundle "install --without emo"

bundle :install

expect(the_bundle).to include_gems "thin 1.0"

end

bundle "install --with debugging"

expect(the_bundle).to include_gems "thin 1.0"

bundle :install

ENV["BUNDLE_WITH"] = nil

end

bundle "install --with debugging"

bundle "install --with ''"

expect(the_bundle).not_to include_gems "thin 1.0"

end

bundle "config set --local without emo"

bundle "install --with emo"

expect(the_bundle).to include_gems "activesupport 2.3.5"

end

bundle "config set --local with debugging"

bundle "install --without debugging", raise_on_error: false

expect(the_bundle).not_to include_gem "thin 1.0"

end

bundle "install --with emo debugging --without emo", raise_on_error: false

expect(last_command).to be_failure

expect(err).to include("The offending groups are: emo")

expect(the_bundle).to include_gem "thin 1.0"

end

bundle "install --with debugging --without emo"

expect(the_bundle).to include_gems "thin 1.0"

expect(the_bundle).not_to include_gems "activesupport 2.3.5"

# frozen_string_literal: true

RSpec.describe "bundle install with explicit source paths" do

build_lib "foo"

install_gemfile <<-G

G

end

lockfile <<~L

GEM

remote: https://gem.repo3/

bundle "config set --local disable_checksum_validation true"

end

bundle :install, artifice: "compact_index"

expect(err).to include("Warning: the gem 'myrack' was found in multiple sources.")

expect(the_bundle).to include_gems("myrack-obama 1.0.0", "myrack 1.0.0", source: "remote1")

end

bundle :install, artifice: "compact_index", verbose: true

expect(out).to include("https://gem.repo1/versions")

expect(out).not_to include("https://gem.repo3/quick/Marshal.4.8/")

end

bundle :install, artifice: "compact_index", raise_on_error: false

expect(err).to include("Each source after the first must include a block")

expect(exitstatus).to eq(4)

G

end

bundle :install, artifice: "compact_index"

expect(err).to include("Warning: the gem 'myrack' was found in multiple sources.")

expect(err).to include("Installed from: https://gem.repo1")

expect(the_bundle).to include_gems("myrack-obama 1.0.0", "myrack 1.0.0", source: "remote1")

end

bundle :install, artifice: "compact_index", raise_on_error: false

expect(err).to include("Each source after the first must include a block")

expect(exitstatus).to eq(4)

G

end

gem_checksum = checksum_digest(gem_repo4, "foo", "1.0")

bundle "install --standalone", artifice: "compact_index", env: { "BUNDLER_SPEC_FOO_CHECKSUM" => gem_checksum }

end

G

end

bundle :install, artifice: "compact_index", raise_on_error: false

expect(err).to eq(<<~E.strip)

expect(exitstatus).to eq(37)

end

myrack_checksum = "c0ffee11" * 8

bundle :install, artifice: "compact_index", env: { "BUNDLER_SPEC_MYRACK_CHECKSUM" => myrack_checksum }, raise_on_error: false

expect(exitstatus).to eq(37)

end

gem_checksum = checksum_digest(gem_repo2, "myrack", "1.0.0")

bundle :install, artifice: "compact_index", env: { "BUNDLER_SPEC_MYRACK_CHECKSUM" => gem_checksum, "DEBUG" => "1" }

expect(lockfile).to eq(previous_lockfile)

end

bundle "config set --local disable_checksum_validation true"

bundle :install, artifice: "compact_index"

expect(lockfile).to eq(previous_lockfile)

end

bundle :install, artifice: "compact_index", raise_on_error: false

expect(err).to include("Each source after the first must include a block")

expect(exitstatus).to eq(4)

G

end

bundle :install, artifice: "compact_index"

expect(err).not_to include("Warning: the gem 'myrack' was found in multiple sources.")

expect(the_bundle).to include_gems("depends_on_myrack 1.0.1", "myrack 1.0.0")

end

bundle :install, artifice: "compact_index", raise_on_error: false

expect(err).to include("Each source after the first must include a block")

expect(exitstatus).to eq(4)

end

end

before do

build_repo2

L

end

initial_lockfile = lockfile

bundle "config set --local frozen true"

expect(lockfile).to eq(initial_lockfile)

end

initial_lockfile = lockfile

bundle "config set --local frozen true"

lockfile aggregate_gem_section_lockfile

end

bundle "config set --local deployment true"

bundle "config set --local disable_checksum_validation true"

expect(the_bundle).to include_gems("myrack 0.9.1", source: "remote3")

end

bundle "config set --local deployment true"

bundle "install", artifice: "compact_index", raise_on_error: false

E

end

bundle "config set --local deployment true"

bundle "install", artifice: "compact_index", raise_on_error: false

expect(err).to include("Could not reach host gem.repo4. Check your network connection and try again.")

end

it "succeeds but warns, suggesting a source block" do

build_repo4 do

build_gem "depends_on_myrack" do |s|

end

end

it "raises, suggesting a source block" do

build_repo4 do

build_gem "depends_on_myrack" do |s|

expect(stdboth).not_to include "Double checking"

end

build_repo2 do

build_gem "back_deps" do |s|

s.add_dependency "foo"

expect(the_bundle).to include_gems "myrack 1.2"

end

# In this scenario, the gem "somegem" only exists in repo4. It depends on specific version of activesupport that

# exists only in repo1. There happens also be a version of activesupport in repo4, but not the one that version 1.0.0

# of somegem wants. This test makes sure that bundler actually finds version 1.2.3 of active support in the other

expect(the_bundle).to include_gems "foo 1.0"

end

build_repo2 do

build_gem "back_deps" do |s|

s.add_dependency "foo"

expect(out).to include("Fetching gem metadata from #{source_uri}")

end

gemfile <<-G

source "#{source_uri}"

gem "myrack"

expect(out).to eq("1.0.0")

end

gemfile <<-G

source "#{source_uri}"

gem "myrack"

expect(vendored_gems("bin/myrackup")).to exist

end

gemfile <<-G

source "#{source_uri}"

gem "myrack"

expect(the_bundle).to include_gems "myrack 1.0.0"

end

gemfile <<-G

source "#{basic_auth_source_uri}"

source "#{file_uri_for(gem_repo1)}"

end

end

build_repo2 do

build_gem "back_deps" do |s|

s.add_dependency "foo"

expect(the_bundle).to include_gems "myrack 1.2"

end

# In this scenario, the gem "somegem" only exists in repo4. It depends on specific version of activesupport that

# exists only in repo1. There happens also be a version of activesupport in repo4, but not the one that version 1.0.0

# of somegem wants. This test makes sure that bundler actually finds version 1.2.3 of active support in the other

expect(out).to include("Fetching source index from http://localgemserver.test/extra")

end

build_repo2 do

build_gem "back_deps" do |s|

s.add_dependency "foo"

expect(the_bundle).to include_gems "back_deps 1.0"

end

build_repo2 do

build_gem "back_deps" do |s|

s.add_dependency "foo"

expect(out).to include("Fetching gem metadata from #{source_uri}")

end

gemfile <<-G

source "#{source_uri}"

gem "myrack"

expect(out).to eq("1.0.0")

end

gemfile <<-G

source "#{source_uri}"

gem "myrack"

expect(vendored_gems("bin/myrackup")).to exist

end

gemfile <<-G

source "#{source_uri}"

gem "myrack"

expect(out).not_to include("#{user}:#{password}")

end

gemfile <<-G

source "#{basic_auth_source_uri}"

source "#{file_uri_for(gem_repo1)}"

end

end

before do

gemfile <<-G

source "https://gem.repo1"

expect(out).to include("gems are installed into `./vendor/bundle`")

end

bundle "install --path vendor/bundle --system", raise_on_error: false

expect(err).to include("Please choose only one option.")

expect(exitstatus).to eq(15)

end

bundle "install --path vendor/bundle"

FileUtils.rm_r bundled_app("vendor")

bundle "install"

context "with path_relative_to_cwd set to true" do

before { bundle "config set path_relative_to_cwd true" }

bundle "install --gemfile='#{bundled_app}/Gemfile' --path vendor/bundle", dir: bundled_app.parent

expect(out).to include("installed into `./vendor/bundle`")

expect(bundled_app("../vendor/bundle")).to be_directory

end

end

it_behaves_like "an option to force redownloading gems" do

let(:flag) { "force" }

end

#{version}

L

source "https://gem.repo4"

gem "myrack"

bundle "exec ruby -e #{source.dump}"

end

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` " \

"(called at -e:1)"

end

end

describe ".with_clean_env" do

bundle "exec ruby -e #{source.dump}"

end

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

end

describe ".clean_system" do

bundle "exec ruby -e #{source.dump}"

end

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

end

describe ".clean_exec" do

bundle "exec ruby -e #{source.dump}"

end

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

end

describe ".environment" do

bundle "exec ruby -e #{source.dump}"

end

expect(deprecations).to include "Bundler.environment has been removed in favor of Bundler.load (called at -e:1)"

end

end

end

bundle "exec --no-keep-file-descriptors -e 1", raise_on_error: false

end

expect(deprecations).to include "The `--no-keep-file-descriptors` has been deprecated. `bundle exec` no longer mess with your file descriptors. Close them in the exec'd script if you need to"

end

end

describe "bundle update --quiet" do

bundle "check --path vendor/bundle", raise_on_error: false

end

expect(deprecations).to include(

"The `--path` flag is deprecated because it relies on being " \

"remembered across bundler invocations, which bundler will no " \

)

end

end

context "bundle check --path=" do

bundle "check --path=vendor/bundle", raise_on_error: false

end

expect(deprecations).to include(

"The `--path` flag is deprecated because it relies on being " \

"remembered across bundler invocations, which bundler will no " \

)

end

end

context "bundle cache --all" do

bundle "cache --all", raise_on_error: false

end

expect(deprecations).to include(

"The `--all` flag is deprecated because it relies on being " \

"remembered across bundler invocations, which bundler will no " \

)

end

end

context "bundle cache --path" do

bundle "cache --path foo", raise_on_error: false

end

expect(deprecations).to include(

"The `--path` flag is deprecated because its semantics are unclear. " \

"Use `bundle config cache_path` to configure the path of your cache of gems, " \

)

end

end

describe "bundle config" do

bundle "config"

end

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

end

describe "old get interface" do

bundle "config waka"

end

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

end

describe "old set interface" do

bundle "config waka wakapun"

end

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

end

describe "old set interface with --local" do

bundle "config --local waka wakapun"

end

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

end

describe "old set interface with --global" do

bundle "config --global waka wakapun"

end

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

end

describe "old unset interface" do

bundle "config --delete waka"

end

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

end

describe "old unset interface with --local" do

bundle "config --delete --local waka"

end

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

end

describe "old unset interface with --global" do

bundle "config --delete --global waka"

end

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

end

end

G

end

bundle "update"

expect(deprecations).to include("Pass --all to `bundle update` to update everything")

end

it "does not warn when --all is passed" do

bundle "update --all"

G

end

expect(deprecations).to include("The --binstubs option will be removed in favor of `bundle binstubs --all`")

end

end

context "bundle install with both gems.rb and Gemfile present" do

bundle "install #{flag_name} #{value}"

end

expect(deprecations).to include(

"The `#{flag_name}` flag is deprecated because it relies on " \

"being remembered across bundler invocations, which bundler " \

)

end

end

end

end

G

end

expect(deprecations).to include(

"Your Gemfile contains multiple global sources. " \

"Using `source` more than once without a block is a security risk, and " \

)

end

bundle "install"

expect(deprecations).to include(

)

end

end

context "bundle install in frozen mode with a lockfile with a single rubygems section with multiple remotes" do

bundle "config set --local frozen true"

end

bundle "install"

expect(deprecations).to include("Your lockfile contains a single rubygems source section with multiple remotes, which is insecure. Make sure you run `bundle install` in non frozen mode and commit the result to make your lockfile secure.")

end

end

context "when Bundler.setup is run in a ruby script" do

RUBY

end

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

end

context "bundle show" do

bundle "show --outdated"

end

expect(deprecations).to include("the `--outdated` flag to `bundle show` was undocumented and will be removed without replacement")

end

end

end

end

context "with --install" do

bundle "remove myrack --install"

expect(err).to include "[DEPRECATED] The `--install` flag has been deprecated. `bundle install` is triggered by default."

end

end

end

bundle "viz"

end

expect(deprecations).to include "The `viz` command has been renamed to `graph` and moved to a plugin. See https://github.com/rubygems/bundler-graph"

end

end

context "bundle plugin install --local_git" do

end

end

bundle "plugin install foo --local_git #{lib_path("foo-1.0")}"

expect(out).to include("Installed plugin foo")

expect(deprecations).to include "--local_git is deprecated, use --git"

end

end

describe "deprecating rubocop" do

bundle "gem my_new_gem --rubocop", raise_on_error: false

end

expect(deprecations).to include \

"--rubocop is deprecated, use --linter=rubocop"

end

bundle "gem my_new_gem --no-rubocop", raise_on_error: false

end

expect(deprecations).to include \

"--no-rubocop is deprecated, use --linter"

end

bundle "gem my_new_gem", env: { "BUNDLE_GEM__RUBOCOP" => "true" }, raise_on_error: false

end

expect(deprecations).to include \

"config gem.rubocop is deprecated; we've updated your config to use gem.linter instead"

end

bundle "gem my_new_gem", env: { "BUNDLE_GEM__RUBOCOP" => "false" }, raise_on_error: false

end

expect(deprecations).to include \

"config gem.rubocop is deprecated; we've updated your config to use gem.linter instead"

end

plugin_should_be_installed("foo")

end

bundle "plugin install foo --git /phony/path/project --local_git [email protected]:/repo/project", raise_on_error: false

expect(exitstatus).not_to eq(0)

end

G

bundle "lock", env: { "DEBUG_RESOLVER" => "1" }, raise_on_error: false

expect(out).to include("backtracking").exactly(26).times

it_behaves_like "an unbundling helper"

end

let(:modified_env) { "Bundler.clean_env" }

it_behaves_like "an unbundling helper"

end

end

it "should set ENV to unbundled_env in the block" do

expected = Bundler.unbundled_env

end

end

before do

create_file("source.rb", <<-'RUBY')

Bundler.ui.silence { Bundler.clean_system("ruby", "-e", "exit(42) unless ENV['BUNDLE_FOO'] == 'bar'") }

end

end

before do

create_file("source.rb", <<-'RUBY')

Process.fork do

expect(bundled_app("bin/myrackup")).not_to exist

end

skip "delete permission error" if Gem.win_platform?

bundle "install --binstubs bin/"

expect(out).to include("You have not configured a value for `bin`")

end

gemfile <<-G

source "https://gem.repo1"

gem "activesupport"

"9.4.0"

end

build_repo4 do

build_bundler previous_minor

G

pristine_system_gems "bundler-#{current_version}"

end

it "installs locked version when using system path and uses it" do

end

describe "after setup" do

install_gemfile <<-G

source "https://gem.repo1"

gem "myrack"

expect(out).to eq("myrack-1.0.0")

end

install_gemfile <<-G

source "https://gem.repo1"

gem "myrack"

begin

enabled = (target_lockfile || lockfile).match?(/^CHECKSUMS$/)

rescue Errno::ENOENT

end

checksums_section(enabled, &block)

end

def replace_version_file(version, dir: source_root)

version_file = File.expand_path("lib/bundler/version.rb", dir)

contents = File.read(version_file)

File.open(version_file, "w") {|f| f << contents }

end

end

describe "with --force" do

bundle "update myrack --force"

expect(err).to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`"

end

bundle "update myrack --no-color --force"

expect(err).to include "[DEPRECATED] The `--force` option has been renamed to `--redownload`"

end