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

data/spec/unit/mixin/user_context_spec.rb

@@ -43,7 +43,7 @@ describe "a class that mixes in user_context" do
       allow(::Chef::Util::Windows::LogonSession).to receive(:new).and_return(logon_session)
     end
 
-    let(:logon_session) { instance_double("::Chef::Util::Windows::LogonSession", :set_user_context => nil, :open => nil, :close => nil) }
+    let(:logon_session) { instance_double("::Chef::Util::Windows::LogonSession", set_user_context: nil, open: nil, close: nil) }
 
     it "does not raise an exception when the user and all parameters are nil" do
       expect { instance_with_user_context.with_context(nil, nil, nil) {} }.not_to raise_error

data/spec/unit/mixin/xml_escape_spec.rb

@@ -49,6 +49,6 @@ describe Chef::Mixin::XMLEscape do
   end
 
   it "converts win 1252 characters correctly" do
-    expect(@escaper.xml_escape("#{0x80.chr}")).to eq("€")
+    expect(@escaper.xml_escape((0x80.chr).to_s)).to eq("€")
   end
 end

data/spec/unit/node/attribute_spec.rb

@@ -22,8 +22,8 @@ require "chef/node/attribute"
 
 describe Chef::Node::Attribute do
   let(:events) { instance_double(Chef::EventDispatch::Dispatcher) }
-  let(:run_context) { instance_double(Chef::RunContext, :events => events) }
-  let(:node) { instance_double(Chef::Node, :run_context => run_context) }
+  let(:run_context) { instance_double(Chef::RunContext, events: events) }
+  let(:node) { instance_double(Chef::Node, run_context: run_context) }
   before(:each) do
     allow(events).to receive(:attribute_changed)
     @attribute_hash =
@@ -184,7 +184,7 @@ describe Chef::Node::Attribute do
 
     [ :normal, :default, :override, :automatic ].each do |accessor|
       it "should set #{accessor}" do
-        na = Chef::Node::Attribute.new({ :normal => true }, { :default => true }, { :override => true }, { :automatic => true })
+        na = Chef::Node::Attribute.new({ normal: true }, { default: true }, { override: true }, { automatic: true })
         expect(na.send(accessor)).to eq({ accessor.to_s => true })
       end
     end
@@ -522,20 +522,20 @@ describe Chef::Node::Attribute do
 
   describe "has_key?" do
     it "should return true if an attribute exists" do
-      expect(@attributes.has_key?("music")).to eq(true)
+      expect(@attributes.key?("music")).to eq(true)
     end
 
     it "should return false if an attribute does not exist" do
-      expect(@attributes.has_key?("ninja")).to eq(false)
+      expect(@attributes.key?("ninja")).to eq(false)
     end
 
     it "should return false if an attribute does not exist using dot notation" do
-      expect(@attributes.has_key?("does_not_exist_at_all")).to eq(false)
+      expect(@attributes.key?("does_not_exist_at_all")).to eq(false)
     end
 
     it "should return true if an attribute exists but is set to false" do
-      @attributes.has_key?("music")
-      expect(@attributes["music"].has_key?("apophis")).to eq(true)
+      @attributes.key?("music")
+      expect(@attributes["music"].key?("apophis")).to eq(true)
     end
 
     it "does not find keys above the current nesting level" do
@@ -886,11 +886,11 @@ describe Chef::Node::Attribute do
     end
 
     it "should return true if any key has the value supplied" do
-      expect(@attributes.has_value?("cookies")).to eq(true)
+      expect(@attributes.value?("cookies")).to eq(true)
     end
 
     it "should return false no key has the value supplied" do
-      expect(@attributes.has_value?("lololol")).to eq(false)
+      expect(@attributes.value?("lololol")).to eq(false)
     end
 
     it "should alias value?" do

data/spec/unit/node/vivid_mash_spec.rb

@@ -61,7 +61,7 @@ describe Chef::Node::VividMash do
 
     it "deep converts values through arrays" do
       expect(root).to receive(:reset_cache).with("foo")
-      vivid["foo"] = [ { :bar => true } ]
+      vivid["foo"] = [ { bar: true } ]
       expect(vivid["foo"].class).to eql(Chef::Node::AttrArray)
       expect(vivid["foo"][0].class).to eql(Chef::Node::VividMash)
       expect(vivid["foo"][0]["bar"]).to be true
