chef 18.2.7 → 18.4.2

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

@@ -41,7 +41,7 @@ describe Chef::Provider::Package::Rpm do
   let(:rpm_q_status) { instance_double("Mixlib::ShellOut", exitstatus: rpm_q_exitstatus, stdout: rpm_q_stdout) }
 
   before(:each) do
-    allow(::File).to receive(:exist?).with("PLEASE STUB File.exists? EXACTLY").and_return(true)
+    allow(::File).to receive(:exist?).with("PLEASE STUB File.exist? EXACTLY").and_return(true)
 
     # Ensure all shell out usage is stubbed with exact arguments
     allow(provider).to receive(:shell_out_compacted!).with("PLEASE STUB YOUR SHELLOUT CALLS").and_return(nil)
@@ -412,7 +412,7 @@ describe Chef::Provider::Package::Rpm do
 
     let(:new_resource) do
       # When we pass a source in as the name, then #initialize in the
-      # provider will call File.exists?. Because of the ordering in our
+      # provider will call File.exist?. Because of the ordering in our
       # let() bindings and such, we have to set the stub here and not in a
       # before block.
       allow(::File).to receive(:exist?).with(package_source).and_return(true)

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

@@ -491,4 +491,14 @@ describe Chef::Provider::Package::Zypper do
       provider.remove_package(%w{emacs vim}, ["1.0", "2.0"])
     end
   end
+
+  describe "resolve_available_version" do
+    it "should return correct version if multiple packages are shown" do
+      status = double(stdout: "S  | Name                     | Type    | Version             | Arch   | Repository\n---+--------------------------+---------+---------------------+--------+-------------------------------------------------------------\n   | apache2-mod_wsgi         | package | 4.7.1-150400.3.3.1  | x86_64 | Update repository with updates from SUSE Linux Enterprise 15\n   | apache2-mod_wsgi         | package | 4.7.1-150400.1.52   | x86_64 | Main Repository\ni+ | apache2-mod_wsgi-python3 | package | 4.5.18-150000.4.6.1 | x86_64 | Update repository with updates from SUSE Linux Enterprise 15\nv  | apache2-mod_wsgi-python3 | package | 4.5.18-4.3.1        | x86_64 | Main Repository\n", exitstatus: 0)
+
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
+      result = provider.send(:resolve_available_version, "apache2-mod_wsgi-python3", nil)
+      expect(result).to eq("4.5.18-150000.4.6.1")
+    end
+  end
 end

data/spec/unit/provider/powershell_script_spec.rb

@@ -17,10 +17,14 @@
 #
 
 require "spec_helper"
-describe Chef::Provider::PowershellScript, "action_run" do
+describe Chef::Provider::PowershellScript, "action_run", windows_only: true do
   let(:events) { Chef::EventDispatch::Dispatcher.new }
 
-  let(:run_context) { Chef::RunContext.new(Chef::Node.new, {}, events) }
+  let(:run_context) {
+    @node = Chef::Node.new
+    @node.consume_external_attrs(OHAI_SYSTEM.data.dup, {})
+    Chef::RunContext.new(@node, {}, events)
+  }
 
   let(:new_resource) do
     Chef::Resource::PowershellScript.new("run some powershell code", run_context)
@@ -44,7 +48,7 @@ describe Chef::Provider::PowershellScript, "action_run" do
         "C:\\Windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe" -NoLogo -NonInteractive -NoProfile -ExecutionPolicy Bypass -InputFormat None -InputFormat Fabulous -File "C:\\Temp\\Script.ps1"
       CMD
 
-      expect(provider.command).to eq(expected)
+      expect(provider.send(:command)).to eq(expected)
     end
 
     it "uses pwsh when given the pwsh interpreter" do
@@ -55,7 +59,99 @@ describe Chef::Provider::PowershellScript, "action_run" do
         "pwsh" -NoLogo -NonInteractive -NoProfile -ExecutionPolicy Bypass -InputFormat None  -File "C:\\Temp\\Script.ps1"
       CMD
 
