berkshelf 5.2.0 → 8.0.15

data/spec/unit/berkshelf/community_rest_spec.rb

@@ -1,21 +1,21 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::CommunityREST do
   describe "ClassMethods" do
     describe "::unpack" do
-      let(:target) { '/foo/bar' }
-      let(:destination) { '/destination/bar' }
-      let(:file) { double('file') }
-      let(:gzip_reader) { double('gzip_reader') }
-      let(:archive) { double('mixlib_archive') }
+      let(:target) { "/foo/bar" }
+      let(:destination) { "/destination/bar" }
+      let(:file) { double("file") }
+      let(:gzip_reader) { double("gzip_reader") }
+      let(:archive) { double("mixlib_archive") }
 
       before do
-        allow(File).to receive(:open).with(target, 'rb').and_return(file)
+        allow(File).to receive(:open).with(target, "rb").and_return(file)
         allow(archive).to receive(:extract).with(destination)
         allow(Mixlib::Archive).to receive(:new).with(target).and_return(archive)
       end
 
-      it 'unpacks the tar' do
+      it "unpacks the tar" do
         expect(::IO).to receive(:binread).with(target, 2).and_return([0x1F, 0x8B].pack("C*"))
         expect(Mixlib::Archive).to receive(:new).with(target).and_return(archive)
         expect(archive).to receive(:extract).with(destination)
@@ -25,38 +25,38 @@ describe Berkshelf::CommunityREST do
     end
 
     describe "::uri_escape_version" do
-      it 'returns a string' do
+      it "returns a string" do
         expect(Berkshelf::CommunityREST.uri_escape_version(nil)).to be_a(String)
       end
 
-      it 'converts a version to it\'s underscored version' do
-        expect(Berkshelf::CommunityREST.uri_escape_version('1.1.2')).to eq('1_1_2')
+      it "converts a version to it's underscored version" do
+        expect(Berkshelf::CommunityREST.uri_escape_version("1.1.2")).to eq("1_1_2")
       end
 
-      it 'works when the version has more than three points' do
-        expect(Berkshelf::CommunityREST.uri_escape_version('1.1.1.2')).to eq('1_1_1_2')
+      it "works when the version has more than three points" do
+        expect(Berkshelf::CommunityREST.uri_escape_version("1.1.1.2")).to eq("1_1_1_2")
       end
 
-      it 'works when the version has less than three points' do
-        expect(Berkshelf::CommunityREST.uri_escape_version('1.2')).to eq('1_2')
+      it "works when the version has less than three points" do
+        expect(Berkshelf::CommunityREST.uri_escape_version("1.2")).to eq("1_2")
       end
     end
 
     describe "::version_from_uri" do
-      it 'returns a string' do
+      it "returns a string" do
         expect(Berkshelf::CommunityREST.version_from_uri(nil)).to be_a(String)
       end
 
-      it 'extracts the version from the URL' do
-        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_2')).to eq('1.1.2')
+      it "extracts the version from the URL" do
+        expect(Berkshelf::CommunityREST.version_from_uri("/api/v1/cookbooks/nginx/versions/1_1_2")).to eq("1.1.2")
       end
 
-      it 'works when the version has more than three points' do
-        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_1_2')).to eq('1.1.1.2')
+      it "works when the version has more than three points" do
+        expect(Berkshelf::CommunityREST.version_from_uri("/api/v1/cookbooks/nginx/versions/1_1_1_2")).to eq("1.1.1.2")
       end
 
-      it 'works when the version has less than three points' do
-        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_2')).to eq('1.2')
+      it "works when the version has less than three points" do
+        expect(Berkshelf::CommunityREST.version_from_uri("/api/v1/cookbooks/nginx/versions/1_2")).to eq("1.2")
       end
     end
   end
@@ -64,161 +64,153 @@ describe Berkshelf::CommunityREST do
   let(:api_uri) { Berkshelf::CommunityREST::V1_API }
   subject { Berkshelf::CommunityREST.new(api_uri) }
 