@@ -69,7 +69,7 @@ describe Chef::Node::VividMash do
 
     it "deep converts values through nested arrays" do
       expect(root).to receive(:reset_cache).with("foo")
-      vivid["foo"] = [ [ { :bar => true } ] ]
+      vivid["foo"] = [ [ { bar: true } ] ]
       expect(vivid["foo"].class).to eql(Chef::Node::AttrArray)
       expect(vivid["foo"][0].class).to eql(Chef::Node::AttrArray)
       expect(vivid["foo"][0][0].class).to eql(Chef::Node::VividMash)
@@ -78,7 +78,7 @@ describe Chef::Node::VividMash do
 
     it "deep converts values through hashes" do
       expect(root).to receive(:reset_cache).with("foo")
-      vivid["foo"] = { baz: { :bar => true } }
+      vivid["foo"] = { baz: { bar: true } }
       expect(vivid["foo"]).to be_an_instance_of(Chef::Node::VividMash)
       expect(vivid["foo"]["baz"]).to be_an_instance_of(Chef::Node::VividMash)
       expect(vivid["foo"]["baz"]["bar"]).to be true

data/spec/unit/node_map_spec.rb

@@ -22,6 +22,12 @@ require "chef/node_map"
 class Foo; end
 class Bar; end
 
+class FooResource < Chef::Resource; end
+class BarResource < Chef::Resource; end
+
+class FooProvider < Chef::Provider; end
+class BarProvider < Chef::Provider; end
+
 describe Chef::NodeMap do
 
   let(:node_map) { Chef::NodeMap.new }
@@ -139,14 +145,14 @@ describe Chef::NodeMap do
   describe "deleting classes" do
     it "deletes a class and removes the mapping completely" do
       node_map.set(:thing, Bar)
-      expect( node_map.delete_class(Bar) ).to eql({ :thing => [{ :klass => Bar }] })
+      expect( node_map.delete_class(Bar) ).to include({ thing: [{ klass: Bar, cookbook_override: false, core_override: false }] })
       expect( node_map.get(node, :thing) ).to eql(nil)
     end
 
     it "deletes a class and leaves the mapping that still has an entry" do
       node_map.set(:thing, Bar)
       node_map.set(:thing, Foo)
-      expect( node_map.delete_class(Bar) ).to eql({ :thing => [{ :klass => Bar }] })
+      expect( node_map.delete_class(Bar) ).to eql({ thing: [{ klass: Bar, cookbook_override: false, core_override: false }] })
       expect( node_map.get(node, :thing) ).to eql(Foo)
     end
 
@@ -154,7 +160,7 @@ describe Chef::NodeMap do
       node_map.set(:thing1, Bar)
       node_map.set(:thing2, Bar)
       node_map.set(:thing2, Foo)
-      expect( node_map.delete_class(Bar) ).to eql({ :thing1 => [{ :klass => Bar }], :thing2 => [{ :klass => Bar }] })
+      expect( node_map.delete_class(Bar) ).to eql({ thing1: [{ klass: Bar, cookbook_override: false, core_override: false }], thing2: [{ klass: Bar, cookbook_override: false, core_override: false }] })
       expect( node_map.get(node, :thing1) ).to eql(nil)
       expect( node_map.get(node, :thing2) ).to eql(Foo)
     end
@@ -204,4 +210,66 @@ describe Chef::NodeMap do
     end
   end
 
