chef 13.5.3 → 13.6.0

data/spec/unit/provider/package/rubygems_spec.rb

@@ -383,6 +383,11 @@ describe Chef::Provider::Package::Rubygems do
       provider.load_current_resource
       expect(provider.target_version_already_installed?(provider.current_resource.version, new_resource.version)).to be_falsey
     end
+
+    it "version_equals? should return false so that we can search for candidates" do
+      provider.load_current_resource
+      expect(provider.version_equals?(provider.current_resource.version, new_resource.version)).to be_falsey
+    end
   end
 
   describe "when new_resource version is an rspec version" do

data/spec/unit/provider/package/zypper_spec.rb

@@ -140,6 +140,14 @@ describe Chef::Provider::Package::Zypper do
       provider.install_package(["emacs"], ["1.0"])
     end
 
+    it "setting the property should allow downgrade" do
+      new_resource.allow_downgrade true
+      shell_out_expectation!(
+        "zypper", "--non-interactive", "install", "--auto-agree-with-licenses", "--oldpackage", "emacs=1.0"
+      )
+      provider.install_package(["emacs"], ["1.0"])
+    end
+
     it "should add user provided options to the command" do
       new_resource.options "--user-provided"
       shell_out_expectation!(

data/spec/unit/provider/remote_file/network_file_spec.rb

@@ -33,7 +33,7 @@ describe Chef::Provider::RemoteFile::NetworkFile do
     let(:source_file) { double("::File", :read => nil) }
 
     before do
-      allow(fetcher).to receive(:node).and_return({ "platform_family" => "windows" })
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
     end
 
     it "stages the local file to a temporary file" do

data/spec/unit/provider/route_spec.rb

@@ -236,9 +236,11 @@ describe Chef::Provider::Route do
         @node.automatic_attrs[:platform] = platform
 
         route_file = StringIO.new
+        allow(File).to receive(:exist?).with("/etc/sysconfig/network").and_return(false)
         expect(File).to receive(:new).with("/etc/sysconfig/network", "w").and_return(route_file)
         @run_context.resource_collection << @default_resource
         @default_provider.generate_config
+        expect(route_file.string).to match(/GATEWAY=10\.0\.0\.9/)
       end
     end
 

data/spec/unit/provider/windows_task_spec.rb

@@ -143,6 +143,17 @@ describe Chef::Provider::WindowsTask do
         provider.run_action(:create)
         expect(new_resource).to be_updated_by_last_action
       end
+
+      it "updates the task XML if frequency is set as `:none`" do
+        new_resource.frequency :none
+        new_resource.random_delay ""
+        allow(provider).to receive(:task_need_update?).and_return(true)
+        allow(provider).to receive(:basic_validation).and_return(true)
+        allow(provider).to receive(:run_schtasks).and_return("CREATE", { "F" => "", "SC" => :once, "ST" => "00:00", "SD" => "12/12/2012", "TR" => nil, "RU" => "SYSTEM" })
+        expect(provider).to receive(:update_task_xml)
+        provider.run_action(:create)
+        expect(new_resource).to be_updated_by_last_action
+      end
     end
   end
 
@@ -507,6 +518,18 @@ describe Chef::Provider::WindowsTask do
       expect(provider).to receive(:run_schtasks).twice
       output = provider.send(:update_task_xml, ["random_delay"])
     end
+
+    it "updates the task XML if frequency is set as `:none`" do
+      new_resource.frequency :none
+      new_resource.random_delay ""
+      shell_out_obj = double("xml", :exitstatus => 0, :stdout => task_xml)
+      allow(provider).to receive(:powershell_out).and_return(shell_out_obj)
+      expect(::File).to receive(:delete)
+      expect(::File).to receive(:join)
+      expect(::File).to receive(:open)
+      expect(provider).to receive(:run_schtasks).twice
+      output = provider.send(:update_task_xml, ["random_delay"])
+    end
   end
 
   describe "#load_task_hash" do
@@ -541,5 +564,10 @@ describe Chef::Provider::WindowsTask do
       new_resource.frequency :once
       expect(provider.send(:frequency_modifier_allowed)).to be(false)
     end
+
+    it "returns false for frequency :none" do
+      new_resource.frequency :none
+      expect(provider.send(:frequency_modifier_allowed)).to be(false)
+    end
   end
 end

data/spec/unit/provider/zypper_repository_spec.rb

@@ -0,0 +1,124 @@
+#
+# Author:: Tim Smith (<tsmith@chef.io>)
+# Copyright:: 2017, 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"
+
+# Output of the command:
+# => rpm -qa gpg-pubkey*
+RPM_KEYS = <<-EOF
+gpg-pubkey-307e3d54-4be01a65
+gpg-pubkey-3dbdc284-53674dd4
+EOF
+
+# Output of the command:
+# => gpg --with-fingerprint [FILE]
+GPG_FINGER = <<-EOF
+pub  2048R/3DBDC284 2011-08-19 [expires: 2024-06-14]
+      Key fingerprint = 573B FD6B 3D8F BC64 1079  A6AB ABF5 BD82 7BD9 BF62
+uid                            nginx signing key <signing-key@nginx.com>
+EOF
+
+describe Chef::Provider::ZypperRepository do
+  let(:new_resource) { Chef::Resource::ZypperRepository.new("Nginx Repository") }
+  let(:provider) do
+    node = Chef::Node.new
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, events)
+    Chef::Provider::ZypperRepository.new(new_resource, run_context)
+  end
+
+  let(:rpm_key_finger) do
+    double("shell_out_with_systems_locale", stdout: RPM_KEYS, exitstatus: 0, error?: false)
+  end
+
+  let(:gpg_finger) do
+    double("shell_out_with_systems_locale", stdout: GPG_FINGER, exitstatus: 0, error?: false)
+  end
+
+  it "responds to load_current_resource" do
+    expect(provider).to respond_to(:load_current_resource)
+  end
+
+  describe "#action_create" do
+    it "skips key import if gpgautoimportkeys is false" do
+      new_resource.gpgautoimportkeys(false)
+      expect(provider).to receive(:declare_resource)
+      expect(Chef::Log).to receive(:debug)
+      provider.run_action(:create)
+    end
+  end
+
+  describe "#escaped_repo_name" do
+    it "returns an escaped repo name" do
+      expect(provider.escaped_repo_name).to eq('Nginx\\ Repository')
+    end
+  end
+
+  describe "#cookbook_name" do
+    it "returns 'test' when the cookbook property is set" do
+      new_resource.cookbook("test")
+      expect(provider.cookbook_name).to eq("test")
+    end
+  end
+
+  describe "#key_type" do
+    it "returns :remote_file with an http URL" do
+      expect(provider.key_type("https://www.chef.io/key")).to eq(:remote_file)
+    end
+
+    it "returns :cookbook_file with a chef managed file" do
+      expect(provider).to receive(:has_cookbook_file?).and_return(true)
+      expect(provider.key_type("/foo/nginx.key")).to eq(:cookbook_file)
+    end
+
+    it "throws exception if an unknown file specified" do
+      expect(provider).to receive(:has_cookbook_file?).and_return(false)
+      expect { provider.key_type("/foo/nginx.key") }.to raise_error(Chef::Exceptions::FileNotFound)
+    end
+  end
+
+  describe "#key_installed?" do
+    before do
+      expect(provider).to receive(:shell_out).with("rpm -qa gpg-pubkey*").and_return(rpm_key_finger)
+    end
+
+    it "returns true if the key is installed" do
+      expect(provider).to receive(:key_fingerprint).and_return("3dbdc284")
+      expect(provider.key_installed?("/foo/nginx.key")).to be_truthy
+    end
+
+    it "returns false if the key is not installed" do
+      expect(provider).to receive(:key_fingerprint).and_return("BOGUS")
+      expect(provider.key_installed?("/foo/nginx.key")).to be_falsey
+    end
+  end
+
+  describe "#key_fingerprint" do
+    it "returns the key's fingerprint" do
+      expect(provider).to receive(:shell_out!).with("gpg --with-fingerprint /foo/nginx.key").and_return(gpg_finger)
+      expect(provider.key_fingerprint("/foo/nginx.key")).to eq("3dbdc284")
+    end
+  end
+
+  describe "#install_gpg_key" do
+    it "skips installing the key if a nil value for key is passed" do
+      expect(Chef::Log).to receive(:debug)
+      provider.install_gpg_key(nil)
+    end
+  end
+end

