chef 14.2.0 → 14.3.37

data/spec/unit/data_bag_item_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -53,7 +53,7 @@ describe Chef::DataBagItem do
     end
 
     it "should let you set the raw_data with a hash containing symbols" do
-      expect { data_bag_item.raw_data = { :id => "octahedron" } }.not_to raise_error
+      expect { data_bag_item.raw_data = { id: "octahedron" } }.not_to raise_error
     end
 
     it "should let you set the raw_data from a mash" do
@@ -297,7 +297,7 @@ describe Chef::DataBagItem do
     end
 
     it "should create if the item is not found" do
-      exception = double("404 error", :code => "404")
+      exception = double("404 error", code: "404")
       expect(server).to receive(:put).and_raise(Net::HTTPServerException.new("foo", exception))
       expect(server).to receive(:post).with("data/books", data_bag_item)
       data_bag_item.save

data/spec/unit/data_bag_spec.rb

@@ -88,7 +88,7 @@ describe Chef::DataBag do
     end
 
     it "should silently proceed when the data bag already exists" do
-      exception = double("409 error", :code => "409")
+      exception = double("409 error", code: "409")
       expect(@rest).to receive(:post).and_raise(Net::HTTPServerException.new("foo", exception))
       @data_bag.save
     end

data/spec/unit/data_collector/resource_report_spec.rb

@@ -133,7 +133,7 @@ describe Chef::DataCollector::ResourceReport do
         }
       end
       let(:conditional) do
-        double("Chef::Resource::Conditional", :to_text => "because")
+        double("Chef::Resource::Conditional", to_text: "because")
       end
 
       it "should handle any Exception and throw a helpful message by mocking the identity" do

data/spec/unit/data_collector_spec.rb

@@ -2,7 +2,7 @@
 # Author:: Adam Leff (<adamleff@chef.io)
 # Author:: Ryan Cragun (<ryan@chef.io>)
 #
-# Copyright:: Copyright 2012-2016, Chef Software Inc.
+# Copyright:: Copyright 2012-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -804,14 +804,15 @@ describe Chef::DataCollector::Reporter do
 
     context "when valid output_locations are provided" do
       it "does not raise an exception" do
-        Chef::Config[:data_collector][:output_locations] = { :urls => ["http://data_collector"], :files => ["data_collection.json"] }
+        expect(reporter).to receive(:open).with("data_collection.json", "a")
+        Chef::Config[:data_collector][:output_locations] = { urls: ["http://data_collector"], files: ["data_collection.json"] }
         expect { reporter.send(:validate_data_collector_output_locations!) }.not_to raise_error(Chef::Exceptions::ConfigurationError)
       end
     end
 
     context "when output_locations contains an invalid URI" do
       it "raises an exception" do
-        Chef::Config[:data_collector][:output_locations] = { :urls => ["this is not a url"], :files => ["/tmp/data_collection.json"] }
+        Chef::Config[:data_collector][:output_locations] = { urls: ["this is not a url"], files: ["/tmp/data_collection.json"] }
         expect { reporter.send(:validate_data_collector_output_locations!) }.to raise_error(Chef::Exceptions::ConfigurationError)
       end
     end

data/spec/unit/deprecated_spec.rb

@@ -20,40 +20,46 @@ require "chef/deprecated"
 
 describe Chef::Deprecated do
   class TestDeprecation < Chef::Deprecated::Base
-    def id; 999; end
-
-    def target; "test.html"; end
-
-    def link; "#{Chef::Deprecated::Base::BASE_URL}test.html"; end
+    target 999, "test.html"
   end
 
   context "loading a deprecation class" do
     it "loads the correct class" do
-      expect(Chef::Deprecated.create(:test_deprecation)).to be_an_instance_of(TestDeprecation)
+      expect(Chef::Deprecated.create(:test_deprecation, nil, nil)).to be_an_instance_of(TestDeprecation)
     end
 
-    it "optionally sets a message" do
-      deprecation = Chef::Deprecated.create(:test_deprecation, "A test message")
+    it "sets a message" do
+      deprecation = Chef::Deprecated.create(:test_deprecation, "A test message", nil)
       expect(deprecation.message).to eql("A test message")
     end
 
-    it "optionally sets the location" do
+    it "sets the location" do
       deprecation = Chef::Deprecated.create(:test_deprecation, nil, "A test location")
       expect(deprecation.location).to eql("A test location")
     end
   end
 
   context "formatting deprecation warnings" do
