chef 14.1.12 → 14.2.0

data/spec/support/shared/unit/execute_resource.rb

@@ -22,7 +22,7 @@ require "spec_helper"
 shared_examples_for "an execute resource" do
 
   before(:each) do
-    @resource = execute_resource
+    @resource = resource
   end
 
   it "should create a new Chef::Resource::Execute" do

data/spec/support/shared/unit/provider/useradd_based_user_provider.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 #
 # License:: Apache License, Version 2.0
 #
@@ -385,7 +385,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
         expect(Pathname).to receive(:new).with(@new_resource.home).and_return(@new_home_mock)
         expect(@new_home_mock).to receive(:cleanpath).and_return(home_check["new_resource_home"].last)
 
-        expect(provider.updating_home?).to eq(home_check["expected_result"])
+        expect(provider.send(:updating_home?)).to eq(home_check["expected_result"])
       end
     end
     it "should return true if the current home does not exist but a home is specified by the new resource" do
@@ -396,7 +396,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
       @current_resource.home nil
       @new_resource.home "/home/kitten"
 
-      expect(provider.updating_home?).to eq(true)
+      expect(provider.send(:updating_home?)).to eq(true)
     end
   end
 end

data/spec/unit/chef_fs/data_handler/data_handler_base_spec.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Jeremy Miller (<jm@chef.io>)
+# Copyright:: Copyright 2014-2018, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "lib/chef/chef_fs/data_handler/data_handler_base"
+
+describe Chef::ChefFS::DataHandler::DataHandlerBase do
+  describe "#normalize_hash" do
+    let(:some_item) do
+      { "name" => "grizzly",
+        "gender" => "female",
+        "age" => 3,
+        "food" => "honey"
+      }
+    end
+
+    let(:item_defaults) do
+      { "family" => "ursidae",
+        "hibernate" => true,
+        "food" => "berries",
+        "avg_lifespan_years" => 22
+      }
+    end
+
+    let(:normalized) do
+      { "name" => "grizzly",
+        "gender" => "female",
+        "family" => "ursidae",
+        "hibernate" => true,
+        "avg_lifespan_years" => 22,
+        "age" => 3,
+        "food" => "honey"
+      }
+    end
+
+    let(:handler) { described_class.new }
+
+    it "normalizes the Hash, filling in default values" do
+      expect(handler.normalize_hash(some_item, item_defaults)).to eq(normalized)
+    end
+
+    it "prefers already existing values over default values" do
+      expect(handler.normalize_hash(some_item, item_defaults)["food"]).to eq("honey")
+    end
+
+    it "handles being passed a nil value instead of Hash" do
+      expect(handler.normalize_hash(nil, item_defaults)).to eq(item_defaults)
+    end
+  end
+end

data/spec/unit/cookbook/manifest_v0_spec.rb

@@ -82,7 +82,7 @@ describe Chef::Cookbook::ManifestV0 do
 
     it "creates an all_files key and populates it" do
       result = described_class.from_hash(source_hash)
-      expect(result[:all_files].map { |f| f["name"] }).to match_array %w{ recipes/default.rb attributes/default.rb README.rdoc }
+      expect(result[:all_files].map { |f| f["name"] }).to match_array %w{ recipes/default.rb attributes/default.rb root_files/README.rdoc }
     end
 
     it "deletes unwanted segment types" do

data/spec/unit/cookbook_manifest_spec.rb

@@ -122,6 +122,8 @@ describe Chef::CookbookManifest do
         parts = relative_path.split("/")
         name = if %w{templates files}.include?(parts[0]) && parts.length == 3
                  File.join(parts[0], parts[2])
+               elsif parts.length == 1
+                 "root_files/#{parts[0]}"
                else
                  relative_path
                end

data/spec/unit/dsl/recipe_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2014-2016, Chef Software, Inc.
+# Copyright:: Copyright 2014-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -53,10 +53,6 @@ describe Chef::DSL::Recipe do
     it "responds to shell_out" do
       expect(recipe.respond_to?(:shell_out!)).to be true
     end
-
-    it "responds to shell_out" do
-      expect(recipe.respond_to?(:shell_out_with_systems_locale)).to be true
-    end
   end
 
   context "when included in a class that defines the required interface directly" do

data/spec/unit/http/authenticator_spec.rb

@@ -20,18 +20,18 @@ require "spec_helper"
 require "chef/http/authenticator"
 
 describe Chef::HTTP::Authenticator do
