chef 12.18.31 → 13.0.118

data/spec/unit/application_spec.rb

@@ -1,7 +1,7 @@
 #
 # Author:: AJ Christensen (<aj@junglist.gen.nz>)
 # Author:: Mark Mzyk (mmzyk@chef.io)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -187,53 +187,56 @@ describe Chef::Application do
         allow(Chef::Log).to receive(:level=)
         @monologger = double("Monologger")
         expect(MonoLogger).to receive(:new).with(Chef::Config[:log_location]).and_return(@monologger)
+        allow(MonoLogger).to receive(:new).with(STDOUT).and_return(@monologger)
+        allow(@monologger).to receive(:formatter=).with(Chef::Log.logger.formatter)
         expect(Chef::Log).to receive(:init).with(@monologger)
         @app.configure_logging
       end
 
       shared_examples_for "log_level_is_auto" do
-        context "when STDOUT is to a tty" do
+        before do
+          allow(STDOUT).to receive(:tty?).and_return(true)
+        end
+
+        it "configures the log level to :warn" do
+          @app.configure_logging
+          expect(Chef::Log.level).to eq(:warn)
+        end
+
+        context "when force_formater is configured" do
           before do
-            allow(STDOUT).to receive(:tty?).and_return(true)
+            Chef::Config[:force_formatter] = true
           end
 
-          it "configures the log level to :warn" do
+          it "configures the log level to warn" do
             @app.configure_logging
             expect(Chef::Log.level).to eq(:warn)
           end
-
-          context "when force_logger is configured" do
-            before do
-              Chef::Config[:force_logger] = true
-            end
-
-            it "configures the log level to info" do
-              @app.configure_logging
-              expect(Chef::Log.level).to eq(:info)
-            end
-          end
         end
 
-        context "when STDOUT is not to a tty" do
+        context "when force_logger is configured" do
           before do
-            allow(STDOUT).to receive(:tty?).and_return(false)
+            Chef::Config[:force_logger] = true
           end
 
-          it "configures the log level to :info" do
+          it "configures the log level to info" do
             @app.configure_logging
             expect(Chef::Log.level).to eq(:info)
           end
+        end
 
-          context "when force_formatter is configured" do
-            before do
-              Chef::Config[:force_formatter] = true
-            end
-            it "sets the log level to :warn" do
-              @app.configure_logging
-              expect(Chef::Log.level).to eq(:warn)
-            end
+        context "when both are is configured" do
+          before do
+            Chef::Config[:force_logger] = true
+            Chef::Config[:force_formatter] = true
+          end
+
+          it "configures the log level to warn" do
+            @app.configure_logging
+            expect(Chef::Log.level).to eq(:warn)
           end
         end
+
       end
 
       context "when log_level is not set" do
@@ -299,16 +302,23 @@ describe Chef::Application do
       Chef::Application.fatal! "blah"
     end
 
-    describe "when an exit code is supplied" do
+    describe "when a standard exit code is supplied" do
       it "should exit with the given exit code" do
-        expect(Process).to receive(:exit).with(-100).and_return(true)
+        expect(Process).to receive(:exit).with(42).and_return(true)
+        Chef::Application.fatal! "blah", 42
+      end
+    end
+
+    describe "when a non-standard exit code is supplied" do
+      it "should exit with the default exit code" do
+        expect(Process).to receive(:exit).with(1).and_return(true)
         Chef::Application.fatal! "blah", -100
       end
     end
 
     describe "when an exit code is not supplied" do
       it "should exit with the default exit code" do
-        expect(Process).to receive(:exit).with(-1).and_return(true)
+        expect(Process).to receive(:exit).with(1).and_return(true)
         Chef::Application.fatal! "blah"
       end
     end

data/spec/unit/chef_fs/file_system/operation_failed_error_spec.rb

@@ -17,7 +17,7 @@
 #
 
 require "spec_helper"
