berkshelf 5.5.0 → 5.6.0

data/spec/support/chef_api.rb

@@ -58,13 +58,13 @@ module Berkshelf
           "files/default",
           "attributes",
           "providers",
-          "resources"
+          "resources",
         ]
         files = [
           "recipes/default.rb",
           "templates/default/template.erb",
           "files/default/file.h",
-          "attributes/default.rb"
+          "attributes/default.rb",
         ]
 
         directories.each do |directory|
@@ -82,7 +82,6 @@ module Berkshelf
           a << "" # ensure newline
         end.join("\n")
 
-
         if options[:dependencies]
           options[:dependencies].each do |name, constraint|
             metadata << "depends '#{name}', '#{constraint}'\n"
@@ -95,7 +94,7 @@ module Berkshelf
           end
         end
 
-        File.open(cookbook_path.join("metadata.rb"), 'w+') do |f|
+        File.open(cookbook_path.join("metadata.rb"), "w+") do |f|
           f.write metadata
         end
 
@@ -120,14 +119,14 @@ module Berkshelf
 
       private
 
-        def ridley
-          @ridley ||= Ridley.new(
-            server_url: Berkshelf::RSpec::ChefServer.server_url,
-            client_name: Berkshelf.chef_config[:node_name],
-            client_key: Berkshelf.chef_config[:client_key],
-            ssl: { verify: false }
-          )
-        end
+      def ridley
+        @ridley ||= Ridley.new(
+          server_url: Berkshelf::RSpec::ChefServer.server_url,
+          client_name: Berkshelf.chef_config[:node_name],
+          client_key: Berkshelf.chef_config[:client_key],
+          ssl: { verify: false }
+        )
+      end
     end
   end
 end

data/spec/support/chef_server.rb

@@ -1,5 +1,5 @@
-require 'chef_zero/server'
-require 'json'
+require "chef_zero/server"
+require "json"
 
 module Berkshelf::RSpec
   module ChefServer
@@ -58,18 +58,18 @@ module Berkshelf::RSpec
     end
 
     def chef_cookbook(name, hash = {})
-      chef_server.load_data({ 'cookbooks' => { name => hash }})
+      chef_server.load_data({ "cookbooks" => { name => hash } })
     end
 
     def chef_cookbooks
-      chef_server.data_store.list(['organizations', 'chef', 'cookbooks']).inject({}) do |hash, name|
-        hash[name] = chef_server.data_store.list(['organizations', 'chef', 'cookbooks', name])
+      chef_server.data_store.list(%w{organizations chef cookbooks}).inject({}) do |hash, name|
+        hash[name] = chef_server.data_store.list(["organizations", "chef", "cookbooks", name])
         hash
       end
     end
 
     def chef_data_bag(name, hash = {})
-      chef_server.load_data({ 'data' => { name => hash }})
+      chef_server.load_data({ "data" => { name => hash } })
     end
 
     def chef_environment(name, hash = {})
@@ -77,7 +77,7 @@ module Berkshelf::RSpec
     end
 
     def chef_environment_locks(name)
-      JSON.parse(chef_server.data_store.get(['organizations', 'chef', 'environments', name]))['cookbook_versions']
+      JSON.parse(chef_server.data_store.get(["organizations", "chef", "environments", name]))["cookbook_versions"]
     rescue ChefZero::DataStore::DataNotFoundError
       {}
     end
@@ -92,8 +92,8 @@ module Berkshelf::RSpec
 
     private
 
-      def load_data(key, name, hash)
-        chef_server.load_data({ key.to_s => { name => JSON.generate(hash) }})
-      end
+    def load_data(key, name, hash)
+      chef_server.load_data({ key.to_s => { name => JSON.generate(hash) } })
+    end
   end
 end

data/spec/support/git.rb

@@ -1,10 +1,10 @@
 module Berkshelf
   module RSpec
     module Git
-      require 'buff/shell_out'
+      require "buff/shell_out"
       include Buff::ShellOut
 
