berkshelf 0.3.3 → 0.3.7

data/lib/berkshelf/resolver.rb

@@ -4,8 +4,11 @@ module Berkshelf
     extend Forwardable
     include DepSelector
 
-    def_delegators :@graph, :package, :packages
+    def_delegator :@graph, :package
+    def_delegator :@graph, :packages
 
+    # @param [Downloader] downloader
+    # @param [Array<CookbookSource>, CookbookSource] sources
     def initialize(downloader, sources = Array.new)
       @downloader = downloader
       @graph = DependencyGraph.new
@@ -18,58 +21,55 @@ module Berkshelf
       Array(sources).each do |source|
         add_source(source, false)
       end
-      add_sources_dependencies
+
+      Array(sources).each do |source|
+        add_source_dependencies(source)
+      end
     end
 
+    # Add the given source to the collection of sources for this instance
+    # of Resolver. By default the dependencies of the given source will also
+    # be added as sources to the collection.
+    #
     # @param [Berkshelf::CookbookSource] source
     #   source to add
     # @param [Boolean] include_dependencies
-    #   if true, after adding the source the dependencies defined in the
-    #   sources metadata will be added to the graph and downloaded
+    #   adds the dependencies of the given source as sources to the collection of
+    #   if true. Dependencies will be ignored if false.
     #
-    # @return [DepSelector::PackageVersion]
+    # @return [Array<CookbookSource>]
     def add_source(source, include_dependencies = true)
-      raise DuplicateSourceDefined if has_source?(source.name)
-
-      set_source(source.name, source)
+      if has_source?(source)
+        raise DuplicateSourceDefined, "A source named '#{source.name}' is already present."
+      end
 
-      install_or_use_source(source)
+      set_source(source)
+      use_source(source) || install_source(source)
 
       package = add_package(source.name)
-      package_version = add_version(package, Version.new(source.metadata.version))
+      package_version = add_version(package, Version.new(source.cached_cookbook.version))
       
-      add_dependencies(package_version, source.dependencies) if include_dependencies
+      if include_dependencies
+        add_source_dependencies(source)
+      end
 
-      package_version
+      sources
     end
 
-    # @param [DepSelector::PackageVersion] parent_pkgver
-    #   the PackageVersion you would like to add the given dependencies to. In this case
-    #   the package version is a version of a Cookbook.
-    # @param [Hash] dependencies
-    #   A hash containing Cookbook names for keys and version constraint strings for
-    #   values. This is the same format obtained by sending the 'dependencies' message
-    #   to an instance of Chef::Cookbook::Metadata.
+    # Add the dependencies of the given source as sources in the collection of sources
+    # on this instance of Resolver. Any dependencies which already have a source in the
+    # collection of sources of the same name will not be added to the collection a second
+    # time.
     #
-    #   Example:
-    #       { 
-    #         "build-essential" => ">= 0.0.0",
-    #         "ohai" => "~> 1.0.2"
-    #       }
-    def add_dependencies(parent_pkgver, dependencies)
-      dependencies.each do |name, constraint|
-        dep_package = add_package(name)
-        parent_pkgver.dependencies << Dependency.new(dep_package, VersionConstraint.new(constraint))
-
-        unless has_source?(name)
-          source = CookbookSource.new(name, constraint)
-
-          install_or_use_source(source)
-
-          dep_pkgver = add_version(dep_package, Version.new(source.metadata.version))
-          add_dependencies(dep_pkgver, source.dependencies)
-          set_source(source.name, source)
-        end
+    # @param [CookbookSource] source
+    #   source to convert dependencies into sources
+    #
+    # @return [Array<CookbookSource>]
+    def add_source_dependencies(source)
+      source.cached_cookbook.dependencies.each do |name, constraint|
+        next if has_source?(name)
+
+        add_source(CookbookSource.new(name, constraint))
       end
     end
 
@@ -88,22 +88,24 @@ module Berkshelf
 
       [].tap do |cached_cookbooks|
         solution.each do |name, version|
-          source = get_source(name)
-          cached_cookbooks << CachedCookbook.new(source.name, source.local_path, source.metadata)
+          cached_cookbooks << get_source(name).cached_cookbook
         end
       end
     end
 
-    # @param [#to_s] source
+    # @param [CookbookSource, #to_s] source
     #   name of the source to return
     #
     # @return [Berkshelf::CookbookSource]
     def [](source)
+      if source.is_a?(CookbookSource)
+        source = source.name
+      end
       @sources[source.to_s]
     end
     alias_method :get_source, :[]
 
-    # @param [#to_s] source
+    # @param [CoobookSource, #to_s] source
     #   the source to test if the resolver has added
     def has_source?(source)
       !get_source(source).nil?
@@ -114,28 +116,53 @@ module Berkshelf
       attr_reader :downloader
       attr_reader :graph
 
