chef 13.5.3-universal-mingw32 → 13.6.0-universal-mingw32

data/lib/chef/resource/zypper_package.rb

@@ -25,6 +25,7 @@ class Chef
       provides :package, platform_family: "suse"
 
       property :gpg_check, [ TrueClass, FalseClass ], default: lazy { Chef::Config[:zypper_check_gpg] }
+      property :allow_downgrade, [ true, false ], default: false
     end
   end
 end

data/lib/chef/resource/zypper_repository.rb

@@ -39,6 +39,7 @@ class Chef
       property :mode, default: "0644"
       property :refresh_cache, [true, false], default: true
       property :source, String, regex: /.*/
+      property :cookbook, String
       property :gpgautoimportkeys, [true, false], default: true
 
       default_action :create

data/lib/chef/util/dsc/lcm_output_parser.rb

@@ -28,7 +28,7 @@ class Chef
           # Parses the output from LCM and returns a list of Chef::Util::DSC::ResourceInfo objects
           # that describe how the resources affected the system
           #
-          # Example:
+          # Example for WhatIfParser:
           #   parse <<-EOF
           #   What if: [Machine]: LCM: [Start Set      ]
           #   What if: [Machine]: LCM: [Start Resource ] [[File]FileToNotBeThere]
@@ -53,7 +53,62 @@ class Chef
           #     )
           #   ]
           #
-          def self.parse(lcm_output)
+          # Example for TestDSCParser:
+          #   parse <<-EOF
+          #   InDesiredState            : False
+          #   ResourcesInDesiredState   :
+          #   ResourcesNotInDesiredState: {[Environment]texteditor}
+          #   ReturnValue               : 0
+          #   PSComputerName            : .
+          #   EOF
+          #
+          #   would return
+          #
+          #   [
+          #     Chef::Util::DSC::ResourceInfo.new(
+          #       '{[Environment]texteditor}',
+          #       true,
+          #       [
+          #       ]
+          #     )
+          #   ]
+          #
+
+          def self.parse(lcm_output, test_dsc_configuration)
+            test_dsc_configuration ? test_dsc_parser(lcm_output) : what_if_parser(lcm_output)
+          end
+
+          def self.test_dsc_parser(lcm_output)
+            lcm_output ||= ""
+            current_resource = Hash.new
+
+            resources = []
+            lcm_output.lines.each do |line|
+              op_action , op_value = line.strip.split(":")
+              op_action&.strip!
+              case op_action
+              when "InDesiredState"
+                current_resource[:skipped] = op_value.strip == "True" ? true : false
+              when "ResourcesInDesiredState"
+                current_resource[:name] = op_value.strip if op_value
+              when "ResourcesNotInDesiredState"
+                current_resource[:name] = op_value.strip if op_value
+              when "ReturnValue"
+                current_resource[:context] = nil
+              end
+            end
+            if current_resource[:name]
+              resources.push(current_resource)
+            end
+
+            if resources.length > 0
+              build_resource_info(resources)
+            else
+              raise Chef::Exceptions::LCMParser, "Could not parse:\n#{lcm_output}"
+            end
+          end
+
+          def self.what_if_parser(lcm_output)
             lcm_output ||= ""
             current_resource = Hash.new
 

data/lib/chef/util/dsc/local_configuration_manager.rb

@@ -29,7 +29,7 @@ class Chef::Util::DSC
 
     def test_configuration(configuration_document, shellout_flags)
       status = run_configuration_cmdlet(configuration_document, false, shellout_flags)
-      log_what_if_exception(status.stderr) unless status.succeeded?
+      log_dsc_exception(status.stderr) unless status.succeeded?
       configuration_update_required?(status.return_value)
     end
 
@@ -77,7 +77,7 @@ class Chef::Util::DSC
         ps4_base_command
       else
         if ps_version_gte_5?
-          "#{common_command_prefix} Test-DscConfiguration -path #{@configuration_path}"
+          "#{common_command_prefix} Test-DscConfiguration -path #{@configuration_path} | format-list"
         else
           ps4_base_command + " -whatif; if (! $?) { exit 1 }"
         end
@@ -88,31 +88,31 @@ class Chef::Util::DSC
       Chef::Platform.supported_powershell_version?(@node, 5)
     end
 
-    def log_what_if_exception(what_if_exception_output)
-      if whatif_not_supported?(what_if_exception_output)
+    def log_dsc_exception(dsc_exception_output)
+      if whatif_not_supported?(dsc_exception_output)
         # LCM returns an error if any of the resources do not support the opptional What-If
         Chef::Log.warn("Received error while testing configuration due to resource not supporting 'WhatIf'")
