bundler 1.2.5 → 1.3.0.pre

data/spec/other/show_spec.rb

@@ -13,7 +13,7 @@ describe "bundle show" do
 
     bundle "show"
 
-    bundled_app("Gemfile.lock").should exist
+    expect(bundled_app("Gemfile.lock")).to exist
   end
 
   it "creates a Gemfile.lock when invoked with a gem name" do
@@ -21,28 +21,28 @@ describe "bundle show" do
 
     bundle "show rails"
 
-    bundled_app("Gemfile.lock").should exist
+    expect(bundled_app("Gemfile.lock")).to exist
   end
 
   it "prints path if gem exists in bundle" do
     bundle "show rails"
-    out.should == default_bundle_path('gems', 'rails-2.3.2').to_s
+    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 "show bundler"
-    out.should == File.expand_path('../../../', __FILE__)
+    expect(out).to eq(File.expand_path('../../../', __FILE__))
   end
 
   it "complains if gem not in bundle" do
     bundle "show missing"
-    out.should =~ /could not find gem 'missing'/i
+    expect(out).to match(/could not find gem 'missing'/i)
   end
 
   it "prints path of all gems in bundle" do
     bundle "show --paths"
-    out.should include(default_bundle_path('gems', 'rake-10.0.2').to_s)
-    out.should include(default_bundle_path('gems', 'rails-2.3.2').to_s)
+    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)
   end
 end
 
@@ -58,7 +58,7 @@ describe "bundle show with a git repo" do
     should_be_installed "foo 1.0"
 
     bundle :show
-    out.should include("foo (1.0 #{@git.ref_for('master', 6)}")
+    expect(out).to include("foo (1.0 #{@git.ref_for('master', 6)}")
   end
 
   it "prints out branch names other than master" do
@@ -73,7 +73,7 @@ describe "bundle show with a git repo" do
     should_be_installed "foo 1.0.omg"
 
     bundle :show
-    out.should include("foo (1.0 #{@git.ref_for('omg', 6)}")
+    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
@@ -83,6 +83,6 @@ describe "bundle show with a git repo" do
     G
 
     bundle :show
-    out.should include("foo (1.0 #{sha[0..6]})")
+    expect(out).to include("foo (1.0 #{sha[0..6]})")
   end
 end

data/spec/quality_spec.rb

@@ -47,13 +47,13 @@ describe "The library itself" do
         error_messages << check_for_extra_spaces(filename)
       end
     end
-    error_messages.compact.should be_well_formed
+    expect(error_messages.compact).to be_well_formed
   end
 
   it "can still be built" do
     Dir.chdir(root) do
       `gem build bundler.gemspec`
-      $?.should eq(0)
+      expect($?).to eq(0)
 
       # clean up the .gem generated
       system("rm bundler-#{Bundler::VERSION}.gem")

data/spec/realworld/dependency_api_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe "gemcutter's dependency API", :realworld => true do
+  def wait_for_server(port, seconds = 15)
+    tries = 0
+    TCPSocket.new("127.0.0.1", port)
+  rescue => e
+    raise(e) if tries > (seconds * 2)
+    tries += 1
+    sleep 0.5
+    retry
+  end
+
+  context "when Gemcutter API takes too long to respond" do
+    before do
+      # need to hack, so we can require rack
+      old_gem_home = ENV['GEM_HOME']
+      ENV['GEM_HOME'] = Spec::Path.base_system_gems.to_s
+      require 'rack'
+      ENV['GEM_HOME'] = old_gem_home
+
+      port = 21453
+      port += 1 while TCPSocket.new("127.0.0.1", port) rescue false
+      @server_uri = "http://127.0.0.1:#{port}"
+
+      require File.expand_path('../../support/artifice/endpoint_timeout', __FILE__)
+      require 'thread'
+      @t = Thread.new {
+        server = Rack::Server.start(:app       => EndpointTimeout,
+                                    :Host      => '0.0.0.0',
+                                    :Port      => port,
+                                    :server    => 'webrick',
+                                    :AccessLog => [])
+        server.start
+      }
+      @t.run
+
+      wait_for_server(port)
+    end
+
+    after do
+      @t.kill
+    end
+
+    it "times out and falls back on the modern index" do
+      gemfile <<-G
+        source "#{@server_uri}"
+        gem "rack"
+
+        old_v, $VERBOSE = $VERBOSE, nil
+        Bundler::Fetcher::API_TIMEOUT = 1
+        $VERBOSE = old_v
+      G
+
+      bundle :install
+      expect(out).to include("\nFetching full source index from #{@server_uri}")
+      should_be_installed "rack 1.0.0"
+    end
+  end
+
+end