data/spec/unit/provider_resolver_spec.rb

@@ -708,18 +708,21 @@ describe Chef::ProviderResolver do
 
           "rhel" => {
     #        service: [ Chef::Resource::SystemdService, Chef::Provider::Service::Systemd ],
-            package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
+            package:  [ Chef::Resource::DnfPackage, Chef::Provider::Package::Dnf ],
             ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Redhat ],
 
             %w{amazon xcp xenserver ibm_powerkvm cloudlinux parallels} => {
               "3.1.4" => {
+                package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
     #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
               },
             },
             %w{redhat centos scientific oracle} => {
               "7.0" => {
+                package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
               },
               "6.0" => {
+                package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
     #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
               },
             },

data/spec/unit/resource/windows_task_spec.rb

@@ -102,8 +102,14 @@ describe Chef::Resource::WindowsTask do
   end
 
   context "#validate_start_time" do
-    it "raises error if start_time is nil" do
-      expect { resource.send(:validate_start_time, nil) }.to raise_error(Chef::Exceptions::ArgumentError, "`start_time` needs to be provided with `frequency :once`")
+    it "raises error if start_time is nil when frequency `:once`" do
+      resource.frequency :once
+      expect { resource.send(:validate_start_time, nil, :once) }.to raise_error(Chef::Exceptions::ArgumentError, "`start_time` needs to be provided with `frequency :once`")
+    end
+
+    it "raises error if start_time is given when frequency `:none`" do
+      resource.frequency :none
+      expect { resource.send(:validate_start_time, "12.00", :none) }.to raise_error(Chef::Exceptions::ArgumentError, "`start_time` property is not supported with `frequency :none`")
     end
   end
 

