berkshelf 2.0.18 → 3.0.0.beta1

data/spec/unit/berkshelf/locations/git_location_spec.rb

@@ -1,25 +1,27 @@
 require 'spec_helper'
 
 describe Berkshelf::GitLocation do
-  let(:complacent_constraint) { double('comp-vconstraint', satisfies?: true) }
+  let(:constraint) { double('comp-vconstraint', satisfies?: true) }
+  let(:dependency) { double('dep', name: "berkshelf-cookbook-fixture", version_constraint: constraint) }
 
-  describe '.initialize' do
-    it 'raises InvalidGitURI if given an invalid Git URI for options[:git]' do
-      expect {
-        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture', complacent_constraint, git: '/something/on/disk')
-      }.to raise_error(Berkshelf::InvalidGitURI)
+  describe "ClassMethods" do
+    describe "::new" do
+      it 'raises InvalidGitURI if given an invalid Git URI for options[:git]' do
+        expect {
+          described_class.new(dependency, git: '/something/on/disk')
+        }.to raise_error(Berkshelf::InvalidGitURI)
+      end
     end
-  end
 
-  describe '.tmpdir' do
-    it 'creates a temporary directory within the Berkshelf temporary directory' do
-      expect(Berkshelf::GitLocation.tmpdir).to include(Berkshelf.tmp_dir)
+    describe "::tmpdir" do
+      it 'creates a temporary directory within the Berkshelf temporary directory' do
+        expect(described_class.tmpdir).to include(Berkshelf.tmp_dir)
+      end
     end
   end
 
