berkshelf 1.4.6 → 2.0.0.beta

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -1,110 +1,106 @@
 require 'spec_helper'
 
-module Berkshelf
-  describe CookbookStore do
-    subject { CookbookStore.new(tmp_path.join("cbstore_rspec")) }
+describe Berkshelf::CookbookStore do
+  describe '#initialize' do
+    it 'creates the storage_path' do
+      storage_path = tmp_path.join('random_storage')
+      Berkshelf::CookbookStore.new(storage_path)
 
-    describe "#initialize" do
-      it "creates the storage_path" do
-        storage_path = tmp_path.join("random_storage")
-        subject.class.new(storage_path)
-
-        storage_path.should exist
-      end
+      expect(storage_path).to exist
     end
+  end
 
-    describe "#cookbook_path" do
-      let(:cookbook_name) { "nginx" }
-      let(:cookbook_version) { "0.101.2" }
 
-      before(:each) do
-        @cb_path = subject.cookbook_path(cookbook_name, cookbook_version)
-      end
 
-      it "returns an instance of Pathname" do
-        @cb_path.should be_a(Pathname)
-      end
+  subject { Berkshelf::CookbookStore.new(tmp_path.join("cbstore_rspec")) }
 
-      it "returns a Cookbook Version's filepath within the storage path" do
-        @cb_path.dirname.should eql(subject.storage_path)
-      end
+  describe '#cookbook_path' do
+    let(:cookbook_name) { 'nginx' }
+    let(:cookbook_version) { '0.101.2' }
+    let(:path) { subject.cookbook_path(cookbook_name, cookbook_version) }
 
-      it "returns a basename containing the cookbook name and version separated by a dash" do
-        @cb_path.basename.to_s.should eql("#{cookbook_name}-#{cookbook_version}")
-      end
+    it 'returns an instance of Pathname' do
+      expect(path).to be_a(Pathname)
     end
 
-    describe "#satisfy" do
-      let(:name) { "nginx" }
-      let(:version) { "0.101.4" }
-      let(:constraint) { Solve::Constraint.new("~> 0.101.2") }
-      let(:cached_cb) { double('cached-cb', name: name, version: Solve::Version.new(version)) }
-      let(:cached_two) { double('cached-two', name: "mysql", version: Solve::Version.new("1.2.6")) }
+    it 'returns a the filepath within the storage path' do
+      expect(path.dirname).to eq(subject.storage_path)
+    end
 
-      before(:each) do
-        subject.stub(:cookbooks).and_return([cached_cb, cached_two])
-      end
+    it 'returns a basename containing the cookbook name and version separated by a dash' do
+      expect(path.basename.to_s).to eq("#{cookbook_name}-#{cookbook_version}")
+    end
+  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)
+  describe '#satisfy' do
+    let(:name) { 'nginx' }
+    let(:version) { '0.101.4' }
+    let(:constraint) { Solve::Constraint.new('~> 0.101.2') }
+    let(:cached_one) { double('cached-one', name: name, version: Solve::Version.new(version)) }
+    let(:cached_two) { double('cached-two', name: 'mysql', version: Solve::Version.new('1.2.6')) }
 
-        subject.satisfy(name, constraint).should eql(cached_cb)
-      end
+    before { subject.stub(:cookbooks).and_return([cached_one, cached_two]) }
+
+    it 'gets and returns the the CachedCookbook best matching the name and constraint' do
+      subject.should_receive(:cookbook).with(name, version).and_return(cached_one)
+      result = subject.satisfy(name, constraint)
 
-      context "when there are no cookbooks in the cookbook store" do
-        before(:each) { subject.stub(:cookbooks).and_return([]) }
+      expect(result).to eq(cached_one)
+    end
+
+    context 'when there are no cookbooks in the cookbook store' do
+      before { subject.stub(:cookbooks).and_return([]) }
 
-        it "returns nil" do
-          subject.satisfy(name, constraint).should be_nil
-        end
+      it 'returns nil' do
+        result = subject.satisfy(name, constraint)
+        expect(result).to be_nil
       end
+    end
 
-      context "when there is no matching cookbook for the given name and constraint" do
-        let(:version) { Solve::Version.new("1.0.0") }
-        let(:constraint) { Solve::Constraint.new("= 0.1.0") }
+    context 'when there is no matching cookbook for the given name and constraint' do
+      let(:version) { Solve::Version.new('1.0.0') }
+      let(:constraint) { Solve::Constraint.new('= 0.1.0') }
 
-        before(:each) do
-          subject.stub(:cookbooks).and_return([ double('badcache', name: 'none', version: version) ])
-        end
+      before { subject.stub(:cookbooks).and_return([ double('badcache', name: 'none', version: version) ]) }
 
-        it "returns nil if there is no matching cookbook for the name and constraint" do
-          subject.satisfy(name, constraint).should be_nil
-        end
+      it 'returns nil if there is no matching cookbook for the name and constraint' do
+        result = subject.satisfy(name, constraint)
+        expect(result).to be_nil
       end
     end
+  end
 