data/spec/unit/resource/zypper_repository_spec.rb

@@ -46,20 +46,22 @@ describe Chef::Resource::ZypperRepository do
       expect { resource.action :delete }.to raise_error(ArgumentError)
     end
 
-    it "should resolve to a Noop class when zypper is not found" do
-      expect(Chef::Provider::ZypperRepository).to receive(:which).with("zypper").and_return(false)
+    it "resolves to a Noop class when on non-linux OS" do
+      node.automatic[:os] = "windows"
+      node.automatic[:platform_family] = "windows"
       expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
     end
 
-    it "should resolve to a ZypperRepository class when zypper is found" do
-      expect(Chef::Provider::ZypperRepository).to receive(:which).with("zypper").and_return(true)
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::ZypperRepository)
+    it "resolves to a Noop class when on non-suse linux" do
+      node.automatic[:os] = "linux"
+      node.automatic[:platform_family] = "debian"
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
     end
-  end
 
-  context "on windows", :windows_only do
-    it "should resolve to a NoOp provider" do
-      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::Noop)
+    it "resolves to a ZypperRepository class when on a suse platform_family" do
+      node.automatic[:os] = "linux"
+      node.automatic[:platform_family] = "suse"
+      expect(resource.provider_for_action(:add)).to be_a(Chef::Provider::ZypperRepository)
     end
   end
 end

data/spec/unit/util/dsc/lcm_output_parser_spec.rb

@@ -19,20 +19,33 @@
 require "chef/util/dsc/lcm_output_parser"
 
 describe Chef::Util::DSC::LocalConfigurationManager::Parser do
-  context "empty input parameter" do
+  context "empty input parameter for WhatIfParser" do
     it "raises an exception when there are no valid lines" do
       str = <<-EOF
 
       EOF
-      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str) }.to raise_error(Chef::Exceptions::LCMParser)
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false) }.to raise_error(Chef::Exceptions::LCMParser)
     end
 
     it "raises an exception for a nil input" do
