bundler 1.7.15 → 1.8.0.pre

data/spec/bundler/friendly_errors_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-require "bundler"
-require "bundler/friendly_errors"
-
-describe Bundler, "friendly errors" do
-  it "rescues Thor::AmbiguousTaskError and raises SystemExit" do
-    expect {
-      Bundler.with_friendly_errors do
-        raise Thor::AmbiguousTaskError.new("")
-      end
-    }.to raise_error(SystemExit)
-  end
-end

data/spec/bundler/gem_helper_spec.rb

@@ -1,226 +0,0 @@
-require "spec_helper"
-require 'rake'
-require 'bundler/gem_helper'
-
-describe Bundler::GemHelper do
-  let(:app_name) { "test" }
-  let(:app_path) { bundled_app app_name }
-  let(:app_gemspec_path) { app_path.join("#{app_name}.gemspec") }
-
-  before(:each) do
-    global_config "BUNDLE_GEM__MIT" => "false", "BUNDLE_GEM__TEST" => "false", "BUNDLE_GEM__COC" => "false"
-    bundle "gem #{app_name}"
-  end
-
-  context "determining gemspec" do
-    subject { Bundler::GemHelper.new(app_path) }
-
-    context "fails" do
-      it "when there is no gemspec" do
-        FileUtils.rm app_gemspec_path
-        expect { subject }.to raise_error(/Unable to determine name/)
-      end
-
-      it "when there are two gemspecs and the name isn't specified" do
-        FileUtils.touch app_path.join("#{app_name}-2.gemspec")
-        expect { subject }.to raise_error(/Unable to determine name/)
-      end
-    end
-
-    context "interpolates the name" do
-      it "when there is only one gemspec" do
-        expect(subject.gemspec.name).to eq(app_name)
-      end
-
-      it "for a hidden gemspec" do
-        FileUtils.mv app_gemspec_path, app_path.join(".gemspec")
-        expect(subject.gemspec.name).to eq(app_name)
-      end
-    end
-
-    it "handles namespaces and converts them to CamelCase" do
-      bundle "gem #{app_name}-foo_bar"
-      app_path = bundled_app "#{app_name}-foo_bar"
-
-      lib = app_path.join("lib/#{app_name}/foo_bar.rb").read
-      expect(lib).to include("module #{app_name.capitalize}")
-      expect(lib).to include("module FooBar")
-    end
-  end
-
-  context "gem management" do
-    def mock_confirm_message(message)
-      expect(Bundler.ui).to receive(:confirm).with(message)
-    end
-
-    def mock_build_message(name, version)
-      message = "#{name} #{version} built to pkg/#{name}-#{version}.gem."
-      mock_confirm_message message
-    end
-
-    subject! { Bundler::GemHelper.new(app_path) }
-    let(:app_version) { "0.0.1" }
-    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) { File.read(app_gemspec_path) }
-
-    before(:each) do
-      content = app_gemspec_content.gsub("TODO: ", "")
-      File.open(app_gemspec_path, "w") { |file| file << content }
-    end
-
-    it "uses a shell UI for output" do
-      expect(Bundler.ui).to be_a(Bundler::UI::Shell)
-    end
-
-    describe "#install" do
-      let!(:rake_application) { Rake.application }
-
-      before(:each) do
-        Rake.application = Rake::Application.new
-      end
-
-      after(:each) do
-        Rake.application = rake_application
-      end
-
-      context "defines Rake tasks" do
-        let(:task_names) { %w[build install release] }
-
-        context "before installation" do
-          it "raises an error with appropriate message" do
-            task_names.each do |name|
-              expect { Rake.application[name] }.
-                to raise_error("Don't know how to build task '#{name}'")
-            end
-          end
-        end
-
-        context "after installation" do
-          before do
-            subject.install
-          end
-
-          it "adds Rake tasks successfully" do
-            task_names.each do |name|
-              expect { Rake.application[name] }.not_to raise_error
-              expect(Rake.application[name]).to be_instance_of Rake::Task
-            end
-          end
-
-          it "provides a way to access the gemspec object" do
-            expect(subject.gemspec.name).to eq(app_name)
-          end
-        end
-      end
-    end
-
-    describe "#build_gem" do
-      context "when build failed" do
-        it "raises an error with appropriate message" do
-          # break the gemspec by adding back the TODOs
-          File.open(app_gemspec_path, "w"){ |file| file << app_gemspec_content }
-          expect { subject.build_gem }.to raise_error(/TODO/)
-        end
-      end
-
-      context "when build was successful" do
-        it "creates .gem file" do
-          mock_build_message app_name, app_version
-          subject.build_gem
-          expect(app_gem_path).to exist
-        end
-      end
-    end
-
-    describe "#install_gem" do
-      context "when installation was successful" do
-        it "gem is installed" do
-          mock_build_message app_name, app_version
-          mock_confirm_message "#{app_name} (#{app_version}) installed."
-          subject.install_gem
-          expect(app_gem_path).to exist
-          expect(`gem list`).to include("#{app_name} (#{app_version})")
-        end
-      end
-
-      context "when installation fails" do
-        it "raises an error with appropriate message" do
-          # create empty gem file in order to simulate install failure
-          allow(subject).to receive(:build_gem) do
-            FileUtils.mkdir_p(app_gem_dir)
-            FileUtils.touch app_gem_path
-            app_gem_path
-          end
-          expect { subject.install_gem }.to raise_error(/Couldn't install gem/)
-        end
-      end
-    end
-
-    describe "#release_gem" do
-      before do
-        Dir.chdir(app_path) do
-          `git init`
-          `git config user.email "you@example.com"`
-          `git config user.name "name"`
-          `git config push.default simple`
-        end
-      end
-
-      context "fails" do
-        it "when there are unstaged files" do
-          expect { subject.release_gem }.
-            to raise_error("There are files that need to be committed first.")
-        end
-
-        it "when there are uncommitted files" do
-          Dir.chdir(app_path) { `git add .` }
-          expect { subject.release_gem }.
-            to raise_error("There are files that need to be committed first.")
-        end
-
-        it "when there is no git remote" do
-          # silence messages
-          allow(Bundler.ui).to receive(:confirm)
-          allow(Bundler.ui).to receive(:error)
-
-          Dir.chdir(app_path) { `git commit -a -m "initial commit"` }
-          expect { subject.release_gem }.to raise_error
-        end
-      end
-
-      context "succeeds" do
-        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"`
-          end
-        end
-
-        it "on releasing" do
-          mock_build_message app_name, app_version
-          mock_confirm_message "Tagged v#{app_version}."
-          mock_confirm_message "Pushed git commits and tags."
-          expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)
-
-          Dir.chdir(app_path) { sys_exec("git push -u origin master", true) }
-
-          subject.release_gem
-        end
-
-        it "even if tag already exists" do
-          mock_build_message app_name, app_version
-          mock_confirm_message "Tag v#{app_version} has already been created."
-          expect(subject).to receive(:rubygem_push).with(app_gem_path.to_s)
-
-          Dir.chdir(app_path) do
-            `git tag -a -m \"Version #{app_version}\" v#{app_version}`
-          end
-
-          subject.release_gem
-        end
-      end
-    end
-  end
-end

