berkshelf 5.2.0 → 8.0.15

data/spec/unit/berkshelf/uploader_spec.rb

@@ -1,164 +1,246 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe Uploader do
     let(:berksfile) do
       double(Berksfile,
         lockfile: lockfile,
-        dependencies: [],
-      )
+        dependencies: [])
     end
 
     let(:lockfile) do
       double(Lockfile,
-        graph: graph
-      )
+        graph: graph)
     end
 
     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 { Uploader.new(berksfile) }
 
-    describe '#initialize' do
-      it 'saves the berksfile' do
+    describe "#initialize" do
+      it "saves the berksfile" do
         instance = Uploader.new(berksfile)
         expect(instance.berksfile).to be(berksfile)
       end
 
-      it 'saves the lockfile' do
+      it "saves the lockfile" do
         instance = Uploader.new(berksfile)
         expect(instance.lockfile).to be(lockfile)
       end
 
-      it 'saves the options' do
+      it "saves the options" do
         instance = Uploader.new(berksfile, force: true, validate: false)
         options = instance.options
         expect(options[:force]).to be(true)
         expect(options[:validate]).to be(false)
       end
 
-      it 'saves the names' do
-        instance = Uploader.new(berksfile, 'cookbook_1', 'cookbook_2')
-        expect(instance.names).to eq(['cookbook_1', 'cookbook_2'])
+      it "saves the names" do
+        instance = Uploader.new(berksfile, "cookbook_1", "cookbook_2")
+        expect(instance.names).to eq(%w{cookbook_1 cookbook_2})
       end
     end
 
-    describe '#run' do
-      let(:options) { Hash.new }
+    describe "#run" do
+      let(:options) { {} }
 
       let(:chef_config) do
-        double(Ridley::Chef::Config,
-          node_name: 'fake-client',
-          client_key: 'client-key',
-          chef_server_url: 'http://configured-chef-server/',
-          validation_client_name: 'validator',
-          validation_key: 'validator.pem',
-          cookbook_copyright: 'user',
-          cookbook_email: 'user@example.com',
-          cookbook_license: 'apachev2',
-          knife: {
-            chef_guard: false
-          }
-        )
+        double(Berkshelf::ChefConfigCompat,
+          node_name: "fake-client",
+          client_key: "client-key",
+          chef_server_url: "http://configured-chef-server/",
+          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
-        )
+          chef: chef_config)
       end
 
       let(:default_ridley_options) do
         {
-          client_name: 'fake-client',
-          client_key: 'client-key',
+          client_name: "fake-client",
+          client_key: "client-key",
           ssl: {
-            verify: true
-          }
+            verify: true,
+          },
         }
       end
 
       before do
         allow(Berkshelf).to receive(:config).and_return(berkshelf_config)
+        allow(Berkshelf).to receive(:ssl_policy).and_return(ssl_policy)
       end
 
-      context 'when there is no value for :chef_server_url' do
+      context "when there is no value for :chef_server_url" do
         before { allow(chef_config).to receive_messages(chef_server_url: nil) }
-        let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.server_url' }
+        let(:message) { "Missing required attribute in your Berkshelf configuration: chef.server_url" }
 
-        it 'raises an error' do
+        it "raises an error" do
           expect { subject.run }.to raise_error(Berkshelf::ChefConnectionError, message)
         end
       end
 
-      context 'when there is no value for :client_name' do
+      context "when there is no value for :client_name" do
         before { allow(chef_config).to receive_messages(node_name: nil) }
-        let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.node_name' }
+        let(:message) { "Missing required attribute in your Berkshelf configuration: chef.node_name" }
 
-        it 'raises an error' do
+        it "raises an error" do
           expect { subject.run }.to raise_error(Berkshelf::ChefConnectionError, message)
         end
       end
 
-      context 'when there is no value for :client_key' do
+      context "when there is no value for :client_key" do
         before { allow(chef_config).to receive_messages(client_key: nil) }
-        let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.client_key' }
+        let(:message) { "Missing required attribute in your Berkshelf configuration: chef.client_key" }
 
-        it 'raises an error' do
-          expect {
+        it "raises an error" do
+          expect do
             subject.run
-          }.to raise_error(Berkshelf::ChefConnectionError, message)
+          end.to raise_error(Berkshelf::ChefConnectionError, message)
         end
       end
 
-      context 'when no options are given' do
+      context "when no options are given" do
         let(:ridley_options) do
-          { server_url: 'http://configured-chef-server/' }.merge(default_ridley_options)
+          { server_url: "http://configured-chef-server/" }.merge(default_ridley_options)
         end
 