-    let(:base_url) { Chef::Deprecated::Base::BASE_URL }
     let(:message) { "A test message" }
     let(:location) { "the location" }
 
     it "displays the full URL" do
-      expect(TestDeprecation.new().url).to eql("#{base_url}test.html")
+      expect(TestDeprecation.new().url).to eql("https://docs.chef.io/deprecations_test.html")
     end
 
     it "formats a complete deprecation message" do
-      expect(TestDeprecation.new(message, location).inspect).to eql("#{message} (CHEF-999)#{location}.\nhttps://docs.chef.io/deprecations_test.html")
+      expect(TestDeprecation.new(message, location).to_s).to eql("Deprecation CHEF-999 from the location\n\n  A test message\n\nPlease see https://docs.chef.io/deprecations_test.html for further details and information on how to correct this problem.")
+    end
+  end
+
+  it "has no overlapping deprecation IDs" do
+    id_map = {}
+    ObjectSpace.each_object(Class).select { |cls| cls < Chef::Deprecated::Base }.each do |cls|
+      (id_map[cls.deprecation_id] ||= []) << cls
+    end
+    collisions = id_map.select { |k, v| v.size != 1 }
+    unless collisions.empty?
+      raise "Found deprecation ID collisions:\n#{collisions.map { |k, v| "* #{k} #{v.map(&:name).join(', ')}" }.join("\n")}"
     end
   end
 end

data/spec/unit/dsl/audit_spec.rb

@@ -12,7 +12,7 @@ end
 
 describe Chef::DSL::Audit do
   let(:auditor) { AuditDSLTester.new("cookbook_name", "recipe_name", run_context) }
-  let(:run_context) { instance_double(Chef::RunContext, :audits => audits, :cookbook_collection => cookbook_collection) }
+  let(:run_context) { instance_double(Chef::RunContext, audits: audits, cookbook_collection: cookbook_collection) }
   let(:audits) { {} }
   let(:cookbook_collection) { {} }
 

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -39,8 +39,8 @@ end
 describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
   before do
     platform_hash = {
-      :openbsd => { :default => "free, functional, secure" },
-      [:redhat, :centos, :fedora, :scientific] => { :default => '"stable"' },
+      :openbsd => { default: "free, functional, secure" },
+      [:redhat, :centos, :fedora, :scientific] => { default: '"stable"' },
       :ubuntu => { "10.04" => "using upstart more", :default => "using init more" },
       :default => "bork da bork",
     }
@@ -48,24 +48,24 @@ describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
   end
 
   it "returns the default value when the platform doesn't match" do
-    expect(@platform_specific_value.value_for_node(:platform => :dos)).to eq("bork da bork")
+    expect(@platform_specific_value.value_for_node(platform: :dos)).to eq("bork da bork")
   end
 
   it "returns a value for a platform set as a group" do
-    expect(@platform_specific_value.value_for_node(:platform => :centos)).to eq('"stable"')
+    expect(@platform_specific_value.value_for_node(platform: :centos)).to eq('"stable"')
   end
 
   it "returns a value for the platform when it was set as a symbol but fetched as a string" do
-    expect(@platform_specific_value.value_for_node(:platform => "centos")).to eq('"stable"')
+    expect(@platform_specific_value.value_for_node(platform: "centos")).to eq('"stable"')
   end
 
   it "returns a value for a specific platform version" do
-    node = { :platform => "ubuntu", :platform_version => "10.04" }
+    node = { platform: "ubuntu", platform_version: "10.04" }
     expect(@platform_specific_value.value_for_node(node)).to eq("using upstart more")
   end
 
   it "returns a platform-default value if the platform version doesn't match an explicit one" do
-    node = { :platform => "ubuntu", :platform_version => "9.10" }
+    node = { platform: "ubuntu", platform_version: "9.10" }
     expect(@platform_specific_value.value_for_node(node)).to eq("using init more")
   end
 
@@ -73,11 +73,11 @@ describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
     # this matches the behavior in the original implementation.
     # whether or not it's correct is another matter.
     platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new({})
-    expect(platform_specific_value.value_for_node(:platform => "foo")).to be_nil
+    expect(platform_specific_value.value_for_node(platform: "foo")).to be_nil
   end
 
   it "raises an argument error if the platform hash is not correctly structured" do
-    bad_hash = { :ubuntu => :foo } # should be :ubuntu => {:default => 'foo'}
+    bad_hash = { ubuntu: :foo } # should be :ubuntu => {:default => 'foo'}
     expect { Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(bad_hash) }.to raise_error(ArgumentError)
   end
 