-      require_relative 'path_helpers'
+      require_relative "path_helpers"
       include Berkshelf::RSpec::PathHelpers
 
       def git_origin_for(repo, options = {})
@@ -12,8 +12,8 @@ module Berkshelf
       end
 
       def generate_fake_git_remote(uri, options = {})
-        name = uri.split('/').last || 'rspec_cookbook'
-        name = name.gsub('.git', '')
+        name = uri.split("/").last || "rspec_cookbook"
+        name = name.gsub(".git", "")
         path = remotes.join(name)
 
         capture(:stdout) do
@@ -86,16 +86,16 @@ module Berkshelf
         # The path to store the local git clones.
         #
         # @return [Pathname]
-        def clones
-          ensure_and_return(tmp_path.join('clones'))
-        end
+      def clones
+        ensure_and_return(tmp_path.join("clones"))
+      end
 
         # The path to store the git remotes.
         #
         # @return [Pathname]
-        def remotes
-          ensure_and_return(tmp_path.join('remotes'))
-        end
+      def remotes
+        ensure_and_return(tmp_path.join("remotes"))
+      end
 
         # Generate a cookbook by the given name.
         #
@@ -103,15 +103,15 @@ module Berkshelf
         #   the name of the cookbook to create
         # @param [Hash] options
         #   the list ooptions to pass to the generator
-        def generate_git_cookbook(name, options = {})
-          options = {
-            skip_vagrant: true,
-            skip_test_kitchen: true,
-            force: true,
-          }.merge(options)
-
-          Berkshelf::Cli.new.invoke(:cookbook, [name.to_s], options)
-        end
+      def generate_git_cookbook(name, options = {})
+        options = {
+          skip_vagrant: true,
+          skip_test_kitchen: true,
+          force: true,
+        }.merge(options)
+
+        Berkshelf::Cli.new.invoke(:cookbook, [name.to_s], options)
+      end
 
         # Make sure the given path exists and return the path
         #
@@ -119,10 +119,10 @@ module Berkshelf
         #   the path to create and return
         #
         # @return [Pathname]
-        def ensure_and_return(path)
-          FileUtils.mkdir(path) unless File.exist?(path)
-          return Pathname.new(path).expand_path
-        end
+      def ensure_and_return(path)
+        FileUtils.mkdir(path) unless File.exist?(path)
+        return Pathname.new(path).expand_path
+      end
     end
   end
 end

data/spec/support/kitchen.rb

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

data/spec/support/matchers/filepath_matchers.rb

@@ -1,5 +1,5 @@
-require 'rspec/expectations'
-require 'pathname'
+require "rspec/expectations"
+require "pathname"
 
 RSpec::Matchers.define :be_relative_path do
   match do |given|

data/spec/support/path_helpers.rb

@@ -5,7 +5,7 @@ module Berkshelf
       #
       # @return [Pathname]
       def berkshelf_path
-        tmp_path.join('berkshelf').expand_path
+        tmp_path.join("berkshelf").expand_path
       end
 
       # The Berkshelf cookbook store
@@ -19,21 +19,21 @@ module Berkshelf
       #
       # @return [Pathname]
       def tmp_path
-        Berkshelf.root.join('spec/tmp')
+        Berkshelf.root.join("spec/tmp")
       end
 
       # The path to the spec fixtures
       #
       # @return [Pathname]
       def fixtures_path
-        Berkshelf.root.join('spec/fixtures')
+        Berkshelf.root.join("spec/fixtures")
       end
 
       # The path to the Chef config fixture
       #
       # @return [String]
       def chef_config_path
-        Berkshelf.root.join('spec/config/knife.rb').to_s
+        Berkshelf.root.join("spec/config/knife.rb").to_s
       end
 
       # The actual Chef config object
@@ -54,16 +54,16 @@ module Berkshelf
         # directory on each run.
         #
         # @return [nil]