-      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil) }.to raise_error(Chef::Exceptions::LCMParser)
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil, false) }.to raise_error(Chef::Exceptions::LCMParser)
     end
   end
 
-  context "correctly formatted output from lcm" do
+  context "empty input parameter for TestDSCParser" do
+    it "raises an exception when there are no valid lines" do
+      str = <<-EOF
+
+      EOF
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+
+    it "raises an exception for a nil input" do
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil, true) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+  end
+
+  context "correctly formatted output from lcm for WhatIfParser" do
     it "returns a single resource when only 1 logged with the correct name" do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
@@ -40,7 +53,7 @@ logtype: [machinename]: LCM:  [ Start  Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources.length).to eq(1)
       expect(resources[0].name).to eq("[name]")
     end
@@ -54,7 +67,7 @@ logtype: [machinename]: LCM:  [ End    Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_truthy
     end
 
@@ -68,11 +81,11 @@ logtype: [machinename]: LCM:  [ End    Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].change_log).to match_array(["[name]", "[message]", "[name]"])
     end
 
-    it "should return false for changes_state?" do
+    it "returns false for changes_state?" do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ] [name]
@@ -80,11 +93,11 @@ logtype: [machinename]: LCM:  [ Skip   Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_falsey
     end
 
-    it "should return an empty array for change_log if changes_state? is false" do
+    it "returns an empty array for change_log if changes_state? is false" do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ] [name]
@@ -92,13 +105,64 @@ logtype: [machinename]: LCM:  [ Skip   Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].change_log).to be_empty
     end
   end
 
-  context "Incorrectly formatted output from LCM" do
-    it "should allow missing a [End Resource] when its the last one and still find all the resource" do
+  context "correctly formatted output from lcm for TestDSCParser" do
+    it "returns a single resource when only 1 logged with the correct name" do
+      str = <<EOF
+InDesiredState            : False
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name]
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources.length).to eq(1)
+      expect(resources[0].name).to eq("[name]")
+    end
+
+    it "identifies when a resource changes the state of the system" do
+      str = <<EOF
+InDesiredState            : False
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name]
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_truthy
+    end
+
+    it "returns false for changes_state?" do
+      str = <<EOF
+InDesiredState            : True
+ResourcesInDesiredState   : [name]
+ResourcesNotInDesiredState:
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+
+    it "returns an empty array for change_log if changes_state? is false" do
+      str = <<EOF
+InDesiredState            : True
+ResourcesInDesiredState   : [name]
+ResourcesNotInDesiredState:
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].change_log).to be_empty
+    end
+  end
+
+  context "Incorrectly formatted output from LCM for WhatIfParser" do
+    it "allows missing [End Resource] when its the last one and still find all the resource" do
       str = <<-EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
@@ -114,12 +178,12 @@ logtype: [machinename]: LCM:  [ End    Set      ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
 
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_falsey
       expect(resources[1].changes_state?).to be_truthy
     end
 
-    it "should allow missing a [End Resource] when its the first one and still find all the resource" do
+    it "allow missing [End Resource] when its the first one and still find all the resource" do
       str = <<-EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
@@ -135,12 +199,12 @@ logtype: [machinename]: LCM:  [ End    Resource ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
 
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_falsey
       expect(resources[1].changes_state?).to be_truthy
     end
 
-    it "should allow missing set and end resource and assume an unconverged resource in this case" do
+    it "allows missing set and end resource and assume an unconverged resource in this case" do
       str = <<-EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
@@ -154,11 +218,31 @@ logtype: [machinename]: LCM:  [ End    Set      ]
 logtype: [machinename]: LCM:  [ End    Resource ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_truthy
       expect(resources[0].name).to eql("[name]")
       expect(resources[1].changes_state?).to be_truthy
       expect(resources[1].name).to eql("[name2]")
     end
   end
+
+  context "Incorrectly formatted output from LCM for TestDSCParser" do
+    it "allows missing [End Resource] when its the last one and still find all the resource" do
+      str = <<EOF
+InDesiredState            : True
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name]
+ReturnValue               : 0
+PSComputerName            : .
+InDesiredState            : True
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name2]
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+  end
 end