-      expect(provider.command).to eq(expected)
+      expect(provider.send(:command)).to eq(expected)
+    end
+
+    it "returns the script specific to the inline interpreter when using use_inline_interpreter" do
+      new_resource.code = "test script"
+      new_resource.use_inline_powershell = true
+      # This is a string that is ONLY in the use_inline_interpreter version of this
+      expect(provider.send(:powershell_wrapper_script)).to include("$interpolatedexitcode = $")
+    end
+
+    it "returns the script specific to the normal interpreter when not using use_inline_interpreter" do
+      new_resource.code = "test script"
+      new_resource.use_inline_powershell = false
+      # This is a string that is ONLY in the non use_inline_interpreter version of this
+      expect(provider.send(:powershell_wrapper_script)).to include("new-variable -name interpolatedexitcode -visibility private")
+    end
+
+    it "Correctly returns for $True for regular powershell" do
+      new_resource.code = "$True"
+      new_resource.use_inline_powershell = false
+      new_resource.convert_boolean_return = true
+      expect(provider.run_action(:run)).to eq(nil)
+    end
+
+    it "Correctly returns for $True for inline powershell with convert_boolean_return" do
+      new_resource.code = "$True"
+      new_resource.use_inline_powershell = true
+      new_resource.convert_boolean_return = true
+      expect(provider.run_action(:run)).to eq(nil)
+    end
+
+    it "Correctly throws exception for $False for regular powershell" do
+      new_resource.code = "$False"
+      new_resource.use_inline_powershell = false
+      new_resource.convert_boolean_return = true
+      expect { provider.run_action(:run) }.to raise_error(an_instance_of(Mixlib::ShellOut::ShellCommandFailed))
+    end
+
+    it "Correctly throws exception for $False for inline powershell" do
+      new_resource.code = "$False"
+      new_resource.use_inline_powershell = true
+      new_resource.convert_boolean_return = true
+      expect { provider.run_action(:run) }.to raise_error(an_instance_of(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed))
+    end
+
+    it "return 1 fails correctly for non-inline" do
+      new_resource.code = "return 1"
+      new_resource.use_inline_powershell = false
+      expect { provider.run_action(:run) }.to raise_error(an_instance_of(Mixlib::ShellOut::ShellCommandFailed))
+    end
+
+    it "return 1 fails correctly for inline" do
+      new_resource.code = "return 1"
+      new_resource.use_inline_powershell = true
+      expect { provider.run_action(:run) }.to raise_error(an_instance_of(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed))
+    end
+
+    it "return 1 is valid when returns includes 1 for non-inline" do
+      new_resource.code = "return 1"
+      new_resource.use_inline_powershell = false
+      new_resource.returns = [1]
+      expect(provider.run_action(:run)).to eq(nil)
+    end
+    it "return 1 is valid when returns includes 1 for inline" do
+      new_resource.code = "return 1"
+      new_resource.use_inline_powershell = true
+      new_resource.returns = [1]
+      expect(provider.run_action(:run)).to eq(nil)
+    end
+
+    it "bad powershell exceptions for non-inline" do
+      new_resource.code = "xyzzy"
+      new_resource.use_inline_powershell = false
+      expect { provider.run_action(:run) }.to raise_error(an_instance_of(Mixlib::ShellOut::ShellCommandFailed))
+    end
+
+    it "bad powershell exceptions for inline" do
+      new_resource.code = "xyzzy"
+      new_resource.use_inline_powershell = true
+      expect { provider.run_action(:run) }.to raise_error(an_instance_of(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed))
+    end
+
+    it "uses powershell for inline by default" do
+      new_resource.code = "$host.version.major -lt 7"
+      new_resource.use_inline_powershell = true
+      expect(provider.run_action(:run)).to eq(nil)
+    end
+
+    it "uses pwsh for inline when asked" do
+      new_resource.code = "$host.version.major -ge 7"
+      new_resource.use_inline_powershell = true
+      new_resource.interpreter = "pwsh"
+      expect(provider.run_action(:run)).to eq(nil)
     end
   end
 end

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

@@ -251,7 +251,7 @@ describe Chef::Provider::RemoteFile::HTTP do
       end
 
       context "and the response has no Date or Last-Modified header" do
-        let(:last_response) { { "date" => nil, "last_modified" => nil } }
+        let(:last_response) { { "date" => nil, "last-modified" => nil } }
         it "does not set an mtime in the result" do
           # RFC 2616 suggests that servers that do not set a Date header do not
           # have a reliable clock, so no use in making them deal with dates.
@@ -265,19 +265,19 @@ describe Chef::Provider::RemoteFile::HTTP do
       context "and the response has a Last-Modified header" do
         let(:last_response) do
           # Last-Modified should be preferred to Date if both are set
-          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last_modified" => "Fri, 17 May 2013 11:11:11 GMT" }
+          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last-modified" => "Fri, 17 May 2013 11:11:11 GMT" }
         end
 
         it "sets the mtime to the Last-Modified time in the response" do
           fetcher.fetch
           expect(cache_control_data.etag).to be_nil