+  describe "locked mode" do
+    context "while unlocked" do
+      it "allows setting the same key twice" do
+        expect(Chef).to_not receive(:deprecated)
+        node_map.set(:foo, FooResource)
+        node_map.set(:foo, BarResource)
+        expect(node_map.get(node, :foo)).to eql(BarResource)
+      end
+    end
+
+    context "while locked" do
+      # Uncomment the commented `expect`s in 15.0.
+      it "rejects setting the same key twice" do
+        expect(Chef).to receive(:deprecated).with(:map_collision, /resource foo/)
+        node_map.set(:foo, FooResource)
+        node_map.lock!
+        node_map.set(:foo, BarResource)
+        # expect(node_map.get(node, :foo)).to eql(FooResource)
+      end
+
+      it "allows setting the same key twice when the first has allow_cookbook_override" do
+        expect(Chef).to_not receive(:deprecated)
+        node_map.set(:foo, FooResource, allow_cookbook_override: true)
+        node_map.lock!
+        node_map.set(:foo, BarResource)
+        expect(node_map.get(node, :foo)).to eql(BarResource)
+      end
+
+      it "allows setting the same key twice when the first has allow_cookbook_override with a future version" do
+        expect(Chef).to_not receive(:deprecated)
+        node_map.set(:foo, FooResource, allow_cookbook_override: "< 100")
+        node_map.lock!
+        node_map.set(:foo, BarResource)
+        expect(node_map.get(node, :foo)).to eql(BarResource)
+      end
+
+      it "rejects setting the same key twice when the first has allow_cookbook_override with a past version" do
+        expect(Chef).to receive(:deprecated).with(:map_collision, /resource foo/)
+        node_map.set(:foo, FooResource, allow_cookbook_override: "< 1")
+        node_map.lock!
+        node_map.set(:foo, BarResource)
+        # expect(node_map.get(node, :foo)).to eql(FooResource)
+      end
+
+      it "allows setting the same key twice when the second has __core_override__" do
+        expect(Chef).to_not receive(:deprecated)
+        node_map.set(:foo, FooResource)
+        node_map.lock!
+        node_map.set(:foo, BarResource, __core_override__: true)
+        expect(node_map.get(node, :foo)).to eql(BarResource)
+      end
+
+      it "rejects setting the same key twice for a provider" do
+        expect(Chef).to receive(:deprecated).with(:map_collision, /provider foo/)
+        node_map.set(:foo, FooProvider)
+        node_map.lock!
+        node_map.set(:foo, BarProvider)
+        # expect(node_map.get(node, :foo)).to eql(FooProvider)
+      end
+    end
+  end
+
 end

data/spec/unit/node_spec.rb

@@ -52,7 +52,7 @@ describe Chef::Node do
 
   describe "when the node does not exist on the server" do
     before do
-      response = OpenStruct.new(:code => "404")
+      response = OpenStruct.new(code: "404")
       exception = Net::HTTPServerException.new("404 not found", response)
       allow(Chef::Node).to receive(:load).and_raise(exception)
       node.name("created-node")
@@ -852,7 +852,7 @@ describe Chef::Node do
   describe "consuming json" do
 
     before do
-      @ohai_data = { :platform => "foo", :platform_version => "bar" }
+      @ohai_data = { platform: "foo", platform_version: "bar" }
     end
 
     it "consumes the run list portion of a collection of attributes and returns the remainder" do
@@ -944,7 +944,7 @@ describe Chef::Node do
 
   describe "preparing for a chef client run" do
     before do
-      @ohai_data = { :platform => "foobuntu", :platform_version => "23.42" }
+      @ohai_data = { platform: "foobuntu", platform_version: "23.42" }
     end
 
     it "sets its platform according to platform detection" do
@@ -1096,12 +1096,12 @@ describe Chef::Node do
     before do
       node.chef_environment = "rspec"
       @expansion = Chef::RunList::RunListExpansion.new("rspec", [])
-      @expansion.default_attrs.replace({ :default => "from role", :d_role => "role only" })
-      @expansion.override_attrs.replace({ :override => "from role", :o_role => "role only" })
+      @expansion.default_attrs.replace({ default: "from role", d_role: "role only" })
+      @expansion.override_attrs.replace({ override: "from role", o_role: "role only" })
 
       @environment = Chef::Environment.new
-      @environment.default_attributes = { :default => "from env", :d_env => "env only" }
-      @environment.override_attributes = { :override => "from env", :o_env => "env only" }
+      @environment.default_attributes = { default: "from env", d_env: "env only" }
+      @environment.override_attributes = { override: "from env", o_env: "env only" }
       allow(Chef::Environment).to receive(:load).and_return(@environment)
       node.apply_expansion_attributes(@expansion)
     end
@@ -1269,7 +1269,7 @@ describe Chef::Node do
   end
 
   describe "converting to or from json" do
-    it "should serialize itself as json", :json => true do
+    it "should serialize itself as json", json: true do
       node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
       json = Chef::JSONCompat.to_json(node)
       expect(json).to match(/json_class/)
@@ -1281,16 +1281,16 @@ describe Chef::Node do
       expect(json).to match(/run_list/)
     end
 