-  describe '#initialize' do
-    context 'Faraday handlers' do
-      it 'includes follow_redirects to prevent 301 from community, stopping some cookbooks installing' do
-        expect(subject.builder.handlers).to include(Ridley::Middleware::FollowRedirects)
-      end
-    end
-  end
-
-  describe '#download' do
-    let(:archive) { double('archive', path: '/foo/bar', unlink: true) }
+  describe "#download" do
+    let(:archive) { double("archive", path: "/foo/bar", unlink: true) }
 
     before do
-      allow(subject).to receive(:stream).with(any_args()).and_return(archive)
+      allow(subject).to receive(:stream).with(any_args).and_return(archive)
       allow(Berkshelf::CommunityREST).to receive(:unpack)
-        .and_return('/some/path')
+        .and_return("/some/path")
     end
 
-    it 'unpacks the archive' do
+    it "unpacks the archive" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon/versions/1_0_0").to_return(
         status: 200,
         body: '{ "cookbook": "/path/to/cookbook", "version": "1.0.0" }',
-        headers: { 'Content-Type' => 'application/json' },
+        headers: { "Content-Type" => "application/json" }
       )
 
       expect(Berkshelf::CommunityREST).to receive(:unpack)
-        .with('/foo/bar', String)
-        .and_return('/foo/nginx')
+        .with("/foo/bar", String)
+        .and_return("/foo/nginx")
         .once
       expect(archive).to receive(:unlink).once
 
-      subject.download('bacon', '1.0.0')
+      subject.download("bacon", "1.0.0")
     end
   end
 
-  describe '#find' do
-    it 'returns the cookbook and version information' do
+  describe "#find" do
+    it "returns the cookbook and version information" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon/versions/1_0_0").to_return(
         status: 200,
         body: '{ "cookbook": "/path/to/cookbook", "version": "1.0.0" }',
-        headers: { 'Content-Type' => 'application/json' },
+        headers: { "Content-Type" => "application/json" }
       )
 
-      result = subject.find('bacon', '1.0.0')
+      result = subject.find("bacon", "1.0.0")
 
-      expect(result.cookbook).to eq('/path/to/cookbook')
-      expect(result.version).to eq('1.0.0')
+      expect(result["cookbook"]).to eq("/path/to/cookbook")
+      expect(result["version"]).to eq("1.0.0")
     end
 
-    it 'raises a CookbookNotFound error on a 404 response for a non-existent cookbook' do
+    it "raises a CookbookNotFound error on a 404 response for a non-existent cookbook" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real/versions/1_0_0").to_return(
         status: 404,
-        body: nil,
+        body: "Not Found"
       )
 
-      expect {
-        subject.find('not_real', '1.0.0')
-      }.to raise_error(Berkshelf::CookbookNotFound)
+      expect do
+        subject.find("not_real", "1.0.0")
+      end.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'raises a CommunitySiteError error on any non 200 or 404 response' do
+    it "raises a CommunitySiteError error on any non 200 or 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real/versions/1_0_0").to_return(
         status: 500,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.find('not_real', '1.0.0')
-      }.to raise_error(Berkshelf::CommunitySiteError)
+      expect do
+        subject.find("not_real", "1.0.0")
+      end.to raise_error(Berkshelf::CommunitySiteError)
     end
   end
 
-  describe '#latest_version' do
-    it 'returns the version number of the latest version of the cookbook' do
+  describe "#latest_version" do
+    it "returns the version number of the latest version of the cookbook" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon").to_return(
         status: 200,
         body: '{ "latest_version": "1.0.0" }',
-        headers: { 'Content-Type' => 'application/json' }
+        headers: { "Content-Type" => "application/json" }
       )
 
-      latest = subject.latest_version('bacon')
-      expect(latest).to eq('1.0.0')
+      latest = subject.latest_version("bacon")
+      expect(latest).to eq("1.0.0")
     end
 
-    it 'raises a CookbookNotFound error on a 404 response' do
+    it "raises a CookbookNotFound error on a 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 404,
-        body: nil,
+        body: "Not Found"
       )
 