-  let(:class_instance) { Chef::HTTP::Authenticator.new }
-  let(:method) { double("method") }
-  let(:url) { double("url") }
+  let(:class_instance) { Chef::HTTP::Authenticator.new(client_name: "test") }
+  let(:method) { "GET" }
+  let(:url) { URI("https://chef.example.com/organizations/test") }
   let(:headers) { Hash.new }
-  let(:data) { double("data") }
-
-  before do
-    allow(class_instance).to receive(:authentication_headers).and_return({})
-  end
+  let(:data) { "" }
 
   context "when handle_request is called" do
     shared_examples_for "merging the server API version into the headers" do
+      before do
+        allow(class_instance).to receive(:authentication_headers).and_return({})
+      end
+
       it "merges the default version of X-Ops-Server-API-Version into the headers" do
         # headers returned
         expect(class_instance.handle_request(method, url, headers, data)[2]).
@@ -96,5 +96,30 @@ describe Chef::HTTP::Authenticator do
         class_instance.handle_request(method, url, headers, data)
       end
     end
+
+    context "when ssh_agent_signing" do
+      let(:public_key) { <<-EOH }
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA49TA0y81ps0zxkOpmf5V
+4/c4IeR5yVyQFpX3JpxO4TquwnRh8VSUhrw8kkTLmB3cS39Db+3HadvhoqCEbqPE
+6915kXSuk/cWIcNozujLK7tkuPEyYVsyTioQAddSdfe+8EhQVf3oHxaKmUd6waXr
+WqYCnhxgOjxocenREYNhZ/OETIeiPbOku47vB4nJK/0GhKBytL2XnsRgfKgDxf42
+BqAi1jglIdeq8lAWZNF9TbNBU21AO1iuT7Pm6LyQujhggPznR5FJhXKRUARXBJZa
+wxpGV4dGtdcahwXNE4601aXPra+xPcRd2puCNoEDBzgVuTSsLYeKBDMSfs173W1Q
+YwIDAQAB
+-----END PUBLIC KEY-----
+EOH
+
+      let(:class_instance) { Chef::HTTP::Authenticator.new(client_name: "test", raw_key: public_key, ssh_agent_signing: true) }
+
+      it "sets use_ssh_agent if needed" do
+        expect(Mixlib::Authentication::SignedHeaderAuth).to receive(:signing_object).and_wrap_original { |m, *args|
+          m.call(*args).tap do |signing_obj|
+            expect(signing_obj).to receive(:sign).with(instance_of(OpenSSL::PKey::RSA), use_ssh_agent: true).and_return({})
+          end
+        }
+        class_instance.handle_request(method, url, headers, data)
+      end
+    end
   end
 end

data/spec/unit/mixin/shell_out_spec.rb

@@ -226,11 +226,71 @@ describe Chef::Mixin::ShellOut do
 
       describe "when the last argument is not a Hash" do
         it "should no longer add environment options and set environment['LC_ALL'] to nil" do
-          expect(shell_out_obj).to receive(:shell_out_command).with(cmd).and_return(true)
+          expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {}).and_return(true)
           shell_out_obj.shell_out_with_systems_locale(cmd)
         end
       end
     end
 
+    describe "#shell_out default_env: false" do
+
+      describe "when the last argument is a Hash" do
+        describe "and environment is an option" do
+          it "should not change environment['LC_ALL'] when set to nil" do
+            options = { :environment => { "LC_ALL" => nil } }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+
+          it "should not change environment['LC_ALL'] when set to non-nil" do
+            options = { :environment => { "LC_ALL" => "en_US.UTF-8" } }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+
+          it "should no longer set environment['LC_ALL'] to nil when 'LC_ALL' not present" do
+            options = { :environment => { "HOME" => "/Users/morty" } }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+        end
+
+        describe "and env is an option" do
+          it "should not change env when set to nil" do
+            options = { :env => { "LC_ALL" => nil } }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+
+          it "should not change env when set to non-nil" do
+            options = { :env => { "LC_ALL" => "en_US.UTF-8" } }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+
+          it "should no longer set env['LC_ALL'] to nil when 'LC_ALL' not present" do
+            options = { :env => { "HOME" => "/Users/morty" } }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+        end
+
+        describe "and no env/environment option is present" do
+          it "should no longer add environment option and set environment['LC_ALL'] to nil" do
+            options = { :user => "morty" }
+            expect(shell_out_obj).to receive(:shell_out_command).with(cmd, options).and_return(true)
+            shell_out_obj.shell_out(cmd, **options, default_env: false)
+          end
+        end
+      end
+
+      describe "when the last argument is not a Hash" do
+        it "should no longer add environment options and set environment['LC_ALL'] to nil" do
+          expect(shell_out_obj).to receive(:shell_out_command).with(cmd, {}).and_return(true)
+          shell_out_obj.shell_out(cmd, default_env: false)
+        end
+      end
+    end
+
   end
 end