-        it 'uses the Berkshelf::Config options' do
-          expect(Ridley).to receive(:open).with(
+        it "uses the Berkshelf::Config options" do
+          expect(Berkshelf::RidleyCompat).to receive(:new_client).with(
             server_url:  chef_config.chef_server_url,
             client_name: chef_config.node_name,
             client_key:  chef_config.client_key,
             ssl: {
-              verify: berkshelf_config.ssl.verify
+              verify: berkshelf_config.ssl.verify,
+              cert_store: cert_store,
             }
           )
           subject.run
         end
       end
 
-      context 'when a Chef Server url is passed as an option' do
-        subject { Uploader.new(berksfile, server_url: 'http://custom') }
+      context "when ssl_verify: false is passed as an option" do
+        subject { Uploader.new(berksfile, ssl_verify: false) }
 
-        it 'uses the passed in :server_url' do
-          expect(Ridley).to receive(:open)
-            .with(include(server_url: 'http://custom'))
+        it "uses the passed option" do
+          expect(Berkshelf::RidleyCompat).to receive(:new_client).with(
+            server_url:  chef_config.chef_server_url,
+            client_name: chef_config.node_name,
+            client_key:  chef_config.client_key,
+            ssl: {
+              verify: false,
+              cert_store: cert_store,
+            }
+          )
           subject.run
         end
       end
 
-      context 'when a client name is passed as an option' do
-        subject { Uploader.new(berksfile, client_name: 'custom') }
+      context "when a Chef Server url is passed as an option" do
+        subject { Uploader.new(berksfile, server_url: "http://custom") }
 
-        it 'uses the passed in :client_name' do
-          expect(Ridley).to receive(:open)
-            .with(include(client_name: 'custom'))
+        it "uses the passed in :server_url" do
+          expect(Berkshelf::RidleyCompat).to receive(:new_client)
+            .with(include(server_url: "http://custom"))
           subject.run
         end
       end
 
-      context 'when a client key is passed as an option' do
-        subject { Uploader.new(berksfile, client_key: 'custom') }
+      context "when a client name is passed as an option" do
+        subject { Uploader.new(berksfile, client_name: "custom") }
 
-        it 'uses the passed in :client_key' do
-          expect(Ridley).to receive(:open)
-            .with(include(client_key: 'custom'))
+        it "uses the passed in :client_name" do
+          expect(Berkshelf::RidleyCompat).to receive(:new_client)
+            .with(include(client_name: "custom"))
           subject.run
         end
       end
+
+      context "when a client key is passed as an option" do
+        subject { Uploader.new(berksfile, client_key: "custom") }
+
+        it "uses the passed in :client_key" do
+          expect(Berkshelf::RidleyCompat).to receive(:new_client)
+            .with(include(client_key: "custom"))
+          subject.run
+        end
+      end
+    end
+
+    describe "#lookup_dependencies" do
+      before do
+        allow_any_instance_of(Berkshelf::Berksfile).to receive(:lockfile).and_return(lockfile)
+      end
+
+      let(:berksfile) { Berkshelf::Berksfile.from_file(fixtures_path.join("berksfiles/default")) }
+      let(:lockfile) { Berkshelf::Lockfile.from_file(fixtures_path.join("lockfiles/default.lock")) }
+
+      context "when given a cookbook that has no dependencies" do
+        subject { described_class.new(berksfile).send(:lookup_dependencies, "yum") }
+
+        it "returns empty array" do
+          expect(subject).to eq []
+        end
+      end
+
+      context "when given a cookbook that has dependencies" do
+        subject { described_class.new(berksfile).send(:lookup_dependencies, "yum-epel") }
+
+        it "returns array of cookbook's dependencies" do
+          expect(subject).to eq ["yum"]
+        end
+      end
+
+      context "when given a cookbook that has dependencies which have dependencies" do
+        subject { described_class.new(berksfile).send(:lookup_dependencies, "runit") }
+
+        it "returns array of cookbook's dependencies and their dependencies" do
+          expect(subject).to eq %w{build-essential yum yum-epel}
+        end
+      end
+    end
+
+    describe "#filtered_cookbooks" do
+      context "when iterating over a list of of cookbooks that have dependencies" do
+        before do
+          allow_any_instance_of(Berkshelf::Dependency).to receive(:berksfile).and_return(berksfile)
+          allow_any_instance_of(Berkshelf::Berksfile).to receive(:lockfile).and_return(lockfile)
+          allow(Berkshelf::CookbookStore).to receive(:instance).and_return(cookbook_store)
+        end
+
+        let(:berksfile) { Berkshelf::Berksfile.from_file(fixtures_path.join("berksfiles/default")) }
+        let(:lockfile) { Berkshelf::Lockfile.from_file(fixtures_path.join("lockfiles/default.lock")) }
+        let(:cookbook_store) { Berkshelf::CookbookStore.new(fixtures_path.join("cookbook-path-uploader")) }
+
+        subject { described_class.new(berksfile).send(:filtered_cookbooks) }
+
+        it "returns filtered list in correct order" do
+          upload_order = subject.map(&:name)
+          # assert that dependent cookbooks are uploaded before the cookbooks that depend on them
+          expect(upload_order.index("apt")).to be < upload_order.index("jenkins")
+          expect(upload_order.index("runit")).to be < upload_order.index("jenkins")
+          expect(upload_order.index("yum")).to be < upload_order.index("jenkins")
+          expect(upload_order.index("jenkins")).to be < upload_order.index("jenkins-config")
+          expect(upload_order.index("yum")).to be < upload_order.index("jenkins-config")
+          expect(upload_order.index("build-essential")).to be < upload_order.index("runit")
+          expect(upload_order.index("yum")).to be < upload_order.index("runit")
+          expect(upload_order.index("yum-epel")).to be < upload_order.index("runit")
+          expect(upload_order.index("yum")).to be < upload_order.index("yum-epel")
+          expect(upload_order.uniq.length).to eql(upload_order.length)
+        end
+      end
     end
   end
 end

data/spec/unit/berkshelf/validator_spec.rb

@@ -1,30 +1,37 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::Validator do
-  describe '#validate_files' do
-    let(:cookbook) { double('cookbook', cookbook_name: 'cookbook', path: 'path') }
+  describe "#validate_files" do
+    let(:cookbook) { double("cookbook", cookbook_name: "cookbook", path: "path") }
 
-    it 'raises an error when the cookbook has spaces in the files' do
-      allow(Dir).to receive(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
-      expect {
+    it "raises an error when the cookbook has spaces in the files" do
+      allow(Dir).to receive(:glob).and_return(["/there are/spaces/in this/recipes/default.rb"])
+      allow(cookbook).to receive(:dependencies).and_return({"cookbook" => "1.0.0"})
+      expect do
         subject.validate_files(cookbook)
-      }.to raise_error(Berkshelf::InvalidCookbookFiles)
+      end.to raise_error(Berkshelf::InvalidCookbookFiles)
     end
 
-    it 'does not raise an error when the cookbook is valid' do
-      allow(Dir).to receive(:glob).and_return(['/there-are/no-spaces/in-this/recipes/default.rb'])
-      expect {
+    it "does not raise an error when the cookbook is valid" do
+      allow(Dir).to receive(:glob).and_return(["/there-are/no-spaces/in-this/recipes/default.rb"])
+      allow(cookbook).to receive(:dependencies).and_return({"cookbook" => "1.0.0"})
+      expect do
         subject.validate_files(cookbook)
-      }.to_not raise_error
+      end.to_not raise_error
     end
 
-    it 'does not raise an exception with spaces in the path' do
-      allow(Dir).to receive(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
-      allow_any_instance_of(Pathname).to receive(:dirname).and_return('/there are/spaces/in this')
+    it "raises an error when the cookbook version is not valid" do
+      allow(cookbook).to receive(:dependencies).and_return({"cookbook" => "1"})
+      expect do
+        subject.validate_files(cookbook)
+      end.to raise_error
+    end
 
-      expect {
+    it "does not raise an error when the cookbook version is valid" do
+      allow(cookbook).to receive(:dependencies).and_return({"cookbook" => "1.0"})
+      expect do
         subject.validate_files(cookbook)
-      }.to_not raise_error
+      end.to_not raise_error
     end
   end
 end

data/spec/unit/berkshelf/visualizer_spec.rb

@@ -1,43 +1,52 @@
-require 'rspec'
-require 'spec_helper'
+require "rspec"
+require "spec_helper"
 
 module Berkshelf
   describe Visualizer, :not_supported_on_windows do
-    describe '#to_png' do
-      context 'when graphviz is not installed' do
+    describe "#to_png" do
+      context "when graphviz is not installed" do
         before do
           allow(Berkshelf).to receive(:which)
-            .with('dot')
+            .with("dot")
             .and_return(nil)
           allow(Berkshelf).to receive(:which)
-            .with('dot.exe')
+            .with("dot.exe")
             .and_return(nil)
         end
 
-        it 'raises a GraphvizNotInstalled exception' do
+        it "raises a GraphvizNotInstalled exception" do
           expect { subject.to_png }.to raise_error(GraphvizNotInstalled)
         end
       end
 
-      context 'when the graphviz command fails', :graphviz do
+      context "when the graphviz command fails", :graphviz do
         before do
-          response = double(success?: false, stderr: 'Something happened!')
+          response = double(error?: true, stderr: "Something happened!")
           allow(subject).to receive(:shell_out).and_return(response)
         end
 
-        it 'raises a GraphvizCommandFailed exception' do
+        it "raises a GraphvizCommandFailed exception" do
           expect { subject.to_png }.to raise_error(GraphvizCommandFailed)
         end
       end
 
-      context 'when the graphviz command succeeds', :graphviz do
-        it 'builds a png from a Lockfile' do
-          outfile = tmp_path.join('test-graph.png').to_s
-          lockfile = Lockfile.from_file(fixtures_path.join('lockfiles/default.lock').to_s)
+      context "when the graphviz command succeeds", :graphviz do
+        it "builds a dot from a Lockfile" do
+          outfile = tmp_path.join("test-graph.dot").to_s
+          lockfile = Lockfile.from_file(fixtures_path.join("lockfiles/default.lock").to_s)
+
+          Visualizer.from_lockfile(lockfile).to_dot_file(outfile)
+
+          expect(File.exist?(outfile)).to be true
+        end
+
+        it "builds a png from a Lockfile" do
+          outfile = tmp_path.join("test-graph.png").to_s
+          lockfile = Lockfile.from_file(fixtures_path.join("lockfiles/default.lock").to_s)
 
           Visualizer.from_lockfile(lockfile).to_png(outfile)
 
-          expect(File.exists?(outfile)).to be true
+          expect(File.exist?(outfile)).to be true
         end
       end
     end

data/spec/unit/berkshelf_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
-  describe '.formatter' do
-    context 'with default formatter' do
+  describe ".formatter" do
+    context "with default formatter" do
       before { Berkshelf.instance_variable_set(:@formatter, nil) }
 
-      it 'is human readable' do
+      it "is human readable" do
         expect(Berkshelf.formatter).to be_an_instance_of(HumanFormatter)
       end
     end
 
-    context 'with a custom formatter' do
+    context "with a custom formatter" do
       before(:all) do
         Berkshelf.instance_eval { @formatter = nil }
       end
@@ -21,41 +21,41 @@ module Berkshelf
         Berkshelf.set_format :custom
       end
 
-      it 'is custom class' do
+      it "is custom class" do
         expect(Berkshelf.formatter).to be_an_instance_of(CustomFormatter)
       end
     end
   end
 
-  describe '.berkshelf_path' do
+  describe ".berkshelf_path" do
     before { Berkshelf.instance_variable_set(:@berkshelf_path, nil) }
 
-    context 'with default path' do
+    context "with default path" do
       before do
-        @berkshelf_path = ENV['BERKSHELF_PATH']
-        ENV['BERKSHELF_PATH'] = nil
+        @berkshelf_path = ENV["BERKSHELF_PATH"]
+        ENV["BERKSHELF_PATH"] = nil
       end
 
       after do
-        ENV['BERKSHELF_PATH'] = @berkshelf_path
+        ENV["BERKSHELF_PATH"] = @berkshelf_path
       end
 
-      it 'is ~/.berkshelf' do
-        expect(Berkshelf.berkshelf_path).to eq File.expand_path('~/.berkshelf')
-        expect(Berkshelf.instance_variable_get(:@berkshelf_path)).to eq File.expand_path('~/.berkshelf')
+      it "is ~/.berkshelf" do
+        expect(Berkshelf.berkshelf_path).to eq File.expand_path("~/.berkshelf")
+        expect(Berkshelf.instance_variable_get(:@berkshelf_path)).to eq File.expand_path("~/.berkshelf")
       end
     end
 
     context 'with ENV["BERKSHELF_PATH"]' do
       it 'is ENV["BERKSHELF_PATH"]' do
-        expect(Berkshelf.berkshelf_path).to eq File.expand_path(ENV['BERKSHELF_PATH'])
-        expect(Berkshelf.instance_variable_get(:@berkshelf_path)).to eq File.expand_path(ENV['BERKSHELF_PATH'])
+        expect(Berkshelf.berkshelf_path).to eq File.expand_path(ENV["BERKSHELF_PATH"])
+        expect(Berkshelf.instance_variable_get(:@berkshelf_path)).to eq File.expand_path(ENV["BERKSHELF_PATH"])
       end
     end
   end
 
-  describe '::log' do
-    it 'returns Berkshelf::Logger' do
+  describe "::log" do
+    it "returns Berkshelf::Logger" do
       expect(Berkshelf.log).to be_a(Berkshelf::Logger)
     end
   end