berkshelf 0.4.0.rc4 → 0.4.0

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -87,8 +87,8 @@ module Berkshelf
 
     describe "#cookbooks" do
       before(:each) do
-        CookbookSource.new("nginx", "0.101.2").download(subject.storage_path)
-        CookbookSource.new("mysql", "1.2.6").download(subject.storage_path)
+        generate_cookbook(subject.storage_path, "nginx", "0.101.2")
+        generate_cookbook(subject.storage_path, "mysql", "1.2.6")
       end
 
       it "returns a list of CachedCookbooks" do
@@ -97,7 +97,7 @@ module Berkshelf
         end
       end
 
-      it "return an instance of CachedCookbook for every downloaded cookbook" do
+      it "contains a CachedCookbook for every cookbook in the storage path" do
         subject.cookbooks.should have(2).items
       end
 

data/spec/unit/berkshelf/downloader_spec.rb

@@ -2,81 +2,209 @@ require 'spec_helper'
 
 module Berkshelf
   describe Downloader do
+    describe "ClassMethods" do
+      subject { Downloader }
+
+      describe "::initialize" do
+        context "when no value for locations is given" do
+          it "sets the @locations instance variable to a blank array" do
+            downloader = subject.new(double('store'))
+
+            downloader.instance_variable_get(:@locations).should be_a(Array)
+            downloader.instance_variable_get(:@locations).should have(0).items
+          end
+        end
+
+        context "when an explicit value of locations is given" do
+          let(:locations) do
+            [
+              {
+                type: :chef_api,
+                value: double('capi'),
+                options: double('capi_opts')
+              },
+              {
+                type: :chef_api,
+                value: double('capi2'),
+                options: double('capi_opts2')
+              }
+            ]
+          end
+
+          it "sets the @locations instance variable to the given locations" do
+            downloader = subject.new(double('store'), locations: locations)
+
+            downloader.instance_variable_get(:@locations).should eql(locations)
+          end
+        end
+      end
+    end
+
     subject { Downloader.new(CookbookStore.new(tmp_path)) }
-    let(:source) { CookbookSource.new("sparkle_motion") }
 
-    describe "#enqueue" do
-      it "should add a source to the queue" do
-        subject.enqueue(source)
+    describe "#download" do
+      let(:source) { double('source', name: "artifact", version_constraint: "= 0.10.0") }
+      let(:location) { double('location') }
+      let(:cached_cookbook) { double('cached') }
+
+      context "when the source has a location" do
+        before(:each) do
+          source.stub(:location).and_return(location)
+          location.should_receive(:download).with(subject.storage_path).and_return(cached_cookbook)
+          source.should_receive(:cached_cookbook=).with(cached_cookbook)
+        end
+
+        it "sends 'download' to the source's location and sets the source's cached_cookbook to the result" do          
+          subject.download(source).should be_true
+        end
+
+        it "returns an Array containing the cached_cookbook and location used to download" do
+          result = subject.download(source)
 
-        subject.queue.should have(1).source
+          result.should be_a(Array)
+          result[0].should eql(cached_cookbook)
+          result[1].should eql(location)
+        end
       end
 
-      it "should not allow you to add an invalid source" do
-        lambda {
-          subject.enqueue("a string, not a source")
-        }.should raise_error(ArgumentError)
+      context "when the source does not have a location" do
+        before(:each) do
+          source.stub(:location).and_return(nil)
+          subject.stub(:locations).and_return([{type: :chef_api, value: :knife, options: Hash.new}])
+        end
+
+        it "sends the 'download' message to the default location" do
+          Location.should_receive(:init).with(source.name, source.version_constraint, chef_api: :knife).and_return(location)
+          location.should_receive(:download).with(subject.storage_path).and_return(cached_cookbook)
+          source.should_receive(:cached_cookbook=).with(cached_cookbook)
+
+          subject.download(source)
+        end
       end
     end
 
-    describe "#dequeue" do
-      before(:each) { subject.enqueue(source) }
+    describe "#locations" do
+      let(:type) { :site }
+      let(:value) { double('value') }
+      let(:options) { double('options') }
+
+      it "returns an array of Hashes representing locations" do
+        subject.add_location(type, value, options)
+
+        subject.locations.each { |l| l.should be_a(Hash) }
+      end
 