-      expect {
-        subject.latest_version('not_real')
-      }.to raise_error(Berkshelf::CookbookNotFound)
+      expect do
+        subject.latest_version("not_real")
+      end.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'raises a CommunitySiteError error on any non 200 or 404 response' do
+    it "raises a CommunitySiteError error on any non 200 or 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 500,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.latest_version('not_real')
-      }.to raise_error(Berkshelf::CommunitySiteError)
+      expect do
+        subject.latest_version("not_real")
+      end.to raise_error(Berkshelf::CommunitySiteError)
     end
   end
 
-  describe '#versions' do
-    it 'returns an array containing an item for each version' do
+  describe "#versions" do
+    it "returns an array containing an item for each version" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon").to_return(
         status: 200,
         body: '{ "versions": ["/bacon/versions/1_0_0", "/bacon/versions/2_0_0"] }',
-        headers: { 'Content-Type' => 'application/json' }
+        headers: { "Content-Type" => "application/json" }
       )
 
-      versions = subject.versions('bacon')
+      versions = subject.versions("bacon")
       expect(versions.size).to eq(2)
     end
 
-    it 'raises a CookbookNotFound error on a 404 response' do
+    it "raises a CookbookNotFound error on a 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 404,
-        body: nil,
+        body: "Not Found"
       )
 
-      expect {
-        subject.versions('not_real')
-      }.to raise_error(Berkshelf::CookbookNotFound)
+      expect do
+        subject.versions("not_real")
+      end.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'raises a CommunitySiteError error on any non 200 or 404 response' do
+    it "raises a CommunitySiteError error on any non 200 or 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 500,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.versions('not_real')
-      }.to raise_error(Berkshelf::CommunitySiteError)
+      expect do
+        subject.versions("not_real")
+      end.to raise_error(Berkshelf::CommunitySiteError)
     end
   end
 
-  describe '#satisfy' do
-    it 'returns the version number of the best solution' do
+  describe "#satisfy" do
+    it "returns the version number of the best solution" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon").to_return(
         status: 200,
         body: '{ "versions": ["/bacon/versions/1_0_0", "/bacon/versions/2_0_0"] }',
-        headers: { 'Content-Type' => 'application/json' }
+        headers: { "Content-Type" => "application/json" }
       )
 
-      result = subject.satisfy('bacon', '= 1.0.0')
-      expect(result).to eq('1.0.0')
+      result = subject.satisfy("bacon", "= 1.0.0")
+      expect(result).to eq("1.0.0")
     end
   end
 
-  describe '#stream' do
+  describe "#stream" do
     skip
   end
 end

data/spec/unit/berkshelf/config_spec.rb

@@ -1,51 +1,80 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::Config do
-  describe '::file' do
-    context 'when the file does not exist' do
-      before { allow(File).to receive(:exists?).and_return(false) }
+  describe "::instance" do
+    it "should be a Berkshelf::Config" do
+      expect(Berkshelf::Config.instance).to be_an_instance_of(Berkshelf::Config)
+    end
 
-      it 'is nil' do
-        expect(Berkshelf::Config.file).to be_nil
+    context "attributes" do
+      it "should have a default API timeout" do
+        expect(Berkshelf::Config.instance.api.timeout).to eq("30")
       end
     end
-  end
 
-  describe '::instance' do
-    it 'should be a Berkshelf::Config' do
-      expect(Berkshelf::Config.instance).to be_an_instance_of(Berkshelf::Config)
-    end
+    context "a Chef config to read defaults from" do
+      let(:chef_config) do
+        double(
+          Berkshelf::ChefConfigCompat,
+          chef_server_url: "https://chef.example.com",
+          validation_client_name: "validator",
+          validation_key: "validator.pem",
+          client_key: "client-key",
+          node_name: "fake-client",
+          trusted_certs_dir: "/tmp/fakecerts",
+          artifactory_api_key: "secret"
+        )
+      end
+
+      before do
+        allow(Berkshelf).to receive(:chef_config).and_return(chef_config)
+      end
 
