chef 16.0.287 → 16.2.73

data/spec/unit/provider/script_spec.rb

@@ -34,124 +34,34 @@ describe Chef::Provider::Script, "action_run" do
 
   let(:provider) { Chef::Provider::Script.new(new_resource, run_context) }
 
-  let(:tempfile) { Tempfile.open("rspec-provider-script") }
-
-  before(:each) do
-    allow(provider).to receive(:shell_out!).and_return(true)
-    allow(provider).to receive(:script_file).and_return(tempfile)
-  end
-
-  context "#script_file" do
-    it "creates a temporary file to store the script" do
-      allow(provider).to receive(:script_file).and_call_original
-      expect(provider.script_file).to be_an_instance_of(Tempfile)
+  describe "#command" do
+    it "is only the intepreter in quotes by default" do
+      expect(provider.command.strip).to eq(%q{"perl"})
     end
-  end
 
-  context "#unlink_script_file" do
-    it "unlinks the tempfile" do
-      tempfile_path = tempfile.path
-      provider.unlink_script_file
-      expect(File.exist?(tempfile_path)).to be false
+    it "is the interpreter in quotes with the flags when flags are used" do
+      new_resource.flags "-f"
+      expect(provider.command).to eq(%q{"perl" -f})
     end
   end
 
-  context "when configuring the script file's security" do
-    context "when not running on Windows" do
-      before do
-        allow(ChefUtils).to receive(:windows?).and_return(false)
-      end
-      context "#set_owner_and_group" do
-        it "sets the owner and group for the script file" do
-          new_resource.user "toor"
-          new_resource.group "wheel"
-          expect(FileUtils).to receive(:chown).with("toor", "wheel", tempfile.path)
-          provider.set_owner_and_group
-        end
-      end
-    end
-
-    context "when running on Windows" do
-      before do
-        allow(ChefUtils).to receive(:windows?).and_return(true)
-        expect(new_resource.user).to eq(nil)
-        stub_const("Chef::ReservedNames::Win32::API::Security::GENERIC_READ", 1)
-        stub_const("Chef::ReservedNames::Win32::API::Security::GENERIC_EXECUTE", 4)
-        stub_const("Chef::ReservedNames::Win32::Security", Class.new)
-        stub_const("Chef::ReservedNames::Win32::Security::SecurableObject", Class.new)
-        stub_const("Chef::ReservedNames::Win32::Security::SID", Class.new)
-        stub_const("Chef::ReservedNames::Win32::Security::ACE", Class.new)
-        stub_const("Chef::ReservedNames::Win32::Security::ACL", Class.new)
-      end
-
-      context "when an alternate user is not specified" do
-        it "does not attempt to set the script file's security descriptor" do
-          expect(provider).to receive(:grant_alternate_user_read_access)
-          expect(Chef::ReservedNames::Win32::Security::SecurableObject).not_to receive(:new)
-          provider.set_owner_and_group
-        end
-      end
-
-      context "when an alternate user is specified" do
-        let(:security_descriptor) { instance_double("Chef::ReservedNames::Win32::Security::SecurityDescriptor", dacl: []) }
-        let(:securable_object) { instance_double("Chef::ReservedNames::Win32::Security::SecurableObject", :security_descriptor => security_descriptor, :dacl= => nil) }
-        it "sets the script file's security descriptor" do
-          new_resource.user("toor")
-          expect(Chef::ReservedNames::Win32::Security::SecurableObject).to receive(:new).and_return(securable_object)
-          expect(Chef::ReservedNames::Win32::Security::SID).to receive(:from_account).and_return(nil)
-          expect(Chef::ReservedNames::Win32::Security::ACE).to receive(:access_allowed).and_return(nil)
-          expect(Chef::ReservedNames::Win32::Security::ACL).to receive(:create).and_return(nil)
-          expect(securable_object).to receive(:dacl=)
-          provider.set_owner_and_group
-        end
-      end
-    end
-  end
-
-  context "with the script file set to the correct owner and group" do
+  describe "#action_run" do
     before do