-        def reload_configs
-          Berkshelf.chef_config = chef_config
+      def reload_configs
+        Berkshelf.chef_config = chef_config
 
-          # This fucking sucks...
-          # load 'berkshelf/chef/config.rb'
-          load 'berkshelf/config.rb'
+        # This fucking sucks...
+        # load 'berkshelf/chef/config.rb'
+        load "berkshelf/config.rb"
 
-          Berkshelf.config = Berkshelf::Config.new
-          nil
-        end
+        Berkshelf.config = Berkshelf::Config.new
+        nil
+      end
     end
   end
 end

data/spec/support/shared_examples/formatter.rb

@@ -1,4 +1,4 @@
-require 'rspec'
+require "rspec"
 
 RSpec.shared_examples "a formatter object" do
   Berkshelf::BaseFormatter.instance_methods(false).each do |name|

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::Berksfile do
   describe "ClassMethods" do
-    describe '::from_file' do
+    describe "::from_file" do
       let(:content) do
         <<-EOF.strip
         cookbook 'ntp', '<= 1.0.0'
@@ -12,13 +12,13 @@ describe Berkshelf::Berksfile do
         solver :foo, :required
         EOF
       end
-      let(:berksfile) { tmp_path.join('Berksfile') }
+      let(:berksfile) { tmp_path.join("Berksfile") }
 
-      before { File.open(berksfile, 'w+') { |f| f.write(content) } }
+      before { File.open(berksfile, "w+") { |f| f.write(content) } }
       subject(:from_file) { described_class.from_file(berksfile) }
 
       it "reads the content of the Berksfile and binds them to a new instance" do
-        %w(ntp mysql nginx ssh_known_hosts2).each do |name|
+        %w{ntp mysql nginx ssh_known_hosts2}.each do |name|
           expect(subject).to have_dependency(name)
         end
       end
@@ -27,62 +27,62 @@ describe Berkshelf::Berksfile do
         expect(subject).to be_a(described_class)
       end
 
-      context 'when Berksfile does not exist at given path' do
-        let(:bad_path) { tmp_path.join('thisdoesnotexist') }
+      context "when Berksfile does not exist at given path" do
+        let(:bad_path) { tmp_path.join("thisdoesnotexist") }
 
-        it 'raises BerksfileNotFound' do
-          expect {
+        it "raises BerksfileNotFound" do
+          expect do
             Berkshelf::Berksfile.from_file(bad_path)
-          }.to raise_error(Berkshelf::BerksfileNotFound)
+          end.to raise_error(Berkshelf::BerksfileNotFound)
         end
       end
     end
   end
 
-  let(:dependency_one) { double('dependency_one', name: 'nginx') }
-  let(:dependency_two) { double('dependency_two', name: 'mysql') }
+  let(:dependency_one) { double("dependency_one", name: "nginx") }
+  let(:dependency_two) { double("dependency_two", name: "mysql") }
 
   subject do
-    berksfile_path = tmp_path.join('Berksfile').to_s
+    berksfile_path = tmp_path.join("Berksfile").to_s
     FileUtils.touch(berksfile_path)
     Berkshelf::Berksfile.new(berksfile_path)
   end
 
-  describe '#cookbook' do
-    let(:name) { 'artifact' }
-    let(:constraint) { double('constraint') }
+  describe "#cookbook" do
+    let(:name) { "artifact" }
+    let(:constraint) { double("constraint") }
     let(:default_options) { { group: [] } }
 
-    it 'sends the add_dependency message with the name, constraint, and options to the instance of the includer' do
+    it "sends the add_dependency message with the name, constraint, and options to the instance of the includer" do
       expect(subject).to receive(:add_dependency).with(name, constraint, default_options)
       subject.cookbook(name, constraint, default_options)
     end
 
-    it 'merges the default options into specified options' do
-      expect(subject).to receive(:add_dependency)do |arg_name, arg_constraint, arg_options|
+    it "merges the default options into specified options" do
+      expect(subject).to receive(:add_dependency) do |arg_name, arg_constraint, arg_options|
         expect(arg_name).to eq(name)
         expect(arg_constraint).to eq(constraint)
         expect(arg_options[:path]).to match(%r{/Users/reset})
         expect(arg_options[:group]).to eq([])
       end
 
