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

data/spec/unit/mixin/checksum_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Mixin::Checksum do
     @checksum_user = Chef::CMCCheck.new
     @cache = Chef::Digester.instance
     @file = CHEF_SPEC_DATA + "/checksum/random.txt"
-    @stat = double("File::Stat", { :mtime => Time.at(0) })
+    @stat = double("File::Stat", { mtime: Time.at(0) })
     allow(File).to receive(:stat).and_return(@stat)
   end
 

data/spec/unit/mixin/enforce_ownership_and_permissions_spec.rb

@@ -51,11 +51,11 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
       allow_any_instance_of(Chef::FileAccessControl).to receive(:define_resource_requirements)
       allow_any_instance_of(Chef::FileAccessControl).to receive(:describe_changes)
 
-      passwd_struct = OpenStruct.new(:name => "root", :passwd => "x",
-                                     :uid => 0, :gid => 0, :dir => "/root",
-                                     :shell => "/bin/bash")
+      passwd_struct = OpenStruct.new(name: "root", passwd: "x",
+                                     uid: 0, gid: 0, dir: "/root",
+                                     shell: "/bin/bash")
 
-      group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
+      group_struct = OpenStruct.new(name: "root", passwd: "x", gid: 0)
       allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
       allow(Etc).to receive(:getgrgid).and_return(group_struct)
     end
@@ -75,11 +75,11 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
       allow_any_instance_of(Chef::FileAccessControl).to receive(:uid_from_resource).and_return(0)
       allow_any_instance_of(Chef::FileAccessControl).to receive(:describe_changes)
 
-      passwd_struct = OpenStruct.new(:name => "root", :passwd => "x",
-                                     :uid => 0, :gid => 0, :dir => "/root",
-                                     :shell => "/bin/bash")
+      passwd_struct = OpenStruct.new(name: "root", passwd: "x",
+                                     uid: 0, gid: 0, dir: "/root",
+                                     shell: "/bin/bash")
 
-      group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
+      group_struct = OpenStruct.new(name: "root", passwd: "x", gid: 0)
       allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
       allow(Etc).to receive(:getgrgid).and_return(group_struct)
     end

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -56,7 +56,7 @@ describe Chef::Mixin::HomebrewUser do
     context "debug statement prints owner name" do
 
       before do
-        expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(:name => "name"))
+        expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(name: "name"))
       end
 
       it "returns the owner of the brew executable when it is at a default location" do

data/spec/unit/mixin/params_validate_spec.rb

@@ -34,7 +34,7 @@ describe Chef::Mixin::ParamsValidate do
   end
 
   it "should allow a hash and a hash as arguments to validate" do
-    expect { @vo.validate({ :one => "two" }, {}) }.not_to raise_error
+    expect { @vo.validate({ one: "two" }, {}) }.not_to raise_error
   end
 
   it "should raise an argument error if validate is called incorrectly" do
@@ -42,26 +42,26 @@ describe Chef::Mixin::ParamsValidate do
   end
 
   it "should require validation map keys to be symbols or strings" do
-    expect { @vo.validate({ :one => "two" }, { :one => true }) }.not_to raise_error
-    expect { @vo.validate({ :one => "two" }, { "one" => true }) }.not_to raise_error
-    expect { @vo.validate({ :one => "two" }, { Hash.new => true }) }.to raise_error(ArgumentError)
+    expect { @vo.validate({ one: "two" }, { one: true }) }.not_to raise_error
+    expect { @vo.validate({ one: "two" }, { "one" => true }) }.not_to raise_error
+    expect { @vo.validate({ one: "two" }, { Hash.new => true }) }.to raise_error(ArgumentError)
   end
 
   it "should allow options to be required with true" do
-    expect { @vo.validate({ :one => "two" }, { :one => true }) }.not_to raise_error
+    expect { @vo.validate({ one: "two" }, { one: true }) }.not_to raise_error
   end
 
   it "should allow options to be optional with false" do
-    expect { @vo.validate({}, { :one => false }) }.not_to raise_error
+    expect { @vo.validate({}, { one: false }) }.not_to raise_error
   end
 
   it "should allow you to check what kind_of? thing an argument is with kind_of" do
     expect do
       @vo.validate(
-        { :one => "string" },
+        { one: "string" },
         {
-          :one => {
-            :kind_of => String,
+          one: {
+            kind_of: String,
           },
         }
       )
@@ -69,10 +69,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :one => "string" },
+        { one: "string" },
         {
-          :one => {
-            :kind_of => Array,
+          one: {
+            kind_of: Array,
           },
         }
       )
@@ -82,10 +82,10 @@ describe Chef::Mixin::ParamsValidate do
   it "should allow you to specify an argument is required with required" do
     expect do
       @vo.validate(
-        { :one => "string" },
+        { one: "string" },
         {
-          :one => {
-            :required => true,
+          one: {
+            required: true,
           },
         }
       )
@@ -93,10 +93,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :two => "string" },
+        { two: "string" },
         {
-          :one => {
-            :required => true,
+          one: {
+            required: true,
           },
         }
       )