-      allow(provider).to receive(:set_owner_and_group)
+      allow(provider).to receive(:stream_to_stdout?).and_return(false)
     end
 
-    describe "when writing the script to the file" do
-      it "should put the contents of the script in the temp file" do
-        allow(provider).to receive(:unlink_script_file) # stub to avoid remove
-        provider.action_run
-        expect(IO.read(tempfile.path)).to eq("$| = 1; print 'i like beans'\n")
-        provider.unlink_script_file
-      end
-
-      it "closes before executing the script and unlinks it when finished" do
-        tempfile_path = tempfile.path
-        provider.action_run
-        expect(tempfile).to be_closed
-        expect(File.exist?(tempfile_path)).to be false
-      end
-    end
-
-    describe "when running the script" do
-      let (:default_opts) do
-        { timeout: 3600, returns: 0, default_env: false, log_level: :info, log_tag: "script[run some perl code]" }
-      end
-
-      before do
-        allow(STDOUT).to receive(:tty?).and_return(false)
-      end
-
-      it 'should set the command to "interpreter"  "tempfile"' do
-        expect(provider.command).to eq(%Q{"perl"  "#{tempfile.path}"})
-      end
-
-      it "should call shell_out! with the command" do
-        expect(provider).to receive(:shell_out!).with(provider.command, default_opts).and_return(true)
-        provider.action_run
-      end
-
-      it "should set the command to 'interpreter flags tempfile'" do
-        new_resource.flags "-f"
-        expect(provider.command).to eq(%Q{"perl" -f "#{tempfile.path}"})
-      end
+    it "should call shell_out! with the command and correct options" do
+      opts = {
+        timeout: 3600,
+        returns: 0,
+        default_env: false,
+        log_level: :info,
+        log_tag: "script[run some perl code]",
+        input: "$| = 1; print 'i like beans'",
+      }
+
+      expect(provider).to receive(:shell_out!).with(provider.command, opts).and_return(true)
+      provider.action_run
     end
   end
-
 end

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

@@ -30,7 +30,7 @@ describe Chef::Provider::User::Dscl do
   let(:salt) { nil }
   let(:iterations) { nil }
 