-          expect(cache_control_data.mtime).to eq(last_response["last_modified"])
+          expect(cache_control_data.mtime).to eq(last_response["last-modified"])
         end
       end
 
       context "and the response has a Date header but no Last-Modified header" do
         let(:last_response) do
-          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last_modified" => nil }
+          { "date" => "Fri, 17 May 2013 23:23:23 GMT", "last-modified" => nil }
         end
 
         it "sets the mtime to the Date in the response" do

data/spec/unit/provider/service/systemd_service_spec.rb

@@ -56,6 +56,7 @@ describe Chef::Provider::Service::Systemd do
       allow(provider).to receive(:is_active?).and_return(false)
       allow(provider).to receive(:is_enabled?).and_return(false)
       allow(provider).to receive(:is_masked?).and_return(false)
+      allow(provider).to receive(:is_static?).and_return(false)
       allow(provider).to receive(:is_indirect?).and_return(false)
     end
 

data/spec/unit/provider/user/linux_spec.rb

@@ -136,6 +136,7 @@ describe Chef::Provider::User::Linux, linux_only: true do
         "home" => ["/home/notarealuser", "/Users/notarealuser"],
         "shell" => ["/usr/bin/zsh", "/bin/bash"],
         "password" => %w{abcd 12345},
+        "sensitive" => [true],
       }
     end
 
@@ -147,6 +148,15 @@ describe Chef::Provider::User::Linux, linux_only: true do
       end
     end
 
+    it "should show a blank for password if sensitive set to true" do
+      @new_resource.password mapping["password"][0]
+      @current_resource.password mapping["password"][1]
+      @new_resource.sensitive true
+      @current_resource.sensitive true
+      provider.compare_user
+      expect(provider.change_desc).to eql(["change password from ******** to ********"])
+    end
+
     %w{uid gid}.each do |property|
       it "should return false if string #{property} matches fixnum" do
         @new_resource.send(property, "100")

data/spec/unit/resource/apt_repository_spec.rb

@@ -68,6 +68,11 @@ describe Chef::Resource::AptRepository do
     expect(resource.key).to eql(["key1"])
   end
 
+  it "allows setting options to a String and coerces it to an Array" do
+    resource.options = "by-hash=no"
+    expect(resource.options).to eql(["by-hash=no"])
+  end
+
   it "fails if the user provides a repo_name with a forward slash" do
     expect { resource.repo_name "foo/bar" }.to raise_error(ArgumentError)
   end

data/spec/unit/resource/chef_client_systemd_timer_spec.rb

@@ -102,7 +102,7 @@ describe Chef::Resource::ChefClientSystemdTimer do
 
     it "sets CPUQuota if cpu_quota property is set" do
       resource.cpu_quota 50
-      expect(provider.service_content["Service"]["CPUQuota"]).to eq(50)
+      expect(provider.service_content["Service"]["CPUQuota"]).to eq("50%")
     end
   end
 end

data/spec/unit/resource/chocolatey_installer_spec.rb