data/spec/bundler/psyched_yaml_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'bundler/psyched_yaml'
-
-describe Bundler::YamlSyntaxError do
-  it "is raised on YAML parse errors" do
-    expect{ YAML.parse "{foo" }.to raise_error(Bundler::YamlSyntaxError)
-  end
-end

data/spec/bundler/retry_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Bundler::Retry do
-  it "return successful result if no errors" do
-    attempts = 0
-    result = Bundler::Retry.new(nil, nil, 3).attempt do
-      attempts += 1
-      :success
-    end
-    expect(result).to eq(:success)
-    expect(attempts).to eq(1)
-  end
-
-  it "defaults to retrying twice" do
-    attempts = 0
-    expect {
-      Bundler::Retry.new(nil).attempt do
-        attempts += 1
-        raise "nope"
-      end
-    }.to raise_error("nope")
-    expect(attempts).to eq(3)
-  end
-
-  it "returns the first valid result" do
-    jobs = [Proc.new{ raise "foo" }, Proc.new{ :bar }, Proc.new{ raise "foo" }]
-    attempts = 0
-    result = Bundler::Retry.new(nil, nil, 3).attempt do
-      attempts += 1
-      jobs.shift.call
-    end
-    expect(result).to eq(:bar)
-    expect(attempts).to eq(2)
-  end
-
-  it "raises the last error" do
-    errors = [StandardError, StandardError, StandardError, Bundler::GemfileNotFound]
-    attempts = 0
-    expect {
-      Bundler::Retry.new(nil, nil, 3).attempt do
-        attempts += 1
-        raise errors.shift
-      end
-    }.to raise_error(Bundler::GemfileNotFound)
-    expect(attempts).to eq(4)
-  end
-
-  it "raises exceptions" do
-    error = Bundler::GemfileNotFound
-    attempts = 0
-    expect {
-      Bundler::Retry.new(nil, error).attempt do
-        attempts += 1
-        raise error
-      end
-    }.to raise_error(error)
-    expect(attempts).to eq(1)
-  end
-end