-      subject.cookbook(name, constraint, path: '/Users/reset')
+      subject.cookbook(name, constraint, path: "/Users/reset")
     end
 
-    it 'converts a single specified group option into an array of groups' do
+    it "converts a single specified group option into an array of groups" do
       expect(subject).to receive(:add_dependency).with(name, constraint, group: [:production])
       subject.cookbook(name, constraint, group: :production)
     end
 
-    context 'when no constraint specified' do
-      it 'sends the add_dependency message with a nil value for constraint' do
+    context "when no constraint specified" do
+      it "sends the add_dependency message with a nil value for constraint" do
         expect(subject).to receive(:add_dependency).with(name, nil, default_options)
         subject.cookbook(name, default_options)
       end
     end
 
-    context 'when no options specified' do
-      it 'sends the add_dependency message with an empty Hash for the value of options' do
+    context "when no options specified" do
+      it "sends the add_dependency message with an empty Hash for the value of options" do
         expect(subject).to receive(:add_dependency).with(name, constraint, default_options)
         subject.cookbook(name, constraint)
       end
@@ -93,11 +93,11 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#group' do
-    let(:name) { 'artifact' }
-    let(:group) { 'production' }
+  describe "#group" do
+    let(:name) { "artifact" }
+    let(:group) { "production" }
 
-    it 'sends the add_dependency message with an array of groups determined by the parameter to the group block' do
+    it "sends the add_dependency message with an array of groups determined by the parameter to the group block" do
       expect(subject).to receive(:add_dependency).with(name, nil, group: [group])
 
       subject.group(group) do
@@ -110,14 +110,14 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#metadata' do
-    let(:path) { fixtures_path.join('cookbooks/example_cookbook') }
-    subject { Berkshelf::Berksfile.new(path.join('Berksfile')) }
+  describe "#metadata" do
+    let(:path) { fixtures_path.join("cookbooks/example_cookbook") }
+    subject { Berkshelf::Berksfile.new(path.join("Berksfile")) }
 
     before { Dir.chdir(path) }
 
-    it 'sends the add_dependency message with an explicit version constraint and the path to the cookbook' do
-      expect(subject).to receive(:add_dependency).with('example_cookbook', nil, path: path.to_s, metadata: true)
+    it "sends the add_dependency message with an explicit version constraint and the path to the cookbook" do
+      expect(subject).to receive(:add_dependency).with("example_cookbook", nil, path: path.to_s, metadata: true)
       subject.metadata
     end
 
@@ -171,9 +171,9 @@ describe Berkshelf::Berksfile do
   describe "#sources" do
     context "when there are no sources" do
       it "raises an exception" do
-        expect {
+        expect do
           subject.sources
-        }.to raise_error(Berkshelf::NoAPISourcesDefined)
+        end.to raise_error(Berkshelf::NoAPISourcesDefined)
       end
     end
 
@@ -212,21 +212,21 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#extension' do
+  describe "#extension" do
     it "is a DSL method" do
       expect(subject).to have_exposed_method(:extension)
     end
   end
 
-  describe '#dependencies' do
+  describe "#dependencies" do
     let(:groups) do
       [
         :nautilus,
-        :skarner
+        :skarner,
       ]
     end
 
-    it 'returns all Berkshelf::Dependencys added to the instance of Berksfile' do
+    it "returns all Berkshelf::Dependencys added to the instance of Berksfile" do
       subject.add_dependency(dependency_one.name)
       subject.add_dependency(dependency_two.name)
 
@@ -236,15 +236,15 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#cookbooks' do
-    it 'raises an exception if a cookbook is not installed' do
-      subject.add_dependency('bacon', nil)
+  describe "#cookbooks" do
+    it "raises an exception if a cookbook is not installed" do
+      subject.add_dependency("bacon", nil)
       expect { subject.cookbooks }.to raise_error(Berkshelf::DependencyNotFound)
     end
 