-    context 'attributes' do
-      it 'should have a default API timeout' do
-        expect(Berkshelf::Config.instance.api.timeout).to eq('30')
+      {
+        chef_server_url: "https://chef.example.com",
+        validation_client_name: "validator",
+        validation_key_path: "validator.pem",
+        client_key: "client-key",
+        node_name: "fake-client",
+        trusted_certs_dir: "/tmp/fakecerts",
+        artifactory_api_key: "secret",
+      }.each do |attr, default|
+        it "should have a default chef.#{attr}" do
+          expect(Berkshelf::Config.instance.chef.send(attr)).to eq(default)
+        end
       end
     end
   end
 
-  describe '::path' do
-    it 'is a string' do
+  describe "::path" do
+    it "is a string" do
       expect(Berkshelf::Config.path).to be_a(String)
     end
 
-    before do
-      allow(File).to receive(:exists?).and_return(false)
-    end
-
     after do
       Berkshelf::Config.instance_variable_set(:@path, nil)
     end
 
     context "when ENV['BERKSHELF_CONFIG'] is used" do
       before do
-        allow(ENV).to receive(:[]).with('BERKSHELF_CONFIG').and_return('/tmp/config.json')
-        allow(File).to receive(:exists?).with('/tmp/config.json').and_return(true)
+        allow(ENV).to receive(:[]).with("BERKSHELF_CONFIG").and_return("/tmp/config.json")
+        allow(File).to receive(:exist?).with("/tmp/config.json").and_return(true)
       end
 
       it "points to a location within it" do
         expect(Berkshelf::Config.path).to match(%r{/tmp/config.json})
       end
     end
+
+    it "reads json from a path" do
+      Tempfile.open(["berkstest", ".json"]) do |t|
+        t.write JSON.generate({ "ssl" => { "verify" => false } })
+        t.close
+        expect(Berkshelf::Config).to receive(:local_location).at_least(:once).and_return(t.path)
+        Berkshelf::Config.reload
+        expect( Berkshelf::Config.instance[:ssl][:verify] ).to be false
+      end
+    end
   end
 
   describe "::set_path" do

data/spec/unit/berkshelf/cookbook_store_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::CookbookStore do
   describe "ClassMethods" do
@@ -6,8 +6,8 @@ describe Berkshelf::CookbookStore do
     describe "::import"
 
     describe "::new" do
-      it 'creates the storage_path' do
-        storage_path = tmp_path.join('random_storage')
+      it "creates the storage_path" do
+        storage_path = tmp_path.join("random_storage")
         Berkshelf::CookbookStore.new(storage_path)
 
         expect(storage_path).to exist
@@ -17,103 +17,103 @@ describe Berkshelf::CookbookStore do
 
   subject { Berkshelf::CookbookStore.new(tmp_path.join("cbstore_rspec")) }
 
-  describe '#cookbook_path' do
-    let(:cookbook_name) { 'nginx' }
-    let(:cookbook_version) { '0.101.2' }
+  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 an instance of Pathname' do
+    it "returns an instance of Pathname" do
       expect(path).to be_a(Pathname)
     end
 
-    it 'returns a the filepath within the storage path' do
+    it "returns a the filepath within the storage path" do
       expect(path.dirname).to eq(subject.storage_path)
     end
 
-    it 'returns a basename containing the cookbook name and version separated by a dash' do
+    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
 
-  describe '#satisfy' do
-    let(:name) { 'nginx' }
-    let(:version) { '0.101.4' }
-    let(:constraint) { Semverse::Constraint.new('~> 0.101.2') }
-    let(:cached_one) { double('cached-one', name: name, version: Semverse::Version.new(version)) }
-    let(:cached_two) { double('cached-two', name: 'mysql', version: Semverse::Version.new('1.2.6')) }
+  describe "#satisfy" do
+    let(:name) { "nginx" }
+    let(:version) { "0.101.4" }
+    let(:constraint) { Semverse::Constraint.new("~> 0.101.2") }
+    let(:cached_one) { double("cached-one", name: name, version: Semverse::Version.new(version)) }
+    let(:cached_two) { double("cached-two", name: "mysql", version: Semverse::Version.new("1.2.6")) }
 
     before { allow(subject).to receive(:cookbooks).and_return([cached_one, cached_two]) }
 