@@ -98,32 +98,32 @@ describe Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue do
   end
 
   it "returns the default value when the platform family doesn't match" do
-    expect(@platform_family_value.value_for_node(:platform_family => :os2)).to eq("default value")
+    expect(@platform_family_value.value_for_node(platform_family: :os2)).to eq("default value")
   end
 
   it "returns a value for the platform family when it was set as a string but fetched as a symbol" do
-    expect(@platform_family_value.value_for_node(:platform_family => :debian)).to eq("debian value")
+    expect(@platform_family_value.value_for_node(platform_family: :debian)).to eq("debian value")
   end
 
   it "returns a value for the platform family when it was set as a symbol but fetched as a string" do
-    expect(@platform_family_value.value_for_node(:platform_family => "gentoo")).to eq("gentoo value")
+    expect(@platform_family_value.value_for_node(platform_family: "gentoo")).to eq("gentoo value")
   end
 
   it "returns an array value stored for a platform family" do
-    expect(@platform_family_value.value_for_node(:platform_family => "suse")).to eq(@array_values)
+    expect(@platform_family_value.value_for_node(platform_family: "suse")).to eq(@array_values)
   end
 
   it "returns a value for the platform family when it was set within an array hash key as a symbol" do
-    expect(@platform_family_value.value_for_node(:platform_family => :rhel)).to eq("redhatty value")
+    expect(@platform_family_value.value_for_node(platform_family: :rhel)).to eq("redhatty value")
   end
 
   it "returns a value for the platform family when it was set within an array hash key as a string" do
-    expect(@platform_family_value.value_for_node(:platform_family => "fedora")).to eq("redhatty value")
+    expect(@platform_family_value.value_for_node(platform_family: "fedora")).to eq("redhatty value")
   end
 
   it "returns nil if there is no default and no platforms match" do
     platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new({})
-    expect(platform_specific_value.value_for_node(:platform_family => "foo")).to be_nil
+    expect(platform_specific_value.value_for_node(platform_family: "foo")).to be_nil
   end
 
 end

data/spec/unit/dsl/reboot_pending_spec.rb

@@ -36,7 +36,7 @@ describe Chef::DSL::RebootPending do
         end
 
         it 'should return true if "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations" exists' do