-    describe "#cookbook" do
-      subject { CookbookStore.new(fixtures_path.join("cookbooks")) }
+  describe '#cookbook' do
+    subject { Berkshelf::CookbookStore.new(fixtures_path.join('cookbooks')) }
 
-      it "returns a CachedCookbook if the specified cookbook version exists" do
-        subject.cookbook("example_cookbook", "0.5.0").should be_a(CachedCookbook)
-      end
+    it 'returns a CachedCookbook if the specified cookbook version exists' do
+      expect(subject.cookbook('example_cookbook', '0.5.0')).to be_a(Berkshelf::CachedCookbook)
+    end
 
-      it "returns nil if the specified cookbook version does not exist" do
-        subject.cookbook("doesnotexist", "0.1.0").should be_nil
-      end
+    it 'returns nil if the specified cookbook version does not exist' do
+      expect(subject.cookbook('doesnotexist', '0.1.0')).to be_nil
     end
+  end
 
-    describe "#cookbooks" do
-      before(:each) do
-        generate_cookbook(subject.storage_path, "nginx", "0.101.2")
-        generate_cookbook(subject.storage_path, "mysql", "1.2.6")
-      end
+  describe '#cookbooks' do
+    before do
+      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
-        subject.cookbooks.each do |cb|
-          cb.should be_a(CachedCookbook)
-        end
+    it 'returns a list of CachedCookbooks' do
+      subject.cookbooks.each do |cookbook|
+        expect(cookbook).to be_a(Berkshelf::CachedCookbook)
       end
+    end
 
-      it "contains a CachedCookbook for every cookbook in the storage path" do
-        subject.cookbooks.should have(2).items
-      end
+    it 'contains a CachedCookbook for every cookbook in the storage path' do
+      expect(subject.cookbooks).to 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
+    context 'given a value for the filter parameter' do
+      it 'returns only the CachedCookbooks whose name match the filter' do
+        expect(subject.cookbooks('mysql')).to have(1).item
       end
     end
   end

data/spec/unit/berkshelf/core_ext/file_utils_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe FileUtils do
-  describe "#mv" do
+  describe '#mv' do
     let(:src) { double('src') }
     let(:dest) { double('dest') }
     let(:options) { double('options') }
 
-    it "replaces mv with cp_r and rm_rf" do
+    it 'replaces mv with cp_r and rm_rf' do
       subject.stub(:windows?) { true }
       FileUtils.should_receive(:cp_r).with(src, dest, options)
       FileUtils.should_receive(:rm_rf).with(src)

data/spec/unit/berkshelf/downloader_spec.rb

@@ -1,210 +1,190 @@
 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
+describe Berkshelf::Downloader 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
+
+  describe '.initialize' do
+    context 'when no value for locations is given' do
+      it 'sets the @locations instance variable to a blank array' do
+        downloader = Berkshelf::Downloader.new(double('store'))
+        locations = downloader.instance_variable_get(:@locations)
+
+        expect(locations).to be_a(Array)
+        expect(locations).to be_empty
       end
     end
 
-    subject { Downloader.new(CookbookStore.new(tmp_path)) }
+    context 'when an explicit value of locations is given' do
+      it 'sets the @locations instance variable to the given locations' do
+        downloader = Berkshelf::Downloader.new(double('store'), locations: locations)
+        expect(downloader.instance_variable_get(:@locations)).to eq(locations)
+      end
+    end
+  end
 
-    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
+  let!(:cookbook_store) { Berkshelf::CookbookStore.new(tmp_path) }
+  subject { Berkshelf::Downloader.new(cookbook_store) }
 
-        it "returns an Array containing the cached_cookbook and location used to download" do
-          result = subject.download(source)
+  describe '#download' do
+    let(:source) { double('source', name: 'artifact', version_constraint: '= 0.10.0') }
+    let(:location) { double('location') }
+    let(:cached_cookbook) { double('cached') }
 
-          result.should be_a(Array)
-          result[0].should eql(cached_cookbook)
-          result[1].should eql(location)
-        end
+    context 'when the source has a location' do
+      before 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
 
-      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: :config, options: Hash.new}])
-        end
+      it "sends :download to the source's location and sets the source's cached_cookbook to the result" do
+        expect(subject.download(source)).to be_true
+      end
 
-        it "sends the 'download' message to the default location" do
-          Location.should_receive(:init).with(source.name, source.version_constraint, chef_api: :config).and_return(location)
-          location.should_receive(:download).with(subject.storage_path).and_return(cached_cookbook)
-          source.should_receive(:cached_cookbook=).with(cached_cookbook)
+      it 'returns an Array containing the cached_cookbook and location used to download' do
+        result = subject.download(source)
 
-          subject.download(source)
-        end
+        expect(result).to be_a(Array)
+        expect(result[0]).to eq(cached_cookbook)
+        expect(result[1]).to eq(location)
       end
     end
 
-    describe "#locations" do
-      let(:type) { :site }
-      let(:value) { double('value') }
-      let(:options) { double('options') }
+    context 'when the source does not have a location' do
+      before do
+        source.stub(:location).and_return(nil)
+        subject.stub(:locations).and_return([{ type: :chef_api, value: :config, options: {} }])
+      end
 
