chef 16.13.16-universal-mingw32 → 17.3.48-universal-mingw32

data/spec/unit/provider/systemd_unit_spec.rb

@@ -117,6 +117,7 @@ describe Chef::Provider::SystemdUnit, :linux_only do
       allow(provider).to receive(:enabled?).and_return(false)
       allow(provider).to receive(:masked?).and_return(false)
       allow(provider).to receive(:static?).and_return(false)
+      allow(provider).to receive(:indirect?).and_return(false)
     end
 
     it "should create a current resource with the name of the new resource" do
@@ -811,6 +812,49 @@ describe Chef::Provider::SystemdUnit, :linux_only do
         end
       end
 
+      def with_systemctl_show(systemctl_path, instance, opts, stdout)
+        systemctl_show = [systemctl_path, instance, "show", "-p", "UnitFileState", "-p", "ActiveState", unit_name]
+        expect(provider).to receive(:shell_out).with(*systemctl_show, **opts).and_return(double(stdout: stdout, exitstatus: 0, error?: false))
+      end
+
+      describe "systemd_unit_status" do
+        before(:each) do
+          provider.current_resource = current_resource
+          current_resource.unit_name(unit_name)
+        end
+
+        it "should return status if '#{systemctl_path} --system show -p UnitFileState -p ActiveState unit_name' returns 0 and has nil" do
+          # No unit known for this service, and inactive
+          nil_and_inactive = <<-STDOUT
+            ActiveState=inactive
+            UnitFileState=
+          STDOUT
+          nil_and_inactive_h = {
+            "ActiveState" => "inactive",
+            "UnitFileState" => nil,
+          }
+          with_systemctl_show(systemctl_path, "--system", {},  nil_and_inactive)
+          expect(provider.systemd_unit_status).to eql(nil_and_inactive_h)
+        end
+
+        it "should not error if '#{systemctl_path} --system show' is run against a template unit" do
+          current_resource.unit_name("foo@.service")
+          template_error = "Failed to get properties: Unit name foo@.service is neither a valid invocation ID nor unit name."
+          systemctl_show = [systemctl_path, "--system", "show", "-p", "UnitFileState", "-p", "ActiveState", "foo@.service"]
+          expect(provider).to receive(:shell_out).with(*systemctl_show).and_return(double(stdout: "", stderr: template_error, exitstatus: 1, error?: true))
+          expect(provider.systemd_unit_status).to eql({})
+        end
+      end
+
+      enabled_and_active = <<-STDOUT
+        ActiveState=active
+        UnitFileState=enabled
+      STDOUT
+      disabled_and_inactive = <<-STDOUT
+        ActiveState=disabled
+        UnitFileState=inactive
+      STDOUT
+
       describe "#active?" do
         before(:each) do
           provider.current_resource = current_resource
@@ -820,33 +864,25 @@ describe Chef::Provider::SystemdUnit, :linux_only do
         context "when a user is specified" do
           it "returns true when unit is active" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.active?).to be true
           end
 
           it "returns false when unit is inactive" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-active", unit_name, user_cmd_opts)
-              .and_return(shell_out_failure)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, disabled_and_inactive)
             expect(provider.active?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when unit is active" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-active", unit_name)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.active?).to be true
           end
 
           it "returns false when unit is not active" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-active", unit_name)
-              .and_return(shell_out_failure)
+            with_systemctl_show(systemctl_path, "--system", {}, disabled_and_inactive)
             expect(provider.active?).to be false
           end
         end
@@ -861,33 +897,25 @@ describe Chef::Provider::SystemdUnit, :linux_only do
         context "when a user is specified" do
           it "returns true when unit is enabled" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.enabled?).to be true
           end
 
           it "returns false when unit is not enabled" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_disabled)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, disabled_and_inactive)
             expect(provider.enabled?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when unit is enabled" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_success)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.enabled?).to be true
           end
 
           it "returns false when unit is not enabled" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_disabled)
+            with_systemctl_show(systemctl_path, "--system", {}, disabled_and_inactive)
             expect(provider.enabled?).to be false
           end
         end