-      # @param [#to_s] source
-      #   name of the source to set
-      # @param [CookbookSource] value
-      #   source to set as value
-      def []=(source, value)
-        @sources[source.to_s] = value
+      # @param [CookbookSource] source
+      def set_source(source)
+        @sources[source.name] = source
       end
-      alias_method :set_source, :[]=
 
-      def install_or_use_source(source)
-        if downloader.downloaded?(source)
-          msg = "Using #{source.name} (#{source.metadata.version})"
+      # @param [Berkshelf::CookbookSource] source
+      #
+      # @return [Boolean]
+      def install_source(source)
+        downloader.download!(source)
+        Berkshelf.ui.info "Installing #{source.name} (#{source.cached_cookbook.version}) from #{source.location}"
+      end
 
-          if source.location.is_a?(CookbookSource::PathLocation)
-            msg << " at #{source.location}"  
+      # Use the given source to create a constraint solution if the source has been downloaded or can
+      # be satisfied by a cached cookbook that is already present in the cookbook store.
+      #
+      # @note Git location sources which have not yet been downloaded will not be satisfied by a
+      #   cached cookbook from the cookbook store.
+      #
+      # @param [Berkshelf::CookbookSource] source
+      #
+      # @raise [ConstraintNotSatisfied] if the CachedCookbook does not satisfy the version constraint of
+      #   this instance of Location.
+      #   contain a cookbook that satisfies the given version constraint of this instance of
+      #   CookbookSource.
+      #
+      # @return [Boolean]
+      def use_source(source)        
+        if source.downloaded?
+          cached = source.cached_cookbook
+          source.location.validate_cached(cached)
+        else
+          if source.location.is_a?(CookbookSource::GitLocation)
+            return false
           end
 
-          Berkshelf.ui.info msg
-        else
-          downloader.download!(source)
-          Berkshelf.ui.info "Installing #{source.name} (#{source.local_version}) from #{source.location}"
+          cached = downloader.cookbook_store.satisfy(source.name, source.version_constraint)
+          return false if cached.nil?
+
+          get_source(source).cached_cookbook = cached
         end
+
+        msg = "Using #{cached.cookbook_name} (#{cached.version})"
+        msg << " at #{source.location}" if source.location.is_a?(CookbookSource::PathLocation)
+        Berkshelf.ui.info msg
+
+        true
       end
 
       def selector
@@ -148,14 +175,6 @@ module Berkshelf
         end
       end
 
-      # Add the dependencies of each source to the graph
-      def add_sources_dependencies
-        sources.each do |source|
-          package_version = package(source.name)[Version.new(source.metadata.version)]
-          add_dependencies(package_version, source.dependencies)
-        end
-      end
-
       # @param [String] name
       #   name of the package to add to the graph
       def add_package(name)

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "0.3.3"
+  VERSION = "0.3.7"
 end

data/spec/fixtures/cookbooks/example_cookbook-0.5.0/metadata.rb

@@ -1,3 +1,4 @@
+name             "example_cookbook"
 maintainer       "Josiah Kiehl"
 maintainer_email "josiah@skirmisher.net"
 license          "DO WHAT YOU WANT CAUSE A PIRATE IS FREE"

data/spec/fixtures/cookbooks/example_metadata_name/metadata.rb

@@ -0,0 +1,2 @@
+name      "has_metadata"
+version   "1.0.0"

data/spec/fixtures/cookbooks/example_metadata_no_name/metadata.rb

@@ -0,0 +1 @@
+version   "1.0.0"

data/spec/fixtures/cookbooks/example_no_metadata/recipes/default.rb

@@ -0,0 +1 @@
+puts "example"

data/spec/support/chef_api.rb

@@ -1,3 +1,4 @@
+require 'pathname'
 require 'chef/rest'
 require 'chef/cookbook_version'
 
@@ -17,6 +18,47 @@ module Berkshelf
         false
       end
 
+      def generate_cookbook(path, name, version, options = {})
+        path = Pathname.new(path)
+        cookbook_path = path.join("#{name}-#{version}")
+        directories = [
+          "recipes",
+          "templates/default",
+          "files/default",
+          "attributes",
+          "definitions",
+          "providers",
+          "resources"
+        ]
+        files = [
+          "recipes/default.rb",
+          "templates/default/template.erb",
+          "files/default/file.h",
+          "attributes/default.rb"
+        ]
+
+        directories.each do |directory|
+          FileUtils.mkdir_p(cookbook_path.join(directory))
+        end
+
+        files.each do |file|
+          FileUtils.touch(cookbook_path.join(file))
+        end
+
+        metadata = <<-EOF
+name "#{name}"
+version "#{version}"
+EOF
+
+        if options[:dependencies]
+          options[:dependencies].each do |name, constraint|
+            metadata << "depends '#{name}', '#{constraint}'\n"
+          end
+        end
+
+        File.write(cookbook_path.join("metadata.rb"), metadata)
+      end
+
       private
 
         def rest