data/spec/bundler/settings_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require 'bundler/settings'
-
-describe Bundler::Settings do
-  describe "#set_local" do
-    context "when the local config file is not found" do
-      it "raises a GemfileNotFound error with explanation" do
-        expect{ subject.set_local("foo", "bar") }.
-          to raise_error(Bundler::GemfileNotFound, "Could not locate Gemfile")
-      end
-    end
-  end
-end

data/spec/bundler/source/rubygems_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Bundler::Source::Rubygems do
-  before do
-    allow(Bundler).to receive(:root){ Pathname.new("root") }
-  end
-
-  describe "caches" do
-    it "includes Bundler.app_cache" do
-      expect(subject.caches).to include(Bundler.app_cache)
-    end
-
-    it "includes GEM_PATH entries" do
-      Gem.path.each do |path|
-        expect(subject.caches).to include(File.expand_path("#{path}/cache"))
-      end
-    end
-
-    it "is an array of strings or pathnames" do
-      subject.caches.each do |cache|
-        expect([String, Pathname]).to include(cache.class)
-      end
-    end
-  end
-end

data/spec/bundler/source_list_spec.rb

@@ -1,361 +0,0 @@
-require 'spec_helper'
-
-describe Bundler::SourceList do
-  before do
-    allow(Bundler).to receive(:root) { Pathname.new '/' }
-  end
-
-  subject(:source_list) { Bundler::SourceList.new }
-
-  let(:rubygems_aggregate) { Bundler::Source::Rubygems.new }
-
-  describe "adding sources" do
-    before do
-      source_list.add_path_source('path' => '/existing/path/to/gem')
-      source_list.add_git_source('uri' => 'git://existing-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://existing-rubygems.org'])
-    end
-
-    describe "#add_path_source" do
-      before do
-        @duplicate = source_list.add_path_source('path' => '/path/to/gem')
-        @new_source = source_list.add_path_source('path' => '/path/to/gem')
-      end
-
-      it "returns the new path source" do
-        expect(@new_source).to be_instance_of(Bundler::Source::Path)
-      end
-
-      it "passes the provided options to the new source" do
-        expect(@new_source.options).to eq('path' => '/path/to/gem')
-      end
-
-      it "adds the source to the beginning of path_sources" do
-        expect(source_list.path_sources.first).to equal(@new_source)
-      end
-
-      it "removes existing duplicates" do
-        expect(source_list.path_sources).not_to include equal(@duplicate)
-      end
-    end
-
-    describe "#add_git_source" do
-      before do
-        @duplicate = source_list.add_git_source('uri' => 'git://host/path.git')
-        @new_source = source_list.add_git_source('uri' => 'git://host/path.git')
-      end
-
-      it "returns the new git source" do
-        expect(@new_source).to be_instance_of(Bundler::Source::Git)
-      end
-
-      it "passes the provided options to the new source" do
-        expect(@new_source.options).to eq('uri' => 'git://host/path.git')
-      end
-
-      it "adds the source to the beginning of git_sources" do
-        expect(source_list.git_sources.first).to equal(@new_source)
-      end
-
-      it "removes existing duplicates" do
-        expect(source_list.git_sources).not_to include equal(@duplicate)
-      end
-    end
-
-    describe "#add_rubygems_source" do
-      before do
-        @duplicate = source_list.add_rubygems_source('remotes' => ['https://rubygems.org/'])
-        @new_source = source_list.add_rubygems_source('remotes' => ['https://rubygems.org/'])
-      end
-
-      it "returns the new rubygems source" do
-        expect(@new_source).to be_instance_of(Bundler::Source::Rubygems)
-      end
-
-      it "passes the provided options to the new source" do
-        expect(@new_source.options).to eq('remotes' => ['https://rubygems.org/'])
-      end
-
-      it "adds the source to the beginning of rubygems_sources" do
-        expect(source_list.rubygems_sources.first).to equal(@new_source)
-      end
-
-      it "removes duplicates" do
-        expect(source_list.rubygems_sources).not_to include equal(@duplicate)
-      end
-    end
-
-    describe "#add_rubygems_remote" do
-      before do
-        @returned_source = source_list.add_rubygems_remote('https://rubygems.org/')
-      end
-
-      it "returns the aggregate rubygems source" do
-        expect(@returned_source).to be_instance_of(Bundler::Source::Rubygems)
-      end
-
-      it "adds the provided remote to the beginning of the aggregate source" do
-        source_list.add_rubygems_remote('https://othersource.org')
-        expect(@returned_source.remotes.first).to eq(URI('https://othersource.org/'))
-      end
-    end
-  end
-
-  describe "#all_sources" do
-    it "includes the aggregate rubygems source when rubygems sources have been added" do
-      source_list.add_git_source('uri' => 'git://host/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://rubygems.org'])
-      source_list.add_path_source('path' => '/path/to/gem')
-
-      expect(source_list.all_sources).to include rubygems_aggregate
-    end
-
-    it "includes the aggregate rubygems source when no rubygems sources have been added" do
-      source_list.add_git_source('uri' => 'git://host/path.git')
-      source_list.add_path_source('path' => '/path/to/gem')
-
-      expect(source_list.all_sources).to include rubygems_aggregate
-    end
-
-    it "returns path sources before git sources before rubygems sources before the aggregate" do
-      source_list.add_git_source('uri' => 'git://host/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://rubygems.org'])
-      source_list.add_path_source('path' => '/path/to/gem')
-
-      expect(source_list.all_sources).to eq [
-        Bundler::Source::Path.new('path' => '/path/to/gem'),
-        Bundler::Source::Git.new('uri' => 'git://host/path.git'),
-        Bundler::Source::Rubygems.new('remotes' => ['https://rubygems.org']),
-        rubygems_aggregate,
-      ]
-    end
-
-    it "returns sources of the same type in the reverse order that they were added" do
-      source_list.add_git_source('uri' => 'git://third-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://fifth-rubygems.org'])
-      source_list.add_path_source('path' => '/third/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://fourth-rubygems.org'])
-      source_list.add_path_source('path' => '/second/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://third-rubygems.org'])
-      source_list.add_git_source('uri' => 'git://second-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://second-rubygems.org'])
-      source_list.add_path_source('path' => '/first/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://first-rubygems.org'])
-      source_list.add_git_source('uri' => 'git://first-git.org/path.git')
-
-      expect(source_list.all_sources).to eq [
-        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'),
-        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'),
-        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::Rubygems.new('remotes' => ['https://fourth-rubygems.org']),
-        Bundler::Source::Rubygems.new('remotes' => ['https://fifth-rubygems.org']),
-        rubygems_aggregate,
-      ]
-    end
-  end
-
-  describe "#path_sources" do
-    it "returns an empty array when no path sources have been added" do
-      source_list.add_rubygems_remote('https://rubygems.org')
-      source_list.add_git_source('uri' => 'git://host/path.git')
-      expect(source_list.path_sources).to be_empty
-    end
-
-    it "returns path sources in the reverse order that they were added" do
-      source_list.add_git_source('uri' => 'git://third-git.org/path.git')
-      source_list.add_rubygems_remote('https://fifth-rubygems.org')
-      source_list.add_path_source('path' => '/third/path/to/gem')
-      source_list.add_rubygems_remote('https://fourth-rubygems.org')
-      source_list.add_path_source('path' => '/second/path/to/gem')
-      source_list.add_rubygems_remote('https://third-rubygems.org')
-      source_list.add_git_source('uri' => 'git://second-git.org/path.git')
-      source_list.add_rubygems_remote('https://second-rubygems.org')
-      source_list.add_path_source('path' => '/first/path/to/gem')
-      source_list.add_rubygems_remote('https://first-rubygems.org')
-      source_list.add_git_source('uri' => 'git://first-git.org/path.git')
-
-      expect(source_list.path_sources).to eq [
-        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'),
-      ]
-    end
-  end
-
-  describe "#git_sources" do
-    it "returns an empty array when no git sources have been added" do
-      source_list.add_rubygems_remote('https://rubygems.org')
-      source_list.add_path_source('path' => '/path/to/gem')
-
-      expect(source_list.git_sources).to be_empty
-    end
-
-    it "returns git sources in the reverse order that they were added" do
-      source_list.add_git_source('uri' => 'git://third-git.org/path.git')
-      source_list.add_rubygems_remote('https://fifth-rubygems.org')
-      source_list.add_path_source('path' => '/third/path/to/gem')
-      source_list.add_rubygems_remote('https://fourth-rubygems.org')
-      source_list.add_path_source('path' => '/second/path/to/gem')
-      source_list.add_rubygems_remote('https://third-rubygems.org')
-      source_list.add_git_source('uri' => 'git://second-git.org/path.git')
-      source_list.add_rubygems_remote('https://second-rubygems.org')
-      source_list.add_path_source('path' => '/first/path/to/gem')
-      source_list.add_rubygems_remote('https://first-rubygems.org')
-      source_list.add_git_source('uri' => 'git://first-git.org/path.git')
-
-      expect(source_list.git_sources).to eq [
-        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'),
-      ]
-    end
-  end
-
-  describe "#rubygems_sources" do
-    it "includes the aggregate rubygems source when rubygems sources have been added" do
-      source_list.add_git_source('uri' => 'git://host/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://rubygems.org'])
-      source_list.add_path_source('path' => '/path/to/gem')
-
-      expect(source_list.rubygems_sources).to include rubygems_aggregate
-    end
-
-    it "returns only the aggregate rubygems source when no rubygems sources have been added" do
-      source_list.add_git_source('uri' => 'git://host/path.git')
-      source_list.add_path_source('path' => '/path/to/gem')
-
-      expect(source_list.rubygems_sources).to eq [rubygems_aggregate]
-    end
-
-    it "returns rubygems sources in the reverse order that they were added" do
-      source_list.add_git_source('uri' => 'git://third-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://fifth-rubygems.org'])
-      source_list.add_path_source('path' => '/third/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://fourth-rubygems.org'])
-      source_list.add_path_source('path' => '/second/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://third-rubygems.org'])
-      source_list.add_git_source('uri' => 'git://second-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://second-rubygems.org'])
-      source_list.add_path_source('path' => '/first/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://first-rubygems.org'])
-      source_list.add_git_source('uri' => 'git://first-git.org/path.git')
-
-      expect(source_list.rubygems_sources).to eq [
-        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::Rubygems.new('remotes' => ['https://fourth-rubygems.org']),
-        Bundler::Source::Rubygems.new('remotes' => ['https://fifth-rubygems.org']),
-        rubygems_aggregate,
-      ]
-    end
-  end
-
-  describe "#get" do
-    context "when it includes an equal source" do
-      let(:rubygems_source) { Bundler::Source::Rubygems.new('remotes' => ['https://rubygems.org']) }
-      before { @equal_source = source_list.add_rubygems_remote('https://rubygems.org') }
-
-      it "returns the equal source" do
-        expect(source_list.get(rubygems_source)).to be @equal_source
-      end
-    end
-
-    context "when it does not include an equal source" do
-      let(:path_source) { Bundler::Source::Path.new('path' => '/path/to/gem') }
-
-      it "returns nil" do
-        expect(source_list.get(path_source)).to be_nil
-      end
-    end
-  end
-
-  describe "#lock_sources" do
-    it "combines the rubygems sources into a single instance, removing duplicate remotes from the end" do
-      source_list.add_git_source('uri' => 'git://third-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://duplicate-rubygems.org'])
-      source_list.add_path_source('path' => '/third/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://third-rubygems.org'])
-      source_list.add_path_source('path' => '/second/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://second-rubygems.org'])
-      source_list.add_git_source('uri' => 'git://second-git.org/path.git')
-      source_list.add_rubygems_source('remotes' => ['https://first-rubygems.org'])
-      source_list.add_path_source('path' => '/first/path/to/gem')
-      source_list.add_rubygems_source('remotes' => ['https://duplicate-rubygems.org'])
-      source_list.add_git_source('uri' => 'git://first-git.org/path.git')
-
-      expect(source_list.lock_sources).to eq [
-        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'),
-        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'),
-        Bundler::Source::Rubygems.new('remotes' => [
-          'https://duplicate-rubygems.org',
-          'https://first-rubygems.org',
-          'https://second-rubygems.org',
-          'https://third-rubygems.org',
-        ]),
-      ]
-    end
-  end
-
-  describe "replace_sources!" do
-    let(:existing_locked_source) { Bundler::Source::Path.new('path' => '/existing/path') }
-    let(:removed_locked_source)  { Bundler::Source::Path.new('path' => '/removed/path') }
-
-    let(:locked_sources) { [existing_locked_source, removed_locked_source] }
-
-    before do
-      @existing_source = source_list.add_path_source('path' => '/existing/path')
-      @new_source = source_list.add_path_source('path' => '/new/path')
-      source_list.replace_sources!(locked_sources)
-    end
-
-    it "maintains the order and number of sources" do
-      expect(source_list.path_sources).to eq [@new_source, @existing_source]
-    end
-
-    it "retains the same instance of the new source" do
-      expect(source_list.path_sources[0]).to be @new_source
-    end
-
-    it "replaces the instance of the existing source" do
-      expect(source_list.path_sources[1]).to be existing_locked_source
-    end
-  end
-
-  describe "#cached!" do
-    let(:rubygems_source) { source_list.add_rubygems_remote('https://rubygems.org') }
-    let(:git_source)      { source_list.add_git_source('uri' => 'git://host/path.git') }
-    let(:path_source)     { source_list.add_path_source('path' => '/path/to/gem') }
-
-    it "calls #cached! on all the sources" do
-      expect(rubygems_source).to receive(:cached!)
-      expect(git_source).to receive(:cached!)
-      expect(path_source).to receive(:cached!)
-      source_list.cached!
-    end
-  end
-
-  describe "#remote!" do
-    let(:rubygems_source) { source_list.add_rubygems_remote('https://rubygems.org') }
-    let(:git_source)      { source_list.add_git_source('uri' => 'git://host/path.git') }
-    let(:path_source)     { source_list.add_path_source('path' => '/path/to/gem') }
-
-    it "calls #remote! on all the sources" do
-      expect(rubygems_source).to receive(:remote!)
-      expect(git_source).to receive(:remote!)
-      expect(path_source).to receive(:remote!)
-      source_list.remote!
-    end
-  end
-
-end