-      it "returns an array of Hashes representing locations" do
-        subject.add_location(type, value, options)
+      it 'sends the :download message to the default location' do
+        Berkshelf::Location.should_receive(:init).with(source.name, source.version_constraint, chef_api: :config).and_return(location)
+        location.should_receive(:download).with(subject.storage_path).and_return(cached_cookbook)
+        source.should_receive(:cached_cookbook=).with(cached_cookbook)
 
-        subject.locations.each { |l| l.should be_a(Hash) }
+        subject.download(source)
       end
+    end
+  end
+
+  describe '#locations' do
+    let(:type) { :site }
+    let(:value) { double('value') }
+    let(:options) { double('options') }
 
-      context "when no locations are explicitly added" do
-        subject { Downloader.new(double('store')) }
+    it 'returns an array of Hashes representing locations' do
+      subject.add_location(type, value, options)
 
-        it "returns an array of default locations" do
-          subject.locations.should eql(Downloader::DEFAULT_LOCATIONS)
-        end
+      subject.locations.each do |location|
+        expect(location).to be_a(Hash)
       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
+    context 'when no locations are explicitly added' do
+      subject { Berkshelf::Downloader.new(double('store')) }
+
+      it 'returns an array of default locations' do
+        expect(subject.locations).to eq(Berkshelf::Downloader::DEFAULT_LOCATIONS)
       end
     end
 
-    describe "#add_location" do
-      let(:type) { :site }
-      let(:value) { double('value') }
-      let(:options) { double('options') }
+    context 'when locations are explicitly added' do
+      subject { Berkshelf::Downloader.new(double('store'), locations: locations) }
 
-      it "adds a hash to the end of the array of locations" do
-        subject.add_location(type, value, options)
+      it 'contains only the locations passed to the initializer' do
+        expect(subject.locations).to eq(locations)
+      end
 
-        subject.locations.should have(1).item
+      it 'does not include the array of default locations' do
+        expect(subject.locations).to_not include(Berkshelf::Downloader::DEFAULT_LOCATIONS)
       end
+    end
+  end
 
-      it "adds a hash with a type, value, and options key" do
-        subject.add_location(type, value, options)
+  describe '#add_location' do
+    let(:type) { :site }
+    let(:value) { double('value') }
+    let(:options) { double('options') }
 
-        subject.locations.last.should have_key(:type)
-        subject.locations.last.should have_key(:value)
-        subject.locations.last.should have_key(:options)
-      end
+    it 'adds a hash to the end of the array of locations' do
+      subject.add_location(type, value, options)
+      expect(subject.locations).to have(1).item
+    end
 
-      it "sets the value of the given 'value' to the value of the key 'value'" do
-        subject.add_location(type, value, options)
+    it 'adds a hash with a type, value, and options key' do
+      subject.add_location(type, value, options)
+      location = subject.locations.last
 
-        subject.locations.last[:value].should eql(value)
+      [:type, :value, :options].each do |key|
+        expect(location).to have_key(key)
       end
+    end
 
-      it "sets the value of the given 'type' to the value of the key 'type'" do
-        subject.add_location(type, value, options)
+    it 'sets the value of the given :value to the value of the key :value' do
+      subject.add_location(type, value, options)
+      expect(subject.locations.last[:value]).to eq(value)
+    end
 
-        subject.locations.last[:type].should eql(type)
-      end
+    it 'sets the value of the given :type to the value of the key :type' do
+      subject.add_location(type, value, options)
+      expect(subject.locations.last[:type]).to eq(type)
+    end
 
-      it "sets the value of the given 'options' to the value of the key 'options'" do
-        subject.add_location(type, value, options)
+    it 'sets the value of the given :options to the value of the key :options' do
+      subject.add_location(type, value, options)
+      expect(subject.locations.last[:options]).to eq(options)
+    end
 
-        subject.locations.last[:options].should eql(options)
-      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)
 
-      it "raises a DuplicateLocationDefined error if a location of the given type and value was already added" do
+      expect {
         subject.add_location(type, value, options)
+      }.to raise_error(Berkshelf::DuplicateLocationDefined)
+    end
 
-        lambda {
-          subject.add_location(type, value, options)
-        }.should raise_error(DuplicateLocationDefined)
-      end
-
-      context "adding multiple locations" do
-        let(:type_2) { :site }
-        let(:value_2) { double('value_2') }
-        let(:options_2) { double('options_2') }
+    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)
+      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
+        expect(subject.locations).to have(2).items
 
-          subject.locations[0][:value].should eql(value)
-          subject.locations[1][:value].should eql(value_2)
-        end
+        expect(subject.locations[0][:value]).to eql(value)
+        expect(subject.locations[1][:value]).to 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)
+  describe '#has_location?' do
+    let(:type) { :site }
+    let(:value) { double('value') }
 
-        subject.has_location?(type, value).should be_true
-      end
+    it 'returns true if a source of the given type and value was already added' do
+      subject.add_location(type, value)
+      expect(subject.has_location?(type, value)).to 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
+    it 'returns false if a source of the given type and value was not added' do
+      expect(subject.has_location?(type, value)).to be_false
     end
   end
 end