berkshelf 5.2.0 → 8.0.15

data/spec/unit/berkshelf/dependency_spec.rb

@@ -1,88 +1,88 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::Dependency do
-  let(:cookbook_name) { 'nginx' }
-  let(:berksfile) { double('berksfile', filepath: fixtures_path.join('Berksfile').to_s) }
+  let(:cookbook_name) { "nginx" }
+  let(:berksfile) { double("berksfile", filepath: fixtures_path.join("Berksfile").to_s) }
 
   describe "ClassMethods" do
     describe "::new" do
       let(:source) { described_class.new(berksfile, cookbook_name) }
 
-      context 'given no location key (i.e. :git, :path, :site)' do
-        it 'sets a nil valie for location' do
+      context "given no location key (i.e. :git, :path, :site)" do
+        it "sets a nil valie for location" do
           expect(source.location).to be_nil
         end
       end
 
-      context 'given no value for :locked_version' do
-        it 'returns a wildcard match for any version' do
+      context "given no value for :locked_version" do
+        it "returns a wildcard match for any version" do
           expect(source.locked_version).to be_nil
         end
       end
 
-      context 'given no value for :constraint' do
-        it 'returns a wildcard match for any version' do
-          expect(source.version_constraint.to_s).to eq('>= 0.0.0')
+      context "given no value for :constraint" do
+        it "returns a wildcard match for any version" do
+          expect(source.version_constraint.to_s).to eq(">= 0.0.0")
         end
       end
 
-      context 'given a value for :constraint' do
-        let(:source) { described_class.new(berksfile, cookbook_name, constraint: '~> 1.0.84') }
+      context "given a value for :constraint" do
+        let(:source) { described_class.new(berksfile, cookbook_name, constraint: "~> 1.0.84") }
 
-        it 'returns a Semverse::Constraint for the given version for version_constraint' do
-          expect(source.version_constraint.to_s).to eq('~> 1.0.84')
+        it "returns a Semverse::Constraint for the given version for version_constraint" do
+          expect(source.version_constraint.to_s).to eq("~> 1.0.84")
         end
       end
 
-      context 'given a location key :git' do
-        let(:url) { 'git://url_to_git' }
+      context "given a location key :git" do
+        let(:url) { "https://url_to_git" }
         let(:source) { described_class.new(berksfile, cookbook_name, git: url) }
 
-        it 'initializes a GitLocation for location' do
+        it "initializes a GitLocation for location" do
           expect(source.location).to be_a(Berkshelf::GitLocation)
         end
 
-        it 'points to the given Git URL' do
+        it "points to the given Git URL" do
           expect(source.location.uri).to eq(url)
         end
       end
 
-      context 'given a location key :path' do
-        context 'given a value for path that contains a cookbook' do
-          let(:path) { fixtures_path.join('cookbooks', 'example_cookbook').to_s }
+      context "given a location key :path" do
+        context "given a value for path that contains a cookbook" do
+          let(:path) { fixtures_path.join("cookbooks", "example_cookbook").to_s }
           let(:location) { described_class.new(berksfile, cookbook_name, path: path).location }
 
-          it 'initializes a PathLocation for location' do
+          it "initializes a PathLocation for location" do
             expect(location).to be_a(Berkshelf::PathLocation)
           end
 
-          it 'points to the specified path' do
+          it "points to the specified path" do
             expect(location.options[:path]).to eq(path)
           end
         end
 
-        context 'given a group option containing a single group' do
+        context "given a group option containing a single group" do
           let(:group) { :production }
           let(:source) { described_class.new(berksfile, cookbook_name, group: group) }
 
-          it 'assigns the single group to the groups attribute' do
+          it "assigns the single group to the groups attribute" do
             expect(source.groups).to include(group)
           end
         end
 
-        context 'given a group option containing an array of groups' do
-          let(:groups) { [ :development, :test ] }
+        context "given a group option containing an array of groups" do
+          let(:groups) { %i{development test} }
           let(:source) { described_class.new(berksfile, cookbook_name, group: groups) }
 
-          it 'assigns all the groups to the group attribute' do
+          it "assigns all the groups to the group attribute" do
             expect(source.groups).to eq(groups)
           end
         end
 
