berkshelf 6.0.1 → 6.1.0

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "6.0.1"
+  VERSION = "6.1.0"
 end

data/lib/berkshelf/visualizer.rb

@@ -1,6 +1,6 @@
-require "buff/shell_out"
 require "set"
 require "tempfile"
+require "berkshelf/shell_out"
 
 module Berkshelf
   class Visualizer
@@ -18,7 +18,7 @@ module Berkshelf
       end
     end
 
-    include Buff::ShellOut
+    include Berkshelf::ShellOut
 
     def initialize
       @nodes = {}
@@ -100,7 +100,7 @@ module Berkshelf
       command = %{dot -T png #{tempfile.path} -o "#{outfile}"}
       response = shell_out(command)
 
-      unless response.success?
+      if response.error?
         raise GraphvizCommandFailed.new(command, response.stderr)
       end
 

data/spec/fixtures/complex-cookbook-path/cookbooks/app/metadata.rb

@@ -0,0 +1,2 @@
+name "app"
+version "1.2.3"

data/spec/fixtures/complex-cookbook-path/cookbooks/jenkins-config/metadata.rb

@@ -0,0 +1,4 @@
+name "jenkins-config"
+version "0.1.0"
+
+depends "jenkins", "~> 2.0"

data/spec/fixtures/complex-cookbook-path/cookbooks/jenkins/metadata.rb

@@ -0,0 +1,2 @@
+name "jenkins"
+version "2.0.1"

data/spec/support/git.rb

@@ -1,9 +1,6 @@
 module Berkshelf
   module RSpec
     module Git
-      require "buff/shell_out"
-      include Buff::ShellOut
-
       require_relative "path_helpers"
       include Berkshelf::RSpec::PathHelpers
 
@@ -25,20 +22,24 @@ module Berkshelf
             shell_out "git add ."
             shell_out "git commit -am \"A commit.\""
 
-            options[:tags].each do |tag|
-              shell_out "echo \"#{tag}\" > content_file"
-              shell_out "git add content_file"
-              shell_out "git commit -am \"#{tag} content\""
-              shell_out "git tag \"#{tag}\""
-            end if options[:tags]
-
-            options[:branches].each do |branch|
-              shell_out "git checkout -b #{branch} master"
-              shell_out "echo \"#{branch}\" > content_file"
-              shell_out "git add content_file"
-              shell_out "git commit -am \"#{branch} content\""
-              shell_out "git checkout master"
-            end if options[:branches]
+            if options[:tags]
+              options[:tags].each do |tag|
+                shell_out "echo \"#{tag}\" > content_file"
+                shell_out "git add content_file"
+                shell_out "git commit -am \"#{tag} content\""
+                shell_out "git tag \"#{tag}\""
+              end
+            end
+
+            if options[:branches]
+              options[:branches].each do |branch|
+                shell_out "git checkout -b #{branch} master"
+                shell_out "echo \"#{branch}\" > content_file"
+                shell_out "git add content_file"
+                shell_out "git commit -am \"#{branch} content\""
+                shell_out "git checkout master"
+              end
+            end
           end
         end
 

data/spec/support/kitchen.rb

@@ -1,14 +0,0 @@
-module Berkshelf
-  module RSpec
-    module Kitchen
-      require "kitchen/generator/init"
-
-      def stub_kitchen!
-        generator = double("kitchen-generator", invoke_all: nil)
-        allow(::Kitchen::Generator::Init).to receive(:new)
-          .with(any_args())
-          .and_return(generator)
-      end
-    end
-  end
-end

data/spec/unit/berkshelf/chef_repo_universe_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+module Berkshelf
+  describe ChefRepoUniverse do
+    let(:fixture) { nil }
+    let(:fixture_path) { File.expand_path("../../../fixtures/#{fixture}", __FILE__) }
+    subject { described_class.new("file://#{fixture_path}", path: fixture_path).universe }
+
+    context "with cookbooks in ./" do
+      let(:fixture) { "cookbook-path" }
+
+      it "returns the correct universe" do
+        expect(subject.size).to eq 1
+        expect(subject[0].name).to eq "jenkins-config"
+        expect(subject[0].version).to eq "0.1.0"
+        expect(subject[0].dependencies).to eq "jenkins" => "~> 2.0"
+      end
+    end
+
+    context "with cookbooks in cookbooks/" do
+      let(:fixture) { "complex-cookbook-path" }
+
+      it "returns the correct universe" do
+        expect(subject.size).to eq 3
+        expect(subject[0].name).to eq "app"
+        expect(subject[0].version).to eq "1.2.3"
+        expect(subject[0].dependencies).to eq({})
+        expect(subject[1].name).to eq "jenkins"
+        expect(subject[1].version).to eq "2.0.1"
+        expect(subject[1].dependencies).to eq({})
+        expect(subject[2].name).to eq "jenkins-config"
+        expect(subject[2].version).to eq "0.1.0"
+        expect(subject[2].dependencies).to eq "jenkins" => "~> 2.0"
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/config_spec.rb

@@ -21,6 +21,52 @@ describe Berkshelf::Config do
         expect(Berkshelf::Config.instance.api.timeout).to eq("30")
       end
     end
+
+    context "a Chef config to read defaults from" do
+      let(:chef_config) do
+        double(
+          Ridley::Chef::Config,
+          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",
+          cookbook_copyright: "user",
+          cookbook_email: "user@example.com",
+          cookbook_license: "apachev2"
+        )
+      end
+
+      before do
+        allow(Berkshelf).to receive(:chef_config).and_return(chef_config)
+      end
+
+      {
+        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
+
+      {
+        copyright: "user",
+        email: "user@example.com",
+        license: "apachev2",
+      }.each do |attr, default|
+        it "should have a default cookbook.#{attr}" do
+          expect(Berkshelf::Config.instance.cookbook.send(attr)).to eq(default)
+        end
+      end
+    end
   end
 
   describe "::path" do

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -9,13 +9,6 @@ describe Berkshelf::CookbookGenerator do
   let(:target) { tmp_path.join(name) }
   let(:kitchen_generator) { double("kitchen-generator", invoke_all: nil) }
 
-  before do
-    allow(Kitchen::Generator::Init)
-      .to receive(:new)
-      .with(any_args())
-      .and_return(kitchen_generator)
-  end
-
   context "with default options" do
     before do
       capture(:stdout) do
@@ -82,7 +75,6 @@ describe Berkshelf::CookbookGenerator do
 
   context "given a 'maintainer_email' option" do
     before do
-      allow(Kitchen::Generator::Init).to receive(:new).with(any_args()).and_return(kitchen_generator)
       capture(:stdout) do
         Berkshelf::CookbookGenerator.new([target, name], maintainer_email: "jamie@vialstudios.com").invoke_all
       end

data/spec/unit/berkshelf/downloader_spec.rb

@@ -39,20 +39,22 @@ module Berkshelf
 
       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", {}) { 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", {}) { 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
@@ -60,22 +62,22 @@ module Berkshelf
       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'} }
+          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/", {headers: {'X-Jfrog-Art-Api' => 'secret'}}) { 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'} }
+          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/", {headers: {'X-Jfrog-Art-Api' => 'secret'}}) { 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
@@ -95,6 +97,7 @@ module Berkshelf
             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",
@@ -117,7 +120,7 @@ module Berkshelf
           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}} }
