berkshelf 0.3.3 → 0.3.7

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

@@ -0,0 +1,42 @@
+module Berkshelf
+  describe CookbookSource::Location do
+    let(:name) { "nginx" }
+    let(:constraint) { double('constraint') }
+
+    subject do
+      Class.new do
+        include CookbookSource::Location
+      end.new(name, constraint)
+    end
+
+    it "sets the downloaded? state to false" do
+      subject.downloaded?.should be_false
+    end
+
+    describe "#download" do
+      it "raises a NotImplementedError if not overridden" do
+        lambda {
+          subject.download(double('destination'))
+        }.should raise_error(NotImplementedError)
+      end
+    end
+
+    describe "#validate_cached" do
+      let(:cached) { double('cached-cb', version: "0.1.0") }
+
+      it "raises a ConstraintNotSatisfied error if the version constraint does not satisfy the cached version" do
+        constraint.should_receive(:include?).with(cached.version).and_return(false)
+
+        lambda {
+          subject.validate_cached(cached)
+        }.should raise_error(ConstraintNotSatisfied)
+      end
+
+      it "returns true if the version constraint satisfies the cached version" do
+        constraint.should_receive(:include?).with(cached.version).and_return(true)
+        
+        subject.validate_cached(cached).should be_true
+      end
+    end
+  end
+end

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

@@ -2,16 +2,23 @@ require 'spec_helper'
 
 module Berkshelf
   describe CookbookSource::PathLocation do
+    let(:complacent_constraint) { double('comp-vconstraint', include?: true) }
     let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
-    subject { CookbookSource::PathLocation.new("nginx", :path => path) }
+    subject { CookbookSource::PathLocation.new("nginx", complacent_constraint, path: path) }
 
     describe "#download" do
-      it "returns the path to the cookbook" do
-        subject.download(tmp_path).should eql(path)
+      it "returns an instance of CachedCookbook" do
+        subject.download(tmp_path).should be_a(CachedCookbook)
+      end
+
+      it "sets the downloaded status to true" do
+        subject.download(tmp_path)
+
+        subject.should be_downloaded
       end
 
       context "given a path that does not exist" do