@@ -104,10 +104,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :two => "string" },
+        { two: "string" },
         {
-          :one => {
-            :required => false,
+          one: {
+            required: false,
           },
         }
       )
@@ -117,10 +117,10 @@ describe Chef::Mixin::ParamsValidate do
   it "should allow you to specify whether an object has a method with respond_to" do
     expect do
       @vo.validate(
-        { :one => @vo },
+        { one: @vo },
         {
-          :one => {
-            :respond_to => "validate",
+          one: {
+            respond_to: "validate",
           },
         }
       )
@@ -128,10 +128,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :one => @vo },
+        { one: @vo },
         {
-          :one => {
-            :respond_to => "monkey",
+          one: {
+            respond_to: "monkey",
           },
         }
       )
@@ -141,10 +141,10 @@ describe Chef::Mixin::ParamsValidate do
   it "should allow you to specify whether an object has all the given methods with respond_to and an array" do
     expect do
       @vo.validate(
-        { :one => @vo },
+        { one: @vo },
         {
-          :one => {
-            :respond_to => %w{validate music},
+          one: {
+            respond_to: %w{validate music},
           },
         }
       )
@@ -152,10 +152,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :one => @vo },
+        { one: @vo },
         {
-          :one => {
-            :respond_to => %w{monkey validate},
+          one: {
+            respond_to: %w{monkey validate},
           },
         }
       )