-    it "should serialize valid json with a run list", :json => true do
-      #This test came about because activesupport mucks with Chef json serialization
-      #Test should pass with and without Activesupport
+    it "should serialize valid json with a run list", json: true do
+      # This test came about because activesupport mucks with Chef json serialization
+      # Test should pass with and without Activesupport
       node.run_list << { "type" => "role", "name" => "Cthulu" }
       node.run_list << { "type" => "role", "name" => "Hastur" }
       json = Chef::JSONCompat.to_json(node)
       expect(json).to match(/\"run_list\":\[\"role\[Cthulu\]\",\"role\[Hastur\]\"\]/)
     end
 
-    it "should serialize the correct run list", :json => true do
+    it "should serialize the correct run list", json: true do
       node.run_list << "role[marxist]"
       node.run_list << "role[leninist]"
       node.override_runlist << "role[stalinist]"
@@ -1315,7 +1315,7 @@ describe Chef::Node do
       expect(node_for_json["default"]["env default"]).to eq("env default")
     end
 
-    it "should deserialize itself from json", :json => true do
+    it "should deserialize itself from json", json: true do
       node.from_file(File.expand_path("nodes/test.example.com.rb", CHEF_SPEC_DATA))
       json = Chef::JSONCompat.to_json(node)
       serialized_node = Chef::Node.from_hash(Chef::JSONCompat.parse(json))
@@ -1392,7 +1392,7 @@ describe Chef::Node do
     describe "list" do
       describe "inflated" do
         it "should return a hash of node names and objects" do
-          n1 = double("Chef::Node", :name => "one")
+          n1 = double("Chef::Node", name: "one")
           allow(n1).to receive(:kind_of?).with(Chef::Node) { true }
           expect(@query).to receive(:search).with(:node).and_yield(n1)
           r = Chef::Node.list(true)
@@ -1446,7 +1446,7 @@ describe Chef::Node do
       it "should create if it cannot update" do
         node.name("monkey")
         allow(node).to receive(:data_for_save).and_return({})
-        exception = double("404 error", :code => "404")
+        exception = double("404 error", code: "404")
         expect(@rest).to receive(:put).and_raise(Net::HTTPServerException.new("foo", exception))
         expect(@rest).to receive(:post).with("nodes", {})
         node.save

data/spec/unit/org_spec.rb

@@ -164,7 +164,7 @@ describe Chef::Org do
 
     describe "create" do
       it "creates a new org via the API" do
-        expect(rest).to receive(:post).with("organizations", { :name => "foobar", :full_name => "foo bar bat" }).and_return({})
+        expect(rest).to receive(:post).with("organizations", { name: "foobar", full_name: "foo bar bat" }).and_return({})
         org.create
       end
     end
@@ -181,7 +181,7 @@ describe Chef::Org do
 
     describe "update" do
       it "updates an existing org on via the API" do
-        expect(rest).to receive(:put).with("organizations/foobar", { :name => "foobar", :full_name => "foo bar bat" }).and_return({})
+        expect(rest).to receive(:put).with("organizations/foobar", { name: "foobar", full_name: "foo bar bat" }).and_return({})
         org.update
       end
     end

data/spec/unit/platform/query_helpers_spec.rb

@@ -51,9 +51,9 @@ describe "Chef::Platform#windows_nano_server?" do
   it "returns true when the registry value is 1" do
     allow(ChefConfig).to receive(:windows?).and_return(true)
     allow(Chef::Platform).to receive(:require).with("win32/registry")
-    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).
-      with(key, access).
-      and_yield(registry)
+    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+      .with(key, access)
+      .and_yield(registry)
     expect(registry).to receive(:[]).with("NanoServer").and_return(1)
     expect(Chef::Platform.windows_nano_server?).to be true
   end
@@ -61,9 +61,9 @@ describe "Chef::Platform#windows_nano_server?" do
   it "returns false when the registry value is not 1" do
     allow(ChefConfig).to receive(:windows?).and_return(true)
     allow(Chef::Platform).to receive(:require).with("win32/registry")
-    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).
-      with(key, access).
-      and_yield(registry)
+    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+      .with(key, access)
+      .and_yield(registry)
     expect(registry).to receive(:[]).with("NanoServer").and_return(0)
     expect(Chef::Platform.windows_nano_server?).to be false
   end