data/spec/unit/provider/apt_update_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Thom May (<thom@chef.io>)
-# Copyright:: Copyright (c) 2016-2017, Chef Software Inc.
+# Copyright:: Copyright (c) 2016-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -45,7 +45,7 @@ describe Chef::Provider::AptUpdate do
     before do
       FileUtils.rmdir config_dir
       expect(File.exist?(config_dir)).to be false
-      allow_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_with_systems_locale!).with("apt-get -q update", anything())
+      allow_any_instance_of(Chef::Provider::Execute).to receive(:shell_out!).with("apt-get -q update", anything())
     end
 
     it "should create the directory" do
@@ -64,7 +64,7 @@ describe Chef::Provider::AptUpdate do
   describe "#action_update" do
     it "should update the apt cache" do
       provider.load_current_resource
-      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_with_systems_locale!).with("apt-get -q update", anything())
+      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out!).with("apt-get -q update", anything())
       provider.run_action(:update)
       expect(new_resource).to be_updated_by_last_action
     end
@@ -79,14 +79,14 @@ describe Chef::Provider::AptUpdate do
 
     it "should run if the time stamp is old" do
       expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now - 86_500)
-      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_with_systems_locale!).with("apt-get -q update", anything())
+      expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out!).with("apt-get -q update", anything())
       provider.run_action(:periodic)
       expect(new_resource).to be_updated_by_last_action
     end
 
     it "should not run if the time stamp is new" do
       expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now)
-      expect_any_instance_of(Chef::Provider::Execute).not_to receive(:shell_out_with_systems_locale!).with("apt-get -q update", anything())
+      expect_any_instance_of(Chef::Provider::Execute).not_to receive(:shell_out!).with("apt-get -q update", anything())
       provider.run_action(:periodic)
       expect(new_resource).to_not be_updated_by_last_action
     end
@@ -98,14 +98,14 @@ describe Chef::Provider::AptUpdate do
 
       it "should run if the time stamp is old" do
         expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now - 500)
-        expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out_with_systems_locale!).with("apt-get -q update", anything())
+        expect_any_instance_of(Chef::Provider::Execute).to receive(:shell_out!).with("apt-get -q update", anything())
         provider.run_action(:periodic)
         expect(new_resource).to be_updated_by_last_action
       end
 
       it "should not run if the time stamp is new" do
         expect(File).to receive(:mtime).with("#{stamp_dir}/update-success-stamp").and_return(Time.now - 300)
-        expect_any_instance_of(Chef::Provider::Execute).not_to receive(:shell_out_with_systems_locale!).with("apt-get -q update", anything())
+        expect_any_instance_of(Chef::Provider::Execute).not_to receive(:shell_out!).with("apt-get -q update", anything())
         provider.run_action(:periodic)
         expect(new_resource).to_not be_updated_by_last_action
       end

data/spec/unit/provider/execute_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Prajakta Purohit (<prajakta@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -33,6 +33,7 @@ describe Chef::Provider::Execute do
       timeout:      3600,
       returns:      0,
       log_level:    :info,
+      default_env:  false,
       log_tag:      new_resource.to_s,
     }
   end
@@ -76,7 +77,7 @@ describe Chef::Provider::Execute do
 
   describe "#action_run" do
     it "runs shell_out with the default options" do
-      expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, opts)
+      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
       expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
       expect(Chef::Log).not_to receive(:warn)
       provider.run_action(:run)
@@ -103,7 +104,7 @@ describe Chef::Provider::Execute do
 
     it "if you pass a command attribute, it runs the command" do
       new_resource.command "/usr/argelbargle/bin/oogachacka 12345"
-      expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.command, opts)
+      expect(provider).to receive(:shell_out!).with(new_resource.command, opts)
       expect(provider).to receive(:converge_by).with("execute #{new_resource.command}").and_call_original
       expect(Chef::Log).not_to receive(:warn)
       provider.run_action(:run)
@@ -114,7 +115,7 @@ describe Chef::Provider::Execute do
       new_resource.sensitive true
       # Since the resource is sensitive, it should not have :live_stream set
       opts.delete(:live_stream)