data/spec/realworld/edgecases_spec.rb

@@ -7,23 +7,23 @@ describe "real world edgecases", :realworld => true do
       source :rubygems
       gem "linecache", "0.46"
     G
-    err.should eq("")
+    expect(err).to eq("")
   end
 
   # https://github.com/carlhuda/bundler/issues/1202
-  it "bundle cache works with rubygems 1.3.7 and pre gems", :ruby => "1.8" do
+  it "bundle cache works with rubygems 1.3.7 and pre gems" do
     install_gemfile <<-G
       source :rubygems
       gem "rack",          "1.3.0.beta2"
       gem "will_paginate", "3.0.pre2"
     G
     bundle :cache
-    out.should_not include("Removing outdated .gem files from vendor/cache")
+    expect(out).not_to include("Removing outdated .gem files from vendor/cache")
   end
 
   # https://github.com/carlhuda/bundler/issues/1486
   # this is a hash collision that only manifests on 1.8.7
-  it "finds the correct child versions", :ruby => "1.8" do
+  it "finds the correct child versions" do
     install_gemfile <<-G
       source :rubygems
 
@@ -32,7 +32,7 @@ describe "real world edgecases", :realworld => true do
       gem 'activerecord', '~> 3.0'
       gem 'builder', '~> 2.1.2'
     G
-    out.should include("activemodel (3.0.5)")
+    expect(out).to include("activemodel (3.0.5)")
   end
 
   # https://github.com/carlhuda/bundler/issues/1500
@@ -45,8 +45,8 @@ describe "real world edgecases", :realworld => true do
     G
 
     bundle "install --path vendor/bundle", :expect_err => true
-    err.should_not include("Could not find rake")
-    err.should be_empty
+    expect(err).not_to include("Could not find rake")
+    expect(err).to be_empty
   end
 
   it "checks out git repos when the lockfile is corrupted" do
@@ -172,6 +172,6 @@ describe "real world edgecases", :realworld => true do
     L
 
     bundle :install, :exitstatus => true
-    exitstatus.should == 0
+    expect(exitstatus).to eq(0)
   end
 end

data/spec/runtime/executable_spec.rb

@@ -16,34 +16,34 @@ describe "Running bin/* commands" do
     end
 
     gembin "rackup"
-    out.should == "1.0.0"
+    expect(out).to eq("1.0.0")
   end
 
   it "allows the location of the gem stubs to be specified" do
     bundle "install --binstubs gbin"
 
-    bundled_app("bin").should_not exist
-    bundled_app("gbin/rackup").should exist
+    expect(bundled_app("bin")).not_to exist
+    expect(bundled_app("gbin/rackup")).to exist
 
     gembin bundled_app("gbin/rackup")
-    out.should == "1.0.0"
+    expect(out).to eq("1.0.0")
   end
 
   it "allows absolute paths as a specification of where to install bin stubs" do
     bundle "install --binstubs #{tmp}/bin"
 
     gembin tmp("bin/rackup")
-    out.should == "1.0.0"
+    expect(out).to eq("1.0.0")
   end
 
   it "uses the default ruby install name when shebang is not specified" do
    bundle "install --binstubs"
-   File.open("bin/rackup").gets.should == "#!/usr/bin/env #{RbConfig::CONFIG['ruby_install_name']}\n"
+   expect(File.open("bin/rackup").gets).to eq("#!/usr/bin/env #{RbConfig::CONFIG['ruby_install_name']}\n")
   end
 
   it "allows the name of the shebang executable to be specified" do
     bundle "install --binstubs --shebang ruby-foo"
-    File.open("bin/rackup").gets.should == "#!/usr/bin/env ruby-foo\n"
+    expect(File.open("bin/rackup").gets).to eq("#!/usr/bin/env ruby-foo\n")
   end
 
   it "runs the bundled command when out of the bundle" do
@@ -55,7 +55,7 @@ describe "Running bin/* commands" do
 
     Dir.chdir(tmp) do
       gembin "rackup"
-      out.should == "1.0.0"
+      expect(out).to eq("1.0.0")
     end
   end
 
@@ -75,7 +75,7 @@ describe "Running bin/* commands" do
     end
 
     gembin "rackup"
-    out.should == '1.0'
+    expect(out).to eq('1.0')
   end
 
   it "don't bundle da bundla" do
@@ -90,13 +90,13 @@ describe "Running bin/* commands" do
 
     bundle "install --binstubs"
 
