berkshelf 5.5.0 → 5.6.0

data/spec/unit/berkshelf/uploader_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe Uploader do
     let(:berksfile) do
       double(Berksfile,
         lockfile: lockfile,
-        dependencies: [],
+        dependencies: []
       )
     end
 
@@ -16,53 +16,53 @@ module Berkshelf
     end
 
     let(:graph) { double(Lockfile::Graph, locks: {}) }
-    let(:self_signed_crt_path) { File.join(BERKS_SPEC_DATA, 'trusted_certs') }
+    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
+    describe "#run" do
       let(:options) { Hash.new }
 
       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',
+          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",
           trusted_certs_dir: self_signed_crt_path,
           knife: {
-            chef_guard: false
+            chef_guard: false,
           }
         )
       end
@@ -76,11 +76,11 @@ module Berkshelf
 
       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
 
@@ -89,97 +89,97 @@ module Berkshelf
         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
+        it "uses the Berkshelf::Config options" do
           expect(Ridley).to receive(:open).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,
-              cert_store: cert_store
+              cert_store: cert_store,
             }
           )
           subject.run
         end
       end
 
-      context 'when ssl_verify: false is passed as an option' do
+      context "when ssl_verify: false is passed as an option" do
         subject { Uploader.new(berksfile, ssl_verify: false) }
 
-        it 'uses the passed option' do
+        it "uses the passed option" do
           expect(Ridley).to receive(:open).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
+              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 a Chef Server url is passed as an option" do
+        subject { Uploader.new(berksfile, server_url: "http://custom") }
 
-        it 'uses the passed in :server_url' do
+        it "uses the passed in :server_url" do
           expect(Ridley).to receive(:open)
-            .with(include(server_url: 'http://custom'))
+            .with(include(server_url: "http://custom"))
           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 client name is passed as an option" do
+        subject { Uploader.new(berksfile, client_name: "custom") }
 
-        it 'uses the passed in :client_name' do
+        it "uses the passed in :client_name" do
           expect(Ridley).to receive(:open)
-            .with(include(client_name: 'custom'))
+            .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') }
+      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
+        it "uses the passed in :client_key" do
           expect(Ridley).to receive(:open)
-            .with(include(client_key: 'custom'))
+            .with(include(client_key: "custom"))
           subject.run
         end
       end

data/spec/unit/berkshelf/validator_spec.rb

@@ -1,30 +1,30 @@
-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"])
+      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"])
+      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 "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")
 
-      expect {
+      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,48 +1,48 @@
-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(success?: false, 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 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)
+      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.exists?(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)
+        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)
 

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: berkshelf
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Jamie Winsor
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-24 00:00:00.000000000 Z
+date: 2017-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -246,14 +246,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.4'
 description: Manages a Cookbook's, or an Application's, Cookbook dependencies
 email:
 - jamie@vialstudios.com
@@ -478,7 +478,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.9
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Manages a Cookbook's, or an Application's, Cookbook dependencies