-
-
-  subject { Berkshelf::GitLocation.new('berkshelf-cookbook-fixture', complacent_constraint, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
+  let(:storage_path) { Berkshelf::CookbookStore.instance.storage_path }
+  subject { described_class.new(dependency, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
 
   describe '#download' do
     context 'when a local revision is present' do
@@ -27,25 +29,25 @@ describe Berkshelf::GitLocation do
 
       before do
         Berkshelf::Git.stub(:rev_parse).and_return('abcd1234')
-        Berkshelf::GitLocation.any_instance.stub(:cached?).and_return(true)
-        Berkshelf::GitLocation.any_instance.stub(:validate_cached).with(cached).and_return(cached)
+        described_class.any_instance.stub(:cached?).and_return(true)
+        described_class.any_instance.stub(:validate_cached).with(cached).and_return(cached)
         Berkshelf::CachedCookbook.stub(:from_store_path).with(any_args()).and_return(cached)
       end
 
       it 'returns the cached cookbook' do
-        expect(subject.download(tmp_path)).to eq(cached)
+        expect(subject.download).to eq(cached)
       end
     end
 
     it 'returns an instance of Berkshelf::CachedCookbook' do
-      expect(subject.download(tmp_path)).to be_a(Berkshelf::CachedCookbook)
+      expect(subject.download).to be_a(Berkshelf::CachedCookbook)
     end
 
     it 'downloads the cookbook to the given destination' do
-      cached_cookbook = subject.download(tmp_path)
+      cached_cookbook = subject.download
       ref = subject.ref
 
-      expect(tmp_path).to have_structure {
+      expect(storage_path).to have_structure {
         directory "#{cached_cookbook.cookbook_name}-#{ref}" do
           file 'metadata.rb'
         end
@@ -53,28 +55,28 @@ describe Berkshelf::GitLocation do
     end
 
     context 'given no ref/branch/tag options is given' do
-      subject { Berkshelf::GitLocation.new('berkshelf-cookbook-fixture', complacent_constraint, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
+      subject { described_class.new(dependency, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
 
       it 'sets the branch attribute to the HEAD revision of the cloned repo' do
-        subject.download(tmp_path)
+        subject.download
         expect(subject.branch).to_not be_nil
       end
     end
 
     context 'given a git repo that does not exist' do
-      subject { Berkshelf::GitLocation.new('doesnot_exist', complacent_constraint, git: 'git://github.com/RiotGames/thisrepo_does_not_exist.git') }
+      before { dependency.stub(name: "doesnot_exist") }
+      subject { described_class.new(dependency, git: 'git://github.com/RiotGames/thisrepo_does_not_exist.git') }
 
       it 'raises a GitError' do
         Berkshelf::Git.stub(:git).and_raise(Berkshelf::GitError.new(''))
-        expect {
-          subject.download(tmp_path)
-        }.to raise_error(Berkshelf::GitError)
+        expect { subject.download }.to raise_error(Berkshelf::GitError)
       end
     end
 
     context 'given a git repo that does not contain a cookbook' do
-      let(:fake_remote) { local_git_origin_path_for('not_a_cookbook') }
-      subject { Berkshelf::GitLocation.new('doesnot_exist', complacent_constraint, git: "file://#{fake_remote}.git") }
+      let(:fake_remote) { remote_path('not_a_cookbook') }
+      before { dependency.stub(name: "doesnot_exist") }
+      subject { described_class.new(dependency, git: "file://#{fake_remote}.git") }
 
       it 'raises a CookbookNotFound error' do
         subject.stub(:clone).and_return {
@@ -82,24 +84,16 @@ describe Berkshelf::GitLocation do
           Dir.chdir(fake_remote) { |dir| `git init; echo hi > README; git add README; git commit README -m 'README'`; dir }
         }
 
-        expect {
-          subject.download(tmp_path)
-        }.to raise_error(Berkshelf::CookbookNotFound)
+        expect { subject.download }.to raise_error(Berkshelf::CookbookNotFound)
       end
     end
 
     context 'given the content at the Git repo does not satisfy the version constraint' do
-      subject do
-        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture',
-          double('constraint', satisfies?: false),
-          git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git'
-        )
-      end
+      before { constraint.stub(satisfies?: false) }
+      subject { described_class.new(dependency, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git') }
 
       it 'raises a CookbookValidationFailure error' do
-        expect {
-          subject.download(tmp_path)
-        }.to raise_error(Berkshelf::CookbookValidationFailure)
+        expect { subject.download }.to raise_error(Berkshelf::CookbookValidationFailure)
       end
     end
 
@@ -107,15 +101,12 @@ describe Berkshelf::GitLocation do
       let(:tag) { '1.0.0' }
 
       subject do
-        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture',
-          complacent_constraint,
-          git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git',
-          tag: tag
-        )
+        described_class.new(dependency, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git', tag: tag)
       end
-      let(:cached) { subject.download(tmp_path) }
+
+      let(:cached) { subject.download }
       let(:sha) { subject.ref }
-      let(:expected_path) { tmp_path.join("#{cached.cookbook_name}-#{sha}") }
+      let(:expected_path) { storage_path.join("#{cached.cookbook_name}-#{sha}") }
 
       it 'returns a cached cookbook with a path that contains the ref' do
         expect(cached.path).to eq(expected_path)
@@ -126,15 +117,12 @@ describe Berkshelf::GitLocation do
       let(:branch) { 'master' }
 
       subject do
-        Berkshelf::GitLocation.new('berkshelf-cookbook-fixture',
-          complacent_constraint,
-          git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git',
-          branch: branch
-        )
+        described_class.new(dependency, git: 'git://github.com/RiotGames/berkshelf-cookbook-fixture.git',
+          branch: branch)
       end
-      let(:cached) { subject.download(tmp_path) }
+      let(:cached) { subject.download }
       let(:sha) { subject.ref }
-      let(:expected_path) { tmp_path.join("#{cached.cookbook_name}-#{sha}") }
+      let(:expected_path) { storage_path.join("#{cached.cookbook_name}-#{sha}") }
 
       it 'returns a cached cookbook with a path that contains the ref' do
         expect(cached.path).to eq(expected_path)

data/spec/unit/berkshelf/locations/path_location_spec.rb

@@ -1,35 +1,25 @@
 require 'spec_helper'
 
 describe Berkshelf::PathLocation do
-  let(:complacent_constraint) { double('comp-vconstraint', satisfies?: true) }
+  let(:constraint) { double('comp-vconstraint', satisfies?: true) }
+  let(:dependency) { double('dep', name: "nginx", version_constraint: constraint) }
   let(:path) { fixtures_path.join('cookbooks', 'example_cookbook').to_s }
 
-  describe '.new' do
-    it 'assigns the value of :path to @path' do
-      location = Berkshelf::PathLocation.new('nginx', complacent_constraint, path: path)
-      expect(location.path).to eq(path)
-    end
-  end
-
-
-
-  subject { Berkshelf::PathLocation.new('nginx', complacent_constraint, path: path) }
-
-  describe '#to_s' do
-    context 'for a remote path' do
-      subject { Berkshelf::PathLocation.new('nginx', complacent_constraint, path: path) }
-
-      it 'includes the path information' do
-        expect(subject.to_s).to match(/path\:.+example_cookbook/)
+  describe "ClassMethods" do
+    describe "::new" do
+      it 'assigns the value of :path to #path' do
+        location = described_class.new(dependency, path: path)
+        expect(location.path).to eq(path)
       end
     end
+  end
 
-    context 'for a store path' do
-      subject { Berkshelf::PathLocation.new('nginx', complacent_constraint, path: File.join(Berkshelf.berkshelf_path, 'cookbooks/example_cookbook')) }
+  let(:options) { { path: path } }
+  let(:instance) { described_class.new(dependency, options) }
 
-      it 'does not include the path information' do
-        expect(subject.to_s).to_not match(/path\:.+/)
-      end
+  describe "#download" do
+    it "returns a CachedCookbook" do
+      expect(instance.download).to be_a(Berkshelf::CachedCookbook)
     end
   end
 end

data/spec/unit/berkshelf/lockfile_spec.rb

@@ -15,19 +15,17 @@ describe Berkshelf::Lockfile do
       }.to_not raise_error
     end
 
-    it 'has the correct sources' do
-      expect(subject).to have_source 'build-essential'
-      expect(subject).to have_source 'chef-client'
+    it 'has the correct dependencies' do
+      expect(subject).to have_dependency 'build-essential'
+      expect(subject).to have_dependency 'chef-client'
     end
   end
 
-
-
   subject { Berkshelf::Lockfile.new(berksfile) }
 
-  describe '#sources' do
+  describe '#dependencies' do
     it 'returns an array' do
-      expect(subject.sources).to be_a(Array)
+      expect(subject.dependencies).to be_a(Array)
     end
   end
 
@@ -41,26 +39,26 @@ describe Berkshelf::Lockfile do
     end
   end
 
-  describe '#has_source?' do
+  describe '#has_dependency?' do
     it 'returns true if a matching cookbook is found' do
-      expect(subject.has_source?('build-essential')).to be_true
+      expect(subject.has_dependency?('build-essential')).to be_true
     end
 
     it 'returns false if no matching cookbook is found' do
-      expect(subject.has_source?('foo')).to be_false
+      expect(subject.has_dependency?('foo')).to be_false
     end
   end
 
   describe '#update' do
-    it 'resets the sources' do
-      subject.should_receive(:reset_sources!).once
+    it 'resets the dependencies' do
+      subject.should_receive(:reset_dependencies!).once
       subject.update([])
     end
 
-    it 'appends each of the sources' do
-      source = double('source')
-      subject.should_receive(:append).with(source).once
-      subject.update([source])
+    it 'appends each of the dependencies' do
+      dependency = double('dependency')
+      subject.should_receive(:append).with(dependency).once
+      subject.update([dependency])
     end
 
     it 'saves the file' do
@@ -70,32 +68,32 @@ describe Berkshelf::Lockfile do
   end
 
   describe '#add' do
-    let(:source) { double('source', name: 'build-essential') }
+    let(:dependency) { double('dependency', name: 'build-essential') }
 
-    it 'adds the new source to the @sources instance variable' do
-      subject.add(source)
-      expect(subject).to have_source(source)
+    it 'adds the new dependency to the @dependencies instance variable' do
+      subject.add(dependency)
+      expect(subject).to have_dependency(dependency)
     end
 
-    it 'does not add duplicate sources' do
-      5.times { subject.add(source) }
-      expect(subject).to have_source(source)
+    it 'does not add duplicate dependencies' do
+      5.times { subject.add(dependency) }
+      expect(subject).to have_dependency(dependency)
     end
   end
 
   describe '#remove' do
-    let(:source) { double('source', name: 'build-essential') }
+    let(:dependency) { double('dependency', name: 'build-essential') }
 
     before do
-      subject.add(source)
+      subject.add(dependency)
     end
 
-    it 'removes the source' do
-      subject.remove(source)
-      expect(subject).to_not have_source(source)
+    it 'removes the dependency' do
+      subject.remove(dependency)
+      expect(subject).to_not have_dependency(dependency)
     end
 
-    it 'raises an except if the source does not exist' do
+    it 'raises an except if the dependency does not exist' do
       expect {
         subject.remove(nil)
       }.to raise_error Berkshelf::CookbookNotFound
@@ -110,15 +108,15 @@ describe Berkshelf::Lockfile do
 
   describe '#inspect' do
     it 'returns a pretty-formatted, detailed string' do
-      expect(subject.inspect).to eq '#<Berkshelf::Lockfile Berksfile.lock, sources: [#<Berkshelf::CookbookSource: build-essential (>= 0.0.0), locked_version: 1.1.2, groups: [:default], location: default>, #<Berkshelf::CookbookSource: chef-client (>= 0.0.0), locked_version: 2.1.4, groups: [:default], location: default>]>'
+      expect(subject.inspect).to eq("#<#{described_class} Berksfile.lock, dependencies: [#<Berkshelf::Dependency: build-essential (>= 0.0.0), locked_version: 1.1.2, groups: [:default], location: default>, #<Berkshelf::Dependency: chef-client (>= 0.0.0), locked_version: 2.1.4, groups: [:default], location: default>]>")
     end
   end
 
   describe '#to_hash' do
     let(:hash) { subject.to_hash }
 
-    it 'has the `:sources` key' do
-      expect(hash).to have_key(:sources)
+    it 'has the `:dependencies` key' do
+      expect(hash).to have_key(:dependencies)
     end
   end
 
@@ -144,22 +142,22 @@ describe Berkshelf::Lockfile do
     end
   end
 
-  describe '#reset_sources!' do
-    before { Berkshelf::Lockfile.send(:public, :reset_sources!) }
+  describe '#reset_dependencies!' do
+    before { Berkshelf::Lockfile.send(:public, :reset_dependencies!) }
 
-    it 'sets the sources to an empty hash' do
+    it 'sets the dependencies to an empty hash' do
       expect {
-        subject.reset_sources!
-      }.to change { subject.sources }.to([])
+        subject.reset_dependencies!
+      }.to change { subject.dependencies }.to([])
     end
   end
 
   describe '#cookbook_name' do
     before { Berkshelf::Lockfile.send(:public, :cookbook_name) }
 
-    it 'accepts a cookbook source' do
-      source = double('source', name: 'build-essential', is_a?: true)
-      expect(subject.cookbook_name(source)).to eq 'build-essential'
+    it 'accepts a cookbook dependency' do
+      dependency = double('dependency', name: 'build-essential', is_a?: true)
+      expect(subject.cookbook_name(dependency)).to eq 'build-essential'
     end
 
     it 'accepts a string' do

data/spec/unit/berkshelf/resolver/graph_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Berkshelf::Resolver::Graph do
+  subject { described_class.new }
+
+  describe "#populate" do
+    let(:sources) { Berkshelf::Source.new("http://localhost:26210") }
+
+    before do
+      berks_dependency("ruby", "1.0.0", dependencies: { "elixir" => ">= 0.1.0" })
+      berks_dependency("ruby", "2.0.0")
+      berks_dependency("elixir", "1.0.0")
+    end
+
+    it "adds each dependency to the graph" do
+      subject.populate(sources)
+      expect(subject.artifacts).to have(3).items
+    end
+
+    it "adds the dependencies of each dependency to the graph" do
+      subject.populate(sources)
+      expect(subject.artifacts("ruby", "1.0.0").dependencies).to have(1).item
+    end
+  end
+
+  describe "#universe" do
+    let(:sources) { Berkshelf::Source.new("http://localhost:26210") }
+
+    before do
+      berks_dependency("ruby", "1.0.0")
+      berks_dependency("elixir", "1.0.0")
+    end
+
+    it "returns an array of APIClient::RemoteCookbook" do
+      result = subject.universe(sources)
+      expect(result).to be_a(Array)
+      result.each { |remote| expect(remote).to be_a(Berkshelf::APIClient::RemoteCookbook) }
+    end
+
+    it "contains the entire universe of dependencies" do
+      expect(subject.universe(sources)).to have(2).items
+    end
+  end
+end

data/spec/unit/berkshelf/resolver_spec.rb

@@ -1,111 +1,62 @@
 require 'spec_helper'
 
-describe Berkshelf::Resolver, :chef_server, vcr: {record: :new_episodes, serialize_with: :yaml} do
-  let(:downloader) { Berkshelf::Downloader.new(Berkshelf.cookbook_store) }
-  let(:berksfile) { double(downloader: downloader) }
-  let(:source) do
-    double('source',
-      name: 'mysql',
-      version_constraint: Solve::Constraint.new('= 1.2.4'),
-      :version_constraint= => nil,
-      locked_version: '1.2.4',
-      downloaded?: true,
-      cached_cookbook: double('mysql-cookbook',
-        name: 'mysql-1.2.4',
-        cookbook_name: 'mysql',
-        version: '1.2.4',
-        dependencies: {"nginx" => ">= 0.1.0"}
-      ),
-      location: double('location', validate_cached: true)
-    )
-  end
-
-  describe '.initialize' do
-    it 'adds the specified sources to the sources hash' do
-      resolver = Berkshelf::Resolver.new(berksfile, sources: [source], skip_dependencies: true)
-      expect(resolver).to have_source(source.name)
-    end
-
-    it 'does not add dependencies if skipped' do
-      resolver = Berkshelf::Resolver.new(berksfile, sources: [source], skip_dependencies: true)
-      expect(resolver).to_not have_source('nginx')
-    end
-
-    it 'adds the dependencies of the source as sources' do
-      resolver = Berkshelf::Resolver.new(berksfile, sources: [source])
-      expect(resolver).to have_source('nginx')
-    end
-
-    context 'location is not set' do
-      before(:each) do
-        source.stub(:location) { nil }
-      end
-
-      it 'does not raise' do
-        expect { Berkshelf::Resolver.new(berksfile, sources: [source], skip_dependencies: true) }.to_not raise_error
+describe Berkshelf::Resolver do
+  let(:berksfile) { double('berksfile') }
+  let(:demand) { Berkshelf::Dependency.new(berksfile, "mysql", constraint: "= 1.2.4") }
+
+  describe "ClassMethods" do
+    describe "::initialize" do
+      it 'adds the specified dependencies to the dependencies hash' do
+        resolver = described_class.new(berksfile, demand)
+        expect(resolver).to have_demand(demand)
       end
     end
   end
 
-
   subject { Berkshelf::Resolver.new(berksfile) }
 
-  describe '#add_source' do
-    let(:package_version) { double('package-version', dependencies: Array.new) }
-
-    it 'adds the source to the instance of resolver' do
-      subject.add_source(source, false)
-      expect(subject.sources).to include(source)
-    end
-
-    it 'adds an artifact of the same name of the source to the graph' do
-      subject.graph.should_receive(:artifacts).with(source.name, source.cached_cookbook.version)
-
-      subject.add_source(source, false)
+  describe "#add_demand" do
+    it 'adds the demand to the instance of resolver' do
+      subject.add_demand(demand)
+      expect(subject.demands).to include(demand)
     end
 
-    it 'adds the dependencies of the source as packages to the graph' do
-      subject.should_receive(:add_source_dependencies).with(source)
-
-      subject.add_source(source)
-    end
-
-    it 'raises a DuplicateSourceDefined exception if a source of the same name is added' do
-      subject.should_receive(:has_source?).with(source).and_return(true)
+    it 'raises a DuplicateDemand exception if a demand of the same name is added' do
+      subject.should_receive(:has_demand?).with(demand).and_return(true)
 
       expect {
-        subject.add_source(source)
-      }.to raise_error(Berkshelf::DuplicateSourceDefined)
+        subject.add_demand(demand)
+      }.to raise_error(Berkshelf::DuplicateDemand)
     end
+  end
 
-    context 'when include_dependencies is false' do
-      it 'does not try to include_dependencies' do
-        subject.should_not_receive(:add_source_dependencies)
-
-        subject.add_source(source, false)
-      end
+  describe "#demands" do
+    it "returns an Array" do
+      expect(subject.demands).to be_a(Array)
     end
   end
 
-  describe '#get_source' do
-    before { subject.add_source(source, false) }
+  describe "#get_demand" do
+    before { subject.add_demand(demand) }
 
-    context 'given a string representation of the source to retrieve' do
-      it 'returns the source of the same name' do
-        expect(subject.get_source(source.name)).to eq(source)
+    context 'given a string representation of the demand to retrieve' do
+      it 'returns a Berkshelf::Dependency of the same name' do
+        expect(subject.get_demand(demand.name)).to eq(demand)
       end
     end
   end
 
-  describe '#has_source?' do
-    before { subject.add_source(source, false) }
+  describe '#has_demand?' do
+    before { subject.add_demand(demand) }
 
-    it 'returns true if the source exists' do
-      expect(subject.has_source?(source.name)).to be_true
+    it 'returns true if the demand exists' do
+      expect(subject.has_demand?(demand.name)).to be_true
     end
 
-    it 'returns false if the source does not exist' do
-      expect(subject.has_source?('non-existent')).to be_false
+    it 'returns false if the demand does not exist' do
+      expect(subject.has_demand?('non-existent')).to be_false
     end
   end
+
+  describe "#resolve"
 end