@@ -899,36 +927,33 @@ describe Chef::Provider::SystemdUnit, :linux_only do
           allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
+        masked_and_inactive = <<-STDOUT
+          ActiveState=inactive
+          UnitFileState=masked
+        STDOUT
+
         context "when a user is specified" do
           it "returns true when the unit is masked" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, masked_and_inactive)
             expect(provider.masked?).to be true
           end
 
           it "returns false when the unit is not masked" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "status", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.masked?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when the unit is masked" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "status", unit_name)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--system", {}, masked_and_inactive)
             expect(provider.masked?).to be true
           end
 
           it "returns false when the unit is not masked" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "status", unit_name)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.masked?).to be false
           end
         end
@@ -940,36 +965,33 @@ describe Chef::Provider::SystemdUnit, :linux_only do
           allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
+        static_and_active = <<-STDOUT
+          ActiveState=active
+          UnitFileState=static
+        STDOUT
+
         context "when a user is specified" do
           it "returns true when the unit is static" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, static_and_active)
             expect(provider.static?).to be true
           end
 
           it "returns false when the unit is not static" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.static?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when the unit is static" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--system", {}, static_and_active)
             expect(provider.static?).to be true
           end
 
           it "returns false when the unit is not static" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_masked)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.static?).to be false
           end
         end
@@ -981,36 +1003,33 @@ describe Chef::Provider::SystemdUnit, :linux_only do
           allow(provider).to receive(:which).with("systemctl").and_return(systemctl_path.to_s)
         end
 
+        indirect_and_inactive = <<-STDOUT
+          ActiveState=inactive
+          UnitFileState=indirect
+        STDOUT
+
         context "when a user is specified" do
           it "returns true when the unit is indirect" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_indirect)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, indirect_and_inactive)
             expect(provider.indirect?).to be true
           end
 
           it "returns false when the unit is not indirect" do
             current_resource.user(user_name)
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--user", "is-enabled", unit_name, user_cmd_opts)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--user", user_cmd_opts, enabled_and_active)
             expect(provider.indirect?).to be false
           end
         end
 
         context "when no user is specified" do
           it "returns true when the unit is indirect" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_indirect)
+            with_systemctl_show(systemctl_path, "--system", {}, indirect_and_inactive)
             expect(provider.indirect?).to be true
           end
 
           it "returns false when the unit is not indirect" do
-            expect(provider).to receive(:shell_out_compacted)
-              .with(systemctl_path, "--system", "is-enabled", unit_name)
-              .and_return(shell_out_static)
+            with_systemctl_show(systemctl_path, "--system", {}, enabled_and_active)
             expect(provider.indirect?).to be false
           end
         end

data/spec/unit/provider/zypper_repository_spec.rb

@@ -96,7 +96,7 @@ describe Chef::Provider::ZypperRepository do
     it "skips key import if gpgautoimportkeys is false" do
       new_resource.gpgautoimportkeys(false)
       expect(provider).to receive(:declare_resource)
-      expect(logger).to receive(:trace)
+      expect(logger).to receive(:debug)
       provider.run_action(:create)
     end
   end
@@ -107,13 +107,6 @@ describe Chef::Provider::ZypperRepository do
     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)
@@ -167,10 +160,10 @@ describe Chef::Provider::ZypperRepository do
     end
   end
 
-  describe "#install_gpg_key" do
-    it "skips installing the key if a nil value for key is passed" do
-      expect(logger).to receive(:trace)
-      provider.install_gpg_key(nil)
+  describe "#install_gpg_keys" do
+    it "skips installing the key if an empty array for key URL is passed" do
+      expect(logger).to receive(:debug)
+      provider.install_gpg_keys([])
     end
   end
 end

data/spec/unit/provider_spec.rb

@@ -189,12 +189,4 @@ describe Chef::Provider do
 
     end
   end