-    it 'retrieves the locked (cached) cookbook for each dependency' do
-      subject.add_dependency('bacon', nil)
-      subject.add_dependency('ham', nil)
+    it "retrieves the locked (cached) cookbook for each dependency" do
+      subject.add_dependency("bacon", nil)
+      subject.add_dependency("ham", nil)
       allow(subject).to receive(:retrive_locked)
 
       expect(subject).to receive(:retrieve_locked).twice
@@ -252,29 +252,29 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#groups' do
+  describe "#groups" do
     before do
       allow(subject).to receive(:dependencies) { [dependency_one, dependency_two] }
       allow(dependency_one).to receive(:groups) { [:nautilus, :skarner] }
       allow(dependency_two).to receive(:groups) { [:nautilus, :riven] }
     end
 
-    it 'returns a hash containing keys for every group a dependency is a member of' do
+    it "returns a hash containing keys for every group a dependency is a member of" do
       expect(subject.groups.keys.size).to eq(3)
       expect(subject.groups).to have_key(:nautilus)
       expect(subject.groups).to have_key(:skarner)
       expect(subject.groups).to have_key(:riven)
     end
 
-    it 'returns an Array of Berkshelf::Dependencys who are members of the group for value' do
+    it "returns an Array of Berkshelf::Dependencys who are members of the group for value" do
       expect(subject.groups[:nautilus].size).to eq(2)
       expect(subject.groups[:riven].size).to eq(1)
     end
   end
 
-  describe '#add_dependency' do
-    let(:name) { 'cookbook_one' }
-    let(:constraint) { '= 1.2.0' }
+  describe "#add_dependency" do
+    let(:name) { "cookbook_one" }
+    let(:constraint) { "= 1.2.0" }
     let(:options) { Hash.new }
 
     before(:each) do
@@ -283,7 +283,7 @@ describe Berkshelf::Berksfile do
 
     let(:dependency) { subject.dependencies.first }
 
-    it 'adds new dependency to the list of dependencies' do
+    it "adds new dependency to the list of dependencies" do
       expect(subject.dependencies.size).to eq(1)
     end
 
@@ -299,10 +299,10 @@ describe Berkshelf::Berksfile do
       expect(dependency.version_constraint.to_s).to eq(constraint)
     end
 
-    it 'raises DuplicateDependencyDefined if multiple dependencies of the same name are found' do
-      expect {
+    it "raises DuplicateDependencyDefined if multiple dependencies of the same name are found" do
+      expect do
         subject.add_dependency(name)
-      }.to raise_error(Berkshelf::DuplicateDependencyDefined)
+      end.to raise_error(Berkshelf::DuplicateDependencyDefined)
     end
 
     it "has a nil location if no location options are provided" do
@@ -326,7 +326,7 @@ describe Berkshelf::Berksfile do
     end
 
     context "when given the :path option" do
-      let(:options) { { path: fixtures_path.join('cookbooks', 'example_cookbook') } }
+      let(:options) { { path: fixtures_path.join("cookbooks", "example_cookbook") } }
 
       it "has a PathLocation location" do
         expect(dependency.location).to be_a(Berkshelf::PathLocation)
@@ -334,23 +334,23 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#retrieve_locked' do
-    let(:lockfile) { double('lockfile') }
-    let(:dependency) { double('dependency', name: 'bacon') }
-    let(:locked) { double('locked', cached_cookbook: cached, locked_version: '1.0.0') }
-    let(:cached) { double('cached') }
+  describe "#retrieve_locked" do
+    let(:lockfile) { double("lockfile") }
+    let(:dependency) { double("dependency", name: "bacon") }
+    let(:locked) { double("locked", cached_cookbook: cached, locked_version: "1.0.0") }
+    let(:cached) { double("cached") }
 
     before do
       allow(subject).to receive(:lockfile).and_return(lockfile)
     end
 
