berkshelf 5.2.0 → 8.0.15

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,28 +19,28 @@ 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
       #
       # @return [Bershelf::Chef::Config]
       def chef_config
-        Ridley::Chef::Config.from_file(chef_config_path)
+        Berkshelf::ChefConfigCompat.from_file(chef_config_path)
       end
 
       def clean_tmp_path
@@ -50,20 +50,20 @@ module Berkshelf
 
       private
 
-        # This is the magical "reset" function that gives us a clean working
-        # directory on each run.
-        #
-        # @return [nil]
-        def reload_configs
-          Berkshelf.chef_config = chef_config
+      # This is the magical "reset" function that gives us a clean working
+      # directory on each run.
+      #
+      # @return [nil]
+      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/tmp/berkshelf/cookbooks/fake-0.1.0/metadata.rb

@@ -0,0 +1,2 @@
+name     'fake'
+version  '0.1.0'

data/spec/tmp/berkshelf/cookbooks/fake-0.2.0/metadata.rb

@@ -0,0 +1,2 @@
+name     'fake'
+version  '0.2.0'

data/spec/tmp/berkshelf/cookbooks/fake-1.0.0/metadata.rb

@@ -0,0 +1,2 @@
+name     'fake'
+version  '1.0.0'

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
 
@@ -192,41 +192,21 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe "#site" do
-    it "raises a Berkshelf::Deprecated error" do
-      expect { subject.site }.to raise_error(Berkshelf::DeprecatedError)
-    end
-
-    it "is a DSL method" do
-      expect(subject).to have_exposed_method(:site)
-    end
-  end
-
-  describe "#chef_api" do
-    it "raises a Berkshelf::Deprecated error" do
-      expect { subject.chef_api }.to raise_error(Berkshelf::DeprecatedError)
-    end
-
-    it "is a DSL method" do
-      expect(subject).to have_exposed_method(:chef_api)
-    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
-      ]
+      %i{
+        nautilus
+        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 +216,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,30 +232,30 @@ 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] }
+      allow(dependency_one).to receive(:groups) { %i{nautilus skarner} }
+      allow(dependency_two).to receive(:groups) { %i{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' }
-    let(:options) { Hash.new }
+  describe "#add_dependency" do
+    let(:name) { "cookbook_one" }
+    let(:constraint) { "= 1.2.0" }
+    let(:options) { {} }
 
     before(:each) do
       subject.add_dependency(name, constraint, options)
@@ -283,7 +263,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 +279,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 +306,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 +314,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 +341,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 +364,30 @@ 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) }
-    let(:installer)          { double(Berkshelf::Installer, run: [cached_cookbook]) }
-    let(:raw_metadata_files) { [File::join(cached_cookbook.cookbook_name, 'metadata.rb')] }
+  describe "#vendor" do
+    let(:cached_cookbook)    { instance_double(Berkshelf::CachedCookbook, cookbook_name: "my_cookbook", path: "/my_cookbook/path", compile_metadata: true, reload: nil) }
+    let(:installer)          { instance_double(Berkshelf::Installer, run: [cached_cookbook]) }
+    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: 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)
     end
   end
 
-  describe '#solver' do
+  describe "#solver" do
 
     let(:solver_precedence) { :please_dont_exist }
 

data/spec/unit/berkshelf/berkshelf/api_client/chef_server_connection_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Berkshelf::APIClient::ChefServerConnection do
+  let(:instance) do
+    described_class.new(
+      server_url: "https://chef.example.org/organizations/foobar",
+      timeout: 30,
+      open_timeout: 3,
+      ssl: {}
+    )
+  end
+
+  describe "#universe" do
+    before do
+      body_response = %q{{"ruby":{"1.2.3":{"endpoint_priority":0,"platforms":{},"dependencies":{"build-essential":">= 1.2.2"},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"},"2.0.0":{"endpoint_priority":0,"platforms":{},"dependencies":{"build-essential":">= 1.2.2"},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"}},"elixir":{"1.0.0":{"endpoint_priority":0,"platforms":{"CentOS":"= 6.0.0"},"dependencies":{},"location_type":"supermarket","location_path":"https://supermarket.getchef.com/"}}}}
+
+      stub_request(:get, "https://chef.example.org/organizations/foobar/universe")
+        .to_return(status: 200, body: body_response, headers: { "Content-Type" => "application/json; charset=utf-8" })
+    end
+
+    subject { instance.universe }
+
+    it "returns an array of APIClient::RemoteCookbook" do
+      expect(subject).to be_a(Array)
+
+      subject.each do |remote|
+        expect(remote).to be_a(Berkshelf::APIClient::RemoteCookbook)
+      end
+    end
+
+    it "contains a item for each dependency" do
+      expect(subject.size).to eq(3)
+      expect(subject[0].name).to eql("ruby")
+      expect(subject[0].version).to eql("1.2.3")
+      expect(subject[1].name).to eql("ruby")
+      expect(subject[1].version).to eql("2.0.0")
+      expect(subject[2].name).to eql("elixir")
+      expect(subject[2].version).to eql("1.0.0")
+    end
+
+    it "has the dependencies for each" do
+      expect(subject[0].dependencies).to include("build-essential" => ">= 1.2.2")
+      expect(subject[1].dependencies).to include("build-essential" => ">= 1.2.2")
+      expect(subject[2].dependencies).to be_empty
+    end
+
+    it "has the platforms for each" do
+      expect(subject[0].platforms).to be_empty
+      expect(subject[1].platforms).to be_empty
+      expect(subject[2].platforms).to include("CentOS" => "= 6.0.0")
+    end
+
+    it "has a location_path for each" do
+      subject.each do |remote|
+        expect(remote.location_path).to_not be_nil
+      end
+    end
+
+    it "has a location_type for each" do
+      subject.each do |remote|
+        expect(remote.location_type).to_not be_nil
+      end
+    end
+  end
+end