-        subject { CookbookSource::PathLocation.new("doesnot_exist", :path => tmp_path.join("doesntexist_noway")) }
+        subject { CookbookSource::PathLocation.new("doesnot_exist", complacent_constraint, path: tmp_path.join("doesntexist_noway")) }
 
         it "raises a CookbookNotFound error" do
           lambda {
@@ -21,7 +28,7 @@ module Berkshelf
       end
 
       context "given a path that does not contain a cookbook" do
-        subject { CookbookSource::PathLocation.new("doesnot_exist", :path => fixtures_path) }
+        subject { CookbookSource::PathLocation.new("doesnot_exist", complacent_constraint, path: fixtures_path) }
 
         it "raises a CookbookNotFound error" do
           lambda {
@@ -29,6 +36,16 @@ module Berkshelf
           }.should raise_error(CookbookNotFound)
         end
       end
+
+      context "given the content at path does not satisfy the version constraint" do
+        subject { CookbookSource::PathLocation.new("nginx", double('constraint', include?: false), path: path) }
+
+        it "raises a ConstraintNotSatisfied error" do
+          lambda {
+            subject.download(double('path'))
+          }.should raise_error(ConstraintNotSatisfied)
+        end
+      end
     end
   end
 end

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

@@ -3,8 +3,8 @@ require 'spec_helper'
 module Berkshelf
   describe CookbookSource::SiteLocation do
     describe "ClassMethods" do
-      subject { CookbookSource::SiteLocation }
       let(:constraint) { DepSelector::VersionConstraint.new("~> 0.101.2") }
+      subject { CookbookSource::SiteLocation }
       let(:versions) do
         { 
           DepSelector::Version.new("0.101.2") => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/0_101_2",
@@ -39,19 +39,28 @@ module Berkshelf
       end
     end
 
-    subject { CookbookSource::SiteLocation.new("nginx") }
+    let(:complacent_constraint) { double('comp-vconstraint', include?: true) }
+    subject { CookbookSource::SiteLocation.new("nginx", complacent_constraint) }
 
     describe "#download" do
-      it "returns the path to the cookbook" do
+      it "returns a CachedCookbook" do
         result = subject.download(tmp_path)
         name = subject.name
         ver, uri = subject.latest_version
 
-        result.should eql(tmp_path.join("#{name}-#{ver}").to_s)
+        result.should be_a(CachedCookbook)
+      end
+
+      it "sets the downloaded status to true" do
+        subject.download(tmp_path)
+
+        subject.should be_downloaded
       end
 
-      context "when no version constraint is specified" do
-        it "the latest version of the cookbook is downloaded to the given destination" do
+      context "given a wildcard '>= 0.0.0' version constraint is specified" do
+        subject { CookbookSource::SiteLocation.new("nginx", DepSelector::VersionConstraint.new(">= 0.0.0")) }
+
+        it "downloads the latest version of the cookbook to the given destination" do
           subject.download(tmp_path)
           name = subject.name
           ver, uri = subject.latest_version
@@ -64,8 +73,8 @@ module Berkshelf
         end
       end
 
-      context "given an explicit version_constraint" do
-        subject { CookbookSource::SiteLocation.new("nginx", :version_constraint => DepSelector::VersionConstraint.new("= 0.101.2")) }
+      context "given an exact match version constraint" do
+        subject { CookbookSource::SiteLocation.new("nginx", DepSelector::VersionConstraint.new("= 0.101.2")) }
 
         it "downloads the cookbook with the version matching the version_constraint to the given destination" do
           subject.download(tmp_path)
@@ -79,8 +88,8 @@ module Berkshelf
         end
       end
 
-      context "given a more broad version_constraint" do
-        subject { CookbookSource::SiteLocation.new("nginx", :version_constraint => DepSelector::VersionConstraint.new("~> 0.99.0")) }
+      context "given a more broad version constraint" do
+        subject { CookbookSource::SiteLocation.new("nginx", DepSelector::VersionConstraint.new("~> 0.99.0")) }
 
         it "downloads the best matching cookbook version for the constraint to the given destination" do
           subject.download(tmp_path)
@@ -95,7 +104,12 @@ module Berkshelf
       end
 
       context "given an explicit :site location key" do
-        subject { CookbookSource::SiteLocation.new("nginx", :site => "http://cookbooks.opscode.com/api/v1/cookbooks") }
+        subject do
+          CookbookSource::SiteLocation.new("nginx",
+            complacent_constraint,
+            site: "http://cookbooks.opscode.com/api/v1/cookbooks"
+          )
+        end
 
         it "downloads the cookbook to the given destination" do
           subject.download(tmp_path)
@@ -111,12 +125,17 @@ module Berkshelf
       end
 
       context "given a cookbook that does not exist on the specified site" do
-        subject { CookbookSource::SiteLocation.new("nowaythis_exists", :site => "http://cookbooks.opscode.com/api/v1/cookbooks") }
+        subject do
+          CookbookSource::SiteLocation.new("nowaythis_exists",
+            complacent_constraint,
+            site: "http://cookbooks.opscode.com/api/v1/cookbooks"
+          )
+        end
 
         it "raises a CookbookNotFound error" do
           lambda {
             subject.download(tmp_path)
-            }.should raise_error(CookbookNotFound)
+          }.should raise_error(CookbookNotFound)
         end
       end
     end

data/spec/unit/berkshelf/cookbook_source_spec.rb

@@ -45,15 +45,26 @@ module Berkshelf
       end
 
       context "given a location key :path" do
-        let(:path) { "/Path/To/Cookbook" }
-        let(:source) { subject.new(cookbook_name, :path => path) }
+        context "given a value for path that contains a cookbook" do
+          let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
 
-        it "initializes a PathLocation for location" do
-          source.location.should be_a(subject::PathLocation)
+          it "initializes a PathLocation for location" do
+            subject.new(cookbook_name, path: path).location.should be_a(subject::PathLocation)
+          end
+
+          it "points to the specified path" do
+            subject.new(cookbook_name, path: path).location.path.should eql(path)
+          end
         end
 
-        it "points to the specified path" do
-          source.location.path.should eql(path)
+        context "given a value for path that does not contain a cookbook" do
+          let(:path) { "/does/not/exist" }
+
+          it "rasies Berkshelf::CookbookNotFound" do
+            lambda {
+              subject.new(cookbook_name, path: path)
+            }.should raise_error(Berkshelf::CookbookNotFound)
+          end
         end
       end
 
@@ -133,16 +144,10 @@ module Berkshelf
 
     describe "#download" do
       context "when download is successful" do
-        it "writes a value to local_path" do
+        it "sets a CachedCookbook to the cached_cookbook attr" do
           subject.download(tmp_path)
 
-          subject.local_path.should_not be_nil
-        end
-
-        it "writes a value to local_version" do
-          subject.download(tmp_path)
-
-          subject.local_version.should_not be_nil
+          subject.cached_cookbook.should be_a(Berkshelf::CachedCookbook)
         end
 
         it "returns an array containing the symbol :ok and the local_path" do
@@ -150,7 +155,7 @@ module Berkshelf
 
           result.should be_a(Array)
           result[0].should eql(:ok)
-          result[1].should eql(subject.local_path)
+          result[1].should eql(subject.cached_cookbook)
         end
       end
 
@@ -168,26 +173,12 @@ module Berkshelf
       end
     end
 
-    describe "#metadata" do
-      it "should return the metadata of a CookbookSource that has been downloaded" do
-        subject.download(tmp_path)
-
-        subject.metadata.should be_a(Chef::Cookbook::Metadata)
-      end
-
-      it "should return nil if the CookbookSource has not been downloaded" do
-        subject.metadata.should be_nil
-      end
-    end
-
     describe "#downloaded?" do
-      let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
-      subject { CookbookSource.new("example_cookbook", :path => path) }
-
-      it "returns true if the local_path has been set" do
-        subject.stub(:local_path) { path }
+      subject{ CookbookSource.new("nginx", ">= 1.0.1") }
 
-        subject.downloaded?.should be_true
+      it "delegates the message ':downloaded?' to the location" do
+        subject.location.should_receive(:downloaded?)
+        subject.downloaded?
       end
     end
   end

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -34,15 +34,42 @@ module Berkshelf
       end
     end
 
-    describe "#downloaded?" do
-      it "returns true if the store contains a Cookbook of the given name and version" do
-        CookbookSource.new("nginx", "0.101.2").download(subject.storage_path)
+    describe "#satisfy" do
+      let(:name) { "nginx" }
+      let(:version) { DepSelector::Version.new("0.101.4") }
+      let(:constraint) { DepSelector::VersionConstraint.new("~> 0.101.2") }
+      let(:cached_cb) { double('cached-cb', name: name, version: version) }
+      let(:cached_two) { double('cached-two', name: "mysql", version: DepSelector::Version.new("1.2.6")) }
+
+      before(:each) do
+        subject.stub(:cookbooks).and_return([cached_cb, cached_two])
+      end
+
+      it "gets and returns the the CachedCookbook best matching the name and constraint" do
+        subject.should_receive(:cookbook).with(name, version).and_return(cached_cb)
 
-        subject.downloaded?("nginx", "0.101.2").should be_true
+        subject.satisfy(name, constraint).should eql(cached_cb)
       end
 
-      it "returns false if the store does not contain a Cookbook of the given name and version" do
-        subject.downloaded?("notthere", "0.0.0").should be_false
+      context "when there are no cookbooks in the cookbook store" do
+        before(:each) { subject.stub(:cookbooks).and_return([]) }
+
+        it "returns nil" do
+          subject.satisfy(name, constraint).should be_nil
+        end
+      end
+
+      context "when there is no matching cookbook for the given name and constraint" do
+        let(:version) { DepSelector::Version.new("1.0.0") }
+        let(:constraint) { DepSelector::VersionConstraint.new("= 0.0.1") }
+
+        before(:each) do
+          subject.stub(:cookbooks).and_return([ double('badcache', name: 'none', version: version) ])
+        end
+
+        it "returns nil if there is no matching cookbook for the name and constraint" do
+          subject.satisfy(name, constraint).should be_nil
+        end
       end
     end
 
@@ -59,13 +86,26 @@ module Berkshelf
     end
 
     describe "#cookbooks" do
-      it "returns a list of CachedCookbooks" do
+      before(:each) do
         CookbookSource.new("nginx", "0.101.2").download(subject.storage_path)
+        CookbookSource.new("mysql", "1.2.6").download(subject.storage_path)
+      end
 
+      it "returns a list of CachedCookbooks" do
         subject.cookbooks.each do |cb|
           cb.should be_a(CachedCookbook)
         end
       end
+
+      it "return an instance of CachedCookbook for every downloaded cookbook" do
+        subject.cookbooks.should have(2).items
+      end
+
+      context "given a value for the filter parameter" do
+        it "returns only the CachedCookbooks whose name match the filter" do          
+          subject.cookbooks("mysql").should have(1).item
+        end
+      end
     end
   end
 end

data/spec/unit/berkshelf/git_spec.rb

@@ -5,24 +5,21 @@ module Berkshelf
     describe "ClassMethods" do
       subject { Git }
 
-      describe "#find_git" do
+      describe "::find_git" do
         it "should find git" do
           subject.find_git.should_not be_nil
         end
 
         it "should raise if it can't find git" do
-          begin
-            path = ENV["PATH"]
-            ENV["PATH"] = ""
-
-            lambda { subject.find_git }.should raise_error
-          ensure
-            ENV["PATH"] = path
-          end
+          ENV.should_receive(:[]).with("PATH").and_return(String.new)
+          
+          lambda {
+            subject.find_git
+          }.should raise_error(GitNotFound)
         end
       end
 
-      describe "#clone" do
+      describe "::clone" do
         let(:target) { tmp_path.join("nginx") }
 
         it "clones the repository to the target path" do
@@ -33,7 +30,7 @@ module Berkshelf
         end
       end
 
-      describe "#checkout" do
+      describe "::checkout" do
         let(:repo_path) { tmp_path.join("nginx") }
         let(:repo) { subject.clone("git://github.com/opscode-cookbooks/nginx.git", repo_path) }
         let(:tag) { "0.101.2" }
@@ -47,7 +44,7 @@ module Berkshelf
         end
       end
 
-      describe "#rev_parse" do
+      describe "::rev_parse" do
         let(:repo_path) { tmp_path.join("nginx") }
         before(:each) do
           subject.clone("git://github.com/opscode-cookbooks/nginx.git", repo_path)
@@ -58,6 +55,94 @@ module Berkshelf
           subject.rev_parse(repo_path).should eql("0e4887d9eef8cb83972f974a85890983c8204c3b")
         end
       end
+
+      let(:readonly_uri) { "git://github.com/reset/thor-foodcritic.git" }
+      let(:https_uri) { "https://github.com/reset/solve.git" }
+      let(:ssh_uri) { "git@github.com:reset/solve.git" }
+      let(:http_uri) { "http://github.com/reset/solve.git" }
+      let(:invalid_uri) { "/something/on/disk" }
+
+      describe "::validate_uri" do
+        context "given a valid Git read-only URI" do
+          it "returns true" do
+            subject.validate_uri(readonly_uri)
+          end
+        end
+
+        context "given a valid Git HTTPS URI" do
+          it "returns true" do
+            subject.validate_uri(https_uri)
+          end
+        end
+
+        context "given a valid Git SSH URI" do
+          it "returns true" do
+            subject.validate_uri(ssh_uri)
+          end
+        end
+
+        context "given an invalid URI" do
+          it "returns false" do
+            subject.validate_uri(invalid_uri)
+          end
+        end
+
+        context "given a HTTP URI" do
+          it "returns false" do
+            subject.validate_uri(http_uri)
+          end
+        end
+
+        context "given an integer" do
+          it "returns false" do
+            subject.validate_uri(123)
+          end
+        end
+      end
+
+      describe "::validate_uri!" do
+        context "given a valid Git read-only URI" do
+          it "returns true" do
+            subject.validate_uri!(readonly_uri)
+          end
+        end
+
+        context "given a valid Git HTTPS URI" do
+          it "returns true" do
+            subject.validate_uri!(https_uri)
+          end
+        end
+
+        context "given a valid Git SSH URI" do
+          it "returns true" do
+            subject.validate_uri!(ssh_uri)
+          end
+        end
+
+        context "given an invalid URI" do
+          it "raises InvalidGitURI" do
+            lambda {
+              subject.validate_uri!(invalid_uri)
+            }.should raise_error(InvalidGitURI)
+          end
+        end
+
+        context "given a HTTP URI" do
+          it "raises InvalidGitURI" do
+            lambda {
+              subject.validate_uri!(http_uri)
+            }.should raise_error(InvalidGitURI)
+          end
+        end
+
+        context "given an integer" do
+          it "raises InvalidGitURI" do
+            lambda {
+              subject.validate_uri!(123)
+            }.should raise_error(InvalidGitURI)
+          end
+        end
+      end
     end
   end
 end