-      expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, opts)
+      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
       expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
       expect(Chef::Log).not_to receive(:warn)
       provider.run_action(:run)
@@ -124,7 +125,7 @@ describe Chef::Provider::Execute do
     it "should do nothing if the sentinel file exists" do
       new_resource.creates "/foo_resource"
       expect(FileTest).to receive(:exist?).with(new_resource.creates).and_return(true)
-      expect(provider).not_to receive(:shell_out_with_systems_locale!)
+      expect(provider).not_to receive(:shell_out!)
       expect(Chef::Log).not_to receive(:warn)
       provider.run_action(:run)
       expect(new_resource).not_to be_updated
@@ -137,7 +138,7 @@ describe Chef::Provider::Execute do
       end
 
       it "should raise if user specified relative path without cwd for Chef-13" do
-        expect(provider).not_to receive(:shell_out_with_systems_locale!)
+        expect(provider).not_to receive(:shell_out!)
         expect { provider.run_action(:run) }.to raise_error(Chef::Exceptions::Execute)
       end
     end
@@ -148,7 +149,7 @@ describe Chef::Provider::Execute do
       expect(FileTest).not_to receive(:exist?).with(new_resource.creates)
       expect(FileTest).to receive(:exist?).with(File.join("/tmp", new_resource.creates)).and_return(true)
       expect(Chef::Log).not_to receive(:warn)
-      expect(provider).not_to receive(:shell_out_with_systems_locale!)
+      expect(provider).not_to receive(:shell_out!)
 
       provider.run_action(:run)
       expect(new_resource).not_to be_updated
@@ -157,7 +158,7 @@ describe Chef::Provider::Execute do
     it "should not include stdout/stderr in failure exception for sensitive resource" do
       opts.delete(:live_stream)
       new_resource.sensitive true
-      expect(provider).to receive(:shell_out_with_systems_locale!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect(provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
       expect do
         provider.run_action(:run)
       end.to raise_error(Mixlib::ShellOut::ShellCommandFailed, /suppressed for sensitive resource/)
@@ -166,7 +167,7 @@ describe Chef::Provider::Execute do
     describe "streaming output" do
       it "should not set the live_stream if sensitive is on" do
         new_resource.sensitive true
-        expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, opts)
+        expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
         expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
         expect(Chef::Log).not_to receive(:warn)
         provider.run_action(:run)
@@ -183,7 +184,7 @@ describe Chef::Provider::Execute do
         it "should set the live_stream if the log level is info or above" do
           nopts = opts
           nopts[:live_stream] = @live_stream
-          expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, nopts)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
           expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
           expect(Chef::Log).not_to receive(:warn)
           provider.run_action(:run)
@@ -195,7 +196,7 @@ describe Chef::Provider::Execute do
           new_resource.live_stream true
           nopts = opts
           nopts[:live_stream] = @live_stream
-          expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, nopts)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
           expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
           expect(Chef::Log).not_to receive(:warn)
           provider.run_action(:run)
@@ -204,7 +205,7 @@ describe Chef::Provider::Execute do
 
         it "should not set the live_stream if the resource is sensitive" do
           new_resource.sensitive true
-          expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, opts)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
           expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
           expect(Chef::Log).not_to receive(:warn)
           provider.run_action(:run)
@@ -217,7 +218,7 @@ describe Chef::Provider::Execute do
           nopts = opts
           nopts[:live_stream] = STDOUT
           allow(STDOUT).to receive(:tty?).and_return(true)
-          expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, nopts)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
           expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
           expect(Chef::Log).not_to receive(:warn)
           provider.run_action(:run)
@@ -227,7 +228,7 @@ describe Chef::Provider::Execute do
         it "should not set the live_stream to STDOUT if we are a TTY, not daemonized, but sensitive" do
           new_resource.sensitive true
           allow(STDOUT).to receive(:tty?).and_return(true)
-          expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, opts)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
           expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
           expect(Chef::Log).not_to receive(:warn)
           provider.run_action(:run)
@@ -237,7 +238,7 @@ describe Chef::Provider::Execute do
         it "should not set the live_stream to STDOUT if we are a TTY, but daemonized" do
           Chef::Config[:daemon] = true
           allow(STDOUT).to receive(:tty?).and_return(true)
-          expect(provider).to receive(:shell_out_with_systems_locale!).with(new_resource.name, opts)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
           expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
           expect(Chef::Log).not_to receive(:warn)
           provider.run_action(:run)