-  let (:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
 
   let(:node) do
     Chef::Node.new.tap do |node|
@@ -39,7 +39,7 @@ describe Chef::Provider::User::Dscl do
     end
   end
 
-  let (:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
 
   let(:new_resource) do
     r = Chef::Resource::User::DsclUser.new("toor", run_context)

data/spec/unit/provider/windows_env_spec.rb

@@ -20,14 +20,15 @@ require "spec_helper"
 
 describe Chef::Provider::WindowsEnv, :windows_only do
 
+  let(:run_context) do
+    Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
+  end
+
   before do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
     @new_resource = Chef::Resource::WindowsEnv.new("FOO")
     @new_resource.value("bar")
     @new_resource.user("<System>")
-    @provider = Chef::Provider::WindowsEnv.new(@new_resource, @run_context)
+    @provider = Chef::Provider::WindowsEnv.new(@new_resource, run_context)
   end
 
   it "assumes the key_name exists by default" do

data/spec/unit/provider/zypper_repository_spec.rb

@@ -28,12 +28,40 @@ describe Chef::Provider::ZypperRepository do
 
   # Output of the command:
   # => gpg --with-fingerprint [FILE]
-  ZYPPER_GPG_FINGER = <<~EOF.freeze
+  ZYPPER_GPG_20 = <<~EOF.freeze
     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
 
+  # Output of the command:
+  # => gpg --import-options import-show --dry-run --import --with-colons [FILE]
+  ZYPPER_GPG_22 = <<~EOF.freeze
+    pub:-:2048:1:ABF5BD827BD9BF62:1313747554:1718374819::-:::scSC::::::23::0:
+    fpr:::::::::573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62:
+    uid:-::::1466086904::F18C4DBBFCB45099ABB59088DB6B252FA7E9FB41::nginx signing key <signing-key@nginx.com>::::::::::0:
+    gpg: Total number processed: 1
+  EOF
+
+  # Output of the command:
+  # -> gpg --version
+  ZYPPER_GPG_VERSION = <<~EOF.freeze
+    gpg (GnuPG) 2.2.20
+    libgcrypt 1.8.5
+    Copyright (C) 2020 Free Software Foundation, Inc.
+    License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
+    This is free software: you are free to change and redistribute it.
+    There is NO WARRANTY, to the extent permitted by law.
+
+    Home: /Users/tsmith/.gnupg
+    Supported algorithms:
+    Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
+    Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
+            CAMELLIA128, CAMELLIA192, CAMELLIA256
+    Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
+    Compression: Uncompressed, ZIP, ZLIB, BZIP2
+  EOF
+
   let(:new_resource) { Chef::Resource::ZypperRepository.new("Nginx Repository") }
   let(:logger) { double("Mixlib::Log::Child").as_null_object }
   let(:provider) do
@@ -48,8 +76,16 @@ describe Chef::Provider::ZypperRepository do
     double("shell_out", stdout: ZYPPER_RPM_KEYS, exitstatus: 0, error?: false)
   end
 
-  let(:gpg_finger) do
-    double("shell_out", stdout: ZYPPER_GPG_FINGER, exitstatus: 0, error?: false)
+  let(:gpg_20) do
+    double("shell_out", stdout: ZYPPER_GPG_20, exitstatus: 0, error?: false)
+  end
+
+  let(:gpg_22) do
+    double("shell_out", stdout: ZYPPER_GPG_22, exitstatus: 0, error?: false)
+  end
+
+  let(:gpg_ver) do
+    double("shell_out", stdout: ZYPPER_GPG_VERSION, exitstatus: 0, error?: false)
   end
 
   it "responds to load_current_resource" do
@@ -96,24 +132,38 @@ describe Chef::Provider::ZypperRepository do
 
   describe "#key_installed?" do
     before do
-      expect(provider).to receive(:shell_out).with("rpm -qa gpg-pubkey*").and_return(rpm_key_finger)
+      expect(provider).to receive(:shell_out).with("/bin/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).to receive(:short_key_id).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).to receive(:short_key_id).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")
+  describe "#gpg_version" do
+    it "returns the gpg version by shelling out to gpg" do
+      expect(provider).to receive(:shell_out!).with("gpg --version").and_return(gpg_ver)
+      expect(provider.gpg_version).to eq(Gem::Version.new("2.2.20"))
+    end
+  end
+
+  describe "#short_key_id" do
+    it "returns the short key ID via running a dry-run import on gpg 2.2+" do
+      expect(provider).to receive(:gpg_version).and_return(Gem::Version.new("2.2"))
+      expect(provider).to receive(:shell_out!).with("gpg --import-options import-show --dry-run --import --with-colons /foo/nginx.key").and_return(gpg_22)
+      expect(provider.short_key_id("/foo/nginx.key")).to eq("7bd9bf62")
+    end
+
+    it "returns the short key ID via --with-fingerpint on gpg < 2.2" do
+      expect(provider).to receive(:gpg_version).and_return(Gem::Version.new("2.0"))
+      expect(provider).to receive(:shell_out!).with("gpg --with-fingerprint /foo/nginx.key").and_return(gpg_20)
+      expect(provider.short_key_id("/foo/nginx.key")).to eq("3dbdc284")
     end
   end
 

data/spec/unit/resource/archive_file_spec.rb

@@ -18,8 +18,11 @@
 require "spec_helper"
 
 describe Chef::Resource::ArchiveFile do
-
-  let(:resource) { Chef::Resource::ArchiveFile.new("foo") }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::ArchiveFile.new("foo", run_context) }
+  let(:provider) { resource.provider_for_action(:extract) }
 
   it "has a resource name of :archive_file" do
     expect(resource.resource_name).to eql(:archive_file)
@@ -41,6 +44,12 @@ describe Chef::Resource::ArchiveFile do
     expect(resource.mode).to eql("755")
   end
 
+  it "mode property throws a deprecation warning if Integers are passed" do
+    expect(Chef::Log).to receive(:deprecation)
+    resource.mode 755
+    provider.define_resource_requirements
+  end
+
   it "options property defaults to [:time]" do
     expect(resource.options).to eql([:time])
   end

data/spec/unit/resource/chef_client_cron_spec.rb

@@ -76,13 +76,19 @@ describe Chef::Resource::ChefClientCron do
       allow(provider).to receive(:splay_sleep_time).and_return("123")
     end
 
+    let(:root_path) { windows? ? "C:\\chef/client.rb" : "/etc/chef/client.rb" }
+
     it "creates a valid command if using all default properties" do
-      expect(provider.cron_command).to eql("/bin/sleep 123; /opt/chef/bin/chef-client -c /etc/chef/client.rb -L /var/log/chef/client.log")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /opt/chef/bin/chef-client -c #{root_path} -L /var/log/chef/client.log"
+      )
     end
 
     it "uses daemon_options if set" do
       resource.daemon_options ["--foo 1", "--bar 2"]
