berkshelf 5.2.0 → 8.0.15

data/spec/unit/berkshelf/resolver/graph_spec.rb

@@ -1,15 +1,16 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::Resolver::Graph, :not_supported_on_windows do
+  let(:berksfile) { double("Berksfile", filepath: "/test/Berksfile") }
   subject { described_class.new }
 
   describe "#populate" do
-    let(:sources) { Berkshelf::Source.new("http://localhost:26210") }
+    let(:sources) { Berkshelf::Source.new(berksfile, "http://supermarket.getchef.com") }
 
     before do
-      berks_dependency("ruby", "1.0.0", dependencies: { "elixir" => ">= 0.1.0" })
-      berks_dependency("ruby", "2.0.0")
-      berks_dependency("elixir", "1.0.0")
+      body_response = %q{{"ruby":{"1.0.0":{"endpoint_priority":0,"platforms":{},"dependencies":{"elixir":">= 0.1.0"},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"},"2.0.0":{"endpoint_priority":0,"platforms":{},"dependencies":{},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"}},"elixir":{"1.0.0":{"endpoint_priority":0,"platforms":{},"dependencies":{},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"}}}}
+      stub_request(:get, "http://supermarket.getchef.com/universe")
+        .to_return(status: 200, body: body_response, headers: { "Content-Type" => "application/json; charset=utf-8" })
     end
 
     it "adds each dependency to the graph" do
@@ -24,11 +25,12 @@ describe Berkshelf::Resolver::Graph, :not_supported_on_windows do
   end
 
   describe "#universe" do
-    let(:sources) { Berkshelf::Source.new("http://localhost:26210") }
+    let(:sources) { Berkshelf::Source.new(berksfile, "http://supermarket.getchef.com") }
 
     before do
-      berks_dependency("ruby", "1.0.0")
-      berks_dependency("elixir", "1.0.0")
+      body_response = %q{{"ruby":{"1.0.0":{"endpoint_priority":0,"platforms":{},"dependencies":{},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"}},"elixir":{"1.0.0":{"endpoint_priority":0,"platforms":{},"dependencies":{},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"}}}}
+      stub_request(:get, "http://supermarket.getchef.com/universe")
+        .to_return(status: 200, body: body_response, headers: { "Content-Type" => "application/json; charset=utf-8" })
     end
 
     it "returns an array of APIClient::RemoteCookbook" do

data/spec/unit/berkshelf/resolver_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::Resolver do
-  let(:berksfile) { double('berksfile') }
+  let(:berksfile) { double("berksfile") }
   let(:demand) { Berkshelf::Dependency.new(berksfile, "mysql", constraint: "= 1.2.4") }
 
   before(:each) do
@@ -11,7 +11,7 @@ describe Berkshelf::Resolver do
 
   describe "ClassMethods" do
     describe "::initialize" do
-      it 'adds the specified dependencies to the dependencies hash' do
+      it "adds the specified dependencies to the dependencies hash" do
         resolver = described_class.new(berksfile, demand)
         expect(resolver).to have_demand(demand)
       end
@@ -21,17 +21,17 @@ describe Berkshelf::Resolver do
   subject { Berkshelf::Resolver.new(berksfile) }
 
   describe "#add_demand" do
-    it 'adds the demand to the instance of resolver' do
+    it "adds the demand to the instance of resolver" do
       subject.add_demand(demand)
       expect(subject.demands).to include(demand)
     end
 
-    it 'raises a DuplicateDemand exception if a demand of the same name is added' do
+    it "raises a DuplicateDemand exception if a demand of the same name is added" do
       expect(subject).to receive(:has_demand?).with(demand).and_return(true)
 
-      expect {
+      expect do
         subject.add_demand(demand)
-      }.to raise_error(Berkshelf::DuplicateDemand)
+      end.to raise_error(Berkshelf::DuplicateDemand)
     end
   end
 
@@ -44,44 +44,44 @@ describe Berkshelf::Resolver do
   describe "#get_demand" do
     before { subject.add_demand(demand) }
 
-    context 'given a string representation of the demand to retrieve' do
-      it 'returns a Berkshelf::Dependency of the same name' do
+    context "given a string representation of the demand to retrieve" do
+      it "returns a Berkshelf::Dependency of the same name" do
         expect(subject.get_demand(demand.name)).to eq(demand)
       end
     end
   end
 
-  describe '#has_demand?' do
+  describe "#has_demand?" do
     before { subject.add_demand(demand) }
 
-    it 'returns true if the demand exists' do
+    it "returns true if the demand exists" do
       expect(subject.has_demand?(demand.name)).to be(true)
     end
 
-    it 'returns false if the demand does not exist' do
-      expect(subject.has_demand?('non-existent')).to be(false)
+    it "returns false if the demand does not exist" do
+      expect(subject.has_demand?("non-existent")).to be(false)
     end
   end
 
   describe "#resolve" do
-    describe 'given a missing required solver' do
+    describe "given a missing required solver" do
       before do
         allow(berksfile).to receive(:required_solver).and_return(:xyzzy)
         allow(berksfile).to receive(:preferred_solver).and_return(nil)
       end
 
-      it 'should raise an exception about missing required resolver :xyzzy' do
+      it "should raise an exception about missing required resolver :xyzzy" do
         expect { subject.compute_solver_engine(berksfile) }.to raise_error(/Engine `xyzzy` is not supported/)
       end
     end
 
-    describe 'given a missing preferred solver' do
+    describe "given a missing preferred solver" do
       before do
         allow(berksfile).to receive(:required_solver).and_return(nil)
         allow(berksfile).to receive(:preferred_solver).and_return(:xyzzy)
       end
 
-      it 'should not raise an exception about missing preferred resolver :xyzzy' do
+      it "should not raise an exception about missing preferred resolver :xyzzy" do
         expect { subject.compute_solver_engine(berksfile) }.not_to raise_error
       end
     end

data/spec/unit/berkshelf/ridley_compat_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "chef/cookbook_manifest"
+
+describe Berkshelf::RidleyCompat do
+  let(:opts) { {} }
+
+  subject { described_class.new(**opts) }
+
+  context "default" do
+    it "has a cookbook version_class" do
+      expect(subject.options).to have_key(:version_class)
+      expect(subject.options[:version_class])
+        .to eq(Chef::CookbookManifestVersions)
+    end
+  end
+end

data/spec/unit/berkshelf/shell_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe Shell do
-    let(:stdout) { double('stdout', tty?: true) }
-    let(:stderr) { double('stderr') }
+    let(:stdout) { double("stdout", tty?: true) }
+    let(:stderr) { double("stderr") }
 
     before do
       allow_any_instance_of(described_class).to receive(:stdout)
@@ -13,119 +13,119 @@ module Berkshelf
         .and_return(stderr)
     end
 
-    describe '#mute!' do
-      it 'sets @mute to true' do
+    describe "#mute!" do
+      it "sets @mute to true" do
         subject.mute!
         expect(subject.instance_variable_get(:@mute)).to be(true)
       end
     end
 
-    describe '#unmute!' do
-      it 'sets @mute to false' do
+    describe "#unmute!" do
+      it "sets @mute to false" do
         subject.unmute!
         expect(subject.instance_variable_get(:@mute)).to be(false)
       end
     end
 
-    describe '#say' do
-      context 'when quiet?' do
+    describe "#say" do
+      context "when quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(true)
         end
 
-        it 'does not output anything', :not_supported_on_windows do
+        it "does not output anything", :not_supported_on_windows do
           expect(stdout).to_not receive(:print)
           expect(stdout).to_not receive(:puts)
-          subject.say 'message'
+          subject.say "message"
         end
       end
 
-      context 'with not quiet?' do
+      context "with not quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(false)
         end
 
-        it 'prints to stdout' do
+        it "prints to stdout" do
           expect(stdout).to receive(:print).once
           expect(stdout).to receive(:flush).once
-          subject.say 'message'
+          subject.say "message"
         end
       end
     end
 
-    describe '#say_status' do
-      context 'when quiet?' do
+    describe "#say_status" do
+      context "when quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(true)
         end
 
-        it 'does not output anything' do
+        it "does not output anything" do
           expect(stdout).to_not receive(:print)
           expect(stdout).to_not receive(:puts)
-          subject.say_status 5, 'message'
+          subject.say_status 5, "message"
         end
       end
 
-      context 'with not quiet?' do
+      context "with not quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(false)
         end
 
-        it 'prints to stdout' do
+        it "prints to stdout" do
           expect(stdout).to receive(:print).once
           expect(stdout).to receive(:flush).once
-          subject.say_status 5, 'message'
+          subject.say_status 5, "message"
         end
       end
     end
 
-    describe '#warn' do
-      context 'when quiet?' do
+    describe "#warn" do
+      context "when quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(true)
         end
 
-        it 'does not output anything' do
+        it "does not output anything" do
           expect(stdout).to_not receive(:print)
           expect(stdout).to_not receive(:puts)
-          subject.warn 'warning'
+          subject.warn "warning"
         end
       end
 
-      context 'with not quiet?' do
+      context "with not quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(false)
         end
 
-        it 'calls #say with yellow coloring' do
+        it "calls #say with yellow coloring" do
           expect(stdout).to receive(:print).once
           expect(stdout).to receive(:flush).once
-          subject.warn 'warning'
+          subject.warn "warning"
         end
       end
     end
 
-    context '#error' do
-      context 'when quiet?' do
+    context "#error" do
+      context "when quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(true)
         end
 
         it "outputs an error message", :not_supported_on_windows do
           expect(stderr).to receive(:puts)
-          subject.error 'error!'
+          subject.error "error!"
         end
       end
 
-      context 'with not quiet?' do
+      context "with not quiet?" do
         before do
           allow(subject).to receive(:quiet?).and_return(false)
         end
 
-        it 'prints to stderr' do
+        it "prints to stderr" do
           expect(stderr).to receive(:puts)
             .with(windows? ? "error!" : "\e[31merror!\e[0m")
-          subject.error 'error!'
+          subject.error "error!"
         end
       end
     end

data/spec/unit/berkshelf/source_spec.rb

@@ -1,56 +1,222 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe Source do
-    describe "#universe"
-    describe "#cookbook"
-    describe "#versions"
+    let(:berksfile) { double("Berksfile", filepath: "/test/Berksfile") }
+    let(:arguments) { [] }
+    let(:kwargs) { {} }
+    let(:config) { Config.new }
+    subject(:instance) { described_class.new(berksfile, *arguments, **kwargs) }
+    before do
+      allow(Berkshelf::Config).to receive(:instance).and_return(config)
+    end
+
+    describe "#type" do
+      subject { instance.type }
+
+      context "with a string argument" do
+        let(:arguments) { ["https://example.com"] }
+        it { is_expected.to eq :supermarket }
+      end
+
+      context "with a string argument and options" do
+        let(:arguments) { ["https://example.com" ] }
+        let(:kwargs) { { key: "value" } }
+        it { is_expected.to eq :supermarket }
+      end
+
+      context "with a symbol argument" do
+        let(:arguments) { [:chef_server] }
+        it { is_expected.to eq :chef_server }
+      end
+
+      context "with a symbol argument and options" do
+        let(:arguments) { [:chef_server ] }
+        let(:kwargs) { { key: "value" } }
+        it { is_expected.to eq :chef_server }
+      end
+
+      context "with a hash argument" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }] }
+        it { is_expected.to eq :artifactory }
+      end
+
+      context "with a hash argument and connected options" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual", key: "value" }] }
+        it { is_expected.to eq :artifactory }
+      end
+
+      context "with a hash argument and disconnected options" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }] }
+        let(:kwargs) { { key: "value" } }
+        it { is_expected.to eq :artifactory }
+      end
+    end
+
+    describe "#uri" do
+      subject { instance.uri.to_s }
+
+      context "with a string argument" do
+        let(:arguments) { ["https://example.com"] }
+        it { is_expected.to eq "https://example.com" }
+      end
+
+      context "with a string argument and options" do
+        let(:arguments) { ["https://example.com" ] }
+        let(:kwargs) { { key: "value" } }
+        it { is_expected.to eq "https://example.com" }
+      end
+
+      context "with a symbol argument" do
+        let(:arguments) { [:chef_server] }
+        before { config.chef.chef_server_url = "https://chefserver/" }
+        it { is_expected.to eq "https://chefserver/" }
+      end
+
+      context "with a symbol argument and options" do
+        let(:arguments) { [:chef_server] }
+        let(:kwargs) { { key: "value" } }
+        before { config.chef.chef_server_url = "https://chefserver/" }
+        it { is_expected.to eq "https://chefserver/" }
+      end
+
+      context "with a hash argument" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }] }
+        it { is_expected.to eq "https://example.com/api/chef/chef-virtual" }
+      end
+
+      context "with a hash argument and connected options" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual", key: "value" }] }
+        it { is_expected.to eq "https://example.com/api/chef/chef-virtual" }
+      end
+
+      context "with a hash argument and disconnected options" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" } ] }
+        let(:kwargs) { { key: "value" } }
+        it { is_expected.to eq "https://example.com/api/chef/chef-virtual" }
+      end
+
+      context "with an invalid URI" do
+        let(:arguments) { ["ftp://example.com"] }
+        it { expect { subject }.to raise_error InvalidSourceURI }
+      end
+
+      context "with a chef_repo source" do
+        let(:arguments) { [{ chef_repo: "." }] }
+        it { is_expected.to eq(windows? ? "file://D/test" : "file:///test") }
+      end
+    end
+
+    describe "#options" do
+      subject { instance.options }
+
+      context "with a string argument" do
+        let(:arguments) { ["https://example.com"] }
+
+        it { is_expected.to be_a(Hash) }
+        # Check all baseline values.
+        its([:timeout]) { is_expected.to eq 30 }
+        its([:open_timeout]) { is_expected.to eq 3 }
+        its(%i{ssl verify}) { is_expected.to be true }
+        its(%i{ssl ca_file}) { is_expected.to be_nil }
+        its(%i{ssl ca_path}) { is_expected.to be_nil }
+        its(%i{ssl client_cert}) { is_expected.to be_nil }
+        its(%i{ssl client_key}) { is_expected.to be_nil }
+        its(%i{ssl cert_store}) { is_expected.to be_a(OpenSSL::X509::Store) }
+      end
+
+      context "with a string argument and options" do
+        let(:arguments) { ["https://example.com"] }
+        let(:kwargs) { { key: "value" } }
+        its([:key]) { is_expected.to eq "value" }
+      end
+
+      context "with a symbol argument" do
+        let(:arguments) { [:chef_server] }
+        it { is_expected.to be_a(Hash) }
+      end
+
+      context "with a symbol argument and options" do
+        let(:arguments) { [:chef_server] }
+        let(:kwargs) { { key: "value" } }
+        its([:key]) { is_expected.to eq "value" }
+      end
+
+      context "with a hash argument" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }] }
+        it { is_expected.to be_a(Hash) }
+      end
+
+      context "with a hash argument and connected options" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual", key: "value" }] }
+        its([:key]) { is_expected.to eq "value" }
+      end
+
+      context "with a hash argument and disconnected options" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" } ] }
+        let(:kwargs) { { key: "value" } }
+        its([:key]) { is_expected.to eq "value" }
+      end
+
+      context "with an artifactory source and the API key in the Chef config" do
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }] }
+        before { config.chef.artifactory_api_key = "secret" }
+        its([:api_key]) { is_expected.to eq "secret" }
+      end
+
+      context "with a chef_repo source" do
+        let(:arguments) { [{ chef_repo: "." }] }
+        its([:path]) { is_expected.to eq(windows? ? "D:/test" : "/test") }
+      end
+    end
 
     describe "#==" do
       it "is the same if the uri matches" do