data/spec/unit/berkshelf/cached_cookbook_spec.rb

@@ -6,8 +6,44 @@ module Berkshelf
       subject { CachedCookbook }
 
       describe "#from_path" do
+        context "given a path that contains a cookbook with a metadata file that contains a name attribute" do
+          let(:cookbook_path) { fixtures_path.join("cookbooks", "example_metadata_name") }
+
+          it "returns an instance of CachedCookbook" do
+            subject.from_path(cookbook_path).should be_a(CachedCookbook)
+          end
+
+          it "has a cookbook_name attribute set to what is found in the metadata" do
+            subject.from_path(cookbook_path).cookbook_name.should eql("has_metadata")
+          end
+        end
+
+        context "given a path that contains a cookbook with a metadata file that does not contain a name attribute" do
+          let(:cookbook_path) { fixtures_path.join("cookbooks", "example_metadata_no_name") }
+
+          it "returns an instnace of CachedCookbook" do
+            subject.from_path(cookbook_path).should be_a(CachedCookbook)
+          end
+
+          it "has a cookbook_name attribute set to the basename of the folder" do
+            subject.from_path(cookbook_path).cookbook_name.should eql("example_metadata_no_name")
+          end
+        end
+
+        context "given a path that does not contain a metadata file" do
+          let(:cookbook_path) { fixtures_path.join("cookbooks", "example_no_metadata") }
+
+          it "raises a CookbookNotFound error" do
+            lambda {
+              subject.from_path(cookbook_path)
+            }.should raise_error(Berkshelf::CookbookNotFound)
+          end
+        end
+      end
+
+      describe "#from_store_path" do
         before(:each) do
-          @cached_cb = subject.from_path(fixtures_path.join("cookbooks", "example_cookbook-0.5.0"))
+          @cached_cb = subject.from_store_path(fixtures_path.join("cookbooks", "example_cookbook-0.5.0"))
         end
 
         it "returns an instance of CachedCookbook" do
@@ -20,13 +56,13 @@ module Berkshelf
 
         context "given a path that does not contain a cookbook" do
           it "returns nil" do
-            subject.from_path(tmp_path).should be_nil
+            subject.from_store_path(tmp_path).should be_nil
           end
         end
 
         context "given a path that does not match the CachedCookbook dirname format" do
           it "returns nil" do
-            subject.from_path(fixtures_path.join("cookbooks", "example_cookbook")).should be_nil
+            subject.from_store_path(fixtures_path.join("cookbooks", "example_cookbook")).should be_nil
           end
         end
       end
@@ -47,7 +83,7 @@ module Berkshelf
     end
 
     let(:cb_path) { fixtures_path.join("cookbooks", "nginx-0.100.5") }
-    subject { CachedCookbook.from_path(cb_path) }
+    subject { CachedCookbook.from_store_path(cb_path) }
 
     describe "#checksums" do
       it "returns a Hash containing an entry for all matching cookbook files on disk" do
@@ -82,25 +118,33 @@ module Berkshelf
     end
 
     describe "#validate!" do
-      it "returns true if the cookbook of the given name and version is valid" do
-        @cb = CachedCookbook.from_path(fixtures_path.join("cookbooks", "example_cookbook-0.5.0"))
+      let(:syntax_checker) { double('syntax_checker') }
+
+      before(:each) do
+        subject.stub(:syntax_checker) { syntax_checker }
+      end
+
+      it "asks the syntax_checker to validate the ruby and template files of the cookbook" do
+        syntax_checker.should_receive(:validate_ruby_files).and_return(true)
+        syntax_checker.should_receive(:validate_templates).and_return(true)
 
-        @cb.validate!.should be_true
+        subject.validate!
       end
 
       it "raises CookbookSyntaxError if the cookbook contains invalid ruby files" do
-        @cb = CachedCookbook.from_path(fixtures_path.join("cookbooks", "invalid_ruby_files-1.0.0"))
+        syntax_checker.should_receive(:validate_ruby_files).and_return(false)
 
         lambda {
-          @cb.validate!
+          subject.validate!
         }.should raise_error(CookbookSyntaxError)
       end
 
       it "raises CookbookSyntaxError if the cookbook contains invalid template files" do
-        @cb = CachedCookbook.from_path(fixtures_path.join("cookbooks", "invalid_template_files-1.0.0"))
+        syntax_checker.should_receive(:validate_ruby_files).and_return(true)
+        syntax_checker.should_receive(:validate_templates).and_return(false)
 
         lambda {
-          @cb.validate!
+          subject.validate!
         }.should raise_error(CookbookSyntaxError)
       end
     end

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