-      expect(provider.cron_command).to eql("/bin/sleep 123; /opt/chef/bin/chef-client --foo 1 --bar 2 -c /etc/chef/client.rb -L /var/log/chef/client.log")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /opt/chef/bin/chef-client --foo 1 --bar 2 -c #{root_path} -L /var/log/chef/client.log"
+      )
     end
 
     it "uses custom config dir if set" do
@@ -93,27 +99,37 @@ describe Chef::Resource::ChefClientCron do
     it "uses custom log files / paths if set" do
       resource.log_file_name "my-client.log"
       resource.log_directory "/var/log/my-chef/"
-      expect(provider.cron_command).to eql("/bin/sleep 123; /opt/chef/bin/chef-client -c /etc/chef/client.rb -L /var/log/my-chef/my-client.log")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /opt/chef/bin/chef-client -c #{root_path} -L /var/log/my-chef/my-client.log"
+      )
     end
 
     it "uses mailto if set" do
       resource.mailto "bob@example.com"
-      expect(provider.cron_command).to eql("/bin/sleep 123; /opt/chef/bin/chef-client -c /etc/chef/client.rb -L /var/log/chef/client.log || echo \"Chef Infra Client execution failed\"")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /opt/chef/bin/chef-client -c #{root_path} -L /var/log/chef/client.log || echo \"Chef Infra Client execution failed\""
+      )
     end
 
     it "uses custom chef-client binary if set" do
       resource.chef_binary_path "/usr/local/bin/chef-client"
-      expect(provider.cron_command).to eql("/bin/sleep 123; /usr/local/bin/chef-client -c /etc/chef/client.rb -L /var/log/chef/client.log")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /usr/local/bin/chef-client -c #{root_path} -L /var/log/chef/client.log"
+      )
     end
 
     it "appends to the log file appending if set to false" do
       resource.append_log_file false
-      expect(provider.cron_command).to eql("/bin/sleep 123; /opt/chef/bin/chef-client -c /etc/chef/client.rb > /var/log/chef/client.log 2>&1")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /opt/chef/bin/chef-client -c #{root_path} > /var/log/chef/client.log 2>&1"
+      )
     end
 
     it "sets the license acceptance flag if set" do
       resource.accept_chef_license true
-      expect(provider.cron_command).to eql("/bin/sleep 123; /opt/chef/bin/chef-client -c /etc/chef/client.rb --chef-license accept -L /var/log/chef/client.log")
+      expect(provider.cron_command).to eql(
+        "/bin/sleep 123; /opt/chef/bin/chef-client -c #{root_path} --chef-license accept -L /var/log/chef/client.log"
+      )
     end
   end
 end

data/spec/unit/resource/chef_client_scheduled_task_spec.rb

@@ -43,16 +43,26 @@ describe Chef::Resource::ChefClientScheduledTask do
     expect(resource.frequency_modifier).to eql(10)
   end
 