-        first = described_class.new("http://localhost:8080")
-        other = described_class.new("http://localhost:8080")
+        first = described_class.new(berksfile, "http://localhost:8080")
+        other = described_class.new(berksfile, "http://localhost:8080")
 
         expect(first).to eq(other)
       end
 
       it "is not the same if the uri is different" do
-        first = described_class.new("http://localhost:8089")
-        other = described_class.new("http://localhost:8080")
+        first = described_class.new(berksfile, "http://localhost:8089")
+        other = described_class.new(berksfile, "http://localhost:8080")
 
         expect(first).to_not eq(other)
       end
     end
 
-    describe '.default?' do
-      it 'returns true when the source is the default' do
-        instance = described_class.new(Berksfile::DEFAULT_API_URL)
+    describe ".default?" do
+      it "returns true when the source is the default" do
+        instance = described_class.new(berksfile, Berksfile::DEFAULT_API_URL)
         expect(instance).to be_default
       end
 
-      it 'returns true when the scheme is different' do
-        instance = described_class.new('http://supermarket.chef.io')
+      it "returns true when the scheme is different" do
+        instance = described_class.new(berksfile, "http://supermarket.chef.io")
         expect(instance).to be_default
       end
 
-      it 'returns false when the source is not the default' do
-        instance = described_class.new('http://localhost:8080')
+      it "returns false when the source is not the default" do
+        instance = described_class.new(berksfile, "http://localhost:8080")
         expect(instance).to_not be_default
       end
     end
 
     describe "#search" do
