mirror of
https://github.com/ruby/ruby.git
synced 2025-08-27 06:56:13 +02:00
a782d76fbe
When testing under the ruby/ruby setup, mkmf.rb needs to the `$extout`
global variable set properly.
This is because, in this particular case, the `ruby.h` header needed to
compile extensions is constructed from
`$(extout)/include($arch)/ruby/config.h` but `$extout` is not set by
default.
I tried to fix this in mkmf.rb itself but I couldn't figure it. But
setting it externally to workaround the issue fixes the specs, so I'll
start with that. Also setting it externally causes issues when running
specs upstream against Ruby 2.3 (I guess because of some difference with
Ruby 2.3 mkmf.rb implementation). So I'm avoiding doing it on Ruby 2.3 to
woraround that.
d782984585
1564 lines
43 KiB
Ruby
1564 lines
43 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
RSpec.describe "bundle install with git sources" do
|
|
describe "when floating on master" do
|
|
before :each do
|
|
build_git "foo" do |s|
|
|
s.executables = "foobar"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem 'foo'
|
|
end
|
|
G
|
|
end
|
|
|
|
it "fetches gems" do
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" unless defined?(FOO_PREV_REF)
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "caches the git repo", :bundler => "< 3" do
|
|
expect(Dir["#{default_bundle_path}/cache/bundler/git/foo-1.0-*"]).to have_attributes :size => 1
|
|
end
|
|
|
|
it "caches the git repo globally and properly uses the cached repo on the next invocation" do
|
|
simulate_new_machine
|
|
bundle "config set global_gem_cache true"
|
|
bundle :install
|
|
expect(Dir["#{home}/.bundle/cache/git/foo-1.0-*"]).to have_attributes :size => 1
|
|
|
|
bundle "install --verbose"
|
|
expect(err).to be_empty
|
|
expect(out).to include("Using foo 1.0 from #{lib_path("foo")}")
|
|
end
|
|
|
|
it "caches the evaluated gemspec" do
|
|
git = update_git "foo" do |s|
|
|
s.executables = ["foobar"] # we added this the first time, so keep it now
|
|
s.files = ["bin/foobar"] # updating git nukes the files list
|
|
foospec = s.to_ruby.gsub(/s\.files.*/, 's.files = `git ls-files -z`.split("\x0")')
|
|
s.write "foo.gemspec", foospec
|
|
end
|
|
|
|
bundle "update foo"
|
|
|
|
sha = git.ref_for("master", 11)
|
|
spec_file = default_bundle_path.join("bundler/gems/foo-1.0-#{sha}/foo.gemspec").to_s
|
|
ruby_code = Gem::Specification.load(spec_file).to_ruby
|
|
file_code = File.read(spec_file)
|
|
expect(file_code).to eq(ruby_code)
|
|
end
|
|
|
|
it "does not update the git source implicitly" do
|
|
update_git "foo"
|
|
|
|
install_gemfile bundled_app2("Gemfile"), <<-G, :dir => bundled_app2
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem 'foo'
|
|
end
|
|
G
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "fail" if defined?(FOO_PREV_REF)
|
|
RUBY
|
|
|
|
expect(out).to be_empty
|
|
end
|
|
|
|
it "sets up git gem executables on the path" do
|
|
bundle "exec foobar"
|
|
expect(out).to eq("1.0")
|
|
end
|
|
|
|
it "complains if pinned specs don't exist in the git repo" do
|
|
build_git "foo"
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", "1.1", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
expect(err).to include("The source contains the following gems matching 'foo':\n * foo-1.0")
|
|
end
|
|
|
|
it "complains with version and platform if pinned specs don't exist in the git repo", :jruby do
|
|
build_git "only_java" do |s|
|
|
s.platform = "java"
|
|
end
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
platforms :jruby do
|
|
gem "only_java", "1.2", :git => "#{lib_path("only_java-1.0-java")}"
|
|
end
|
|
G
|
|
|
|
expect(err).to include("The source contains the following gems matching 'only_java':\n * only_java-1.0-java")
|
|
end
|
|
|
|
it "complains with multiple versions and platforms if pinned specs don't exist in the git repo", :jruby do
|
|
build_git "only_java", "1.0" do |s|
|
|
s.platform = "java"
|
|
end
|
|
|
|
build_git "only_java", "1.1" do |s|
|
|
s.platform = "java"
|
|
s.write "only_java1-0.gemspec", File.read("#{lib_path("only_java-1.0-java")}/only_java.gemspec")
|
|
end
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
platforms :jruby do
|
|
gem "only_java", "1.2", :git => "#{lib_path("only_java-1.1-java")}"
|
|
end
|
|
G
|
|
|
|
expect(err).to include("The source contains the following gems matching 'only_java':\n * only_java-1.0-java\n * only_java-1.1-java")
|
|
end
|
|
|
|
it "still works after moving the application directory" do
|
|
bundle "config set --local path vendor/bundle"
|
|
bundle "install"
|
|
|
|
FileUtils.mv bundled_app, tmp("bundled_app.bck")
|
|
|
|
expect(the_bundle).to include_gems "foo 1.0", :dir => tmp("bundled_app.bck")
|
|
end
|
|
|
|
it "can still install after moving the application directory" do
|
|
bundle "config set --local path vendor/bundle"
|
|
bundle "install"
|
|
|
|
FileUtils.mv bundled_app, tmp("bundled_app.bck")
|
|
|
|
update_git "foo", "1.1", :path => lib_path("foo-1.0")
|
|
|
|
gemfile tmp("bundled_app.bck/Gemfile"), <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem 'foo'
|
|
end
|
|
|
|
gem "rack", "1.0"
|
|
G
|
|
|
|
bundle "update foo", :dir => tmp("bundled_app.bck")
|
|
|
|
expect(the_bundle).to include_gems "foo 1.1", "rack 1.0", :dir => tmp("bundled_app.bck")
|
|
end
|
|
end
|
|
|
|
describe "with an empty git block" do
|
|
before do
|
|
build_git "foo"
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack"
|
|
|
|
git "#{lib_path("foo-1.0")}" do
|
|
# this page left intentionally blank
|
|
end
|
|
G
|
|
end
|
|
|
|
it "does not explode" do
|
|
bundle "install"
|
|
expect(the_bundle).to include_gems "rack 1.0"
|
|
end
|
|
end
|
|
|
|
describe "when specifying a revision" do
|
|
before(:each) do
|
|
build_git "foo"
|
|
@revision = revision_for(lib_path("foo-1.0"))
|
|
update_git "foo"
|
|
end
|
|
|
|
it "works" do
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}", :ref => "#{@revision}" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" unless defined?(FOO_PREV_REF)
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "works when the revision is a symbol" do
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}", :ref => #{@revision.to_sym.inspect} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
expect(err).to be_empty
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" unless defined?(FOO_PREV_REF)
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "works when the revision is a non-head ref" do
|
|
# want to ensure we don't fallback to master
|
|
update_git "foo", :path => lib_path("foo-1.0") do |s|
|
|
s.write("lib/foo.rb", "raise 'FAIL'")
|
|
end
|
|
|
|
sys_exec("git update-ref -m \"Bundler Spec!\" refs/bundler/1 master~1", :dir => lib_path("foo-1.0"))
|
|
|
|
# want to ensure we don't fallback to HEAD
|
|
update_git "foo", :path => lib_path("foo-1.0"), :branch => "rando" do |s|
|
|
s.write("lib/foo.rb", "raise 'FAIL_FROM_RANDO'")
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}", :ref => "refs/bundler/1" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
expect(err).to be_empty
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" if defined?(FOO)
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "works when the revision is a non-head ref and it was previously downloaded" do
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
# want to ensure we don't fallback to master
|
|
update_git "foo", :path => lib_path("foo-1.0") do |s|
|
|
s.write("lib/foo.rb", "raise 'FAIL'")
|
|
end
|
|
|
|
sys_exec("git update-ref -m \"Bundler Spec!\" refs/bundler/1 master~1", :dir => lib_path("foo-1.0"))
|
|
|
|
# want to ensure we don't fallback to HEAD
|
|
update_git "foo", :path => lib_path("foo-1.0"), :branch => "rando" do |s|
|
|
s.write("lib/foo.rb", "raise 'FAIL_FROM_RANDO'")
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}", :ref => "refs/bundler/1" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
expect(err).to be_empty
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" if defined?(FOO)
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "does not download random non-head refs" do
|
|
sys_exec("git update-ref -m \"Bundler Spec!\" refs/bundler/1 master~1", :dir => lib_path("foo-1.0"))
|
|
|
|
bundle "config set global_gem_cache true"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
# ensure we also git fetch after cloning
|
|
bundle :update, :all => true
|
|
|
|
sys_exec("git ls-remote .", :dir => Dir[home(".bundle/cache/git/foo-*")].first)
|
|
|
|
expect(out).not_to include("refs/bundler/1")
|
|
end
|
|
end
|
|
|
|
describe "when specifying a branch" do
|
|
let(:branch) { "branch" }
|
|
let(:repo) { build_git("foo").path }
|
|
|
|
it "works" do
|
|
update_git("foo", :path => repo, :branch => branch)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{repo}", :branch => #{branch.dump} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
end
|
|
|
|
context "when the branch starts with a `#`" do
|
|
let(:branch) { "#149/redirect-url-fragment" }
|
|
it "works" do
|
|
skip "git does not accept this" if Gem.win_platform?
|
|
|
|
update_git("foo", :path => repo, :branch => branch)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{repo}", :branch => #{branch.dump} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
end
|
|
end
|
|
|
|
context "when the branch includes quotes" do
|
|
let(:branch) { %('") }
|
|
it "works" do
|
|
skip "git does not accept this" if Gem.win_platform?
|
|
|
|
update_git("foo", :path => repo, :branch => branch)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{repo}", :branch => #{branch.dump} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "when specifying a tag" do
|
|
let(:tag) { "tag" }
|
|
let(:repo) { build_git("foo").path }
|
|
|
|
it "works" do
|
|
update_git("foo", :path => repo, :tag => tag)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{repo}", :tag => #{tag.dump} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
end
|
|
|
|
context "when the tag starts with a `#`" do
|
|
let(:tag) { "#149/redirect-url-fragment" }
|
|
it "works" do
|
|
skip "git does not accept this" if Gem.win_platform?
|
|
|
|
update_git("foo", :path => repo, :tag => tag)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{repo}", :tag => #{tag.dump} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
end
|
|
end
|
|
|
|
context "when the tag includes quotes" do
|
|
let(:tag) { %('") }
|
|
it "works" do
|
|
skip "git does not accept this" if Gem.win_platform?
|
|
|
|
update_git("foo", :path => repo, :tag => tag)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{repo}", :tag => #{tag.dump} do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "when specifying local override" do
|
|
it "uses the local repository instead of checking a new one out" do
|
|
build_git "rack", "0.8", :path => lib_path("local-rack") do |s|
|
|
s.write "lib/rack.rb", "puts :LOCAL"
|
|
end
|
|
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install
|
|
|
|
run "require 'rack'"
|
|
expect(out).to eq("LOCAL")
|
|
end
|
|
|
|
it "chooses the local repository on runtime" do
|
|
build_git "rack", "0.8"
|
|
|
|
FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
|
|
|
|
update_git "rack", "0.8", :path => lib_path("local-rack") do |s|
|
|
s.write "lib/rack.rb", "puts :LOCAL"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
run "require 'rack'"
|
|
expect(out).to eq("LOCAL")
|
|
end
|
|
|
|
it "unlocks the source when the dependencies have changed while switching to the local" do
|
|
build_git "rack", "0.8"
|
|
|
|
FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
|
|
|
|
update_git "rack", "0.8", :path => lib_path("local-rack") do |s|
|
|
s.write "rack.gemspec", build_spec("rack", "0.8") { runtime "rspec", "> 0" }.first.to_ruby
|
|
s.write "lib/rack.rb", "puts :LOCAL"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install
|
|
run "require 'rack'"
|
|
expect(out).to eq("LOCAL")
|
|
end
|
|
|
|
it "updates specs on runtime" do
|
|
system_gems "nokogiri-1.4.2"
|
|
|
|
build_git "rack", "0.8"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
lockfile0 = File.read(bundled_app_lock)
|
|
|
|
FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
|
|
update_git "rack", "0.8", :path => lib_path("local-rack") do |s|
|
|
s.add_dependency "nokogiri", "1.4.2"
|
|
end
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
run "require 'rack'"
|
|
|
|
lockfile1 = File.read(bundled_app_lock)
|
|
expect(lockfile1).not_to eq(lockfile0)
|
|
end
|
|
|
|
it "updates ref on install" do
|
|
build_git "rack", "0.8"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
lockfile0 = File.read(bundled_app_lock)
|
|
|
|
FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
|
|
update_git "rack", "0.8", :path => lib_path("local-rack")
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install
|
|
|
|
lockfile1 = File.read(bundled_app_lock)
|
|
expect(lockfile1).not_to eq(lockfile0)
|
|
end
|
|
|
|
it "explodes and gives correct solution if given path does not exist on install" do
|
|
build_git "rack", "0.8"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install, :raise_on_error => false
|
|
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(err).to be_empty
|
|
end
|
|
|
|
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"))
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install, :raise_on_error => false
|
|
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(err).to be_empty
|
|
end
|
|
|
|
it "does not explode if disable_local_branch_check is given" do
|
|
build_git "rack", "0.8"
|
|
FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}"
|
|
G
|
|
|
|
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
|
|
|
|
it "explodes on different branches on install" do
|
|
build_git "rack", "0.8"
|
|
|
|
FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
|
|
|
|
update_git "rack", "0.8", :path => lib_path("local-rack"), :branch => "another" do |s|
|
|
s.write "lib/rack.rb", "puts :LOCAL"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install, :raise_on_error => false
|
|
expect(err).to match(/is using branch another but Gemfile specifies master/)
|
|
end
|
|
|
|
it "explodes on invalid revision on install" do
|
|
build_git "rack", "0.8"
|
|
|
|
build_git "rack", "0.8", :path => lib_path("local-rack") do |s|
|
|
s.write "lib/rack.rb", "puts :LOCAL"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle :install, :raise_on_error => false
|
|
expect(err).to match(/The Gemfile lock is pointing to revision \w+/)
|
|
end
|
|
|
|
it "does not explode on invalid revision on install" do
|
|
build_git "rack", "0.8"
|
|
|
|
build_git "rack", "0.8", :path => lib_path("local-rack") do |s|
|
|
s.write "lib/rack.rb", "puts :LOCAL"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
|
|
G
|
|
|
|
bundle %(config set local.rack #{lib_path("local-rack")})
|
|
bundle %(config set disable_local_revision_check true)
|
|
bundle :install
|
|
expect(out).to match(/Bundle complete!/)
|
|
end
|
|
end
|
|
|
|
describe "specified inline" do
|
|
# TODO: Figure out how to write this test so that it is not flaky depending
|
|
# on the current network situation.
|
|
# it "supports private git URLs" do
|
|
# gemfile <<-G
|
|
# gem "thingy", :git => "git@notthere.fallingsnow.net:somebody/thingy.git"
|
|
# G
|
|
#
|
|
# bundle :install
|
|
#
|
|
# # p out
|
|
# # p err
|
|
# puts err unless err.empty? # This spec fails randomly every so often
|
|
# err.should include("notthere.fallingsnow.net")
|
|
# err.should include("ssh")
|
|
# end
|
|
|
|
it "installs from git even if a newer gem is available elsewhere" do
|
|
build_git "rack", "0.8"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack-0.8")}"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "rack 0.8"
|
|
end
|
|
|
|
it "installs dependencies from git even if a newer gem is available elsewhere" do
|
|
system_gems "rack-1.0.0"
|
|
|
|
build_lib "rack", "1.0", :path => lib_path("nested/bar") do |s|
|
|
s.write "lib/rack.rb", "puts 'WIN OVERRIDE'"
|
|
end
|
|
|
|
build_git "foo", :path => lib_path("nested") do |s|
|
|
s.add_dependency "rack", "= 1.0"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("nested")}"
|
|
G
|
|
|
|
run "require 'rack'"
|
|
expect(out).to eq("WIN OVERRIDE")
|
|
end
|
|
|
|
it "correctly unlocks when changing to a git source" do
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", "0.9.1"
|
|
G
|
|
|
|
build_git "rack", :path => lib_path("rack")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", "1.0.0", :git => "#{lib_path("rack")}"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "rack 1.0.0"
|
|
end
|
|
|
|
it "correctly unlocks when changing to a git source without versions" do
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack"
|
|
G
|
|
|
|
build_git "rack", "1.2", :path => lib_path("rack")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack", :git => "#{lib_path("rack")}"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "rack 1.2"
|
|
end
|
|
end
|
|
|
|
describe "block syntax" do
|
|
it "pulls all gems from a git block" do
|
|
build_lib "omg", :path => lib_path("hi2u/omg")
|
|
build_lib "hi2u", :path => lib_path("hi2u")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
path "#{lib_path("hi2u")}" do
|
|
gem "omg"
|
|
gem "hi2u"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "omg 1.0", "hi2u 1.0"
|
|
end
|
|
end
|
|
|
|
it "uses a ref if specified" do
|
|
build_git "foo"
|
|
@revision = revision_for(lib_path("foo-1.0"))
|
|
update_git "foo"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}", :ref => "#{@revision}"
|
|
G
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" unless defined?(FOO_PREV_REF)
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "correctly handles cases with invalid gemspecs" do
|
|
build_git "foo" do |s|
|
|
s.summary = nil
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
gem "rails", "2.3.2"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "foo 1.0"
|
|
expect(the_bundle).to include_gems "rails 2.3.2"
|
|
end
|
|
|
|
it "runs the gemspec in the context of its parent directory" do
|
|
build_lib "bar", :path => lib_path("foo/bar"), :gemspec => false do |s|
|
|
s.write lib_path("foo/bar/lib/version.rb"), %(BAR_VERSION = '1.0')
|
|
s.write "bar.gemspec", <<-G
|
|
$:.unshift Dir.pwd
|
|
require 'lib/version'
|
|
Gem::Specification.new do |s|
|
|
s.name = 'bar'
|
|
s.author = 'no one'
|
|
s.version = BAR_VERSION
|
|
s.summary = 'Bar'
|
|
s.files = Dir["lib/**/*.rb"]
|
|
end
|
|
G
|
|
end
|
|
|
|
build_git "foo", :path => lib_path("foo") do |s|
|
|
s.write "bin/foo", ""
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "bar", :git => "#{lib_path("foo")}"
|
|
gem "rails", "2.3.2"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "bar 1.0"
|
|
expect(the_bundle).to include_gems "rails 2.3.2"
|
|
end
|
|
|
|
it "installs from git even if a rubygems gem is present" do
|
|
build_gem "foo", "1.0", :path => lib_path("fake_foo"), :to_system => true do |s|
|
|
s.write "lib/foo.rb", "raise 'FAIL'"
|
|
end
|
|
|
|
build_git "foo", "1.0"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", "1.0", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "foo 1.0"
|
|
end
|
|
|
|
it "fakes the gem out if there is no gemspec" do
|
|
build_git "foo", :gemspec => false
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", "1.0", :git => "#{lib_path("foo-1.0")}"
|
|
gem "rails", "2.3.2"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems("foo 1.0")
|
|
expect(the_bundle).to include_gems("rails 2.3.2")
|
|
end
|
|
|
|
it "catches git errors and spits out useful output" do
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", "1.0", :git => "omgomg"
|
|
G
|
|
|
|
bundle :install, :raise_on_error => false
|
|
|
|
expect(err).to include("Git error:")
|
|
expect(err).to include("fatal")
|
|
expect(err).to include("omgomg")
|
|
end
|
|
|
|
it "works when the gem path has spaces in it" do
|
|
build_git "foo", :path => lib_path("foo space-1.0")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo space-1.0")}"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "foo 1.0"
|
|
end
|
|
|
|
it "handles repos that have been force-pushed" do
|
|
build_git "forced", "1.0"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("forced-1.0")}" do
|
|
gem 'forced'
|
|
end
|
|
G
|
|
expect(the_bundle).to include_gems "forced 1.0"
|
|
|
|
update_git "forced" do |s|
|
|
s.write "lib/forced.rb", "FORCED = '1.1'"
|
|
end
|
|
|
|
bundle "update", :all => true
|
|
expect(the_bundle).to include_gems "forced 1.1"
|
|
|
|
sys_exec("git reset --hard HEAD^", :dir => lib_path("forced-1.0"))
|
|
|
|
bundle "update", :all => true
|
|
expect(the_bundle).to include_gems "forced 1.0"
|
|
end
|
|
|
|
it "ignores submodules if :submodule is not passed" do
|
|
build_git "submodule", "1.0"
|
|
build_git "has_submodule", "1.0" do |s|
|
|
s.add_dependency "submodule"
|
|
end
|
|
sys_exec "git submodule add #{lib_path("submodule-1.0")} submodule-1.0", :dir => lib_path("has_submodule-1.0")
|
|
sys_exec "git commit -m \"submodulator\"", :dir => lib_path("has_submodule-1.0")
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("has_submodule-1.0")}" do
|
|
gem "has_submodule"
|
|
end
|
|
G
|
|
expect(err).to match(/could not find gem 'submodule/i)
|
|
|
|
expect(the_bundle).not_to include_gems "has_submodule 1.0"
|
|
end
|
|
|
|
it "handles repos with submodules" do
|
|
build_git "submodule", "1.0"
|
|
build_git "has_submodule", "1.0" do |s|
|
|
s.add_dependency "submodule"
|
|
end
|
|
sys_exec "git submodule add #{lib_path("submodule-1.0")} submodule-1.0", :dir => lib_path("has_submodule-1.0")
|
|
sys_exec "git commit -m \"submodulator\"", :dir => lib_path("has_submodule-1.0")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("has_submodule-1.0")}", :submodules => true do
|
|
gem "has_submodule"
|
|
end
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "has_submodule 1.0"
|
|
end
|
|
|
|
it "does not warn when deiniting submodules" do
|
|
build_git "submodule", "1.0"
|
|
build_git "has_submodule", "1.0"
|
|
|
|
sys_exec "git submodule add #{lib_path("submodule-1.0")} submodule-1.0", :dir => lib_path("has_submodule-1.0")
|
|
sys_exec "git commit -m \"submodulator\"", :dir => lib_path("has_submodule-1.0")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("has_submodule-1.0")}" do
|
|
gem "has_submodule"
|
|
end
|
|
G
|
|
expect(err).to be_empty
|
|
|
|
expect(the_bundle).to include_gems "has_submodule 1.0"
|
|
expect(the_bundle).to_not include_gems "submodule 1.0"
|
|
end
|
|
|
|
it "handles implicit updates when modifying the source info" do
|
|
git = build_git "foo"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
update_git "foo"
|
|
update_git "foo"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}", :ref => "#{git.ref_for("HEAD^")}" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
run <<-RUBY
|
|
require 'foo'
|
|
puts "WIN" if FOO_PREV_REF == '#{git.ref_for("HEAD^^")}'
|
|
RUBY
|
|
|
|
expect(out).to eq("WIN")
|
|
end
|
|
|
|
it "does not to a remote fetch if the revision is cached locally" do
|
|
build_git "foo"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
FileUtils.rm_rf(lib_path("foo-1.0"))
|
|
|
|
bundle "install"
|
|
expect(out).not_to match(/updating/i)
|
|
end
|
|
|
|
it "doesn't blow up if bundle install is run twice in a row" do
|
|
build_git "foo"
|
|
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
bundle "install"
|
|
bundle "install"
|
|
end
|
|
|
|
it "prints a friendly error if a file blocks the git repo" do
|
|
build_git "foo"
|
|
|
|
FileUtils.mkdir_p(default_bundle_path)
|
|
FileUtils.touch(default_bundle_path("bundler"))
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
expect(exitstatus).to_not eq(0)
|
|
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
|
|
|
|
it "does not duplicate git gem sources" do
|
|
build_lib "foo", :path => lib_path("nested/foo")
|
|
build_lib "bar", :path => lib_path("nested/bar")
|
|
|
|
build_git "foo", :path => lib_path("nested")
|
|
build_git "bar", :path => lib_path("nested")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("nested")}"
|
|
gem "bar", :git => "#{lib_path("nested")}"
|
|
G
|
|
|
|
expect(File.read(bundled_app_lock).scan("GIT").size).to eq(1)
|
|
end
|
|
|
|
describe "switching sources" do
|
|
it "doesn't explode when switching Path to Git sources" do
|
|
build_gem "foo", "1.0", :to_system => true do |s|
|
|
s.write "lib/foo.rb", "raise 'fail'"
|
|
end
|
|
build_lib "foo", "1.0", :path => lib_path("bar/foo")
|
|
build_git "bar", "1.0", :path => lib_path("bar") do |s|
|
|
s.add_dependency "foo"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "bar", :path => "#{lib_path("bar")}"
|
|
G
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "bar", :git => "#{lib_path("bar")}"
|
|
G
|
|
|
|
expect(the_bundle).to include_gems "foo 1.0", "bar 1.0"
|
|
end
|
|
|
|
it "doesn't explode when switching Gem to Git source" do
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack-obama"
|
|
gem "rack", "1.0.0"
|
|
G
|
|
|
|
build_git "rack", "1.0" do |s|
|
|
s.write "lib/new_file.rb", "puts 'USING GIT'"
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "rack-obama"
|
|
gem "rack", "1.0.0", :git => "#{lib_path("rack-1.0")}"
|
|
G
|
|
|
|
run "require 'new_file'"
|
|
expect(out).to eq("USING GIT")
|
|
end
|
|
end
|
|
|
|
describe "bundle install after the remote has been updated" do
|
|
it "installs" do
|
|
build_git "valim"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "valim", :git => "#{file_uri_for(lib_path("valim-1.0"))}"
|
|
G
|
|
|
|
old_revision = revision_for(lib_path("valim-1.0"))
|
|
update_git "valim"
|
|
new_revision = revision_for(lib_path("valim-1.0"))
|
|
|
|
old_lockfile = File.read(bundled_app_lock)
|
|
lockfile(bundled_app_lock, old_lockfile.gsub(/revision: #{old_revision}/, "revision: #{new_revision}"))
|
|
|
|
bundle "install"
|
|
|
|
run <<-R
|
|
require "valim"
|
|
puts VALIM_PREV_REF
|
|
R
|
|
|
|
expect(out).to eq(old_revision)
|
|
end
|
|
|
|
it "gives a helpful error message when the remote ref no longer exists" do
|
|
build_git "foo"
|
|
revision = revision_for(lib_path("foo-1.0"))
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{file_uri_for(lib_path("foo-1.0"))}", :ref => "#{revision}"
|
|
G
|
|
expect(out).to_not match(/Revision.*does not exist/)
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{file_uri_for(lib_path("foo-1.0"))}", :ref => "deadbeef"
|
|
G
|
|
expect(err).to include("Revision deadbeef does not exist in the repository")
|
|
end
|
|
end
|
|
|
|
describe "bundle install with deployment mode configured and git sources" do
|
|
it "works" do
|
|
build_git "valim", :path => lib_path("valim")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "valim", "= 1.0", :git => "#{lib_path("valim")}"
|
|
G
|
|
|
|
simulate_new_machine
|
|
|
|
bundle "config set --local deployment true"
|
|
bundle :install
|
|
end
|
|
end
|
|
|
|
describe "gem install hooks" do
|
|
it "runs pre-install hooks" do
|
|
build_git "foo"
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
File.open(lib_path("install_hooks.rb"), "w") do |h|
|
|
h.write <<-H
|
|
Gem.pre_install_hooks << lambda do |inst|
|
|
STDERR.puts "Ran pre-install hook: \#{inst.spec.full_name}"
|
|
end
|
|
H
|
|
end
|
|
|
|
bundle :install,
|
|
:requires => [lib_path("install_hooks.rb")]
|
|
expect(err_without_deprecations).to eq("Ran pre-install hook: foo-1.0")
|
|
end
|
|
|
|
it "runs post-install hooks" do
|
|
build_git "foo"
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
File.open(lib_path("install_hooks.rb"), "w") do |h|
|
|
h.write <<-H
|
|
Gem.post_install_hooks << lambda do |inst|
|
|
STDERR.puts "Ran post-install hook: \#{inst.spec.full_name}"
|
|
end
|
|
H
|
|
end
|
|
|
|
bundle :install,
|
|
:requires => [lib_path("install_hooks.rb")]
|
|
expect(err_without_deprecations).to eq("Ran post-install hook: foo-1.0")
|
|
end
|
|
|
|
it "complains if the install hook fails" do
|
|
build_git "foo"
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
File.open(lib_path("install_hooks.rb"), "w") do |h|
|
|
h.write <<-H
|
|
Gem.pre_install_hooks << lambda do |inst|
|
|
false
|
|
end
|
|
H
|
|
end
|
|
|
|
bundle :install, :requires => [lib_path("install_hooks.rb")], :raise_on_error => false
|
|
expect(err).to include("failed for foo-1.0")
|
|
end
|
|
end
|
|
|
|
context "with an extension" do
|
|
it "installs the extension" 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", __dir__)
|
|
FileUtils.mkdir_p(path)
|
|
File.open("\#{path}/foo.rb", "w") do |f|
|
|
f.puts "FOO = 'YES'"
|
|
end
|
|
end
|
|
RUBY
|
|
end
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
run <<-R
|
|
require 'foo'
|
|
puts FOO
|
|
R
|
|
expect(out).to eq("YES")
|
|
|
|
run <<-R
|
|
puts $:.grep(/ext/)
|
|
R
|
|
expect(out).to include(Pathname.glob(default_bundle_path("bundler/gems/extensions/**/foo-1.0-*")).first.to_s)
|
|
end
|
|
|
|
it "does not use old extension after ref changes" do
|
|
git_reader = build_git "foo", :no_default => true do |s|
|
|
s.extensions = ["ext/extconf.rb"]
|
|
s.write "ext/extconf.rb", <<-RUBY
|
|
require "mkmf"
|
|
$extout = "$(topdir)/" + RbConfig::CONFIG["EXTOUT"] unless RUBY_VERSION < "2.4"
|
|
create_makefile("foo")
|
|
RUBY
|
|
s.write "ext/foo.c", "void Init_foo() {}"
|
|
end
|
|
|
|
2.times do |i|
|
|
File.open(git_reader.path.join("ext/foo.c"), "w") do |file|
|
|
file.write <<-C
|
|
#include "ruby.h"
|
|
VALUE foo() { return INT2FIX(#{i}); }
|
|
void Init_foo() { rb_define_global_function("foo", &foo, 0); }
|
|
C
|
|
end
|
|
sys_exec("git commit -m \"commit for iteration #{i}\" ext/foo.c", :dir => git_reader.path)
|
|
|
|
git_commit_sha = git_reader.ref_for("HEAD")
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}", :ref => "#{git_commit_sha}"
|
|
G
|
|
|
|
run <<-R
|
|
require 'foo'
|
|
puts foo
|
|
R
|
|
|
|
expect(out).to eq(i.to_s)
|
|
end
|
|
end
|
|
|
|
it "does not prompt to gem install if extension fails" do
|
|
build_git "foo" do |s|
|
|
s.add_dependency "rake"
|
|
s.extensions << "Rakefile"
|
|
s.write "Rakefile", <<-RUBY
|
|
task :default do
|
|
raise
|
|
end
|
|
RUBY
|
|
end
|
|
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
expect(err).to end_with(<<-M.strip)
|
|
An error occurred while installing foo (1.0), and Bundler cannot continue.
|
|
|
|
In Gemfile:
|
|
foo
|
|
M
|
|
expect(out).not_to include("gem install foo")
|
|
end
|
|
|
|
it "does not reinstall the extension" 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", __dir__)
|
|
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_uri_for(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_uri_for(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"
|
|
s.write "Rakefile", <<-RUBY
|
|
task :default do
|
|
path = File.expand_path("lib", __dir__)
|
|
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_uri_for(gem_repo1)}"
|
|
gem "rack", "0.9.1"
|
|
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_uri_for(gem_repo1)}"
|
|
gem "rack", "1.0.0"
|
|
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 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", __dir__)
|
|
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_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo-1.0")}"
|
|
G
|
|
|
|
run <<-R
|
|
require 'foo'
|
|
puts FOO
|
|
R
|
|
|
|
installed_time = out
|
|
|
|
update_git("foo", :branch => "branch2")
|
|
|
|
expect(installed_time).to match(/\A\d+\.\d+\z/)
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(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
|
|
build_git "xxxxxx" do |s|
|
|
s.executables = "xxxxxxbar"
|
|
end
|
|
|
|
Bundler::SharedHelpers.with_clean_git_env do
|
|
ENV["GIT_DIR"] = "bar"
|
|
ENV["GIT_WORK_TREE"] = "bar"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("xxxxxx-1.0")}" do
|
|
gem 'xxxxxx'
|
|
end
|
|
G
|
|
|
|
expect(ENV["GIT_DIR"]).to eq("bar")
|
|
expect(ENV["GIT_WORK_TREE"]).to eq("bar")
|
|
end
|
|
end
|
|
|
|
describe "without git installed" do
|
|
it "prints a better error message when installing" do
|
|
build_git "foo"
|
|
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
|
|
gem "rake", git: "https://github.com/ruby/rake"
|
|
G
|
|
|
|
lockfile <<-L
|
|
GIT
|
|
remote: https://github.com/ruby/rake
|
|
revision: 5c60da8644a9e4f655e819252e3b6ca77f42b7af
|
|
specs:
|
|
rake (13.0.6)
|
|
|
|
GEM
|
|
remote: https://rubygems.org/
|
|
specs:
|
|
|
|
PLATFORMS
|
|
#{lockfile_platforms}
|
|
|
|
DEPENDENCIES
|
|
rake!
|
|
|
|
BUNDLED WITH
|
|
#{Bundler::VERSION}
|
|
L
|
|
|
|
with_path_as("") do
|
|
bundle "install", :raise_on_error => false
|
|
end
|
|
expect(err).
|
|
to include("You need to install git to be able to use gems from git repositories. For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git")
|
|
end
|
|
|
|
it "prints a better error message when updating" do
|
|
build_git "foo"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem 'foo'
|
|
end
|
|
G
|
|
|
|
with_path_as("") do
|
|
bundle "update", :all => true, :raise_on_error => false
|
|
end
|
|
expect(err).
|
|
to include("You need to install git to be able to use gems from git repositories. For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git")
|
|
end
|
|
|
|
it "installs a packaged git gem successfully" do
|
|
build_git "foo"
|
|
|
|
install_gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "#{lib_path("foo-1.0")}" do
|
|
gem 'foo'
|
|
end
|
|
G
|
|
bundle "config set cache_all true"
|
|
bundle :cache
|
|
simulate_new_machine
|
|
|
|
bundle "install", :env => { "PATH" => "" }
|
|
expect(out).to_not include("You need to install git to be able to use gems from git repositories.")
|
|
end
|
|
end
|
|
|
|
describe "when the git source is overridden with a local git repo" do
|
|
before do
|
|
bundle "config set --global local.foo #{lib_path("foo")}"
|
|
end
|
|
|
|
describe "and git output is colorized" do
|
|
before do
|
|
File.open("#{ENV["HOME"]}/.gitconfig", "w") do |f|
|
|
f.write("[color]\n\tui = always\n")
|
|
end
|
|
end
|
|
|
|
it "installs successfully" do
|
|
build_git "foo", "1.0", :path => lib_path("foo")
|
|
|
|
gemfile <<-G
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
gem "foo", :git => "#{lib_path("foo")}", :branch => "master"
|
|
G
|
|
|
|
bundle :install
|
|
expect(the_bundle).to include_gems "foo 1.0"
|
|
end
|
|
end
|
|
end
|
|
|
|
context "git sources that include credentials" do
|
|
context "that are username and password" do
|
|
let(:credentials) { "user1:password1" }
|
|
|
|
it "does not display the password" do
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "https://#{credentials}@github.com/company/private-repo" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(last_command.stdboth).to_not include("password1")
|
|
expect(out).to include("Fetching https://user1@github.com/company/private-repo")
|
|
end
|
|
end
|
|
|
|
context "that is an oauth token" do
|
|
let(:credentials) { "oauth_token" }
|
|
|
|
it "displays the oauth scheme but not the oauth token" do
|
|
install_gemfile <<-G, :raise_on_error => false
|
|
source "#{file_uri_for(gem_repo1)}"
|
|
git "https://#{credentials}:x-oauth-basic@github.com/company/private-repo" do
|
|
gem "foo"
|
|
end
|
|
G
|
|
|
|
expect(last_command.stdboth).to_not include("oauth_token")
|
|
expect(out).to include("Fetching https://x-oauth-basic@github.com/company/private-repo")
|
|
end
|
|
end
|
|
end
|
|
end
|