-      elsif dsc_module_import_failure?(what_if_exception_output)
-        Chef::Log.warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{what_if_exception_output.gsub(/\s+/, ' ')}")
+      elsif dsc_module_import_failure?(dsc_exception_output)
+        Chef::Log.warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{dsc_exception_output.gsub(/\s+/, ' ')}")
       else
-        Chef::Log.warn("Received error while testing configuration:\n#{what_if_exception_output.gsub(/\s+/, ' ')}")
+        Chef::Log.warn("Received error while testing configuration:\n#{dsc_exception_output.gsub(/\s+/, ' ')}")
       end
     end
 
-    def whatif_not_supported?(what_if_exception_output)
-      !! (what_if_exception_output.gsub(/[\r\n]+/, "").gsub(/\s+/, " ") =~ /A parameter cannot be found that matches parameter name 'Whatif'/i)
+    def whatif_not_supported?(dsc_exception_output)
+      !! (dsc_exception_output.gsub(/[\r\n]+/, "").gsub(/\s+/, " ") =~ /A parameter cannot be found that matches parameter name 'Whatif'/i)
     end
 
-    def dsc_module_import_failure?(what_if_output)
-      !! (what_if_output =~ /\sCimException/ &&
-        what_if_output =~ /ProviderOperationExecutionFailure/ &&
-        what_if_output =~ /\smodule\s+is\s+installed/)
+    def dsc_module_import_failure?(command_output)
+      !! (command_output =~ /\sCimException/ &&
+        command_output =~ /ProviderOperationExecutionFailure/ &&
+        command_output =~ /\smodule\s+is\s+installed/)
     end
 
-    def configuration_update_required?(what_if_output)
-      Chef::Log.debug("DSC: DSC returned the following '-whatif' output from test operation:\n#{what_if_output}")
+    def configuration_update_required?(command_output)
+      Chef::Log.debug("DSC: DSC returned the following '-whatif' output from test operation:\n#{command_output}")
       begin
-        Parser.parse(what_if_output)
+        Parser.parse(command_output, ps_version_gte_5?)
       rescue Chef::Exceptions::LCMParser => e
         Chef::Log.warn("Could not parse LCM output: #{e}")
         [Chef::Util::DSC::ResourceInfo.new("Unknown DSC Resources", true, ["Unknown changes because LCM output was not parsable."])]

data/lib/chef/version.rb

@@ -23,7 +23,7 @@ require "chef/version_string"
 
 class Chef
   CHEF_ROOT = File.expand_path("../..", __FILE__)
-  VERSION = Chef::VersionString.new("13.5.3")
+  VERSION = Chef::VersionString.new("13.6.0")
 end
 
 #

data/spec/functional/rebooter_spec.rb

@@ -35,8 +35,9 @@ describe Chef::Platform::Rebooter do
     resource
   end
 
+  let(:node) { Chef::Node.new }
+
   let(:run_context) do
-    node = Chef::Node.new
     events = Chef::EventDispatch::Dispatcher.new
     Chef::RunContext.new(node, {}, events)
   end
@@ -44,7 +45,8 @@ describe Chef::Platform::Rebooter do
   let(:expected) do
     {
       :windows => "#{ENV['SYSTEMROOT']}/System32/shutdown.exe /r /t 300 /c \"rebooter spec test\"",
-      :linux => 'shutdown -r +5 "rebooter spec test"',
+      :linux => 'shutdown -r +5 "rebooter spec test" &',
+      :solaris => 'shutdown -i6 -g5 -y "rebooter spec test" &',
     }
   end
 
@@ -69,8 +71,9 @@ describe Chef::Platform::Rebooter do
       end
 
       shared_context "test a reboot method" do
-        def test_rebooter_method(method_sym, is_windows, expected_reboot_str)
+        def test_rebooter_method(method_sym, is_windows, is_solaris, expected_reboot_str)
           allow(ChefConfig).to receive(:windows?).and_return(is_windows)
+          node.automatic["os"] = node.automatic["platform"] = node.automatic["platform_family"] = "solaris2" if is_solaris
           expect(rebooter).to receive(:shell_out!).once.with(expected_reboot_str)
           expect(rebooter).to receive(:raise).with(Chef::Exceptions::Reboot)
           expect(rebooter).to receive(method_sym).once.and_call_original
@@ -81,24 +84,32 @@ describe Chef::Platform::Rebooter do
       describe "when using #reboot_if_needed!" do
         include_context "test a reboot method"
 