@@ -0,0 +1,151 @@
+#
+# Copyright:: Copyright (c) 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"
+
+describe Chef::Resource::ChocolateyInstaller do
+  include RecipeDSLHelper
+
+  let(:resource) { Chef::Resource::ChocolateyInstaller.new("fakey_fakerton") }
+  let(:config) do
+    <<-CONFIG
+      <?xml version="1.0" encoding="utf-8"?>
+      <chocolatey xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+        <config>
+          <add key="containsLegacyPackageInstalls" value="true" description="Install has packages installed prior to 0.9.9 series." />
+        </config>
+        <sources>
+          <source id="chocolatey" value="https://chocolatey.org/api/v2/" disabled="false" bypassProxy="false" selfService="false" adminOnly="false" priority="0" />
+        </sources>
+        <features>
+          <feature name="checksumFiles" enabled="true" setExplicitly="false" description="Checksum files when pulled in from internet (based on package)." />
+        </features>
+        <apiKeys />
+      </chocolatey>
+    CONFIG
+  end
+
+  # we save off the ENV and set ALLUSERSPROFILE so these specs will work on *nix and non-C drive Windows installs
+  before(:each) do
+    @original_env = ENV.to_hash
+    ENV["ALLUSERSPROFILE"] = "C:\\ProgramData"
+  end
+
+  after(:each) do
+    ENV.clear
+    ENV.update(@original_env)
+  end
+
+  describe "Basic Resource Settings" do
+    context "on windows", :windows_only do
+      it "supports :install, :uninstall, :upgrade actions" do
+        expect { resource.action :install }.not_to raise_error
+        expect { resource.action :uninstall }.not_to raise_error
+        expect { resource.action :upgrade }.not_to raise_error
+      end
+    end
+  end
+
+  describe "Basic chocolatey settings" do
+    context "on windows", :windows_only do
+      it "has a resource name of :chocolatey_installer" do
+        expect(resource.resource_name).to eql(:chocolatey_installer)
+      end
+
+      it "sets the default action as :install" do
+        expect(resource.action).to eql([:install])
+      end
+
+      it "supports :install and :uninstall actions" do
+        expect { resource.action :install }.not_to raise_error
+        expect { resource.action :uninstall }.not_to raise_error
+      end
+
+      it "does not support bologna install options" do
+        expect { resource.action :foo }.to raise_error(Chef::Exceptions::ValidationFailed)
+      end
+    end
+  end
+
+  describe "Installing chocolatey" do
+    context "on windows", :windows_only do
+      it "can install Chocolatey with parameters" do
+        resource.chocolatey_version = "1.4.0"
+        expect { resource.action :install }.not_to raise_error
+      end
+
+      it "logs a warning if a chocolatey install cannot be found" do
+        allow(::File).to receive(:exist?).with('C:\ProgramData\chocolatey\bin\choco.exe').and_return(false)
+        expect { Chef::Log.warn("Chocolatey is already uninstalled.") }.not_to output.to_stderr
+      end
+    end
+  end
+
+  describe "Chocolatey is idempotent because" do
+    context "on windows", :windows_only do
+      it "it does not install choco again if it is already installed" do
+        install_choco
+        chocolatey_installer "install" do
+          action :install
+        end.should_not_be_updated
+      end
+    end
+  end
+
+  describe "upgrading choco versions" do
+
+    context "on windows", :windows_only do
+      describe "when the versions do not match" do
+        it "upgrades if the proposed version is newer" do
+          allow(resource).to receive(:get_choco_version).and_return(Gem::Version.new("1.2.2"))
+          allow(resource).to receive(:chocolatey_version).and_return(Gem::Version.new("4.2.2"))
+          expect { resource.action :upgrade }.not_to raise_error
+          allow(resource).to receive(:get_choco_version).and_return(Gem::Version.new("4.2.2"))
+          expect(resource.get_choco_version).to eql(Gem::Version.new("4.2.2"))
+        end
+      end
+      describe "when the versions match" do
+        it "does not upgrade if the old version is identical" do
+          allow(resource).to receive(:get_choco_version).and_return(Gem::Version.new("2.2.2"))
+          allow(resource).to receive(:chocolatey_version).and_return(Gem::Version.new("2.2.2"))
+          expect { resource.action :upgrade }.not_to raise_error
+          expect(resource).not_to be_updated
+        end
+      end
+    end
+  end
+
+  describe "Uninstalling chocolatey" do
+    context "on windows", :windows_only do
+      it "doesn't error out uninstalling chocolatey if chocolatey is not installed" do
+        allow(::File).to receive(:exist?).with('C:\ProgramData\chocolatey\bin\choco.exe').and_return(false)
+        expect { resource.action :uninstall }.not_to raise_error
+      end
+    end
+  end
+
+  def install_choco
+    require "chef-powershell"
+    include ChefPowerShell::ChefPowerShellModule::PowerShellExec
+    powershell_code = <<-CODE
+      Set-ExecutionPolicy Bypass -Scope Process -Force;
+      [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;
+      iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
+    CODE
+    powershell_exec(powershell_code)
+  end
+end

data/spec/unit/resource/macos_pkg_spec.rb

@@ -0,0 +1,38 @@
+#
+# Copyright:: Copyright (c) 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"
+
+describe Chef::Resource::MacosPkg do
+  let(:resource) { Chef::Resource::MacosPkg.new("fakey_fakerton") }
+
+  it "has a resource name of :macos_pkg" do
+    expect(resource.resource_name).to eql(:macos_pkg)
+  end
+
+  it "sets the default action as :install" do
+    expect(resource.action).to eql([:install])
+  end
+
+  it "supports :install action" do
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "target property defaults to /" do
+    expect(resource.target).to eql("/")
+  end
+end

data/spec/unit/resource/powershell_script_spec.rb

@@ -47,9 +47,9 @@ describe Chef::Resource::PowershellScript do
     expect(resource.convert_boolean_return).to eq(false)
   end
 
-  it "inherits exactly the :cwd, :domain, :environment, :group, :password, :path, :user, :umask, :architecture, :elevated, :interpreter, :login properties from a parent resource class" do
+  it "inherits exactly the :cwd, :domain, :environment, :group, :password, :path, :user, :umask, :architecture, :elevated, :interpreter, :login, :use_inline_powershell properties from a parent resource class" do
     inherited_difference = Chef::Resource::PowershellScript.guard_inherited_attributes -
-      %i{cwd domain environment group password path user umask architecture elevated interpreter login}
+      %i{cwd domain environment group password path user umask architecture elevated interpreter login use_inline_powershell}
 
     expect(inherited_difference).to eq([])
   end

data/spec/unit/resource_spec.rb

@@ -803,6 +803,92 @@ describe Chef::Resource do
     end
   end
 
+  describe "when using resource partials" do
+    let(:resource_using_core_partial) do
+      Class.new(Chef::Resource) do
+        use "core::core_partial"
+      end
+    end
+
+    let(:resource_using_cookbook_partial) do
+      Class.new(Chef::Resource) do
+        use "my_local_partial"
+      end
+    end
+
+    let(:resource_using_nested_partials) do
+      FakeCaller = Struct.new(:label, :path, keyword_init: true)
+      NonDynamicResource = Chef::Resource.dup
+
+      # Fake a caller_locations array, as RSpec uses a different execution path
+      NonDynamicResource.define_singleton_method(:caller_locations) do
+        [
+          FakeCaller.new(label: "use", path: File.join(__dir__, "resource.rb")),
+          FakeCaller.new(label: "noise", path: File.join(__dir__, "no_file")),
+          FakeCaller.new(label: "class_from_file", path: File.join(__dir__, "_level3_partial.rb")),
+          FakeCaller.new(label: "noise", path: File.join(__dir__, "no_file")),
+          FakeCaller.new(label: "class_from_file", path: File.join(__dir__, "_level2_partial.rb")),
+          FakeCaller.new(label: "noise", path: File.join(__dir__, "no_file")),
+          FakeCaller.new(label: "class_from_file", path: File.join(__dir__, "_level1_partial.rb")),
+          FakeCaller.new(label: "noise", path: File.join(__dir__, "no_file")),
+          FakeCaller.new(label: "class_from_file", path: File.join(__dir__, "_level0_partial.rb")),
+        ]
+      end
+
+      Class.new(NonDynamicResource) do
+        use "level3_partial"
+      end
+    end
+
+    it "correcly includes a core partial" do
+      expected_path = File.expand_path(File.join(__dir__, "../..", "lib/chef", "resource/_core_partial.rb"))
+      partial = "property :addon_property, default: true"
+
+      expect(IO).to receive(:read).with(expected_path).and_return(partial)
+      expect(resource_using_core_partial.properties.keys).to include(:addon_property)
+    end
+
+    it "correctly includes a cookbook partial" do
+      expected_path = File.expand_path(File.join(__dir__, "_my_local_partial.rb"))
+      partial = "property :addon_property, default: true"
+
+      expect(IO).to receive(:read).with(expected_path).and_return(partial)
+      expect(resource_using_cookbook_partial.properties.keys).to include(:addon_property)
+    end
+
+    it "correctly includes nested partials" do
+      level0_path = File.expand_path(File.join(__dir__, "_level0_partial.rb"))
+      level0_partial = "property :level0_property, default: true"
+      expect(IO).to receive(:read).with(level0_path).and_return(level0_partial)
+
+      level1_path = File.expand_path(File.join(__dir__, "_level1_partial.rb"))
+      level1_partial = <<-EOF
+        use 'level0_partial'
+        property :level1_property, default: true
+      EOF
+      expect(IO).to receive(:read).with(level1_path).and_return(level1_partial)
+
+      level2_path = File.expand_path(File.join(__dir__, "_level2_partial.rb"))
+      level2_partial = <<-EOF
+        use 'level1_partial'
+        property :level2_property, default: true
+      EOF
+      expect(IO).to receive(:read).with(level2_path).and_return(level2_partial)
+
+      level3_path = File.expand_path(File.join(__dir__, "_level3_partial.rb"))
+      level3_partial = <<-EOF
+        use 'level2_partial'
+        property :level3_property, default: true
+      EOF
+      expect(IO).to receive(:read).with(level3_path).and_return(level3_partial)
+
+      expect(resource_using_nested_partials.properties.keys).to include(:level0_property)
+      expect(resource_using_nested_partials.properties.keys).to include(:level1_property)
+      expect(resource_using_nested_partials.properties.keys).to include(:level2_property)
+      expect(resource_using_nested_partials.properties.keys).to include(:level3_property)
+    end
+  end
+
   describe "should_skip?" do
     before do
       resource = Chef::Resource::Cat.new("sugar", run_context)