-    bundled_app("bin/bundle").should_not exist
+    expect(bundled_app("bin/bundle")).not_to exist
   end
 
   it "does not generate bin stubs if the option was not specified" do
     bundle "install"
 
-    bundled_app("bin/rackup").should_not exist
+    expect(bundled_app("bin/rackup")).not_to exist
   end
 
   it "remembers that the option was specified" do
@@ -115,6 +115,6 @@ describe "Running bin/* commands" do
 
     bundle "install"
 
-    bundled_app("bin/rackup").should exist
+    expect(bundled_app("bin/rackup")).to exist
   end
-end
+end

data/spec/runtime/load_spec.rb

@@ -21,34 +21,34 @@ describe "Bundler.load" do
     end
 
     it "provides a list of the env dependencies" do
-      Bundler.load.dependencies.should have_dep("rack", ">= 0")
+      expect(Bundler.load.dependencies).to have_dep("rack", ">= 0")
     end
 
     it "provides a list of the resolved gems" do
-      Bundler.load.gems.should have_gem("rack-1.0.0", "bundler-#{Bundler::VERSION}")
+      expect(Bundler.load.gems).to have_gem("rack-1.0.0", "bundler-#{Bundler::VERSION}")
     end
 
     it "ignores blank BUNDLE_GEMFILEs" do
-      lambda {
+      expect {
         ENV['BUNDLE_GEMFILE'] = ""
         Bundler.load
-      }.should_not raise_error(Bundler::GemfileNotFound)
+      }.not_to raise_error(Bundler::GemfileNotFound)
     end
 
   end
 
   describe "without a gemfile" do
     it "raises an exception if the default gemfile is not found" do
-      lambda {
+      expect {
         Bundler.load
-      }.should raise_error(Bundler::GemfileNotFound, /could not locate gemfile/i)
+      }.to raise_error(Bundler::GemfileNotFound, /could not locate gemfile/i)
     end
 
     it "raises an exception if a specified gemfile is not found" do
-      lambda {
+      expect {
         ENV['BUNDLE_GEMFILE'] = "omg.rb"
         Bundler.load
-      }.should raise_error(Bundler::GemfileNotFound, /omg\.rb/)
+      }.to raise_error(Bundler::GemfileNotFound, /omg\.rb/)
     end
 
     it "does not find a Gemfile above the testing directory" do
@@ -58,7 +58,7 @@ describe "Bundler.load" do
         @remove_bundler_gemfile = true
       end
       begin
-        lambda { Bundler.load }.should raise_error(Bundler::GemfileNotFound)
+        expect { Bundler.load }.to raise_error(Bundler::GemfileNotFound)
       ensure
         bundler_gemfile.rmtree if @remove_bundler_gemfile
       end
@@ -86,7 +86,7 @@ describe "Bundler.load" do
         end
       RUBY
 
-      out.split("\n").should == ["1.0.0", "no activesupport"]
+      expect(out.split("\n")).to eq(["1.0.0", "no activesupport"])
     end
   end
 
@@ -98,8 +98,8 @@ describe "Bundler.load" do
       G
 
       Bundler.load.specs.each do |spec|
-        spec.to_yaml.should_not =~ /^\s+source:/
-        spec.to_yaml.should_not =~ /^\s+groups:/
+        expect(spec.to_yaml).not_to match(/^\s+source:/)
+        expect(spec.to_yaml).not_to match(/^\s+groups:/)
       end
     end
   end

data/spec/runtime/platform_spec.rb

@@ -29,7 +29,7 @@ describe "Bundler.setup with multi platform stuff" do
       end
     R
 
-    out.should == "WIN"
+    expect(out).to eq("WIN")
   end
 
   it "will resolve correctly on the current platform when the lockfile was targetted for a different one" do

data/spec/runtime/require_spec.rb

@@ -48,32 +48,32 @@ describe "Bundler.require" do
   it "requires the gems" do
     # default group
     run "Bundler.require"
-    out.should eq("two")
+    expect(out).to eq("two")
 
     # specific group
     run "Bundler.require(:bar)"
-    out.should eq("baz\nqux")
+    expect(out).to eq("baz\nqux")
 
     # default and specific group
     run "Bundler.require(:default, :bar)"
-    out.should eq("baz\nqux\ntwo")
+    expect(out).to eq("baz\nqux\ntwo")
 
     # specific group given as a string
     run "Bundler.require('bar')"
-    out.should eq("baz\nqux")
+    expect(out).to eq("baz\nqux")
 
     # specific group declared as a string
     run "Bundler.require(:string)"