-        it "should produce the correct string on Windows", :windows_only do
-          test_rebooter_method(:reboot_if_needed!, true, expected[:windows])
+        it "should produce the correct string on Windows" do
+          test_rebooter_method(:reboot_if_needed!, true, false, expected[:windows])
+        end
+
+        it "should produce a SysV-like shutdown on solaris" do
+          test_rebooter_method(:reboot_if_needed!, false, true, expected[:solaris])
         end
 
-        it "should produce the correct (Linux-specific) string on non-Windows" do
-          test_rebooter_method(:reboot_if_needed!, false, expected[:linux])
+        it "should produce a BSD-like shutdown by default" do
+          test_rebooter_method(:reboot_if_needed!, false, false, expected[:linux])
         end
       end
 
       describe "when using #reboot!" do
         include_context "test a reboot method"
 
-        it "should produce the correct string on Windows", :windows_only do
-          test_rebooter_method(:reboot!, true, expected[:windows])
+        it "should produce the correct string on Windows" do
+          test_rebooter_method(:reboot!, true, false, expected[:windows])
+        end
+
+        it "should produce a SysV-like shutdown on solaris" do
+          test_rebooter_method(:reboot!, false, true, expected[:solaris])
         end
 
-        it "should produce the correct (Linux-specific) string on non-Windows" do
-          test_rebooter_method(:reboot!, false, expected[:linux])
+        it "should produce a BSD-like shutdown by default" do
+          test_rebooter_method(:reboot!, false, false, expected[:linux])
         end
       end
     end

data/spec/functional/resource/windows_task_spec.rb

@@ -163,6 +163,31 @@ describe Chef::Resource::WindowsTask, :windows_only do
       end
     end
 
+    context "frequency :none" do
+      subject do
+        new_resource = Chef::Resource::WindowsTask.new(task_name, run_context)
+        new_resource.command task_name
+        new_resource.run_level :highest
+        new_resource.frequency :none
+        new_resource.random_delay ""
+        new_resource
+      end
+
+      it "creates the scheduled task to run on demand only" do
+        subject.run_action(:create)
+        task_details = windows_task_provider.send(:load_task_hash, task_name)
+
+        expect(task_details[:TaskName]).to eq("\\chef-client")
+        expect(task_details[:TaskToRun]).to eq("chef-client")
+        expect(task_details[:ScheduleType]).to eq("On demand only")
+        expect(task_details[:StartTime]).to eq("N/A")
+        expect(task_details[:StartDate]).to eq("N/A")
+        expect(task_details[:NextRunTime]).to eq("N/A")
+        expect(task_details[:none]).to eq(true)
+        expect(task_details[:run_level]).to eq("HighestAvailable")
+      end
+    end
+
     context "frequency :weekly" do
       subject do
         new_resource = Chef::Resource::WindowsTask.new(task_name, run_context)

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

@@ -0,0 +1,79 @@
+#
+# Author:: Sandra Tiffin (<sandi.tiffin@gmail.com>)
+# Copyright:: Copyright 2014-2016, 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_bag_item_data_handler.rb"
+
+class TestDataBag < Mash
+  attr_accessor :name
+
+  def initialize(bag_name)
+    @name = bag_name
+  end
+end
+
+class TestDataBagItem < Mash
+  attr_accessor :name, :parent
+
+  def path_for_printing
+    "/some/path"
+  end
+
+  def initialize(bag_name, item_name)
+    @name = "#{item_name}.json"
+    @parent = TestDataBag.new(bag_name)
+  end
+end
+
+describe Chef::ChefFS::DataHandler::DataBagItemDataHandler do
+  let(:handler) { described_class.new }
+
+  describe "#verify_integrity" do
+    context "json id does not match data bag item name" do
+      let(:entry) { TestDataBagItem.new("luggage", "bag") }
+      let(:object) do
+        { "raw_data" => { "id" => "duffel" } }
+      end
+      it "rejects the data bag item name" do
+        expect { |b| handler.verify_integrity(object, entry, &b) }.to yield_with_args
+      end
+    end
+
+    context "using a reserved word for the data bag name" do
+      %w{node role environment client}.each do |reserved_word|
+        let(:entry) { TestDataBagItem.new(reserved_word, "bag") }
+        let(:object) do
+          { "raw_data" => { "id" => "bag" } }
+        end
+        it "rejects the data bag name '#{reserved_word}'" do
+          expect { |b| handler.verify_integrity(object, entry, &b) }.to yield_with_args
+        end
+      end
+    end
+
+    context "valid data" do
+      let(:entry) { TestDataBagItem.new("luggage", "bag") }
+      let(:object) do
+        { "raw_data" => { "id" => "bag" } }
+      end
+      it "validates the data bag item" do
+        expect(handler.verify_integrity(object, entry)).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -44,6 +44,17 @@ describe Chef::Client do
     end
   end
 