-require "chef/chef_fs/file_system/operation_failed_error"
+require "chef/chef_fs/file_system/exceptions"
 
 describe Chef::ChefFS::FileSystem::OperationFailedError do
   context "message" do

data/spec/unit/client_spec.rb

@@ -2,7 +2,7 @@
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Tim Hinderliter (<tim@chef.io>)
 # Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -71,48 +71,40 @@ describe Chef::Client do
 
   describe "configuring output formatters" do
     context "when no formatter has been configured" do
-      context "and STDOUT is a TTY" do
+      it "configures the :doc formatter" do
+        expect(client.formatters_for_run).to eq([[:doc]])
+      end
+
+      context "and force_logger is set" do
         before do
-          allow(STDOUT).to receive(:tty?).and_return(true)
+          Chef::Config[:force_logger] = true
         end
 
-        it "configures the :doc formatter" do
-          expect(client.formatters_for_run).to eq([[:doc]])
+        it "configures the :null formatter" do
+          expect(client.formatters_for_run).to eq([[:null]])
         end
+      end
 
-        context "and force_logger is set" do
-          before do
-            Chef::Config[:force_logger] = true
-          end
-
-          it "configures the :null formatter" do
-            expect(Chef::Config[:force_logger]).to be_truthy
-            expect(client.formatters_for_run).to eq([[:null]])
-          end
-
+      context "and force_formatter is set" do
+        before do
+          Chef::Config[:force_formatter] = true
         end
 
+        it "configures the :doc formatter" do
+          expect(client.formatters_for_run).to eq([[:doc]])
+        end
       end
 
-      context "and STDOUT is not a TTY" do
+      context "both are set" do
         before do
-          allow(STDOUT).to receive(:tty?).and_return(false)
+          Chef::Config[:force_formatter] = true
+          Chef::Config[:force_logger] = true
         end
 
-        it "configures the :null formatter" do
-          expect(client.formatters_for_run).to eq([[:null]])
-        end
-
-        context "and force_formatter is set" do
-          before do
-            Chef::Config[:force_formatter] = true
-          end
-          it "it configures the :doc formatter" do
-            expect(client.formatters_for_run).to eq([[:doc]])
-          end
+        it "configures the :doc formatter" do
+          expect(client.formatters_for_run).to eq([[:doc]])
         end
       end
-
     end
 
     context "when a formatter is configured" do
@@ -188,7 +180,7 @@ describe Chef::Client do
             # ---Client#sync_cookbooks -- downloads the list of cookbooks to sync
             #
             expect_any_instance_of(Chef::CookbookSynchronizer).to receive(:sync_cookbooks)
-            expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(http_cookbook_sync)
+            expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions).and_return(http_cookbook_sync)
             expect(http_cookbook_sync).to receive(:post).
               with("environments/_default/cookbook_versions", { :run_list => ["override_recipe"] }).
               and_return({})
@@ -222,7 +214,7 @@ describe Chef::Client do
           # ---Client#sync_cookbooks -- downloads the list of cookbooks to sync
           #
           expect_any_instance_of(Chef::CookbookSynchronizer).to receive(:sync_cookbooks)
-          expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url]).and_return(http_cookbook_sync)
+          expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions).and_return(http_cookbook_sync)
           expect(http_cookbook_sync).to receive(:post).
             with("environments/_default/cookbook_versions", { :run_list => ["new_run_list_recipe"] }).
             and_return({})
@@ -402,6 +394,55 @@ describe Chef::Client do
     end
   end
 