-      it "should remove a source from the queue" do
-        subject.dequeue(source)
+      context "when no locations are explicitly added" do
+        subject { Downloader.new(double('store')) }
 
-        subject.queue.should be_empty
+        it "returns an array of default locations" do
+          subject.locations.should eql(Downloader::DEFAULT_LOCATIONS)
+        end
+      end
+
+      context "when locations are explicitly added" do
+        let(:locations) do
+          [
+            {
+              type: :chef_api,
+              value: double('capi'),
+              options: double('capi_opts')
+            },
+            {
+              type: :chef_api,
+              value: double('capi2'),
+              options: double('capi_opts2')
+            }
+          ]
+        end
+
+        subject { Downloader.new(double('store'), locations: locations) }
+
+        it "contains only the locations passed to the initializer" do
+          subject.locations.should eql(locations)
+        end
+
+        it "does not include the array of default locations" do
+          subject.locations.should_not include(Downloader::DEFAULT_LOCATIONS)
+        end
       end
     end
 
-    describe "#download_all" do
-      let(:source_one) { CookbookSource.new("nginx") }
-      let(:source_two) { CookbookSource.new("mysql") }
+    describe "#add_location" do
+      let(:type) { :site }
+      let(:value) { double('value') }
+      let(:options) { double('options') }
+
+      it "adds a hash to the end of the array of locations" do
+        subject.add_location(type, value, options)
 
-      before(:each) do
-        subject.enqueue source_one
-        subject.enqueue source_two
+        subject.locations.should have(1).item
       end
 
-      it "should remove each item from the queue after a successful download" do
-        subject.download_all
+      it "adds a hash with a type, value, and options key" do
+        subject.add_location(type, value, options)
 
-        subject.queue.should be_empty
+        subject.locations.last.should have_key(:type)
+        subject.locations.last.should have_key(:value)
+        subject.locations.last.should have_key(:options)
       end
 
-      it "should not remove the item from the queue if the download failed" do
-        subject.enqueue CookbookSource.new("does_not_exist_no_way")
-        subject.download_all
+      it "sets the value of the given 'value' to the value of the key 'value'" do
+        subject.add_location(type, value, options)
 
-        subject.queue.should have(1).sources
+        subject.locations.last[:value].should eql(value)
       end
 
-      it "should return a TXResultSet" do
-        results = subject.download_all
+      it "sets the value of the given 'type' to the value of the key 'type'" do
+        subject.add_location(type, value, options)
 
-        results.should be_a(TXResultSet)
+        subject.locations.last[:type].should eql(type)
       end
-    end
 
-    describe "#download" do
-      let(:source) { CookbookSource.new("nginx") }
-      let(:bad_source) { CookbookSource.new("donowaytexists") }
+      it "sets the value of the given 'options' to the value of the key 'options'" do
+        subject.add_location(type, value, options)
 
-      it "returns a TXResult" do
-        subject.download(source).should be_a(TXResult)
+        subject.locations.last[:options].should eql(options)
       end
 
-      context "when successful" do
-        it "returns a successesful TXResult" do
-          subject.download(source).should be_success
-        end
+      it "raises a DuplicateLocationDefined error if a location of the given type and value was already added" do
+        subject.add_location(type, value, options)
+
+        lambda {
+          subject.add_location(type, value, options)
+        }.should raise_error(DuplicateLocationDefined)
       end
 
-      context "when failure" do
-        it "returns a failed TXResult" do
-          subject.download(bad_source).should be_failed
+      context "adding multiple locations" do
+        let(:type_2) { :site }
+        let(:value_2) { double('value_2') }
+        let(:options_2) { double('options_2') }
+
+        it "adds locations in the order they are added" do
+          subject.add_location(type, value, options)
+          subject.add_location(type_2, value_2, options_2)
+
+          subject.locations.should have(2).items
+
+          subject.locations[0][:value].should eql(value)
+          subject.locations[1][:value].should eql(value_2)
         end
       end
     end