-    it 'gets and returns the the CachedCookbook best matching the name and constraint' do
+    it "gets and returns the the CachedCookbook best matching the name and constraint" do
       expect(subject).to receive(:cookbook).with(name, version).and_return(cached_one)
       result = subject.satisfy(name, constraint)
 
       expect(result).to eq(cached_one)
     end
 
-    context 'when there are no cookbooks in the cookbook store' do
+    context "when there are no cookbooks in the cookbook store" do
       before { allow(subject).to receive(:cookbooks).and_return([]) }
 
-      it 'returns nil' do
+      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) { Semverse::Version.new('1.0.0') }
-      let(:constraint) { Semverse::Constraint.new('= 0.1.0') }
+    context "when there is no matching cookbook for the given name and constraint" do
+      let(:version) { Semverse::Version.new("1.0.0") }
+      let(:constraint) { Semverse::Constraint.new("= 0.1.0") }
 
-      before { allow(subject).to receive(:cookbooks).and_return([ double('badcache', name: 'none', version: version) ]) }
+      before { allow(subject).to receive(:cookbooks).and_return([ double("badcache", name: "none", version: version) ]) }
 
-      it 'returns nil if there is no matching cookbook for the name and constraint' do
+      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 { Berkshelf::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
-      expect(subject.cookbook('example_cookbook', '0.5.0')).to be_a(Berkshelf::CachedCookbook)
+    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
-      expect(subject.cookbook('doesnotexist', '0.1.0')).to be_nil
+    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
+  describe "#cookbooks" do
     before do
-      generate_cookbook(subject.storage_path, 'nginx', '0.101.2')
-      generate_cookbook(subject.storage_path, 'mysql', '1.2.6')
+      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
+    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
+    it "contains a CachedCookbook for every cookbook in the storage path" do
       expect(subject.cookbooks.size).to eq(2)
     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').size).to eq(1)
+    context "given a value for the filter parameter" do
+      it "returns only the CachedCookbooks whose name match the filter" do
+        expect(subject.cookbooks("mysql").size).to eq(1)
       end
     end
 
-    context 'when a there is a cookbook without a name attribute' do
+    context "when a there is a cookbook without a name attribute" do
       before do
-        generate_cookbook(subject.storage_path, 'foo', '3.0.1', without_name: true)
+        generate_cookbook(subject.storage_path, "foo", "3.0.1", without_name: true)
       end
 
-      it 'omits the broken cookbook' do
-        expect(subject.cookbooks('foo')).to be_empty
+      it "omits the broken cookbook" do
+        expect(subject.cookbooks("foo")).to be_empty
       end
     end
   end

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

@@ -1,19 +1,18 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe FileUtils do
-  describe '#mv' do
-    let(:src) { 'src' }
-    let(:dest) { 'dest' }
+  describe "#mv" do
+    let(:src) { "src" }
+    let(:dest) { "dest" }
     let(:options) { {} }
 
     it "uses mv by default" do
-      expect(FileUtils).to receive(:old_mv).with(src, dest, options)
+      expect(FileUtils).to receive(:old_mv).with(src, dest, **options)
       FileUtils.mv(src, dest, options)
     end
 
-
-    it 'replaces mv with cp_r and rm_rf' do
-      expect(FileUtils).to receive(:cp_r).with(src, dest, options)
+    it "replaces mv with cp_r and rm_rf" do
+      expect(FileUtils).to receive(:cp_r).with(src, dest, **options)
       expect(FileUtils).to receive(:rm_rf).with(src)
 
       FileUtils.mv(src, dest, options)

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

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Pathname do
   describe "#cookbook?" do