chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/spec/unit/resource/powershell_package_spec.rb

@@ -26,7 +26,7 @@ describe Chef::Resource::PowershellPackage do
     expect(resource).to be_a_kind_of(Chef::Resource::Package)
   end
 
-  #to check the value of resource.resource_name
+  # to check the value of resource.resource_name
   it "has a resource name of :powershell_package" do
     expect(resource.resource_name).to eql(:powershell_package)
   end
@@ -86,4 +86,13 @@ describe Chef::Resource::PowershellPackage do
     resource.source("MyGallery")
     expect(resource.source).to eql("MyGallery")
   end
+
+  it "the skip_publisher_check default is false" do
+    expect(resource.skip_publisher_check).to eql(false)
+  end
+
+  it "the skip_publisher_check setter accepts booleans" do
+    resource.skip_publisher_check(true)
+    expect(resource.skip_publisher_check).to eql(true)
+  end
 end

data/spec/unit/resource/powershell_script_spec.rb

@@ -87,7 +87,7 @@ describe Chef::Resource::PowershellScript do
     it "enables convert_boolean_return by default for guards in the context of powershell_script when no guard params are specified" do
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { :convert_boolean_return => true, :code => "$true" }).and_return(Proc.new {})
+        { convert_boolean_return: true, code: "$true" }).and_return(Proc.new {})
       resource.only_if("$true")
     end
 
@@ -98,27 +98,27 @@ describe Chef::Resource::PowershellScript do
       file_resource.guard_interpreter :powershell_script
 
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { :convert_boolean_return => true, :code => "$true" }).and_return(Proc.new {})
+        { convert_boolean_return: true, code: "$true" }).and_return(Proc.new {})
       resource.only_if("$true")
     end
 
     it "enables convert_boolean_return by default for guards in the context of powershell_script when guard params are specified" do
-      guard_parameters = { :cwd => "/etc/chef", :architecture => :x86_64 }
+      guard_parameters = { cwd: "/etc/chef", architecture: :x86_64 }
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { :convert_boolean_return => true, :code => "$true" }.merge(guard_parameters)).and_return(Proc.new {})
+        { convert_boolean_return: true, code: "$true" }.merge(guard_parameters)).and_return(Proc.new {})
       resource.only_if("$true", guard_parameters)
     end
 
     it "passes convert_boolean_return as true if it was specified as true in a guard parameter" do
-      guard_parameters = { :cwd => "/etc/chef", :convert_boolean_return => true, :architecture => :x86_64 }
+      guard_parameters = { cwd: "/etc/chef", convert_boolean_return: true, architecture: :x86_64 }
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { :convert_boolean_return => true, :code => "$true" }.merge(guard_parameters)).and_return(Proc.new {})
+        { convert_boolean_return: true, code: "$true" }.merge(guard_parameters)).and_return(Proc.new {})
       resource.only_if("$true", guard_parameters)
     end
 
     it "passes convert_boolean_return as false if it was specified as true in a guard parameter" do
-      other_guard_parameters = { :cwd => "/etc/chef", :architecture => :x86_64 }
-      parameters_with_boolean_disabled = other_guard_parameters.merge({ :convert_boolean_return => false, :code => "$true" })
+      other_guard_parameters = { cwd: "/etc/chef", architecture: :x86_64 }
+      parameters_with_boolean_disabled = other_guard_parameters.merge({ convert_boolean_return: false, code: "$true" })
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
         parameters_with_boolean_disabled).and_return(Proc.new {})
       resource.only_if("$true", parameters_with_boolean_disabled)

data/spec/unit/resource/registry_key_spec.rb

@@ -72,7 +72,7 @@ describe Chef::Resource::RegistryKey, "key" do
   end
 
   it "does not allow a hash" do
-    expect { resource.send(:key, { :sonic => "screwdriver" }) }.to raise_error(ArgumentError)
+    expect { resource.send(:key, { sonic: "screwdriver" }) }.to raise_error(ArgumentError)
   end
 end
 