-        context 'given no group option' do
+        context "given no group option" do
           let(:source) { described_class.new(berksfile, cookbook_name) }
 
-          it 'has the default group assigned' do
+          it "has the default group assigned" do
             expect(source.groups).to include(:default)
           end
         end
@@ -92,40 +92,40 @@ describe Berkshelf::Dependency do
 
   subject { described_class.new(berksfile, cookbook_name) }
 
-  describe '#add_group' do
-    it 'stores strings as symbols' do
-      subject.add_group 'foo'
-      expect(subject.groups).to eq([:default, :foo])
+  describe "#add_group" do
+    it "stores strings as symbols" do
+      subject.add_group "foo"
+      expect(subject.groups).to eq(%i{default foo})
     end
 
-    it 'does not store duplicate groups' do
-      subject.add_group 'bar'
-      subject.add_group 'bar'
+    it "does not store duplicate groups" do
+      subject.add_group "bar"
+      subject.add_group "bar"
       subject.add_group :bar
-      expect(subject.groups).to eq([:default, :bar])
+      expect(subject.groups).to eq(%i{default bar})
     end
 
-    it 'adds multiple groups' do
-      subject.add_group 'baz', 'quux'
-      expect(subject.groups).to eq([:default, :baz, :quux])
+    it "adds multiple groups" do
+      subject.add_group "baz", "quux"
+      expect(subject.groups).to eq(%i{default baz quux})
     end
 
-    it 'handles multiple groups as an array' do
-      subject.add_group ['baz', 'quux']
-      expect(subject.groups).to eq([:default, :baz, :quux])
+    it "handles multiple groups as an array" do
+      subject.add_group %w{baz quux}
+      expect(subject.groups).to eq(%i{default baz quux})
     end
   end
 
   describe "#cached_cookbook"
   describe "#download"
 
-  describe '#installed?' do
-    it 'returns true if self.cached_cookbook is not nil' do
-      allow(subject).to receive(:cached_cookbook) { double('cb') }
+  describe "#installed?" do
+    it "returns true if self.cached_cookbook is not nil" do
+      allow(subject).to receive(:cached_cookbook) { double("cb") }
       expect(subject.installed?).to be(true)
     end
 
-    it 'returns false if self.cached_cookbook is nil' do
+    it "returns false if self.cached_cookbook is nil" do
       allow(subject).to receive(:cached_cookbook) { nil }
       expect(subject.installed?).to be(false)
     end

data/spec/unit/berkshelf/downloader_spec.rb

@@ -1,43 +1,200 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Berkshelf::Downloader do
-  let(:berksfile) { double('berksfile') }
-  subject { described_class.new(berksfile) }
-
-  describe "#download" do
-    skip
-  end
-
-  describe "#try_download" do
-    let(:remote_cookbook) { double('remote-cookbook') }
-    let(:source) do
-      source = double('source')
-      allow(source).to receive(:cookbook) { remote_cookbook }
-      source
-    end
-    let(:name) { "fake" }
-    let(:version) { "1.0.0" }
-
-    it "supports the 'opscode' location type" do
-      allow(remote_cookbook).to receive(:location_type) { :opscode }
-      allow(remote_cookbook).to receive(:location_path) { "http://api.opscode.com" }
-      rest = double('community-rest')
-      expect(Berkshelf::CommunityREST).to receive(:new).with("http://api.opscode.com") { rest }
-      expect(rest).to receive(:download).with(name, version)
-      subject.try_download(source, name, version)
+module Berkshelf
+  describe Downloader do
+    let(:berksfile) do
+      double(Berksfile,
+        lockfile: lockfile,
+        dependencies: [])
     end
 
-    it "supports the 'supermarket' location type" do
-      allow(remote_cookbook).to receive(:location_type) { :supermarket }
-      allow(remote_cookbook).to receive(:location_path) { "http://api.supermarket.com" }
-      rest = double('community-rest')
-      expect(Berkshelf::CommunityREST).to receive(:new).with("http://api.supermarket.com") { rest }
-      expect(rest).to receive(:download).with(name, version)
-      subject.try_download(source, name, version)
+    let(:lockfile) do
+      double(Lockfile,
+        graph: graph)
     end
 