@@ -2,31 +2,45 @@ require 'spec_helper'
 
 module Berkshelf
   describe CookbookSource::GitLocation do
-    subject { CookbookSource::GitLocation.new("nginx", :git => "git://github.com/opscode-cookbooks/nginx.git") }
+    let(:complacent_constraint) { double('comp-vconstraint', include?: true) }
+    
+    describe "ClassMethods" do
+      subject { CookbookSource::GitLocation }
+
+      describe "::initialize" do
+        it "raises InvalidGitURI if given an invalid Git URI for options[:git]" do
+          lambda {
+            subject.new("nginx", complacent_constraint, git: "/something/on/disk")
+          }.should raise_error(InvalidGitURI)
+        end
+      end
+    end
+
+    subject { CookbookSource::GitLocation.new("artifact", complacent_constraint, git: "git://github.com/RiotGames/artifact-cookbook.git") }
 
     describe "#download" do
+      it "returns an instance of Berkshelf::CachedCookbook" do
+        subject.download(tmp_path).should be_a(Berkshelf::CachedCookbook)
+      end
+
       it "downloads the cookbook to the given destination" do
-        subject.download(tmp_path)
-        # have to set outside of custom rspec matcher block
-        name, branch = subject.name, subject.branch
+        cached_cookbook = subject.download(tmp_path)
 
         tmp_path.should have_structure {
-          directory "#{name}-#{branch}" do
+          directory "#{cached_cookbook.cookbook_name}-#{Git.rev_parse(cached_cookbook.path)}" do
             file "metadata.rb"
           end
         }
       end
 
-      it "returns the path to the cookbook" do
-        result = subject.download(tmp_path)
-        # have to set outside of custom rspec matcher block
-        name, branch = subject.name, subject.branch
+      it "sets the downloaded status to true" do
+        subject.download(tmp_path)
 
-        result.should eql(tmp_path.join("#{name}-#{branch}").to_s)
+        subject.should be_downloaded
       end
 
       context "given no ref/branch/tag options is given" do
-        subject { CookbookSource::GitLocation.new("nginx", :git => "git://github.com/opscode-cookbooks/nginx.git") }
+        subject { CookbookSource::GitLocation.new("nginx", complacent_constraint, git: "git://github.com/opscode-cookbooks/nginx.git") }
 
         it "sets the branch attribute to the HEAD revision of the cloned repo" do
           subject.download(tmp_path)
@@ -36,17 +50,17 @@ module Berkshelf
       end
 
       context "given a git repo that does not exist" do
-        subject { CookbookSource::GitLocation.new("doesnot_exist", :git => "git://github.com/RiotGames/thisrepo_does_not_exist.git") }
+        subject { CookbookSource::GitLocation.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/thisrepo_does_not_exist.git") }
 
-        it "raises a CookbookNotFound error" do
+        it "raises a GitError" do
           lambda {
             subject.download(tmp_path)
-          }.should raise_error(CookbookNotFound)
+          }.should raise_error(GitError)
         end
       end
 
       context "given a git repo that does not contain a cookbook" do
-        subject { CookbookSource::GitLocation.new("doesnot_exist", :git => "git://github.com/RiotGames/berkshelf.git") }
+        subject { CookbookSource::GitLocation.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/berkshelf.git") }
 
         it "raises a CookbookNotFound error" do
           lambda {
@@ -54,6 +68,42 @@ module Berkshelf
           }.should raise_error(CookbookNotFound)
         end
       end
+
+      context "given the content at the Git repo does not satisfy the version constraint" do
+        subject do
+          CookbookSource::GitLocation.new("nginx",
+            double('constraint', include?: false),
+            git: "git://github.com/opscode-cookbooks/nginx.git"
+          )
+        end
+
+        it "raises a ConstraintNotSatisfied error" do
+          lambda {
+            subject.download(tmp_path)
+          }.should raise_error(ConstraintNotSatisfied)
+        end
+      end
+
+      context "given a value for ref that is a tag or branch and not a commit hash" do
+        subject do
+          CookbookSource::GitLocation.new("artifact", 
+            complacent_constraint,
+            git: "git://github.com/RiotGames/artifact-cookbook.git",
+            ref: "0.9.8"
+          )
+        end
+
+        let(:commit_hash) { "d7be334b094f497f5cce4169a8b3012bf7b27bc3" }
+
+        before(:each) { Git.should_receive(:rev_parse).and_return(commit_hash) }
+
+        it "returns a cached cookbook with a path that contains the commit hash it is pointing to" do
+          cached_cookbook = subject.download(tmp_path)
+          expected_path = tmp_path.join("#{cached_cookbook.cookbook_name}-#{commit_hash}")
+
+          cached_cookbook.path.should eql(expected_path)
+        end
+      end
     end
   end
 end