-    it 'delegates to the lockfile' do
+    it "delegates to the lockfile" do
       expect(lockfile).to receive(:retrieve).with(dependency)
       subject.retrieve_locked(dependency)
     end
   end
 
-  describe '#upload' do
+  describe "#upload" do
     let(:uploader) { double(Berkshelf::Uploader, run: nil) }
 
     before do
@@ -361,22 +361,22 @@ describe Berkshelf::Berksfile do
       allow(Berkshelf::Uploader).to receive(:new).and_return(uploader)
     end
 
-    it 'validates the lockfile is present' do
+    it "validates the lockfile is present" do
       expect(subject).to receive(:validate_lockfile_present!).once
       subject.upload
     end
 
-    it 'validates the lockfile is trusted' do
+    it "validates the lockfile is trusted" do
       expect(subject).to receive(:validate_lockfile_trusted!).once
       subject.upload
     end
 
-    it 'validates the dependencies are installed' do
+    it "validates the dependencies are installed" do
       expect(subject).to receive(:validate_dependencies_installed!).once
       subject.upload
     end
 
-    it 'creates a new Uploader' do
+    it "creates a new Uploader" do
       expect(Berkshelf::Uploader).to receive(:new).with(subject)
       expect(uploader).to receive(:run)
 
@@ -384,31 +384,31 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#vendor' do
-    let(:cached_cookbook)    { double(Berkshelf::CachedCookbook, cookbook_name: 'my_cookbook', path: '/my_cookbook/path', compiled_metadata?: true) }
+  describe "#vendor" do
+    let(:cached_cookbook)    { double(Berkshelf::CachedCookbook, cookbook_name: "my_cookbook", path: "/my_cookbook/path", compiled_metadata?: true) }
     let(:installer)          { double(Berkshelf::Installer, run: [cached_cookbook]) }
-    let(:raw_metadata_files) { [File::join(cached_cookbook.cookbook_name, 'metadata.rb')] }
+    let(:raw_metadata_files) { [File.join(cached_cookbook.cookbook_name, "metadata.rb")] }
 
-    let(:destination) { '/a/destination/path' }
-    let(:options)    { { :exclude => raw_metadata_files + Berkshelf::Berksfile::EXCLUDED_VCS_FILES_WHEN_VENDORING, delete: nil } }
+    let(:destination) { "/a/destination/path" }
+    let(:options) { { :exclude => raw_metadata_files + Berkshelf::Berksfile::EXCLUDED_VCS_FILES_WHEN_VENDORING, delete: nil } }
 
     before do
       allow(Berkshelf::Installer).to receive(:new).and_return(installer)
     end
 
-    it 'invokes FileSyncer with correct arguments' do
+    it "invokes FileSyncer with correct arguments" do
       expect(Berkshelf::FileSyncer).to receive(:sync).with(/vendor/, destination, options)
 
       subject.vendor(destination)
     end
 
-    it 'excludes the top-level metadata.rb file' do
-      expect(options[:exclude].any? { |exclude| File.fnmatch?(exclude, 'my_cookbook/recipes/metadata.rb', File::FNM_DOTMATCH) }).to be(false)
-      expect(options[:exclude].any? { |exclude| File.fnmatch?(exclude, 'my_cookbook/metadata.rb', File::FNM_DOTMATCH) }).to be(true)
+    it "excludes the top-level metadata.rb file" do
+      expect(options[:exclude].any? { |exclude| File.fnmatch?(exclude, "my_cookbook/recipes/metadata.rb", File::FNM_DOTMATCH) }).to be(false)
+      expect(options[:exclude].any? { |exclude| File.fnmatch?(exclude, "my_cookbook/metadata.rb", File::FNM_DOTMATCH) }).to be(true)
     end
   end
 
-  describe '#solver' do
+  describe "#solver" do
 
     let(:solver_precedence) { :please_dont_exist }