-    it "supports the 'file_store' location type" do
+    let(:graph) { double(Lockfile::Graph, locks: {}) }
+    let(:self_signed_crt_path) { File.join(BERKS_SPEC_DATA, "trusted_certs") }
+    let(:self_signed_crt) { OpenSSL::X509::Certificate.new(IO.read("#{self_signed_crt_path}/example.crt")) }
+    let(:cert_store) { OpenSSL::X509::Store.new.add_cert(self_signed_crt) }
+    let(:ssl_policy) { double(SSLPolicy, store: cert_store) }
+
+    subject { described_class.new(berksfile) }
+
+    describe "#download" do
       skip
     end
+
+    describe "#try_download" do
+      let(:remote_cookbook) { double("remote-cookbook") }
+      let(:source) do
+        source = double("source")
+        allow(source).to receive(:cookbook) { remote_cookbook }
+        source
+      end
+      let(:name) { "fake" }
+      let(:version) { "1.0.0" }
+
+      it "supports the 'opscode' location type" do
+        allow(source).to receive(:type) { :supermarket }
+        allow(source).to receive(:options) { { ssl: {} } }
+        allow(remote_cookbook).to receive(:location_type) { :opscode }
+        allow(remote_cookbook).to receive(:location_path) { "http://api.opscode.com" }
+        rest = double("community-rest")
+        expect(CommunityREST).to receive(:new).with("http://api.opscode.com", { ssl: {} }) { rest }
+        expect(rest).to receive(:download).with(name, version)
+        subject.try_download(source, name, version)
+      end
+
+      it "supports the 'supermarket' location type" do
+        allow(source).to receive(:type) { :supermarket }
+        allow(source).to receive(:options) { { ssl: {} } }
+        allow(remote_cookbook).to receive(:location_type) { :supermarket }
+        allow(remote_cookbook).to receive(:location_path) { "http://api.supermarket.com" }
+        rest = double("community-rest")
+        expect(CommunityREST).to receive(:new).with("http://api.supermarket.com", { ssl: {} }) { rest }
+        expect(rest).to receive(:download).with(name, version)
+        subject.try_download(source, name, version)
+      end
+
+      context "supports location paths" do
+        before(:each) do
+          allow(source).to receive(:type) { :supermarket }
+          allow(source).to receive(:options) { { ssl: {} } }
+          allow(source).to receive(:uri_string).and_return("http://localhost:8081/repository/chef-proxy")
+          allow(remote_cookbook).to receive(:location_type) { :opscode }
+        end
+
+        let(:rest) { double("community-rest") }
+
+        it "that are relative and prepends the source URI for the download" do
+          allow(remote_cookbook).to receive(:location_path) { "/api/v1" }
+          expect(CommunityREST).to receive(:new).with("http://localhost:8081/repository/chef-proxy/api/v1", { ssl: {} }) { rest }
+          expect(rest).to receive(:download).with(name, version)
+          subject.try_download(source, name, version)
+        end
+
+        it "that are absolute and uses the given absolute URI" do
+          allow(remote_cookbook).to receive(:location_path) { "http://localhost:8081/repository/chef-proxy/api/v1" }
+          expect(CommunityREST).to receive(:new).with("http://localhost:8081/repository/chef-proxy/api/v1", { ssl: {} }) { rest }
+          expect(rest).to receive(:download).with(name, version)
+          subject.try_download(source, name, version)
+        end
+      end
+
+      context "with an artifactory source" do
+        it "supports the 'opscode' location type" do
+          allow(source).to receive(:type) { :artifactory }
+          allow(source).to receive(:options) { { api_key: "secret", ssl: {} } }
+          allow(remote_cookbook).to receive(:location_type) { :opscode }
+          allow(remote_cookbook).to receive(:location_path) { "http://artifactory/" }
+          rest = double("community-rest")
+          expect(CommunityREST).to receive(:new).with("http://artifactory/", { ssl: {}, headers: { "X-Jfrog-Art-Api" => "secret" } }) { rest }
+          expect(rest).to receive(:download).with(name, version)
+          subject.try_download(source, name, version)
+        end
+
+        it "supports the 'supermarket' location type" do
+          allow(source).to receive(:type) { :artifactory }
+          allow(source).to receive(:options) { { api_key: "secret", ssl: {} } }
+          allow(remote_cookbook).to receive(:location_type) { :supermarket }
+          allow(remote_cookbook).to receive(:location_path) { "http://artifactory/" }
+          rest = double("community-rest")
+          expect(CommunityREST).to receive(:new).with("http://artifactory/", { ssl: {}, headers: { "X-Jfrog-Art-Api" => "secret" } }) { rest }
+          expect(rest).to receive(:download).with(name, version)
+          subject.try_download(source, name, version)
+        end
+      end
+
+      describe "chef_server location type" do
+        let(:chef_server_url) { "http://configured-chef-server/" }
+        let(:ridley_client) do
+          instance_double(Berkshelf::RidleyCompat)
+        end
+        let(:chef_config) do
+          double(Berkshelf::ChefConfigCompat,
+            node_name: "fake-client",
+            client_key: "client-key",
+            chef_server_url: chef_server_url,
+            validation_client_name: "validator",
+            validation_key: "validator.pem",
+            artifactory_api_key: "secret",
+            cookbook_copyright: "user",
+            cookbook_email: "user@example.com",
+            cookbook_license: "apachev2",
+            trusted_certs_dir: self_signed_crt_path)
+        end
+
+        let(:berkshelf_config) do
+          double(Config,
+            ssl:  double(verify: true),
+            chef: chef_config)
+        end
+
+        before do
+          allow(Berkshelf).to receive(:config).and_return(berkshelf_config)
+          allow(subject).to receive(:ssl_policy).and_return(ssl_policy)
+          allow(remote_cookbook).to receive(:location_type) { :chef_server }
+          allow(remote_cookbook).to receive(:location_path) { chef_server_url }
+          allow(source).to receive(:options) { { read_timeout: 30, open_timeout: 3, ssl: { verify: true, cert_store: cert_store } } }
+        end
+
+        it "uses the berkshelf config and provides a custom cert_store" do
+          credentials = {
+            server_url: chef_server_url,
+            client_name: chef_config.node_name,
+            client_key: chef_config.client_key,
+            ssl: {
+              verify: berkshelf_config.ssl.verify,
+              cert_store: cert_store,
+            },
+          }
+          expect(Berkshelf::RidleyCompat).to receive(:new_client).with(credentials) { ridley_client }
+          subject.try_download(source, name, version)
+        end
+
+        context "with a source option for client_name" do
+          before do
+            allow(source).to receive(:options) { { client_name: "other-client", read_timeout: 30, open_timeout: 3, ssl: { verify: true, cert_store: cert_store } } }
+          end
+          it "uses the override" do
+            credentials = {
+              server_url: chef_server_url,
+              client_name: "other-client",
+              client_key: chef_config.client_key,
+              ssl: {
+                verify: berkshelf_config.ssl.verify,
+                cert_store: cert_store,
+              },
+            }
+            expect(Berkshelf::RidleyCompat).to receive(:new_client).with(credentials) { ridley_client }
+            subject.try_download(source, name, version)
+          end
+        end
+
+        context "with a source option for client_key" do
+          before do
+            allow(source).to receive(:options) { { client_key: "other-key", read_timeout: 30, open_timeout: 3, ssl: { verify: true, cert_store: cert_store } } }
+          end
+          it "uses the override" do
+            credentials = {
+              server_url: chef_server_url,
+              client_name: chef_config.node_name,
+              client_key: "other-key",
+              ssl: {
+                verify: berkshelf_config.ssl.verify,
+                cert_store: cert_store,
+              },
+            }
+            expect(Berkshelf::RidleyCompat).to receive(:new_client).with(credentials) { ridley_client }
+            subject.try_download(source, name, version)
+          end
+        end
+      end
+
+      it "supports the 'file_store' location type" do
+        skip
+      end
+    end
   end
 end

data/spec/unit/berkshelf/errors_spec.rb

@@ -1,12 +1,12 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::BerkshelfError do
   skip
 end
 
 describe Berkshelf::CommunitySiteError do
-  let(:api_uri) { 'https://infra.as.code' }
-  let(:message) { 'Cookbook name' }
+  let(:api_uri) { "https://infra.as.code" }
+  let(:message) { "Cookbook name" }
 
   subject { described_class.new(api_uri, message) }