+
+    describe "#has_location?" do
+      let(:type) { :site }
+      let(:value) { double('value') }
+
+      it "returns true if a source of the given type and value was already added" do
+        subject.add_location(type, value)
+
+        subject.has_location?(type, value).should be_true
+      end
+
+      it "returns false if a source of the given type and value was not added" do
+        subject.has_location?(type, value).should be_false
+      end
+    end
   end
 end

data/spec/unit/berkshelf/formatters_spec.rb

@@ -1,24 +1,21 @@
 require 'spec_helper'
 
 module Berkshelf
-  module Formatters
-    class TestFormatter
-      include AbstractFormatter
+  describe Formatters::AbstractFormatter do
+    subject do
+      Class.new do
+        include Formatters::AbstractFormatter
+      end.new
     end
 
-    describe AbstractFormatter do
-      
-      subject { TestFormatter.new }
-
-      it "has abstract methods for all the messaging modes" do
-        lambda { subject.install("my_coobook","1.2.3","http://community") }.should raise_error(MethodNotImplmentedError)
-        lambda { subject.use("my_coobook","1.2.3") }.should raise_error(MethodNotImplmentedError)
-        lambda { subject.use("my_coobook","1.2.3","http://community") }.should raise_error(MethodNotImplmentedError)
-        lambda { subject.upload("my_coobook","1.2.3","http://chef_server") }.should raise_error(MethodNotImplmentedError)
-        lambda { subject.shims_written("/Users/jcocktosten") }.should raise_error(MethodNotImplmentedError)
-        lambda { subject.msg("something you should know") }.should raise_error(MethodNotImplmentedError)
-        lambda { subject.error("whoa this is bad") }.should raise_error(MethodNotImplmentedError)
-      end
+    it "has abstract methods for all the messaging modes" do
+      lambda { subject.install("my_coobook","1.2.3","http://community") }.should raise_error(AbstractFunction)
+      lambda { subject.use("my_coobook","1.2.3") }.should raise_error(AbstractFunction)
+      lambda { subject.use("my_coobook","1.2.3","http://community") }.should raise_error(AbstractFunction)
+      lambda { subject.upload("my_coobook","1.2.3","http://chef_server") }.should raise_error(AbstractFunction)
+      lambda { subject.shims_written("/Users/jcocktosten") }.should raise_error(AbstractFunction)
+      lambda { subject.msg("something you should know") }.should raise_error(AbstractFunction)
+      lambda { subject.error("whoa this is bad") }.should raise_error(AbstractFunction)
     end
   end
 end

data/spec/unit/berkshelf/{cookbook_source/location_spec.rb → location_spec.rb}

@@ -1,9 +1,9 @@
 module Berkshelf
-  describe CookbookSource::Location do
+  describe Location do
     describe "ClassMethods Module" do
       subject do
         Class.new do
-          include CookbookSource::Location
+          include Location
         end
       end
 
@@ -88,7 +88,7 @@ module Berkshelf
     end
 
     describe "ModuleFunctions" do
-      subject { CookbookSource::Location }
+      subject { Location }
 
       describe "::init" do
         let(:name) { "artifact" }
@@ -97,25 +97,25 @@ module Berkshelf
         it "returns an instance of SiteLocation given a site: option key" do
           result = subject.init(name, constraint, site: "http://site/value")
 
-          result.should be_a(CookbookSource::SiteLocation)
+          result.should be_a(SiteLocation)
         end
 
         it "returns an instance of PathLocation given a path: option key" do
           result = subject.init(name, constraint, path: "/Users/reset/code")
 
-          result.should be_a(CookbookSource::PathLocation)
+          result.should be_a(PathLocation)
         end
 
         it "returns an instance of GitLocation given a git: option key" do
           result = subject.init(name, constraint, git: "git://github.com/something.git")
 
-          result.should be_a(CookbookSource::GitLocation)
+          result.should be_a(GitLocation)
         end
 
         it "returns an instance of SiteLocation when no option key is given that matches a registered location_key" do
           result = subject.init(name, constraint)
 
-          result.should be_a(CookbookSource::SiteLocation)
+          result.should be_a(SiteLocation)
         end
 
         context "given two location_keys" do
@@ -133,7 +133,7 @@ module Berkshelf
 
     subject do
       Class.new do