@@ -80,26 +80,26 @@ describe Chef::Resource::RegistryKey, "values" do
   let(:resource) { Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius') }
 
   it "allows a single proper hash of registry values" do
-    resource.values( { :name => "poosh", :type => :string, :data => "carmen" } )
-    expect(resource.values).to eql([ { :name => "poosh", :type => :string, :data => "carmen" } ])
+    resource.values( { name: "poosh", type: :string, data: "carmen" } )
+    expect(resource.values).to eql([ { name: "poosh", type: :string, data: "carmen" } ])
   end
 
   it "allows an array of proper hashes of registry values" do
-    resource.values [ { :name => "poosh", :type => :string, :data => "carmen" } ]
-    expect(resource.values).to eql([ { :name => "poosh", :type => :string, :data => "carmen" } ])
+    resource.values [ { name: "poosh", type: :string, data: "carmen" } ]
+    expect(resource.values).to eql([ { name: "poosh", type: :string, data: "carmen" } ])
   end
 
   it "returns checksummed data if the type is unsafe" do
-    resource.values( { :name => "poosh", :type => :binary, :data => 255.chr * 1 })
-    expect(resource.values).to eql([ { :name => "poosh", :type => :binary, :data => "a8100ae6aa1940d0b663bb31cd466142ebbdbd5187131b92d93818987832eb89" } ])
+    resource.values( { name: "poosh", type: :binary, data: 255.chr * 1 })
+    expect(resource.values).to eql([ { name: "poosh", type: :binary, data: "a8100ae6aa1940d0b663bb31cd466142ebbdbd5187131b92d93818987832eb89" } ])
   end
 
   it "raises an exception if the name field is missing" do
-    expect { resource.values [ { :type => :string, :data => "carmen" } ] }.to raise_error(ArgumentError)
+    expect { resource.values [ { type: :string, data: "carmen" } ] }.to raise_error(ArgumentError)
   end
 
   it "raises an exception if extra fields are present" do
-    expect { resource.values [ { :name => "poosh", :type => :string, :data => "carmen", :screwdriver => "sonic" } ] }.to raise_error(ArgumentError)
+    expect { resource.values [ { name: "poosh", type: :string, data: "carmen", screwdriver: "sonic" } ] }.to raise_error(ArgumentError)
   end
 
   it "does not allow a string" do
@@ -111,26 +111,26 @@ describe Chef::Resource::RegistryKey, "values" do
   end
 
   it "raises an exception if type of name is not string" do
-    expect { resource.values([ { :name => 123, :type => :string, :data => "carmen" } ]) }.to raise_error(ArgumentError)
+    expect { resource.values([ { name: 123, type: :string, data: "carmen" } ]) }.to raise_error(ArgumentError)
   end
 
   it "does not raise an exception if type of name is string" do
-    expect { resource.values([ { :name => "123", :type => :string, :data => "carmen" } ]) }.to_not raise_error
+    expect { resource.values([ { name: "123", type: :string, data: "carmen" } ]) }.to_not raise_error
   end
 
   context "type key not given" do
     it "does not raise an exception" do
-      expect { resource.values([ { :name => "123", :data => "carmen" } ]) }.to_not raise_error
+      expect { resource.values([ { name: "123", data: "carmen" } ]) }.to_not raise_error
     end
   end
 
   context "type key given" do
     it "raises an exception if type of type is not symbol" do
-      expect { resource.values([ { :name => "123", :type => "string", :data => "carmen" } ]) }.to raise_error(ArgumentError)
+      expect { resource.values([ { name: "123", type: "string", data: "carmen" } ]) }.to raise_error(ArgumentError)
     end
 
     it "does not raise an exception if type of type is symbol" do
-      expect { resource.values([ { :name => "123", :type => :string, :data => "carmen" } ]) }.to_not raise_error
+      expect { resource.values([ { name: "123", type: :string, data: "carmen" } ]) }.to_not raise_error
     end
   end
 end
@@ -144,7 +144,7 @@ describe Chef::Resource::RegistryKey, "recursive" do
   end
 
   it "does not allow a hash" do
-    expect { resource.recursive({ :sonic => :screwdriver }) }.to raise_error(ArgumentError)
+    expect { resource.recursive({ sonic: :screwdriver }) }.to raise_error(ArgumentError)
   end
 
   it "does not allow an array" do
@@ -175,7 +175,7 @@ describe Chef::Resource::RegistryKey, "architecture" do
   end
 
   it "does not allow a hash" do
-    expect { resource.architecture({ :sonic => :screwdriver }) }.to raise_error(ArgumentError)
+    expect { resource.architecture({ sonic: :screwdriver }) }.to raise_error(ArgumentError)
   end
 
   it "does not allow an array" do
@@ -195,7 +195,7 @@ describe Chef::Resource::RegistryKey, ":unscrubbed_values" do
   let(:resource) { Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius') }
 
   it "returns unsafe data as-is" do
-    key_values = [ { :name => "poosh", :type => :binary, :data => 255.chr * 1 } ]
+    key_values = [ { name: "poosh", type: :binary, data: 255.chr * 1 } ]
     resource.values(key_values)
     expect(resource.unscrubbed_values).to eql(key_values)
   end
@@ -205,7 +205,7 @@ describe Chef::Resource::RegistryKey, "state" do
   let(:resource) { Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius') }
 
   it "returns scrubbed values" do
-    resource.values([ { :name => "poosh", :type => :binary, :data => 255.chr * 1 } ])
-    expect(resource.state_for_resource_reporter[:values]).to eql( [{ :name => "poosh", :type => :binary, :data => "a8100ae6aa1940d0b663bb31cd466142ebbdbd5187131b92d93818987832eb89" }] )
+    resource.values([ { name: "poosh", type: :binary, data: 255.chr * 1 } ])
+    expect(resource.state_for_resource_reporter[:values]).to eql( [{ name: "poosh", type: :binary, data: "a8100ae6aa1940d0b663bb31cd466142ebbdbd5187131b92d93818987832eb89" }] )
   end
 end

data/spec/unit/resource/remote_file_spec.rb

@@ -199,8 +199,8 @@ describe Chef::Resource::RemoteFile do
       state = resource.state_for_resource_reporter
       if Chef::Platform.windows?
         puts state
-        expect(state[:rights]).to eq([{ :permissions => :read, :principals => "Everyone" }])
-        expect(state[:deny_rights]).to eq([{ :permissions => :full_control, :principals => "Clumsy_Sam" }])
+        expect(state[:rights]).to eq([{ permissions: :read, principals: "Everyone" }])
+        expect(state[:deny_rights]).to eq([{ permissions: :full_control, principals: "Clumsy_Sam" }])
       else
         expect(state[:group]).to eq("pokemon")
         expect(state[:mode]).to eq("0664")

data/spec/unit/resource/resource_notification_spec.rb

@@ -65,7 +65,7 @@ describe Chef::Resource::Notification do
   end
 
   it "resolves a lazy reference to a resource" do
-    notification.resource = { :cat => "keyboard_cat" }
+    notification.resource = { cat: "keyboard_cat" }
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @keyboard_cat
@@ -78,7 +78,7 @@ describe Chef::Resource::Notification do
   it "resolves a lazy reference to its notifying resource" do
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     notification.resource = @keyboard_cat
-    notification.notifying_resource = { :cat => "long_cat" }
+    notification.notifying_resource = { cat: "long_cat" }
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @long_cat
@@ -87,11 +87,11 @@ describe Chef::Resource::Notification do
   end
 
   it "resolves lazy references to both its resource and its notifying resource" do
-    notification.resource = { :cat => "keyboard_cat" }
+    notification.resource = { cat: "keyboard_cat" }
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @keyboard_cat
-    notification.notifying_resource = { :cat => "long_cat" }
+    notification.notifying_resource = { cat: "long_cat" }
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @resource_collection << @long_cat
     notification.resolve_resource_reference(@resource_collection)
@@ -100,7 +100,7 @@ describe Chef::Resource::Notification do
   end
 
   it "raises a RuntimeError if you try to reference multiple resources" do
-    notification.resource = { :cat => %w{keyboard_cat cheez_cat} }
+    notification.resource = { cat: %w{keyboard_cat cheez_cat} }
     @keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
@@ -112,7 +112,7 @@ describe Chef::Resource::Notification do
   end
 
   it "raises a RuntimeError if you try to reference multiple notifying resources" do
-    notification.notifying_resource = { :cat => %w{long_cat cheez_cat} }
+    notification.notifying_resource = { cat: %w{long_cat cheez_cat} }
     @long_cat = Chef::Resource::Cat.new("long_cat")
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
@@ -124,7 +124,7 @@ describe Chef::Resource::Notification do
   end
 
   it "raises a RuntimeError if it can't find a resource in the resource collection when resolving a lazy reference" do
-    notification.resource = { :cat => "keyboard_cat" }
+    notification.resource = { cat: "keyboard_cat" }
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @cheez_cat
@@ -134,7 +134,7 @@ describe Chef::Resource::Notification do
   end
 
   it "raises a RuntimeError if it can't find a notifying resource in the resource collection when resolving a lazy reference" do
-    notification.notifying_resource = { :cat => "long_cat" }
+    notification.notifying_resource = { cat: "long_cat" }
     @cheez_cat = Chef::Resource::Cat.new("cheez_cat")
     @resource_collection = Chef::ResourceCollection.new
     @resource_collection << @cheez_cat

data/spec/unit/resource/service_spec.rb

@@ -168,19 +168,19 @@ describe Chef::Resource::Service do
     end
 
     it "defaults all the feature support to nil" do
-      support_hash = { :status => nil, :restart => nil, :reload => nil }
+      support_hash = { status: nil, restart: nil, reload: nil }
       expect(resource.supports).to eq(support_hash)
     end
 
     it "allows you to set what features this resource supports as a array" do
       support_array = [ :status, :restart ]
-      support_hash = { :status => true, :restart => true }
+      support_hash = { status: true, restart: true }
       resource.supports(support_array)
       expect(resource.supports).to eq(support_hash)
     end
 
     it "allows you to set what features this resource supports as a hash" do
-      support_hash = { :status => true, :restart => true }
+      support_hash = { status: true, restart: true }
       resource.supports(support_hash)
       expect(resource.supports).to eq(support_hash)
     end

data/spec/unit/resource/ssh_known_hosts_entry_spec.rb

@@ -0,0 +1,55 @@
+#
+# Copyright:: Copyright 2018, 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::SshKnownHostsEntry do
+  let(:node) { Chef::Node.new }
+  let(:run_context) do
+    node.automatic[:root_group] = "superduper"
+    empty_events = Chef::EventDispatch::Dispatcher.new
+    Chef::RunContext.new(node, {}, empty_events)
+  end
+  let(:resource) { Chef::Resource::SshKnownHostsEntry.new("example.com", run_context) }
+
+  it "is not a preview resource in Chef 15" do
+    pending("Chef 15") unless Chef::VERSION.start_with?("15")
+    expect(resource.class.preview_resource).to be_falsey
+  end
+
+  it "sets resource name as :ssh_known_hosts_entry" do
+    expect(resource.resource_name).to eql(:ssh_known_hosts_entry)
+  end
+
+  it "sets group property to node['root_group'] by default" do
+    expect(resource.group).to eql("superduper")
+  end
+
+  it "sets the default action as :create" do
+    expect(resource.action).to eql([:create])
+  end
+
+  it "sets the host property as its name property" do
+    expect(resource.host).to eql("example.com")
+  end
+
+  it "supports :create and :flush actions" do
+    expect { resource.action :create }.not_to raise_error
+    expect { resource.action :flush }.not_to raise_error
+    expect { resource.action :delete }.to raise_error(ArgumentError)
+  end
+end

data/spec/unit/resource/template_spec.rb

@@ -64,8 +64,8 @@ describe Chef::Resource::Template do
 
   describe "variables" do
     it "accepts a hash for the variable list" do
-      resource.variables({ :reluctance => :awkward })
-      expect(resource.variables).to eq({ :reluctance => :awkward })
+      resource.variables({ reluctance: :awkward })
+      expect(resource.variables).to eq({ reluctance: :awkward })
     end
   end
 

data/spec/unit/resource/user_spec.rb

@@ -75,7 +75,7 @@ end
     end
 
     it "does not allow a hash" do
-      expect { resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError)
+      expect { resource.send(attrib, { woot: "i found it" }) }.to raise_error(ArgumentError)
     end
   end
 end
@@ -95,7 +95,7 @@ end
     end
 
     it "does not allow a hash" do
-      expect { resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError)
+      expect { resource.send(attrib, { woot: "i found it" }) }.to raise_error(ArgumentError)
     end
   end
 

data/spec/unit/resource/windows_feature_dism.rb

@@ -32,7 +32,7 @@ describe Chef::Resource::WindowsFeatureDism do
   end
 
   it "the feature_name property is the name_property" do
-    node.automatic[:platform_version] = "6.2"
+    node.automatic[:platform_version] = "6.2.9200"
     expect(resource.feature_name).to eql(%w{snmp dhcp})
   end
 
@@ -47,25 +47,25 @@ describe Chef::Resource::WindowsFeatureDism do
   end
 
   it "coerces comma separated lists of features to a lowercase array on 2012+" do
-    node.automatic[:platform_version] = "6.2"
+    node.automatic[:platform_version] = "6.2.9200"
     resource.feature_name "SNMP, DHCP"
     expect(resource.feature_name).to eql(%w{snmp dhcp})
   end
 
   it "coerces a single feature as a String to a lowercase array on 2012+" do
-    node.automatic[:platform_version] = "6.2"
+    node.automatic[:platform_version] = "6.2.9200"
     resource.feature_name "SNMP"
     expect(resource.feature_name).to eql(["snmp"])
   end
 
   it "coerces comma separated lists of features to an array, but preserves case on < 2012" do
-    node.automatic[:platform_version] = "6.1"
+    node.automatic[:platform_version] = "6.1.7601"
     resource.feature_name "SNMP, DHCP"
     expect(resource.feature_name).to eql(%w{SNMP DHCP})
   end
 
   it "coerces a single feature as a String to an array, but preserves case on < 2012" do
-    node.automatic[:platform_version] = "6.1"
+    node.automatic[:platform_version] = "6.1.7601"
     resource.feature_name "SNMP"
     expect(resource.feature_name).to eql(["SNMP"])
   end

data/spec/unit/resource/windows_feature_powershell.rb

@@ -18,7 +18,10 @@
 require "spec_helper"
 
 describe Chef::Resource::WindowsFeaturePowershell do
-  let(:resource) { Chef::Resource::WindowsFeaturePowershell.new(%w{SNMP DHCP}) }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::WindowsFeaturePowershell.new(%w{SNMP DHCP}, run_context) }
 
   it "sets resource name as :windows_feature_powershell" do
     expect(resource.resource_name).to eql(:windows_feature_powershell)
@@ -28,24 +31,42 @@ describe Chef::Resource::WindowsFeaturePowershell do
     expect(resource.action).to eql([:install])
   end
 
+  it "the feature_name property is the name_property" do
+    node.automatic[:platform_version] = "6.2.9200"
+    expect(resource.feature_name).to eql(%w{snmp dhcp})
+  end
+
+  it "sets the default action as :install" do
+    expect(resource.action).to eql([:install])
+  end
+
   it "supports :delete, :install, :remove actions" do
     expect { resource.action :delete }.not_to raise_error
     expect { resource.action :install }.not_to raise_error
     expect { resource.action :remove }.not_to raise_error
   end
 
-  it "sets the feature_name property as its name_property" do
-    expect(resource.feature_name).to eql(%w{SNMP DHCP})
+  it "coerces comma separated lists of features to a lowercase array on 2012+" do
+    node.automatic[:platform_version] = "6.2.9200"
+    resource.feature_name "SNMP, DHCP"
+    expect(resource.feature_name).to eql(%w{snmp dhcp})
+  end
+
+  it "coerces a single feature as a String to a lowercase array on 2012+" do
+    node.automatic[:platform_version] = "6.2.9200"
+    resource.feature_name "SNMP"
+    expect(resource.feature_name).to eql(["snmp"])
   end
 
-  it "coerces comma separated lists of features to arrays" do
+  it "coerces comma separated lists of features to an array, but preserves case on < 2012" do
+    node.automatic[:platform_version] = "6.1.7601"
     resource.feature_name "SNMP, DHCP"
     expect(resource.feature_name).to eql(%w{SNMP DHCP})
   end
 
-  it "coerces a single feature as a String into an array" do
+  it "coerces a single feature as a String to an array, but preserves case on < 2012" do
+    node.automatic[:platform_version] = "6.1.7601"
     resource.feature_name "SNMP"
     expect(resource.feature_name).to eql(["SNMP"])
   end
-
 end