-
-  context "when using use_inline_resources" do
-    it "should log a deprecation warning" do
-      pending Chef::VERSION.start_with?("14.1")
-      expect(Chef).to receive(:deprecated).with(:use_inline_resources, kind_of(String))
-      Class.new(described_class) { use_inline_resources }
-    end
-  end
 end

data/spec/unit/resource/inspec_waiver_file_entry_spec.rb

@@ -0,0 +1,80 @@
+#
+# Author:: Davin Taddeo (<davin@chef.io>)
+# 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::InspecWaiverFileEntry do
+  let(:log_str) { "this is my string to log" }
+  let(:resource) { Chef::Resource::InspecWaiverFileEntry.new("fakey_fakerton") }
+
+  it "has a name of inspec_waiver_file_entry" do
+    expect(resource.resource_name).to eq(:inspec_waiver_file_entry)
+  end
+
+  it "setting the control property to a string does not raise error" do
+    expect { resource.control "my_test_control" }.not_to raise_error
+  end
+
+  it "sets the default action as :add" do
+    expect(resource.action).to eql([:add])
+  end
+
+  it "supports :add action" do
+    expect { resource.action :add }.not_to raise_error
+  end
+
+  it "supports :remove action" do
+    expect { resource.action :remove }.not_to raise_error
+  end
+
+  it "expects expiration property to fail with date format YYYY/MM/DD" do
+    expect { resource.expiration "2022/09/23" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects expiration property to fail with invalid date 2022-02-31" do
+    expect { resource.expiration "2022-02-31" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects expiration property to match YYYY-MM-DD" do
+    expect { resource.expiration "2022-09-23" }.not_to raise_error
+  end
+
+  it "expects the run_test property to fail validation when not a true/false value" do
+    expect { resource.run_test "yes" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects the run_test property to only accept true or false values" do
+    expect { resource.run_test true }.not_to raise_error
+  end
+
+  it "expects the justification property to accept a string value" do
+    expect { resource.justification "Because I don't want to run this compliance test" }.not_to raise_error
+  end
+
+  it "expects the justification property to fail if given a non-string value" do
+    expect { resource.justification true }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects the backup property to fail validation when set to true" do
+    expect { resource.backup true }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects the backup property to fail validation when passed a string" do
+    expect { resource.backup "please" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  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 properties from a parent resource class" do
+  it "inherits exactly the :cwd, :domain, :environment, :group, :password, :path, :user, :umask, :architecture, :elevated, :interpreter, :login 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}
+      %i{cwd domain environment group password path user umask architecture elevated interpreter login}
 
     expect(inherited_difference).to eq([])
   end

data/spec/unit/resource/windows_defender_exclusion_spec.rb

@@ -0,0 +1,62 @@
+#
+# 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::WindowsDefenderExclusion do
+  let(:resource) { Chef::Resource::WindowsDefenderExclusion.new("fakey_fakerton") }
+
+  it "sets resource name as :windows_defender_exclusion" do
+    expect(resource.resource_name).to eql(:windows_defender_exclusion)
+  end
+
+  it "sets the default action as :add" do
+    expect(resource.action).to eql([:add])
+  end
+
+  it "supports :add, :remove actions" do
+    expect { resource.action :add }.not_to raise_error
+    expect { resource.action :remove }.not_to raise_error
+  end
+
+  it "paths property defaults to []" do
+    expect(resource.paths).to eql([])
+  end
+
+  it "paths coerces strings to arrays" do
+    resource.paths "foo,bar"
+    expect(resource.paths).to eq(%w{foo bar})
+  end
+
+  it "extensions property defaults to []" do
+    expect(resource.extensions).to eql([])
+  end
+
+  it "extensions coerces strings to arrays" do
+    resource.extensions "foo,bar"
+    expect(resource.extensions).to eq(%w{foo bar})
+  end
+
+  it "process_paths property defaults to []" do
+    expect(resource.process_paths).to eql([])
+  end
+
+  it "process_paths coerces strings to arrays" do
+    resource.process_paths "foo,bar"
+    expect(resource.process_paths).to eq(%w{foo bar})
+  end
+end