-      let (:cookbooks) {[ 
-        APIClient::RemoteCookbook.new("cb1","1.0.8"),
-        APIClient::RemoteCookbook.new("cb1","1.0.22")
-      ]}
+      let(:cookbooks) do
+        [
+        APIClient::RemoteCookbook.new("cb1", "1.0.8"),
+        APIClient::RemoteCookbook.new("cb1", "1.0.22"),
+      ]
+      end
 
       before do
         allow_any_instance_of(APIClient::Connection).to receive(:universe).and_return(cookbooks)
       end
 
       it "returns the latest version" do
-        instance = described_class.new(Berksfile::DEFAULT_API_URL)
+        instance = described_class.new(berksfile, Berksfile::DEFAULT_API_URL)
         expect(instance.search("cb1")).to eq [cookbooks[1]]
       end
     end

data/spec/unit/berkshelf/source_uri_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::SourceURI do
   describe "ClassMethods" do

data/spec/unit/berkshelf/ssl_policies_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Berkshelf::SSLPolicy do
+  let(:self_signed_crt_path) { File.join(BERKS_SPEC_DATA, "trusted_certs") }
+  let(:self_signed_crt_path_windows_backslashes) { "C:/users/vagrant\\.chef\\trusted_certs" }
+  let(:self_signed_crt_path_windows_forwardslashes) { "C:/users/vagrant/.chef/trusted_certs" }
+
+  let(:chef_config) do
+    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(Berkshelf::Config,
+      ssl:  double(verify: true),
+      chef: chef_config)
+  end
+
+  subject do
+    Berkshelf::SSLPolicy.new
+  end
+
+  before do
+    allow(Berkshelf).to receive(:config).and_return(berkshelf_config)
+  end
+
+  describe "#initialize" do
+    it "sets up the store" do
+      expect(subject.store.class).to be(OpenSSL::X509::Store)
+    end
+
+    it "sets up custom certificates for chef" do
+    end
+  end
+
+  describe "#trusted_certs_dir" do
+    it "uses the trusted_certs_dir from Berkshelf config" do
+      expect(subject.trusted_certs_dir).to eq(self_signed_crt_path)
+    end
+
+    context "trusted_certs_dir in Berkshelf" do
+
+      context "config is not set" do
+        before { allow(chef_config).to receive_messages(trusted_certs_dir: nil) }
+
+        it "defaults to ~/.chef/trusted_certs" do
+          expect(subject.trusted_certs_dir).to eq(
+            File.join(ENV["HOME"], ".chef", "trusted_certs")
+          )
+        end
+      end
+
+      context "config is set but does not exist" do
+        before { allow(chef_config).to receive_messages(trusted_certs_dir: "/fake") }
+
+        it "defaults to ~/.chef/trusted_certs" do
+          expect(subject.trusted_certs_dir).to eq(
+            File.join(ENV["HOME"], ".chef", "trusted_certs")
+          )
+        end
+      end
+
+      context "config has Windows backslashes in trusted_certs_dir path" do
+        before do
+          allow(chef_config).to receive_messages(trusted_certs_dir: self_signed_crt_path_windows_backslashes)
+          allow(File).to receive(:exist?).with(self_signed_crt_path_windows_forwardslashes).and_return(true)
+        end
+
+        it "replaces the backslashes in trusted_certs_dir from Berkshelf config with forwardslashes" do
+          expect(subject.trusted_certs_dir).to eq(
+            self_signed_crt_path_windows_forwardslashes
+          )
+        end
+      end
+    end
+  end
+end