+  describe "load_required_recipe" do
+    let(:rest)        { double("Chef::ServerAPI (required recipe)") }
+    let(:run_context) { double("Chef::RunContext") }
+    let(:recipe)      { double("Chef::Recipe (required recipe)") }
+    let(:required_recipe) do
+      <<EOM
+fake_recipe_variable = "for reals"
+EOM
+    end
+
+    context "when required_recipe is configured" do
+
+      before(:each) do
+        expect(rest).to receive(:get).with("required_recipe").and_return(required_recipe)
+        expect(Chef::Recipe).to receive(:new).with(nil, nil, run_context).and_return(recipe)
+        expect(recipe).to receive(:from_file)
+      end
+
+      it "fetches the recipe and adds it to the run context" do
+        client.load_required_recipe(rest, run_context)
+      end
+
+      context "when the required_recipe has bad contents" do
+        let(:required_recipe) do
+          <<EOM
+this is not a recipe
+EOM
+        end
+        it "should not raise an error" do
+          expect { client.load_required_recipe(rest, run_context) }.not_to raise_error()
+        end
+      end
+    end
+
+    context "when required_recipe returns 404" do
+      let(:http_response) { Net::HTTPNotFound.new("1.1", "404", "Not Found") }
+      let(:http_exception) { Net::HTTPServerException.new('404 "Not Found"', http_response) }
+
+      before(:each) do
+        expect(rest).to receive(:get).with("required_recipe").and_raise(http_exception)
+      end
+
+      it "should log and continue on" do
+        expect(Chef::Log).to receive(:debug)
+        client.load_required_recipe(rest, run_context)
+      end
+    end
+  end
+
   describe "windows_admin_check" do
     context "platform is not windows" do
       before do

data/spec/unit/config_fetcher_spec.rb

@@ -58,7 +58,7 @@ describe Chef::ConfigFetcher do
             and_return(invalid_json)
 
           expect(Chef::Application).to receive(:fatal!).
-            with(invalid_json_error_regex, Chef::Exceptions::DeprecatedExitCode.new)
+            with(invalid_json_error_regex)
           fetcher.fetch_json
         end
       end
@@ -104,7 +104,7 @@ describe Chef::ConfigFetcher do
               with("").and_return(invalid_json)
 
             expect(Chef::Application).to receive(:fatal!).
-              with(invalid_json_error_regex, Chef::Exceptions::DeprecatedExitCode.new)
+              with(invalid_json_error_regex)
             fetcher.fetch_json
           end
         end

data/spec/unit/cookbook/cookbook_version_loader_spec.rb

@@ -40,42 +40,45 @@ describe Chef::Cookbook::CookbookVersionLoader do
       File.join(cookbook_path, cookbook_relative_path)
     end
 
+    def full_paths_for_part(part)
+      loaded_cookbook.files_for(part).inject([]) { |memo, f| memo << f[:full_path]; memo }
+    end
+
     it "loads attribute files of the cookbook" do
-      expect(loaded_cookbook.attribute_filenames).to include(full_path("/attributes/default.rb"))
-      expect(loaded_cookbook.attribute_filenames).to include(full_path("/attributes/smokey.rb"))
+      expect(full_paths_for_part("attributes")).to include(full_path("/attributes/default.rb"))
+      expect(full_paths_for_part("attributes")).to include(full_path("/attributes/smokey.rb"))
     end
 
     it "loads definition files" do
-      expect(loaded_cookbook.definition_filenames).to include(full_path("/definitions/client.rb"))
-      expect(loaded_cookbook.definition_filenames).to include(full_path("/definitions/server.rb"))
+      expect(full_paths_for_part("definitions")).to include(full_path("/definitions/client.rb"))
+      expect(full_paths_for_part("definitions")).to include(full_path("/definitions/server.rb"))
     end
 
     it "loads recipes" do
-      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/default.rb"))
-      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/gigantor.rb"))
-      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/one.rb"))
-      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/return.rb"))
+      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/default.rb"))
+      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/gigantor.rb"))
+      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/one.rb"))
+      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/return.rb"))
     end
 
     it "loads libraries" do