-          allow(recipe).to receive(:registry_value_exists?).with('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => "PendingFileRenameOperations" }).and_return(true)
+          allow(recipe).to receive(:registry_value_exists?).with('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { name: "PendingFileRenameOperations" }).and_return(true)
           expect(recipe.reboot_pending?).to be_truthy
         end
 

data/spec/unit/environment_spec.rb

@@ -73,12 +73,12 @@ describe Chef::Environment do
 
   describe "default attributes" do
     it "should let you set the attributes hash explicitly" do
-      expect(@environment.default_attributes({ :one => "two" })).to eq({ :one => "two" })
+      expect(@environment.default_attributes({ one: "two" })).to eq({ one: "two" })
     end
 
     it "should let you return the attributes hash" do
-      @environment.default_attributes({ :one => "two" })
-      expect(@environment.default_attributes).to eq({ :one => "two" })
+      @environment.default_attributes({ one: "two" })
+      expect(@environment.default_attributes).to eq({ one: "two" })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
@@ -88,12 +88,12 @@ describe Chef::Environment do
 
   describe "override attributes" do
     it "should let you set the attributes hash explicitly" do
-      expect(@environment.override_attributes({ :one => "two" })).to eq({ :one => "two" })
+      expect(@environment.override_attributes({ one: "two" })).to eq({ one: "two" })
     end
 
     it "should let you return the attributes hash" do
-      @environment.override_attributes({ :one => "two" })
-      expect(@environment.override_attributes).to eq({ :one => "two" })
+      @environment.override_attributes({ one: "two" })
+      expect(@environment.override_attributes).to eq({ one: "two" })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
@@ -167,7 +167,7 @@ describe Chef::Environment do
     before(:each) do
       @environment.name("spec")
       @environment.description("Where we run the spec tests")
-      @environment.cookbook_versions({ :apt => "= 1.2.3" })
+      @environment.cookbook_versions({ apt: "= 1.2.3" })
       @hash = @environment.to_hash
     end
 
@@ -190,7 +190,7 @@ describe Chef::Environment do
     before(:each) do
       @environment.name("spec")
       @environment.description("Where we run the spec tests")
-      @environment.cookbook_versions({ :apt => "= 1.2.3" })
+      @environment.cookbook_versions({ apt: "= 1.2.3" })
       @json = @environment.to_json
     end
 
@@ -311,17 +311,17 @@ describe Chef::Environment do
     end
 
     it "updates the name from parameters[:name]" do
-      @environment.update_from_params(:name => "kurrupt")
+      @environment.update_from_params(name: "kurrupt")
       expect(@environment.name).to eq("kurrupt")
     end
 
     it "validates the name given in the params" do
-      expect(@environment.update_from_params(:name => "@$%^&*()")).to be_falsey
+      expect(@environment.update_from_params(name: "@$%^&*()")).to be_falsey
       expect(@environment.invalid_fields[:name]).to eq(%q{Option name's value @$%^&*() does not match regular expression /^[\-[:alnum:]_]+$/})
     end
 
     it "updates the description from parameters[:description]" do
-      @environment.update_from_params(:description => "wow, writing your own object mapper is kinda painful")
+      @environment.update_from_params(description: "wow, writing your own object mapper is kinda painful")
       expect(@environment.description).to eq("wow, writing your own object mapper is kinda painful")
     end
 
@@ -329,13 +329,13 @@ describe Chef::Environment do
       # NOTE: I'm only choosing this (admittedly weird) structure for the hash b/c the better more obvious
       # one, i.e, {:cookbook_version_constraints => {COOKBOOK_NAME => CONSTRAINT}} is difficult to implement
       # the way merb does params
-      params = { :name => "superbowl", :cookbook_version => { "0" => "apache2 ~> 1.0.0", "1" => "nginx < 2.0.0" } }
+      params = { name: "superbowl", cookbook_version: { "0" => "apache2 ~> 1.0.0", "1" => "nginx < 2.0.0" } }
       @environment.update_from_params(params)
       expect(@environment.cookbook_versions).to eq({ "apache2" => "~> 1.0.0", "nginx" => "< 2.0.0" })
     end
 
     it "validates the cookbook constraints" do
-      params = { :cookbook_version => { "0" => "apache2 >>> 1.0.0" } }
+      params = { cookbook_version: { "0" => "apache2 >>> 1.0.0" } }
       expect(@environment.update_from_params(params)).to be_falsey
       err_msg = @environment.invalid_fields[:cookbook_version]["0"]
       expect(err_msg).to eq("apache2 >>> 1.0.0 is not a valid cookbook constraint")
@@ -352,12 +352,12 @@ describe Chef::Environment do
     end
 
     it "updates default attributes from a JSON string in params[:attributes]" do
-      @environment.update_from_params(:name => "fuuu", :default_attributes => %q|{"fuuu":"RAGE"}|)
+      @environment.update_from_params(name: "fuuu", default_attributes: %q|{"fuuu":"RAGE"}|)
       expect(@environment.default_attributes).to eq({ "fuuu" => "RAGE" })
     end
 
     it "updates override attributes from a JSON string in params[:attributes]" do
-      @environment.update_from_params(:name => "fuuu", :override_attributes => %q|{"foo":"override"}|)
+      @environment.update_from_params(name: "fuuu", override_attributes: %q|{"foo":"override"}|)
       expect(@environment.override_attributes).to eq({ "foo" => "override" })
     end
 
@@ -374,7 +374,7 @@ describe Chef::Environment do
     describe "list" do
       describe "inflated" do
         it "should return a hash of environment names and objects" do
-          e1 = double("Chef::Environment", :name => "one")
+          e1 = double("Chef::Environment", name: "one")
           expect(@query).to receive(:search).with(:environment).and_yield(e1)
           r = Chef::Environment.list(true)
           expect(r["one"]).to eq(e1)

data/spec/unit/file_access_control_spec.rb

@@ -36,7 +36,7 @@ describe Chef::FileAccessControl do
         @run_context = Chef::RunContext.new(@node, {}, @events)
         @current_resource = Chef::Resource::File.new("/tmp/different_file.txt")
         @provider_requirements = Chef::Provider::ResourceRequirements.new(@resource, @run_context)
-        @provider = double("File provider", :requirements => @provider_requirements, :manage_symlink_access? => false)
+        @provider = double("File provider", requirements: @provider_requirements, manage_symlink_access?: false)
 
         @fac = Chef::FileAccessControl.new(@current_resource, @resource, @provider)
       end
@@ -61,7 +61,7 @@ describe Chef::FileAccessControl do
     end
 
     it "determines the uid of the owner specified by the resource" do
-      expect(Etc).to receive(:getpwnam).with("toor").and_return(OpenStruct.new(:uid => 2342))
+      expect(Etc).to receive(:getpwnam).with("toor").and_return(OpenStruct.new(uid: 2342))
       expect(@fac.target_uid).to eq(2342)
     end
 
@@ -99,7 +99,7 @@ describe Chef::FileAccessControl do
       # uids. So we have to get ruby and negative uids to smoke the peace pipe
       # with each other.
       @resource.owner("nobody")
-      expect(Etc).to receive(:getpwnam).with("nobody").and_return(OpenStruct.new(:uid => (4294967294)))
+      expect(Etc).to receive(:getpwnam).with("nobody").and_return(OpenStruct.new(uid: (4294967294)))
       expect(@fac.target_uid).to eq(-2)
     end
 
@@ -107,7 +107,7 @@ describe Chef::FileAccessControl do
       # More: when OSX userIDs are created by ActiveDirectory sync, it tends to use huge numbers
       #  which had been incorrectly wrapped.  It does not look like the OSX IDs go below -2
       @resource.owner("bigdude")
-      expect(Etc).to receive(:getpwnam).with("bigdude").and_return(OpenStruct.new(:uid => (4294967286)))
+      expect(Etc).to receive(:getpwnam).with("bigdude").and_return(OpenStruct.new(uid: (4294967286)))
       expect(@fac.target_uid).to eq(4294967286)
     end
 
@@ -153,7 +153,7 @@ describe Chef::FileAccessControl do
     end
 
     it "determines the gid of the group specified by the resource" do
-      expect(Etc).to receive(:getgrnam).with("wheel").and_return(OpenStruct.new(:gid => 2342))
+      expect(Etc).to receive(:getgrnam).with("wheel").and_return(OpenStruct.new(gid: 2342))
       expect(@fac.target_gid).to eq(2342)
     end
 
@@ -273,7 +273,7 @@ describe Chef::FileAccessControl do
 
     it "sets the file's mode as specified in the resource when the current modes are incorrect" do
       # stat returns modes like 0100644 (octal) => 33188 (decimal)
-      #@fac.stub(:stat).and_return(OpenStruct.new(:mode => 33188))
+      # @fac.stub(:stat).and_return(OpenStruct.new(:mode => 33188))
       @current_resource.mode("0644")
       expect(File).to receive(:chmod).with(256, "/tmp/different_file.txt")
       @fac.set_mode
@@ -286,7 +286,7 @@ describe Chef::FileAccessControl do
     end
 
     it "does not set the file's mode when the current modes are correct" do
-      #@fac.stub(:stat).and_return(OpenStruct.new(:mode => 0100400))
+      # @fac.stub(:stat).and_return(OpenStruct.new(:mode => 0100400))
       @current_resource.mode("0400")
       expect(File).not_to receive(:chmod)
       @fac.set_mode
@@ -294,7 +294,7 @@ describe Chef::FileAccessControl do
     end
 
     it "sets all access controls on a file" do
-      allow(@fac).to receive(:stat).and_return(OpenStruct.new(:owner => 99, :group => 99, :mode => 0100444))
+      allow(@fac).to receive(:stat).and_return(OpenStruct.new(owner: 99, group: 99, mode: 0100444))
       @resource.mode(0400)
       @resource.owner(0)
       @resource.group(0)

data/spec/unit/file_content_management/deploy/mv_unix_spec.rb

@@ -38,9 +38,9 @@ describe Chef::FileContentManagement::Deploy::MvUnix do
     let(:target_file_mode) { 0644 }
     let(:target_file_stat) do
       double "File::Stat struct for target file",
-           :mode => target_file_mode,
-           :uid => target_file_uid,
-           :gid => target_file_gid
+           mode: target_file_mode,
+           uid: target_file_uid,
+           gid: target_file_gid
     end
 
     before do

data/spec/unit/file_content_management/deploy/mv_windows_spec.rb

@@ -59,10 +59,10 @@ describe Chef::FileContentManagement::Deploy::MvWindows do
     end
 
     before do
-      allow(Chef::ReservedNames::Win32::Security::SecurableObject).
-        to receive(:new).
-        with(target_file_path).
-        and_return(target_file_security_object, updated_target_security_object)
+      allow(Chef::ReservedNames::Win32::Security::SecurableObject)
+        .to receive(:new)
+        .with(target_file_path)
+        .and_return(target_file_security_object, updated_target_security_object)
 
     end
 
@@ -84,8 +84,8 @@ describe Chef::FileContentManagement::Deploy::MvWindows do
 
       let(:target_file_security_descriptor) do
         double "security descriptor for target file",
-             :group => original_target_file_group,
-             :owner => original_target_file_owner
+             group: original_target_file_group,
+             owner: original_target_file_owner
       end
 
       let(:updated_target_security_descriptor) do
@@ -147,19 +147,19 @@ describe Chef::FileContentManagement::Deploy::MvWindows do
           allow(target_file_security_descriptor).to receive(:dacl_inherits?).and_return(false)
 
           allow(target_file_security_descriptor).to receive(:dacl).and_return(original_target_file_dacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL).
-            to receive(:create).
-            with([]).
-            and_return(empty_dacl)
+          expect(Chef::ReservedNames::Win32::Security::ACL)
+            .to receive(:create)
+            .with([])
+            .and_return(empty_dacl)
 
           allow(target_file_security_descriptor).to receive(:sacl_present?).and_return(true)
           allow(target_file_security_descriptor).to receive(:sacl_inherits?).and_return(false)
 
           allow(target_file_security_descriptor).to receive(:sacl).and_return(original_target_file_sacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL).
-            to receive(:create).
-            with([]).
-            and_return(empty_sacl)
+          expect(Chef::ReservedNames::Win32::Security::ACL)
+            .to receive(:create)
+            .with([])
+            .and_return(empty_sacl)
 
           expect(updated_target_security_object).to receive(:set_dacl).with(empty_dacl, false)
           expect(updated_target_security_object).to receive(:set_sacl).with(empty_sacl, false)
@@ -171,13 +171,13 @@ describe Chef::FileContentManagement::Deploy::MvWindows do
       end
 
       context "and the target has a dacl and sacl" do
-        let(:inherited_dacl_ace) { double("Windows dacl ace (inherited)", :inherited? => true) }
-        let(:not_inherited_dacl_ace) { double("Windows dacl ace (not inherited)", :inherited? => false) }
+        let(:inherited_dacl_ace) { double("Windows dacl ace (inherited)", inherited?: true) }
+        let(:not_inherited_dacl_ace) { double("Windows dacl ace (not inherited)", inherited?: false) }
 
         let(:original_target_file_dacl) { [inherited_dacl_ace, not_inherited_dacl_ace] }
 
-        let(:inherited_sacl_ace) { double("Windows sacl ace (inherited)", :inherited? => true) }
-        let(:not_inherited_sacl_ace) { double("Windows sacl ace (not inherited)", :inherited? => false) }
+        let(:inherited_sacl_ace) { double("Windows sacl ace (inherited)", inherited?: true) }
+        let(:not_inherited_sacl_ace) { double("Windows sacl ace (not inherited)", inherited?: false) }
         let(:original_target_file_sacl) { [inherited_sacl_ace, not_inherited_sacl_ace] }
 
         let(:custom_dacl) { double("Windows ACL for non-inherited dacl aces") }
@@ -188,19 +188,19 @@ describe Chef::FileContentManagement::Deploy::MvWindows do
           allow(target_file_security_descriptor).to receive(:dacl_inherits?).and_return(dacl_inherits?)
 
           allow(target_file_security_descriptor).to receive(:dacl).and_return(original_target_file_dacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL).
-            to receive(:create).
-            with([not_inherited_dacl_ace]).
-            and_return(custom_dacl)
+          expect(Chef::ReservedNames::Win32::Security::ACL)
+            .to receive(:create)
+            .with([not_inherited_dacl_ace])
+            .and_return(custom_dacl)
 
           allow(target_file_security_descriptor).to receive(:sacl_present?).and_return(true)
           allow(target_file_security_descriptor).to receive(:sacl_inherits?).and_return(sacl_inherits?)
 
           allow(target_file_security_descriptor).to receive(:sacl).and_return(original_target_file_sacl)
-          expect(Chef::ReservedNames::Win32::Security::ACL).
-            to receive(:create).
-            with([not_inherited_sacl_ace]).
-            and_return(custom_sacl)
+          expect(Chef::ReservedNames::Win32::Security::ACL)
+            .to receive(:create)
+            .with([not_inherited_sacl_ace])
+            .and_return(custom_sacl)
 
           expect(updated_target_security_object).to receive(:set_dacl).with(custom_dacl, dacl_inherits?)
           expect(updated_target_security_object).to receive(:set_sacl).with(custom_sacl, sacl_inherits?)