+  context "when Ohai tells us to fail" do
+    it "fails" do
+      ohai_system = Ohai::System.new
+      module Ohai::Exceptions
+        class CriticalPluginFailure < Error; end
+      end
+      expect(ohai_system).to receive(:all_plugins) { raise Ohai::Exceptions::CriticalPluginFailure }
+      expect { client.run_ohai }.to raise_error(SystemExit)
+    end
+  end
+
   describe "authentication protocol selection" do
     context "when FIPS is disabled" do
       before do

data/spec/unit/cookbook/synchronizer_spec.rb

@@ -116,9 +116,12 @@ describe Chef::CookbookSynchronizer do
 
   let(:no_lazy_load) { true }
 
+  let(:skip_cookbook_sync) { false }
+
   let(:synchronizer) do
     Chef::Config[:no_lazy_load] = no_lazy_load
     Chef::Config[:file_cache_path] = "/file-cache"
+    Chef::Config[:skip_cookbook_sync] = skip_cookbook_sync
     Chef::CookbookSynchronizer.new(cookbook_manifest, events)
   end
 
@@ -523,5 +526,32 @@ describe Chef::CookbookSynchronizer do
         end
       end
     end
+
+    context "when Chef::Config[:skip_cookbook_sync] is true" do
+      let(:skip_cookbook_sync) { true }
+
+      it "loads the cookbook files and warns the user that this isn't supported" do
+        expect(file_cache).to receive(:load).
+          with("cookbooks/cookbook_a/recipes/default.rb", false).
+          once.
+          and_return("/file-cache/cookbooks/cookbook_a/recipes/default.rb")
+        expect(file_cache).to receive(:load).
+          with("cookbooks/cookbook_a/attributes/default.rb", false).
+          once.
+          and_return("/file-cache/cookbooks/cookbook_a/attributes/default.rb")
+        expect(file_cache).to receive(:load).
+          with("cookbooks/cookbook_a/templates/default/apache2.conf.erb", false).
+          once.
+          and_return("/file-cache/cookbooks/cookbook_a/templates/default/apache2.conf.erb")
+        expect(file_cache).to receive(:load).
+          with("cookbooks/cookbook_a/files/default/megaman.conf", false).
+          once.
+          and_return("/file-cache/cookbooks/cookbook_a/files/default/megaman.conf")
+        expect(Chef::Log).to receive(:warn).
+          with("skipping cookbook synchronization! DO NOT LEAVE THIS ENABLED IN PRODUCTION!!!").
+          once
+        synchronizer.sync_cookbooks
+      end
+    end
   end
 end

data/spec/unit/knife/data_bag_create_spec.rb

@@ -72,6 +72,14 @@ describe Chef::Knife::DataBagCreate do
       expect { knife.run }.to exit_with_code(1)
     end
 
+    it "won't create a data bag with a reserved name for search" do
+      %w{node role client environment}.each do |name|
+        knife.name_args = [name]
+        expect(Chef::DataBag).to receive(:validate_name!).with(knife.name_args[0]).and_raise(Chef::Exceptions::InvalidDataBagName)
+        expect { knife.run }.to exit_with_code(1)
+      end
+    end
+
     context "when given one argument" do
       before do
         knife.name_args = [bag_name]

data/spec/unit/mixin/user_context_spec.rb

@@ -41,7 +41,6 @@ describe "a class that mixes in user_context" do
     before do
       allow(::Chef::Platform).to receive(:windows?).and_return(true)
       allow(::Chef::Util::Windows::LogonSession).to receive(:new).and_return(logon_session)
-      allow(instance_with_user_context).to receive(:node).and_return({ "platform_family" => "windows" })
     end
 
     let(:logon_session) { instance_double("::Chef::Util::Windows::LogonSession", :set_user_context => nil, :open => nil, :close => nil) }
@@ -99,7 +98,7 @@ describe "a class that mixes in user_context" do
 
   context "when not running on Windows" do
     before do
-      allow(instance_with_user_context).to receive(:node).and_return({ "platform_family" => "ubuntu" })
+      allow(::Chef::Platform).to receive(:windows?).and_return(false)
     end
 
     it "raises a ::Chef::Exceptions::UnsupportedPlatform exception" do