-      expect(loaded_cookbook.library_filenames).to include(full_path("/libraries/openldap.rb"))
-      expect(loaded_cookbook.library_filenames).to include(full_path("/libraries/openldap/version.rb"))
+      expect(full_paths_for_part("libraries")).to include(full_path("/libraries/openldap.rb"))
+      expect(full_paths_for_part("libraries")).to include(full_path("/libraries/openldap/version.rb"))
     end
 
     it "loads static files in the files/ dir" do
-      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file1.txt"))
-      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file2.txt"))
+      expect(full_paths_for_part("files")).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file1.txt"))
+      expect(full_paths_for_part("files")).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file2.txt"))
     end
 
     it "loads files that start with a ." do
-      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/.dotfile"))
-      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/.ssh/id_rsa"))
-      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/.a_dotdir/.a_dotfile_in_a_dotdir"))
+      expect(full_paths_for_part("files")).to include(full_path("/files/default/.dotfile"))
+      expect(full_paths_for_part("files")).to include(full_path("/files/default/.ssh/id_rsa"))
+      expect(full_paths_for_part("files")).to include(full_path("/files/default/remotedir/.a_dotdir/.a_dotfile_in_a_dotdir"))
     end
 
     it "loads root files that start with a ." do
       expect(loaded_cookbook.all_files).to include(full_path(".root_dotfile"))
-      expect(loaded_cookbook.root_filenames).to include(full_path(".root_dotfile"))
     end
 
     it "loads all unignored files, even if they don't match a segment type" do
@@ -97,13 +100,22 @@ describe Chef::Cookbook::CookbookVersionLoader do
       let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "kitchen/openldap") }
 
       it "skips ignored files" do
-        expect(loaded_cookbook.recipe_filenames).to include(full_path("recipes/gigantor.rb"))
-        expect(loaded_cookbook.recipe_filenames).to include(full_path("recipes/woot.rb"))
-        expect(loaded_cookbook.recipe_filenames).to_not include(full_path("recipes/ignoreme.rb"))
+        expect(full_paths_for_part("recipes")).to include(full_path("recipes/gigantor.rb"))
+        expect(full_paths_for_part("recipes")).to include(full_path("recipes/woot.rb"))
+        expect(full_paths_for_part("recipes")).to_not include(full_path("recipes/ignoreme.rb"))
       end
 
     end
 
+    context "when a cookbook's metadata.rb does not parse but the compiled metadata.json is present" do
+      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "prefer_metadata_json") }
+
+      it "reads the cookbook" do
+        expect(loaded_cookbook.metadata.name.to_s).to eq("prefer_metadata_json")
+        expect(loaded_cookbook.metadata.version.to_s).to eq("1.2.3")
+      end
+    end
+
     context "when the given path is not actually a cookbook" do
 
       let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/NOTHING_HERE_FOLKS") }

data/spec/unit/cookbook/file_vendor_spec.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 require "spec_helper"
+require "chef/cookbook_version"
 
 describe Chef::Cookbook::FileVendor do
 
@@ -25,6 +26,12 @@ describe Chef::Cookbook::FileVendor do
 
     let(:http) { double("Chef::ServerAPI") }
 
+    # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
+    let(:manifest) do
+      cbv = Chef::CookbookVersion.new("bob", Array(Dir.tmpdir))
+      cbv.cookbook_manifest
+    end
+
     before do
       file_vendor_class.fetch_from_remote(http)
     end
@@ -39,8 +46,11 @@ describe Chef::Cookbook::FileVendor do
 
     context "with a manifest from a cookbook version" do
 
-      # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-      let(:manifest) { { :cookbook_name => "bob", :name => "bob-1.2.3" } }
+      # # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
+      # let(:manifest) do
+      #   cbv = Chef::CookbookVersion.new("bob", Array(Dir.tmpdir))
+      #   cbv.cookbook_manifest
+      # end
 
       it "creates a RemoteFileVendor for a given manifest" do
         file_vendor = file_vendor_class.create_from_manifest(manifest)