+  it "expects default frequency modifier to be 30 when frequency is set to 'minute'" do
+    resource.frequency "minute"
+    expect(resource.frequency_modifier).to eql(30)
+  end
+
+  it "expects default frequency modifier to be 1 when frequency is set to 'daily'" do
+    resource.frequency "daily"
+    expect(resource.frequency_modifier).to eql(1)
+  end
+
   it "validates the start_time property input" do
     expect { resource.start_time("8:00 am") }.to raise_error(Chef::Exceptions::ValidationFailed)
     expect { resource.start_time("8:00") }.to raise_error(Chef::Exceptions::ValidationFailed)
-    expect { resource.start_time("08:00") }.not_to raise_error(Chef::Exceptions::ValidationFailed)
+    expect { resource.start_time("08:00") }.not_to raise_error
   end
 
   it "validates the start_date property input" do
     expect { resource.start_date("2/1/20") }.to raise_error(Chef::Exceptions::ValidationFailed)
     expect { resource.start_date("02/01/20") }.to raise_error(Chef::Exceptions::ValidationFailed)
-    expect { resource.start_date("02/01/2020") }.not_to raise_error(Chef::Exceptions::ValidationFailed)
+    expect { resource.start_date("02/01/2020") }.not_to raise_error
   end
 
   it "raises an error if frequency_modifier is not a positive number" do
@@ -70,12 +80,12 @@ describe Chef::Resource::ChefClientScheduledTask do
 
   describe "#client_cmd" do
     it "creates a valid command if using all default properties" do
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb")
     end
 
     it "uses daemon_options if set" do
       resource.daemon_options ["--foo 1", "--bar 2"]
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --foo 1 --bar 2")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --foo 1 --bar 2") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb --foo 1 --bar 2")
     end
 
     it "uses custom config dir if set" do
@@ -86,17 +96,17 @@ describe Chef::Resource::ChefClientScheduledTask do
     it "uses custom log files / paths if set" do
       resource.log_file_name "my-client.log"
       resource.log_directory "C:/foo/bar"
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L C:/foo/bar/my-client.log -c /etc/chef/client.rb")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L C:/foo/bar/my-client.log -c /etc/chef/client.rb") | eql("C:/opscode/chef/bin/chef-client -L C:/foo/bar/my-client.log -c C:\\chef/client.rb")
     end
 
     it "uses custom chef-client binary if set" do
       resource.chef_binary_path "C:/foo/bar/chef-client"
-      expect(provider.client_cmd).to eql("C:/foo/bar/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb")
+      expect(provider.client_cmd).to eql("C:/foo/bar/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb") | eql("C:/foo/bar/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb")
     end
 
     it "sets the license acceptance flag if set" do
       resource.accept_chef_license true
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --chef-license accept")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --chef-license accept") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb --chef-license accept")
     end
   end
 end

data/spec/unit/resource/chef_client_systemd_timer_spec.rb

@@ -43,13 +43,16 @@ describe Chef::Resource::ChefClientSystemdTimer do
   end
 
   describe "#chef_client_cmd" do
+
+    let(:root_path) { windows? ? "C:\\chef/client.rb" : "/etc/chef/client.rb" }
+
     it "creates a valid command if using all default properties" do
-      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client -c #{root_path}")
     end
 
     it "uses daemon_options if set" do
       resource.daemon_options ["--foo 1", "--bar 2"]
-      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --foo 1 --bar 2 -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --foo 1 --bar 2 -c #{root_path}")
     end
 
     it "uses custom config dir if set" do
@@ -59,12 +62,12 @@ describe Chef::Resource::ChefClientSystemdTimer do
 
     it "uses custom chef-client binary if set" do
       resource.chef_binary_path "/usr/local/bin/chef-client"
-      expect(provider.chef_client_cmd).to eql("/usr/local/bin/chef-client -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/usr/local/bin/chef-client -c #{root_path}")
     end
 
     it "sets the license acceptance flag if set" do
       resource.accept_chef_license true
-      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --chef-license accept -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --chef-license accept -c #{root_path}")
     end
   end
 end