-    out.should eq("six")
+    expect(out).to eq("six")
 
     # required in resolver order instead of gemfile order
     run("Bundler.require(:not)")
-    out.split("\n").sort.should == ['seven', 'three']
+    expect(out.split("\n").sort).to eq(['seven', 'three'])
   end
 
   it "allows requiring gems with non standard names explicitly" do
     run "Bundler.require ; require 'mofive'"
-    out.should == "two\nfive"
+    expect(out).to eq("two\nfive")
   end
 
   it "raises an exception if a require is specified but the file does not exist" do
@@ -86,7 +86,7 @@ describe "Bundler.require" do
       Bundler.require
     R
 
-    err.should == "ZOMG LOAD ERROR"
+    expect(err).to eq("ZOMG LOAD ERROR")
   end
 
   describe "with namespaced gems" do
@@ -104,7 +104,7 @@ describe "Bundler.require" do
       G
 
       run "Bundler.require"
-      out.should eq("jquery/rails")
+      expect(out).to eq("jquery/rails")
     end
 
     it "silently passes if the require fails" do
@@ -122,7 +122,7 @@ describe "Bundler.require" do
       RUBY
       ruby(cmd, :expect_err => true)
 
-      err.should be_empty
+      expect(err).to be_empty
     end
 
     it "does not mangle explictly given requires" do
@@ -134,7 +134,7 @@ describe "Bundler.require" do
       load_error_run <<-R, 'jquery-rails'
         Bundler.require
       R
-      err.should == "ZOMG LOAD ERROR"
+      expect(err).to eq("ZOMG LOAD ERROR")
     end
 
     it "handles the case where regex fails" do
@@ -156,20 +156,20 @@ describe "Bundler.require" do
       RUBY
       run(cmd, :expect_err => true)
 
-      err.should == "ZOMG LOAD ERROR"
+      expect(err).to eq("ZOMG LOAD ERROR")
     end
   end
 
   describe "using bundle exec" do
     it "requires the locked gems" do
       bundle "exec ruby -e 'Bundler.require'"
-      out.should eq("two")
+      expect(out).to eq("two")
 
       bundle "exec ruby -e 'Bundler.require(:bar)'"
-      out.should eq("baz\nqux")
+      expect(out).to eq("baz\nqux")
 
       bundle "exec ruby -e 'Bundler.require(:default, :bar)'"
-      out.should == "baz\nqux\ntwo"
+      expect(out).to eq("baz\nqux\ntwo")
     end
   end
 
@@ -206,7 +206,7 @@ describe "Bundler.require" do
       G
 
       run "Bundler.require"
-      out.should eq("two\nmodule_two\none")
+      expect(out).to eq("two\nmodule_two\none")
     end
 
     describe "a gem with different requires for different envs" do
@@ -224,17 +224,17 @@ describe "Bundler.require" do
 
       it "requires both with Bundler.require(both)" do
         run "Bundler.require(:one, :two)"
-        out.should == "ONE\nTWO"
+        expect(out).to eq("ONE\nTWO")
       end
 
       it "requires one with Bundler.require(:one)" do
         run "Bundler.require(:one)"
-        out.should == "ONE"
+        expect(out).to eq("ONE")
       end
 
       it "requires :two with Bundler.require(:two)" do
         run "Bundler.require(:two)"
-        out.should == "TWO"
+        expect(out).to eq("TWO")
       end
     end
 
@@ -246,7 +246,7 @@ describe "Bundler.require" do
       G
 
       run "Bundler.require"
-      out.should eq("two_not_loaded\none\ntwo")
+      expect(out).to eq("two_not_loaded\none\ntwo")
     end
 
     describe "with busted gems" do
@@ -262,7 +262,7 @@ describe "Bundler.require" do
         load_error_run <<-R, 'no_such_file_omg'
           Bundler.require
         R
-        err.should == 'ZOMG LOAD ERROR'
+        expect(err).to eq('ZOMG LOAD ERROR')
       end
     end
   end
@@ -281,7 +281,7 @@ describe "Bundler.require with platform specific dependencies" do
     G
 
     run "Bundler.require", :expect_err => true
-    err.should be_empty
+    expect(err).to be_empty
   end
 
   it "requires gems pinned to multiple platforms, including the current one" do
@@ -295,7 +295,7 @@ describe "Bundler.require with platform specific dependencies" do
 
     run "Bundler.require; puts RACK", :expect_err => true
 
-    out.should eq("1.0.0")
-    err.should be_empty
+    expect(out).to eq("1.0.0")
+    expect(err).to be_empty
   end
 end