@@ -53,9 +63,6 @@ describe Chef::Cookbook::FileVendor do
 
     context "with a manifest from a cookbook artifact" do
 
-      # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-      let(:manifest) { { :name => "bob" } }
-
       it "creates a RemoteFileVendor for a given manifest" do
         file_vendor = file_vendor_class.create_from_manifest(manifest)
         expect(file_vendor).to be_a_kind_of(Chef::Cookbook::RemoteFileVendor)
@@ -70,8 +77,10 @@ describe Chef::Cookbook::FileVendor do
 
     let(:cookbook_path) { %w{/var/chef/cookbooks /var/chef/other_cookbooks} }
 
-    # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-    let(:manifest) { { :cookbook_name => "bob" } }
+    let(:manifest) do
+      cbv = Chef::CookbookVersion.new("bob", Array(Dir.tmpdir))
+      cbv.cookbook_manifest
+    end
 
     before do
       file_vendor_class.fetch_from_disk(cookbook_path)
@@ -97,8 +106,10 @@ describe Chef::Cookbook::FileVendor do
   context "when vendoring a cookbook with a name mismatch" do
     let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks") }
 
-    # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-    let(:manifest) { { :cookbook_name => "name-mismatch" } }
+    let(:manifest) do
+      cbv = Chef::CookbookVersion.new("name-mismatch", Array(Dir.tmpdir))
+      cbv.cookbook_manifest
+    end
 
     before do
       file_vendor_class.fetch_from_disk(cookbook_path)

data/spec/unit/cookbook/gem_installer_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+require "bundler/dsl"
+
+describe Chef::Cookbook::GemInstaller do
+  let(:cookbook_collection) do
+    {
+      test: double(
+        :cookbook,
+        metadata: double(
+          :metadata,
+          gems: [["httpclient"], ["nokogiri"]]
+        )
+      ),
+      test2: double(
+        :cookbook,
+        metadata: double(
+          :metadata,
+          gems: [["httpclient", ">= 2.0"]]
+        )
+      ),
+      test3: double(
+        :cookbook,
+        metadata: double(
+          :metadata,
+          gems: [["httpclient", ">= 1.0"]]
+        )
+      ),
+    }
+  end
+
+  let(:gem_installer) do
+    described_class.new(cookbook_collection, Chef::EventDispatch::Dispatcher.new)
+  end
+
+  let(:gemfile) do
+    StringIO.new
+  end
+
+  let(:shell_out) do
+    double(:shell_out, stdout: "")
+  end
+
+  let(:bundler_dsl) do
+    b = Bundler::Dsl.new
+    b.instance_eval(gemfile.string)
+    b
+  end
+
+  before(:each) do
+    # Prepare mocks: using a StringIO instead of a File
+    expect(Dir).to receive(:mktmpdir).and_yield("")
+    expect(File).to receive(:open).and_yield(gemfile)
+    expect(gemfile).to receive(:path).and_return("")
+    expect(IO).to receive(:read).and_return("")
+    expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
+
+  end
+
+  it "generates a valid Gemfile" do
+    expect { gem_installer.install }.to_not raise_error
+
+    expect { bundler_dsl }.to_not raise_error
+  end
+
+  it "generate a Gemfile with all constraints" do
+    expect { gem_installer.install }.to_not raise_error
+
+    expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
+  end
+
+  it "generates a valid Gemfile when Chef::Config[:rubygems_url] is set to a String" do
+    Chef::Config[:rubygems_url] = "https://www.rubygems.org"
+    expect { gem_installer.install }.to_not raise_error
+
+    expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
+  end
+
+  it "generates a valid Gemfile when Chef::Config[:rubygems_url] is set to an Array" do
+    Chef::Config[:rubygems_url] = [ "https://www.rubygems.org" ]
+
+    expect { gem_installer.install }.to_not raise_error
+
+    expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
+  end
+end