+          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
@@ -136,7 +139,7 @@ module Berkshelf
 
         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}} }
+            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 = {
@@ -155,7 +158,7 @@ module Berkshelf
 
         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}} }
+            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 = {

data/spec/unit/berkshelf/init_generator_spec.rb

@@ -6,7 +6,6 @@ describe Berkshelf::InitGenerator do
   let(:kitchen_generator) { double("kitchen-generator", invoke_all: nil) }
 
   before do
-    allow(Kitchen::Generator::Init).to receive(:new).with(any_args()).and_return(kitchen_generator)
     FileUtils.mkdir_p(target)
     File.open(File.join(target, "metadata.rb"), "w") do |f|
       f.write("name 'some_cookbook'")

data/spec/unit/berkshelf/locations/git_spec.rb

@@ -240,8 +240,8 @@ module Berkshelf
       end
 
       it "raises an error if the command fails" do
-        shell_out = double("shell_out", success?: false, stderr: nil)
-        allow(Buff::ShellOut).to receive(:shell_out).and_return(shell_out)
+        shell_out = double("shell_out", error?: true, stderr: nil)
+        allow(subject).to receive(:shell_out).and_return(shell_out)
         expect { subject.git("foo") }.to raise_error(GitCommandError)
       end
     end

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

@@ -1,10 +1,11 @@
 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://localhost:26210") }
 
     before do
       berks_dependency("ruby", "1.0.0", dependencies: { "elixir" => ">= 0.1.0" })
@@ -24,7 +25,7 @@ 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://localhost:26210") }
 
     before do
       berks_dependency("ruby", "1.0.0")

data/spec/unit/berkshelf/source_spec.rb

@@ -2,9 +2,10 @@ require "spec_helper"
 
 module Berkshelf
   describe Source do
+    let(:berksfile) { double("Berksfile", filepath: "/test/Berksfile") }
     let(:arguments) { [] }
     let(:config) { Config.new }
-    subject(:instance) { described_class.new(*arguments) }
+    subject(:instance) { described_class.new(berksfile, *arguments) }
     before do
       allow(Berkshelf::Config).to receive(:instance).and_return(config)
     end
@@ -13,12 +14,12 @@ module Berkshelf
       subject { instance.type }
 
       context "with a string argument" do
-        let(:arguments) { ['https://example.com'] }
+        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', {key: 'value'}] }
+        let(:arguments) { ["https://example.com", { key: "value" }] }
         it { is_expected.to eq :supermarket }
       end
 
@@ -28,22 +29,22 @@ module Berkshelf
       end
 
       context "with a symbol argument and options" do
-        let(:arguments) { [:chef_server, {key: 'value'}] }
+        let(:arguments) { [:chef_server, { 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'}] }
+        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'}] }
+        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'}, {key: 'value'}] }
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }, { key: "value" }] }
         it { is_expected.to eq :artifactory }
       end
     end
@@ -52,53 +53,58 @@ module Berkshelf
       subject { instance.uri.to_s }
 
       context "with a string argument" do
-        let(:arguments) { ['https://example.com'] }
-        it { is_expected.to eq 'https://example.com' }
+        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', {key: 'value'}] }
-        it { is_expected.to eq 'https://example.com' }
+        let(:arguments) { ["https://example.com", { 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/' }
+        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, {key: 'value'}] }
-        before { config.chef.chef_server_url = 'https://chefserver/' }
-        it { is_expected.to eq 'https://chefserver/' }
+        let(:arguments) { [:chef_server, { 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' }
+        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' }
+        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'}, {key: 'value'}] }
-        it { is_expected.to eq 'https://example.com/api/chef/chef-virtual' }
+        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 an invalid URI" do
-        let(:arguments) { ['ftp://example.com'] }
+        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://C/test" : "file:///test") }
+      end
     end
 
     describe "#options" do
       subject { instance.options }
 
       context "with a string argument" do
-        let(:arguments) { ['https://example.com'] }
+        let(:arguments) { ["https://example.com"] }
 
         it { is_expected.to be_a(Hash) }
         # Check all baseline values.
@@ -113,8 +119,8 @@ module Berkshelf
       end
 
       context "with a string argument and options" do
-        let(:arguments) { ['https://example.com', {key: 'value'}] }
-        its([:key]) { is_expected.to eq 'value' }
+        let(:arguments) { ["https://example.com", { key: "value" }] }
+        its([:key]) { is_expected.to eq "value" }
       end
 
       context "with a symbol argument" do
@@ -123,43 +129,48 @@ module Berkshelf
       end
 
       context "with a symbol argument and options" do
-        let(:arguments) { [:chef_server, {key: 'value'}] }
-        its([:key]) { is_expected.to eq 'value' }
+        let(:arguments) { [:chef_server, { 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'}] }
+        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' }
+        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'}, {key: 'value'}] }
-        its([:key]) { is_expected.to eq 'value' }
+        let(:arguments) { [{ artifactory: "https://example.com/api/chef/chef-virtual" }, { 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' }
+        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? ? "C:/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
@@ -167,17 +178,17 @@ module Berkshelf
 
     describe ".default?" do
       it "returns true when the source is the default" do
-        instance = described_class.new(Berksfile::DEFAULT_API_URL)
+        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")
+        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")
+        instance = described_class.new(berksfile, "http://localhost:8080")
         expect(instance).to_not be_default
       end
     end
@@ -194,7 +205,7 @@ module Berkshelf
       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