@@ -71,20 +71,20 @@ describe "Chef::Platform#windows_nano_server?" do
   it "returns false when the registry value does not exist" do
     allow(ChefConfig).to receive(:windows?).and_return(true)
     allow(Chef::Platform).to receive(:require).with("win32/registry")
-    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).
-      with(key, access).
-      and_yield(registry)
-    expect(registry).to receive(:[]).with("NanoServer").
-      and_raise(Win32::Registry::Error, "The system cannot find the file specified.")
+    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+      .with(key, access)
+      .and_yield(registry)
+    expect(registry).to receive(:[]).with("NanoServer")
+      .and_raise(Win32::Registry::Error, "The system cannot find the file specified.")
     expect(Chef::Platform.windows_nano_server?).to be false
   end
 
   it "returns false when the registry key does not exist" do
     allow(ChefConfig).to receive(:windows?).and_return(true)
     allow(Chef::Platform).to receive(:require).with("win32/registry")
-    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).
-      with(key, access).
-      and_raise(Win32::Registry::Error, "The system cannot find the file specified.")
+    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+      .with(key, access)
+      .and_raise(Win32::Registry::Error, "The system cannot find the file specified.")
     expect(Chef::Platform.windows_nano_server?).to be false
   end
 end
@@ -122,18 +122,18 @@ describe "Chef::Platform#supports_msi?" do
   it "returns true when the registry key exists" do
     allow(ChefConfig).to receive(:windows?).and_return(true)
     allow(Chef::Platform).to receive(:require).with("win32/registry")
-    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).
-      with(key, access).
-      and_yield(registry)
+    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+      .with(key, access)
+      .and_yield(registry)
     expect(Chef::Platform.supports_msi?).to be true
   end
 
   it "returns false when the registry key does not exist" do
     allow(ChefConfig).to receive(:windows?).and_return(true)
     allow(Chef::Platform).to receive(:require).with("win32/registry")
-    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open).
-      with(key, access).
-      and_raise(Win32::Registry::Error, "The system cannot find the file specified.")
+    expect(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+      .with(key, access)
+      .and_raise(Win32::Registry::Error, "The system cannot find the file specified.")
     expect(Chef::Platform.supports_msi?).to be false
   end
 end
@@ -188,18 +188,18 @@ describe "Chef::Platform#dsc_refresh_mode_disabled?" do
   let(:cmdlet_result) { instance_double("Chef::Util::Powershell::CmdletResult") }
 
   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(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(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(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(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be false

data/spec/unit/policy_builder/expand_node_object_spec.rb

@@ -48,7 +48,7 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
 
     it "implements a setup_run_context method that accepts a list of recipe files to run" do
       expect(policy_builder).to respond_to(:setup_run_context)
-      expect(policy_builder.method(:setup_run_context).arity).to eq(-1) #optional argument
+      expect(policy_builder.method(:setup_run_context).arity).to eq(-1) # optional argument
     end
 
     it "implements a run_context method" do
@@ -176,7 +176,7 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
       let(:expansion) do
         recipe_list = Chef::RunList::VersionedRecipeList.new
         recipe_list.add_recipe("recipe[from_role::default", "1.0.2")
-        double("RunListExpansion", :recipes => recipe_list)
+        double("RunListExpansion", recipes: recipe_list)
       end
 
       let(:node) do
@@ -268,13 +268,13 @@ describe Chef::PolicyBuilder::ExpandNodeObject do
     let(:chef_http) { double("Chef::ServerAPI") }
 
     let(:cookbook_resolve_url) { "environments/#{node.chef_environment}/cookbook_versions" }
-    let(:cookbook_resolve_post_data) { { :run_list => ["first::default", "second::default"] } }
+    let(:cookbook_resolve_post_data) { { run_list: ["first::default", "second::default"] } }
 
     # cookbook_hash is just a hash, but since we're passing it between mock
     # objects, we get a little better test strictness by using a double (which
     # will have object equality rather than semantic equality #== semantics).
     let(:cookbook_hash) { double("cookbook hash") }
-    let(:expanded_cookbook_hash) { double("expanded cookbook hash", :each => nil) }
+    let(:expanded_cookbook_hash) { double("expanded cookbook hash", each: nil) }
 
     let(:cookbook_synchronizer) { double("CookbookSynchronizer") }