-        include CookbookSource::Location
+        include Location
       end.new(name, constraint)
     end
 
@@ -142,10 +142,10 @@ module Berkshelf
     end
 
     describe "#download" do
-      it "raises a NotImplementedError if not overridden" do
+      it "raises a AbstractFunction if not defined" do
         lambda {
           subject.download(double('destination'))
-        }.should raise_error(NotImplementedError)
+        }.should raise_error(AbstractFunction)
       end
     end
 

data/spec/unit/berkshelf/{cookbook_source → locations}/chef_api_location_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 module Berkshelf
-  describe CookbookSource::ChefAPILocation do
+  describe ChefAPILocation do
     let(:test_chef_api) { "https://chefserver:8081" }
 
     describe "ClassMethods" do
-      subject { CookbookSource::ChefAPILocation }
+      subject { ChefAPILocation }
       let(:valid_uri) { test_chef_api }
       let(:invalid_uri) { "notauri" }
       let(:constraint) { double('constraint') }
@@ -110,7 +110,7 @@ module Berkshelf
     end
 
     subject do
-      loc = CookbookSource::ChefAPILocation.new("nginx",
+      loc = ChefAPILocation.new("nginx",
         double('constraint', satisfies?: true),
         chef_api: :knife
       )
@@ -229,7 +229,7 @@ module Berkshelf
 
     describe "#to_s" do
       subject do
-        CookbookSource::ChefAPILocation.new('nginx',
+        ChefAPILocation.new('nginx',
           double('constraint'),
           chef_api: :knife
         )

data/spec/unit/berkshelf/{cookbook_source → locations}/git_location_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 module Berkshelf
-  describe CookbookSource::GitLocation do
+  describe GitLocation do
     let(:complacent_constraint) { double('comp-vconstraint', satisfies?: true) }
     
     describe "ClassMethods" do
-      subject { CookbookSource::GitLocation }
+      subject { GitLocation }
 
       describe "::initialize" do
         it "raises InvalidGitURI if given an invalid Git URI for options[:git]" do
@@ -16,7 +16,7 @@ module Berkshelf
       end
     end
 
-    subject { CookbookSource::GitLocation.new("artifact", complacent_constraint, git: "git://github.com/RiotGames/artifact-cookbook.git") }
+    subject { GitLocation.new("artifact", complacent_constraint, git: "git://github.com/RiotGames/artifact-cookbook.git") }
 
     describe "#download" do
       it "returns an instance of Berkshelf::CachedCookbook" do
@@ -40,7 +40,7 @@ module Berkshelf
       end
 
       context "given no ref/branch/tag options is given" do
-        subject { CookbookSource::GitLocation.new("nginx", complacent_constraint, git: "git://github.com/opscode-cookbooks/nginx.git") }
+        subject { 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)
@@ -50,7 +50,7 @@ module Berkshelf
       end
 
       context "given a git repo that does not exist" do
-        subject { CookbookSource::GitLocation.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/thisrepo_does_not_exist.git") }
+        subject { GitLocation.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/thisrepo_does_not_exist.git") }
 
         it "raises a GitError" do
           lambda {
@@ -60,7 +60,7 @@ module Berkshelf
       end
 
       context "given a git repo that does not contain a cookbook" do
-        subject { CookbookSource::GitLocation.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/berkshelf.git") }
+        subject { GitLocation.new("doesnot_exist", complacent_constraint, git: "git://github.com/RiotGames/berkshelf.git") }
 
         it "raises a CookbookNotFound error" do
           lambda {
@@ -71,7 +71,7 @@ module Berkshelf
 
       context "given the content at the Git repo does not satisfy the version constraint" do
         subject do
-          CookbookSource::GitLocation.new("nginx",
+          GitLocation.new("nginx",
             double('constraint', satisfies?: false),
             git: "git://github.com/opscode-cookbooks/nginx.git"
           )
@@ -86,7 +86,7 @@ module Berkshelf
 
       context "given a value for ref that is a tag or branch and not a commit hash" do
         subject do
-          CookbookSource::GitLocation.new("artifact", 
+          GitLocation.new("artifact", 
             complacent_constraint,
             git: "git://github.com/RiotGames/artifact-cookbook.git",
             ref: "0.9.8"