@@ -165,8 +165,8 @@ describe Chef::Mixin::ParamsValidate do
   it "should let you set a default value with default => value" do
     arguments = Hash.new
     @vo.validate(arguments, {
-      :one => {
-        :default => "is the loneliest number",
+      one: {
+        default: "is the loneliest number",
       },
     })
     expect(arguments[:one]).to eq("is the loneliest number")
@@ -175,10 +175,10 @@ describe Chef::Mixin::ParamsValidate do
   it "should let you check regular expressions" do
     expect do
       @vo.validate(
-        { :one => "is good" },
+        { one: "is good" },
         {
-          :one => {
-            :regex => /^is good$/,
+          one: {
+            regex: /^is good$/,
           },
         }
       )
@@ -186,10 +186,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :one => "is good" },
+        { one: "is good" },
         {
-          :one => {
-            :regex => /^is bad$/,
+          one: {
+            regex: /^is bad$/,
           },
         }
       )
@@ -199,10 +199,10 @@ describe Chef::Mixin::ParamsValidate do
   it "should let you specify your own callbacks" do
     expect do
       @vo.validate(
-        { :one => "is good" },
+        { one: "is good" },
         {
-          :one => {
-            :callbacks => {
+          one: {
+            callbacks: {
               "should be equal to is good" => lambda do |a|
                 a == "is good"
               end,
@@ -214,10 +214,10 @@ describe Chef::Mixin::ParamsValidate do
 
     expect do
       @vo.validate(
-        { :one => "is bad" },
+        { one: "is bad" },
         {
-          :one => {
-            :callbacks => {
+          one: {
+            callbacks: {
               "should be equal to 'is good'" => lambda do |a|
                 a == "is good"
               end,
@@ -229,27 +229,27 @@ describe Chef::Mixin::ParamsValidate do
   end
 
   it "should let you combine checks" do
-    args = { :one => "is good", :two => "is bad" }
+    args = { one: "is good", two: "is bad" }
     expect do
       @vo.validate(
         args,
         {
-          :one => {
-            :kind_of => String,
-            :respond_to => [ :to_s, :upcase ],
-            :regex => /^is good/,
-            :callbacks => {
+          one: {
+            kind_of: String,
+            respond_to: [ :to_s, :upcase ],
+            regex: /^is good/,
+            callbacks: {
               "should be your friend" => lambda do |a|
                 a == "is good"
               end,
             },
-            :required => true,
+            required: true,
           },
-          :two => {
-            :kind_of => String,
-            :required => false,
+          two: {
+            kind_of: String,
+            required: false,
           },
-          :three => { :default => "neato mosquito" },
+          three: { default: "neato mosquito" },
         }
       )
     end.not_to raise_error
@@ -258,22 +258,22 @@ describe Chef::Mixin::ParamsValidate do
       @vo.validate(
         args,
         {
-          :one => {
-            :kind_of => String,
-            :respond_to => [ :to_s, :upcase ],
-            :regex => /^is good/,
-            :callbacks => {
+          one: {
+            kind_of: String,
+            respond_to: [ :to_s, :upcase ],
+            regex: /^is good/,
+            callbacks: {
               "should be your friend" => lambda do |a|
                 a == "is good"
               end,
             },
-            :required => true,
+            required: true,
           },
-          :two => {
-            :kind_of => Hash,
-            :required => false,
+          two: {
+            kind_of: Hash,
+            required: false,
           },
-          :three => { :default => "neato mosquito" },
+          three: { default: "neato mosquito" },
         }
       )
     end.to raise_error(ArgumentError)
@@ -282,10 +282,10 @@ describe Chef::Mixin::ParamsValidate do
   it "should raise an ArgumentError if the validation map has an unknown check" do
     expect do
       @vo.validate(
-        { :one => "two" },
+        { one: "two" },
         {
-          :one => {
-            :busted => "check",
+          one: {
+            busted: "check",
           },
         }
       )
@@ -294,37 +294,37 @@ describe Chef::Mixin::ParamsValidate do
 
   it "should accept keys that are strings in the options" do
     expect do
-      @vo.validate({ "one" => "two" }, { :one => { :regex => /^two$/ } })
+      @vo.validate({ "one" => "two" }, { one: { regex: /^two$/ } })
     end.not_to raise_error
   end
 
   it "should allow an array to kind_of" do
     expect do
       @vo.validate(
-        { :one => "string" },
+        { one: "string" },
         {
-          :one => {
-            :kind_of => [ String, Array ],
+          one: {
+            kind_of: [ String, Array ],
           },
         }
       )
     end.not_to raise_error
     expect do
       @vo.validate(
-        { :one => ["string"] },
+        { one: ["string"] },
         {
-          :one => {
-            :kind_of => [ String, Array ],
+          one: {
+            kind_of: [ String, Array ],
           },
         }
       )
     end.not_to raise_error
     expect do
       @vo.validate(
-        { :one => Hash.new },
+        { one: Hash.new },
         {
-          :one => {
-            :kind_of => [ String, Array ],
+          one: {
+            kind_of: [ String, Array ],
           },
         }
       )
@@ -333,23 +333,23 @@ describe Chef::Mixin::ParamsValidate do
 
   it "asserts that a value returns false from a predicate method" do
     expect do
-      @vo.validate({ :not_blank => "should pass" },
-                   { :not_blank => { :cannot_be => [ :nil, :empty ] } })
+      @vo.validate({ not_blank: "should pass" },
+                   { not_blank: { cannot_be: [ :nil, :empty ] } })
     end.not_to raise_error
     expect do
-      @vo.validate({ :not_blank => "" },
-                   { :not_blank => { :cannot_be => [ :nil, :empty ] } })
+      @vo.validate({ not_blank: "" },
+                   { not_blank: { cannot_be: [ :nil, :empty ] } })
     end.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
   it "allows a custom validation message" do
     expect do
-      @vo.validate({ :not_blank => "should pass" },
-                   { :not_blank => { :cannot_be => [ :nil, :empty ], validation_message: "my validation message" } })
+      @vo.validate({ not_blank: "should pass" },
+                   { not_blank: { cannot_be: [ :nil, :empty ], validation_message: "my validation message" } })
     end.not_to raise_error
     expect do
-      @vo.validate({ :not_blank => "" },
-                   { :not_blank => { :cannot_be => [ :nil, :empty ], validation_message: "my validation message" } })
+      @vo.validate({ not_blank: "" },
+                   { not_blank: { cannot_be: [ :nil, :empty ], validation_message: "my validation message" } })
     end.to raise_error(Chef::Exceptions::ValidationFailed, "my validation message")
   end
 
@@ -361,38 +361,38 @@ describe Chef::Mixin::ParamsValidate do
 
   it "should set and return a default value when the argument is nil, then return the same value" do
     value = "meow"
-    expect(@vo.set_or_return(:test, nil, { :default => value }).object_id).to eq(value.object_id)
+    expect(@vo.set_or_return(:test, nil, { default: value }).object_id).to eq(value.object_id)
     expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
   end
 
   it "should raise an ArgumentError when argument is nil and required is true" do
     expect do
-      @vo.set_or_return(:test, nil, { :required => true })
+      @vo.set_or_return(:test, nil, { required: true })
     end.to raise_error(ArgumentError)
   end
 
   it "should not raise an error when argument is nil and required is false" do
     expect do
-      @vo.set_or_return(:test, nil, { :required => false })
+      @vo.set_or_return(:test, nil, { required: false })
     end.not_to raise_error
   end
 
   it "should set and return @name, then return @name for foo when argument is nil" do
     value = "meow"
     expect(@vo.set_or_return(:name, value, {}).object_id).to eq(value.object_id)
-    expect(@vo.set_or_return(:foo, nil, { :name_attribute => true }).object_id).to eq(value.object_id)
+    expect(@vo.set_or_return(:foo, nil, { name_attribute: true }).object_id).to eq(value.object_id)
   end
 
   it "should allow DelayedEvaluator instance to be set for value regardless of restriction" do
     value = Chef::DelayedEvaluator.new { "test" }
-    @vo.set_or_return(:test, value, { :kind_of => Numeric })
+    @vo.set_or_return(:test, value, { kind_of: Numeric })
   end
 
   it "should raise an error when delayed evaluated attribute is not valid" do
     value = Chef::DelayedEvaluator.new { "test" }
-    @vo.set_or_return(:test, value, { :kind_of => Numeric })
+    @vo.set_or_return(:test, value, { kind_of: Numeric })
     expect do
-      @vo.set_or_return(:test, nil, { :kind_of => Numeric })
+      @vo.set_or_return(:test, nil, { kind_of: Numeric })
     end.to raise_error(Chef::Exceptions::ValidationFailed)
   end