chef 16.1.16 → 16.18.30

data/spec/unit/node_spec.rb

@@ -1483,9 +1483,9 @@ describe Chef::Node do
         end
       end
 
-      context "with whitelisted attributes configured" do
-        it "should only save whitelisted attributes (and subattributes)" do
-          Chef::Config[:default_attribute_whitelist] = [
+      context "with allowed attributes configured" do
+        it "should only save allowed attributes (and subattributes)" do
+          Chef::Config[:allowed_default_attributes] = [
             ["filesystem", "/dev/disk0s2"],
             "network/interfaces/eth0",
           ]
@@ -1525,8 +1525,8 @@ describe Chef::Node do
           node.save
         end
 
-        it "should save false-y whitelisted attributes" do
-          Chef::Config[:default_attribute_whitelist] = [
+        it "should save false-y allowed attributes" do
+          Chef::Config[:allowed_default_attributes] = [
             "foo/bar/baz",
           ]
 
@@ -1560,8 +1560,8 @@ describe Chef::Node do
           node.save
         end
 
-        it "should not save any attributes if the whitelist is empty" do
-          Chef::Config[:default_attribute_whitelist] = []
+        it "should not save any attributes if the allowed is empty" do
+          Chef::Config[:allowed_default_attributes] = []
 
           node.default = {
               "filesystem" => {
@@ -1583,8 +1583,52 @@ describe Chef::Node do
         end
       end
 
-      context "with blacklisted attributes configured" do
-        it "should only save non-blacklisted attributes (and subattributes)" do
+      context "with deprecated whitelist attributes configured" do
+        it "should only save allowed attributes (and subattributes)" do
+          Chef::Config[:default_attribute_whitelist] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
+
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+
+          node.name("picky-monkey")
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+      end
+
+      context "with deprecated blacklist attributes configured" do
+        it "should only save non-blocklisted attributes (and subattributes)" do
           Chef::Config[:default_attribute_blacklist] = [
             ["filesystem", "/dev/disk0s2"],
             "network/interfaces/eth0",
@@ -1620,12 +1664,55 @@ describe Chef::Node do
             "automatic" => {}, "normal" => {}, "override" => {}
           }
           node.name("picky-monkey")
+          Chef::Config[:treat_deprecation_warnings_as_errors] = false
           expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
           node.save
         end
+      end
+
+      context "with blocklisted attributes configured" do
+        it "should only save non-blocklisted attributes (and subattributes)" do
+          Chef::Config[:blocked_default_attributes] = [
+            ["filesystem", "/dev/disk0s2"],
+            "network/interfaces/eth0",
+          ]
+
+          node.default = {
+              "filesystem" => {
+                "/dev/disk0s2" => { "size" => "10mb" },
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth0" => {},
+                  "eth1" => {},
+                },
+              },
+            }
+          node.automatic = {}
+          node.normal = {}
+          node.override = {}
 
-        it "should save all attributes if the blacklist is empty" do
-          Chef::Config[:default_attribute_blacklist] = []
+          selected_data = {
+            "default" => {
+              "filesystem" => {
+                "map - autohome" => { "size" => "10mb" },
+              },
+              "network" => {
+                "interfaces" => {
+                  "eth1" => {},
+                },
+              },
+            },
+            "automatic" => {}, "normal" => {}, "override" => {}
+          }
+          node.name("picky-monkey")
+          expect(@rest).to receive(:put).with("nodes/picky-monkey", hash_including(selected_data)).and_return("foo")
+          node.save
+        end
+
+        it "should save all attributes if the blocklist is empty" do
+          Chef::Config[:blocked_default_attributes] = []
 
           node.default = {
               "filesystem" => {
@@ -1686,11 +1773,11 @@ describe Chef::Node do
           end
 
           let(:http_exception) do
-            begin
-              response.error!
-            rescue => e
-              e
-            end
+
+            response.error!
+          rescue => e
+            e
+
           end
 
           let(:trimmed_node) do

data/spec/unit/platform/query_helpers_spec.rb

@@ -18,7 +18,7 @@
 
 require "spec_helper"
 
-describe "Chef::Platform#supports_dsc_invoke_resource?" do
+describe "Chef::Platform#supports_dsc_invoke_resource?", :windows_only do
   it "returns false if powershell is not present" do
     node = Chef::Node.new
     expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
@@ -39,26 +39,25 @@ describe "Chef::Platform#supports_dsc_invoke_resource?" do
   end
 end
 
-describe "Chef::Platform#dsc_refresh_mode_disabled?" do
+describe "Chef::Platform#dsc_refresh_mode_disabled?", :windows_only do
   let(:node) { instance_double("Chef::Node") }
-  let(:cmdlet) { instance_double("Chef::Util::Powershell::Cmdlet") }
-  let(:cmdlet_result) { instance_double("Chef::Util::Powershell::CmdletResult") }
+  let(:powershell) { instance_double("ChefPowerShell::PowerShell") }
 
   it "returns true when RefreshMode is Disabled" do
-    expect(Chef::Util::Powershell::Cmdlet).to receive(:new)
-      .with(node, "Get-DscLocalConfigurationManager", :object)
-      .and_return(cmdlet)
-    expect(cmdlet).to receive(:run!).and_return(cmdlet_result)
-    expect(cmdlet_result).to receive(:return_value).and_return({ "RefreshMode" => "Disabled" })
+    expect(ChefPowerShell::PowerShell).to receive(:new)
+      .with("Get-DscLocalConfigurationManager")
+      .and_return(powershell)
+    expect(powershell).to receive(:error!)
+    expect(powershell).to receive(:result).and_return({ "RefreshMode" => "Disabled" })
     expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be true
   end
 
   it "returns false when RefreshMode is not Disabled" do
-    expect(Chef::Util::Powershell::Cmdlet).to receive(:new)
-      .with(node, "Get-DscLocalConfigurationManager", :object)
-      .and_return(cmdlet)
-    expect(cmdlet).to receive(:run!).and_return(cmdlet_result)
-    expect(cmdlet_result).to receive(:return_value).and_return({ "RefreshMode" => "LaLaLa" })
+    expect(ChefPowerShell::PowerShell).to receive(:new)
+      .with("Get-DscLocalConfigurationManager")
+      .and_return(powershell)
+    expect(powershell).to receive(:error!)
+    expect(powershell).to receive(:result).and_return({ "RefreshMode" => "LaLaLa" })
     expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be false
   end
 end

data/spec/unit/policy_builder/policyfile_spec.rb

@@ -206,7 +206,7 @@ describe Chef::PolicyBuilder::Policyfile do
     end
 
     before do
-      Chef::Config[:policy_document_native_api] = false
+      Chef::Config[:policy_document_native_api] = true
       Chef::Config[:deployment_group] = "example-policy-stage"
       allow(policy_builder).to receive(:api_service).and_return(api_service)
     end
@@ -214,6 +214,8 @@ describe Chef::PolicyBuilder::Policyfile do
     describe "when using compatibility mode (policy_document_native_api == false)" do
 
       before do
+        Chef::Config[:policy_document_native_api] = false
+        Chef::Config[:treat_deprecation_warnings_as_errors] = false
         Chef::Config[:deployment_group] = "example-policy-stage"
       end
 
@@ -339,6 +341,10 @@ describe Chef::PolicyBuilder::Policyfile do
       end
 
       describe "validating the Policyfile.lock" do
+        before do
+          Chef::Config[:policy_group] = "policy-stage"
+          Chef::Config[:policy_name] = "example"
+        end
 
         it "errors if the policyfile json contains any non-recipe items" do
           parsed_policyfile_json["run_list"] = ["role[foo]"]
@@ -806,6 +812,10 @@ describe Chef::PolicyBuilder::Policyfile do
         context "when using compatibility mode (policy_document_native_api == false)" do
           let(:cookbook1_url) { "cookbooks/example1/#{example1_xyz_version}" }
           let(:cookbook2_url) { "cookbooks/example2/#{example2_xyz_version}" }
+          before do
+            Chef::Config[:policy_document_native_api] = false
+            Chef::Config[:treat_deprecation_warnings_as_errors] = false
+          end
 
           context "when the cookbooks don't exist on the server" do
             include_examples "fetching cookbooks when they don't exist"

data/spec/unit/property_spec.rb

@@ -111,17 +111,17 @@ describe "Chef::Resource.property" do
 
   with_property ":Straße" do
     it "properties with UTF-8 in their name work" do
-      expect(resource.Straße).to eql(nil)
-      expect(resource.Straße "foo").to eql("foo")
-      expect(resource.Straße).to eql("foo")
-      expect(resource.Straße = "bar").to eql("bar")
-      expect(resource.Straße).to eql("bar")
+      expect(resource.Straße).to eql(nil) # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße "foo").to eql("foo") # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße).to eql("foo") # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße = "bar").to eql("bar") # rubocop: disable Naming/AsciiIdentifiers
+      expect(resource.Straße).to eql("bar") # rubocop: disable Naming/AsciiIdentifiers
     end
   end
 
   context "deprecated properties" do
     it "does not create a deprecation warning on definition" do
-      expect { resource_class.class_eval { property :x, String, deprecated: 10 } }.not_to raise_error Chef::Exceptions::DeprecatedFeatureError
+      expect { resource_class.class_eval { property :x, String, deprecated: 10 } }.not_to raise_error
     end
 
     with_property ":x, deprecated: 'a deprecated property'" do

data/spec/unit/provider/batch_spec.rb

@@ -0,0 +1,130 @@
+#
+# Author:: Adam Jacob (adam@chef.io)
+# Copyright:: Copyright 2009-2016, Opscode
+# 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::Provider::Batch do
+  let(:node) do
+    node = Chef::Node.new
+    node.default["kernel"] = {}
+    node.default["kernel"][:machine] = :x86_64.to_s
+    node
+  end
+
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+
+  let(:new_resource) do
+    new_resource = Chef::Resource::Batch.new("cmd.exe and conquer")
+    new_resource.code %q{echo "hello"}
+    new_resource
+  end
+
+  let(:provider) { Chef::Provider::Batch.new(new_resource, run_context) }
+
+  context "#grant_alternate_user_read_access" do
+    before do
+      allow(ChefUtils).to receive(:windows?).and_return(true)
+      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)
+
+      provider.singleton_class.send(:public, :grant_alternate_user_read_access)
+    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.grant_alternate_user_read_access("a fake path")
+      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.grant_alternate_user_read_access("a fake path")
+      end
+    end
+  end
+
+  describe "#with_temp_script_file" do
+    before do
+      provider.singleton_class.send(:public, :with_temp_script_file)
+      provider.singleton_class.send(:public, :script_file_path)
+    end
+
+    it "should put the contents of the script in the temp file" do
+      temp_file_contents = nil
+
+      provider.with_temp_script_file do
+        temp_file_contents = File.read(provider.script_file_path)
+      end
+
+      expect(temp_file_contents.strip).to eq(%q{echo "hello"})
+    end
+  end
+
+  describe "#command" do
+    let(:basepath) { "C:\\Windows\\system32\\" }
+    let(:interpreter) { File.join(basepath, "cmd.exe") }
+
+    before do
+      allow(provider).to receive(:basepath).and_return(basepath)
+      provider.singleton_class.send(:public, :with_temp_script_file)
+      provider.singleton_class.send(:public, :script_file_path)
+    end
+
+    it 'should set the command to "interpreter"  "tempfile"' do
+      command = nil
+      script_file_path = nil
+      provider.with_temp_script_file do
+        command = provider.command
+        script_file_path = provider.script_file_path
+      end
+
+      expect(command).to eq(%Q{"#{interpreter}"  /c "#{script_file_path}"})
+    end
+
+    it "should set the command to 'interpreter flags tempfile'" do
+      new_resource.flags "/f"
+
+      command = nil
+      script_file_path = nil
+      provider.with_temp_script_file do
+        command = provider.command
+        script_file_path = provider.script_file_path
+      end
+
+      expect(command).to eq(%Q{"#{interpreter}" /f /c "#{script_file_path}"})
+    end
+  end
+end

data/spec/unit/provider/cron/unix_spec.rb

@@ -93,7 +93,7 @@ describe Chef::Provider::Cron::Unix do
     end
 
     context "when any other error occurs" do
-      let (:exitstatus) { 2 }
+      let(:exitstatus) { 2 }
 
       it "should raise an exception if another error occurs" do
         expect do

data/spec/unit/provider/cron_spec.rb

@@ -15,7 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 require "spec_helper"
 
 describe Chef::Provider::Cron do
@@ -322,7 +321,7 @@ describe Chef::Provider::Cron do
         expect(cron.hour).to eq("5")
         expect(cron.day).to eq("*")
         expect(cron.month).to eq("Jan")
-        expect(cron.weekday).to eq("Mon")
+        expect(cron.weekday).to eq("1")
         expect(cron.command).to eq("/bin/true param1 param2")
       end
 
@@ -338,6 +337,7 @@ describe Chef::Provider::Cron do
           0 2 * * * /some/other/command
 
           # Chef Name: cronhole some stuff
+          * * * * * /bin/true
         CRONTAB
         cron = @provider.load_current_resource
         expect(@provider.cron_exists).to eq(true)
@@ -347,7 +347,7 @@ describe Chef::Provider::Cron do
         expect(cron.month).to eq("*")
         expect(cron.weekday).to eq("*")
         expect(cron.time).to eq(nil)
-        expect(cron.command).to eq(nil)
+        expect(cron.command).to eq("/bin/true")
       end
 
       it "should not pick up a commented out crontab line" do
@@ -355,6 +355,7 @@ describe Chef::Provider::Cron do
           0 2 * * * /some/other/command
 
           # Chef Name: cronhole some stuff
+          * * * * * /bin/true
           #* 5 * 1 * /bin/true param1 param2
         CRONTAB
         cron = @provider.load_current_resource
@@ -365,7 +366,7 @@ describe Chef::Provider::Cron do
         expect(cron.month).to eq("*")
         expect(cron.weekday).to eq("*")
         expect(cron.time).to eq(nil)
-        expect(cron.command).to eq(nil)
+        expect(cron.command).to eq("/bin/true")
       end
 
       it "should not pick up a later crontab entry" do
@@ -373,6 +374,7 @@ describe Chef::Provider::Cron do
           0 2 * * * /some/other/command
 
           # Chef Name: cronhole some stuff
+          * * * * * /bin/true
           #* 5 * 1 * /bin/true param1 param2
           # Chef Name: something else
           2 * 1 * * /bin/false
@@ -387,7 +389,7 @@ describe Chef::Provider::Cron do
         expect(cron.month).to eq("*")
         expect(cron.weekday).to eq("*")
         expect(cron.time).to eq(nil)
-        expect(cron.command).to eq(nil)
+        expect(cron.command).to eq("/bin/true")
       end
     end
   end
@@ -722,6 +724,40 @@ describe Chef::Provider::Cron do
         end
       end
 
+      context "when integers are provided to the resource to express time values" do
+        it "should not report any difference" do
+          @new_resource.minute(1)
+          @new_resource.hour(1)
+          @new_resource.day(1)
+          @new_resource.month(1)
+          @new_resource.weekday(1)
+          allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
+            # Chef Name: cronhole some stuff
+            1 1 1 1 1 /bin/true
+          CRONTAB
+
+          @provider.run_action(:create)
+          expect(@new_resource).not_to be_updated_by_last_action
+        end
+      end
+
+      context "when strings are provided to the resource to express time values" do
+        it "should not report any difference" do
+          @new_resource.minute("1")
+          @new_resource.hour("1")
+          @new_resource.day("1")
+          @new_resource.month("1")
+          @new_resource.weekday("1")
+          allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
+            # Chef Name: cronhole some stuff
+            1 1 1 1 1 /bin/true
+          CRONTAB
+
+          @provider.run_action(:create)
+          expect(@new_resource).not_to be_updated_by_last_action
+        end
+      end
+
       context "when environment variable is used" do
         before :each do
           @provider.cron_exists = true
@@ -1040,48 +1076,6 @@ describe Chef::Provider::Cron do
     end
   end
 
-  describe "weekday_in_crontab" do
-    context "when weekday is symbol" do
-      it "should return weekday in crontab format" do
-        @new_resource.weekday :wednesday
-        expect(@provider.send(:weekday_in_crontab)).to eq("3")
-      end
-
-      it "should raise an error with an unknown weekday" do
-        expect { @new_resource.weekday :caturday }.to raise_error(RangeError)
-      end
-    end
-
-    context "when weekday is a number in a string" do
-      it "should return the string" do
-        @new_resource.weekday "3"
-        expect(@provider.send(:weekday_in_crontab)).to eq("3")
-      end
-
-      it "should raise an error with an out of range number" do
-        expect { @new_resource.weekday "-1" }.to raise_error(RangeError)
-      end
-    end
-
-    context "when weekday is string with the name of the week" do
-      it "should return the string" do
-        @new_resource.weekday "mon"
-        expect(@provider.send(:weekday_in_crontab)).to eq("mon")
-      end
-    end
-
-    context "when weekday is an integer" do
-      it "should return the integer" do
-        @new_resource.weekday 1
-        expect(@provider.send(:weekday_in_crontab)).to eq("1")
-      end
-
-      it "should raise an error with an out of range integer" do
-        expect { @new_resource.weekday 45 }.to raise_error(RangeError)
-      end
-    end
-  end
-
   describe "#env_var_str" do
     context "when no env vars are set" do
       it "returns an empty string" do
@@ -1196,8 +1190,8 @@ describe Chef::Provider::Cron do
     context "Without command, passed" do
       context "as nil" do
         it "returns an empty string with a next line" do
-          @new_resource.command nil
-          expect(@provider.send(:cmd_str)).to eq(" \n")
+          @new_resource.command "bin/true"
+          expect(@provider.send(:cmd_str)).to eq(" bin/true\n")
         end
       end
       context "as an empty string" do