chef 14.14.29 → 14.15.6

data/spec/unit/lwrp_spec.rb

@@ -199,7 +199,7 @@ describe "LWRP" do
     end
 
     it "should create a method for each attribute" do
-      expect(get_lwrp(:lwrp_foo).new("blah").methods.map { |m| m.to_sym }).to include(:monkey)
+      expect(get_lwrp(:lwrp_foo).new("blah").methods.map(&:to_sym)).to include(:monkey)
     end
 
     it "should build attribute methods that respect validation rules" do
@@ -264,12 +264,12 @@ describe "LWRP" do
       let(:lwrp) do
         Class.new(Chef::Resource::LWRPBase) do
           actions :eat, :sleep
-          default_action [:eat, :sleep]
+          default_action %i{eat sleep}
         end
       end
 
       it "returns the array of default actions" do
-        expect(lwrp.default_action).to eq([:eat, :sleep])
+        expect(lwrp.default_action).to eq(%i{eat sleep})
       end
     end
 
@@ -287,7 +287,7 @@ describe "LWRP" do
         end
 
         it "delegates #actions to the parent" do
-          expect(child.actions).to eq([:nothing, :eat, :sleep])
+          expect(child.actions).to eq(%i{nothing eat sleep})
         end
 
         it "delegates #default_action to the parent" do
@@ -304,7 +304,7 @@ describe "LWRP" do
         end
 
         it "does not delegate #actions to the parent" do
-          expect(child.actions).to eq([:nothing, :dont_eat, :dont_sleep])
+          expect(child.actions).to eq(%i{nothing dont_eat dont_sleep})
         end
 
         it "does not delegate #default_action to the parent" do
@@ -322,7 +322,7 @@ describe "LWRP" do
         end
 
         it "amends actions when they are already defined" do
-          expect(child.actions).to eq([:nothing, :eat, :sleep, :drink])
+          expect(child.actions).to eq(%i{nothing eat sleep drink})
         end
       end
     end
@@ -330,40 +330,40 @@ describe "LWRP" do
     describe "when actions is set to an array" do
       let(:resource_class) do
         Class.new(Chef::Resource::LWRPBase) do
-          actions [ :eat, :sleep ]
+          actions %i{eat sleep}
         end
       end
       let(:resource) do
         resource_class.new("blah")
       end
       it "actions includes those actions" do
-        expect(resource_class.actions).to eq [ :nothing, :eat, :sleep ]
+        expect(resource_class.actions).to eq %i{nothing eat sleep}
       end
       it "allowed_actions includes those actions" do
-        expect(resource_class.allowed_actions).to eq [ :nothing, :eat, :sleep ]
+        expect(resource_class.allowed_actions).to eq %i{nothing eat sleep}
       end
       it "resource.allowed_actions includes those actions" do
-        expect(resource.allowed_actions).to eq [ :nothing, :eat, :sleep ]
+        expect(resource.allowed_actions).to eq %i{nothing eat sleep}
       end
     end
 
     describe "when allowed_actions is set to an array" do
       let(:resource_class) do
         Class.new(Chef::Resource::LWRPBase) do
-          allowed_actions [ :eat, :sleep ]
+          allowed_actions %i{eat sleep}
         end
       end
       let(:resource) do
         resource_class.new("blah")
       end
       it "actions includes those actions" do
-        expect(resource_class.actions).to eq [ :nothing, :eat, :sleep ]
+        expect(resource_class.actions).to eq %i{nothing eat sleep}
       end
       it "allowed_actions includes those actions" do
-        expect(resource_class.allowed_actions).to eq [ :nothing, :eat, :sleep ]
+        expect(resource_class.allowed_actions).to eq %i{nothing eat sleep}
       end
       it "resource.allowed_actions includes those actions" do
-        expect(resource.allowed_actions).to eq [ :nothing, :eat, :sleep ]
+        expect(resource.allowed_actions).to eq %i{nothing eat sleep}
       end
     end
   end
@@ -590,7 +590,7 @@ describe "LWRP" do
 
     it "get_lwrp(:lwrp_once).new is an instance of the LWRP class" do
       lwrp = get_lwrp(:lwrp_once).new("hi")
-      expect(lwrp.kind_of?(test_lwrp_class)).to be_truthy
+      expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
       expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
       expect(get_lwrp(:lwrp_once) === lwrp).to be_truthy
       expect(test_lwrp_class === lwrp).to be_truthy
@@ -603,28 +603,28 @@ describe "LWRP" do
 
       it "subclass.new is a subclass" do
         lwrp = subclass.new("hi")
-        expect(lwrp.kind_of?(subclass)).to be_truthy
+        expect(lwrp.is_a?(subclass)).to be_truthy
         expect(lwrp.is_a?(subclass)).to be_truthy
         expect(subclass === lwrp).to be_truthy
         expect(lwrp.class === subclass)
       end
       it "subclass.new is an instance of the LWRP class" do
         lwrp = subclass.new("hi")
-        expect(lwrp.kind_of?(test_lwrp_class)).to be_truthy
+        expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
         expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
         expect(test_lwrp_class === lwrp).to be_truthy
         expect(lwrp.class === test_lwrp_class)
       end
       it "subclass.new is a get_lwrp(:lwrp_once)" do
         lwrp = subclass.new("hi")
-        expect(lwrp.kind_of?(get_lwrp(:lwrp_once))).to be_truthy
+        expect(lwrp.is_a?(get_lwrp(:lwrp_once))).to be_truthy
         expect(lwrp.is_a?(get_lwrp(:lwrp_once))).to be_truthy
         expect(get_lwrp(:lwrp_once) === lwrp).to be_truthy
         expect(lwrp.class === get_lwrp(:lwrp_once))
       end
       it "get_lwrp(:lwrp_once).new is *not* a subclass" do
         lwrp = get_lwrp(:lwrp_once).new("hi")
-        expect(lwrp.kind_of?(subclass)).to be_falsey
+        expect(lwrp.is_a?(subclass)).to be_falsey
         expect(lwrp.is_a?(subclass)).to be_falsey
         expect(subclass === lwrp.class).to be_falsey
         expect(subclass === get_lwrp(:lwrp_once)).to be_falsey

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -48,7 +48,7 @@ describe Chef::Mixin::HomebrewUser do
     let(:brew_owner) { 2001 }
     let(:default_brew_path) { "/usr/local/bin/brew" }
     let(:stat_double) do
-      d = double()
+      d = double
       expect(d).to receive(:uid).and_return(brew_owner)
       d
     end

data/spec/unit/mixin/params_validate_spec.rb

@@ -30,7 +30,7 @@ end
 
 describe Chef::Mixin::ParamsValidate do
   before(:each) do
-    @vo = TinyClass.new()
+    @vo = TinyClass.new
   end
 
   it "should allow a hash and a hash as arguments to validate" do
@@ -44,7 +44,7 @@ describe Chef::Mixin::ParamsValidate do
   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" }, { {} => true }) }.to raise_error(ArgumentError)
   end
 
   it "should allow options to be required with true" do
@@ -163,7 +163,7 @@ describe Chef::Mixin::ParamsValidate do
   end
 
   it "should let you set a default value with default => value" do
-    arguments = Hash.new
+    arguments = {}
     @vo.validate(arguments, {
       one: {
         default: "is the loneliest number",
@@ -236,7 +236,7 @@ describe Chef::Mixin::ParamsValidate do
         {
           one: {
             kind_of: String,
-            respond_to: [ :to_s, :upcase ],
+            respond_to: %i{to_s upcase},
             regex: /^is good/,
             callbacks: {
               "should be your friend" => lambda do |a|
@@ -260,7 +260,7 @@ describe Chef::Mixin::ParamsValidate do
         {
           one: {
             kind_of: String,
-            respond_to: [ :to_s, :upcase ],
+            respond_to: %i{to_s upcase},
             regex: /^is good/,
             callbacks: {
               "should be your friend" => lambda do |a|
@@ -321,7 +321,7 @@ describe Chef::Mixin::ParamsValidate do
     end.not_to raise_error
     expect do
       @vo.validate(
-        { one: Hash.new },
+        { one: {} },
         {
           one: {
             kind_of: [ String, Array ],
@@ -334,22 +334,22 @@ 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 ] } })
+        { not_blank: { cannot_be: %i{nil empty} } })
     end.not_to raise_error
     expect do
       @vo.validate({ not_blank: "" },
-                   { not_blank: { cannot_be: [ :nil, :empty ] } })
+        { not_blank: { cannot_be: %i{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" } })
+        { not_blank: { cannot_be: %i{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" } })
+        { not_blank: { cannot_be: %i{nil empty}, validation_message: "my validation message" } })
     end.to raise_error(Chef::Exceptions::ValidationFailed, "my validation message")
   end
 

data/spec/unit/mixin/properties_spec.rb

@@ -31,7 +31,7 @@ module ChefMixinPropertiesSpec
           end
 
           it "A.properties has a, ab, and ac with types 'a', ['a', 'b'], and ['b', 'c']" do
-            expect(A.properties.keys).to eq [ :a, :ab, :ac, :d ]
+            expect(A.properties.keys).to eq %i{a ab ac d}
             expect(A.properties[:a].validation_options[:is]).to eq "a"
             expect(A.properties[:ab].validation_options[:is]).to eq %w{a b}
             expect(A.properties[:ac].validation_options[:is]).to eq %w{a c}
@@ -46,13 +46,13 @@ module ChefMixinPropertiesSpec
           end
 
           it "B.properties has b, ab, and bc with types 'b', nil and ['b', 'c']" do
-            expect(B.properties.keys).to eq [ :b, :ab, :bc ]
+            expect(B.properties.keys).to eq %i{b ab bc}
             expect(B.properties[:b].validation_options[:is]).to eq "b"
             expect(B.properties[:ab].validation_options[:is]).to be_nil
             expect(B.properties[:bc].validation_options[:is]).to eq %w{b c}
           end
           it "C.properties has a, b, c, ac and bc with merged types" do
-            expect(C.properties.keys).to eq [ :a, :ab, :ac, :d, :b, :bc, :c ]
+            expect(C.properties.keys).to eq %i{a ab ac d b bc c}
             expect(C.properties[:a].validation_options[:is]).to eq "a"
             expect(C.properties[:b].validation_options[:is]).to eq "b"
             expect(C.properties[:c].validation_options[:is]).to eq "c"
@@ -99,7 +99,7 @@ module ChefMixinPropertiesSpec
         end
 
         it "Outerest.properties.validation_options[:is] inner, outer, outerest" do
-          expect(Outerest.properties.keys).to eq [:inner, :outer, :outerest]
+          expect(Outerest.properties.keys).to eq %i{inner outer outerest}
         end
       end
     end

data/spec/unit/mixin/shell_out_spec.rb

@@ -51,7 +51,7 @@ describe Chef::Mixin::ShellOut do
     let(:retobj) { instance_double(Mixlib::ShellOut, "error!" => false) }
     let(:cmd) { "echo '#{rand(1000)}'" }
 
-    [ :shell_out, :shell_out_compact, :shell_out_compact_timeout, :shell_out!, :shell_out_compact!, :shell_out_compact_timeout! ].each do |method|
+    %i{shell_out shell_out_compact shell_out_compact_timeout shell_out! shell_out_compact! shell_out_compact_timeout!}.each do |method|
       describe "##{method}" do
         before do
           Chef::Config[:treat_deprecation_warnings_as_errors] = false
@@ -75,11 +75,11 @@ describe Chef::Mixin::ShellOut do
               options = { environment: { "HOME" => "/Users/morty" } }
               expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, {
                 environment: {
-                  "HOME"     => "/Users/morty",
-                  "LC_ALL"   => Chef::Config[:internal_locale],
-                  "LANG"     => Chef::Config[:internal_locale],
+                  "HOME" => "/Users/morty",
+                  "LC_ALL" => Chef::Config[:internal_locale],
+                  "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path   => sanitized_path,
+                  env_path => sanitized_path,
                 },
               }).and_return(retobj)
               shell_out_obj.send(method, cmd, options)
@@ -89,11 +89,11 @@ describe Chef::Mixin::ShellOut do
               options = { environment: { "HOME" => "/Users/morty" } }
               expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, {
                 environment: {
-                  "HOME"     => "/Users/morty",
-                  "LC_ALL"   => Chef::Config[:internal_locale],
-                  "LANG"     => Chef::Config[:internal_locale],
+                  "HOME" => "/Users/morty",
+                  "LC_ALL" => Chef::Config[:internal_locale],
+                  "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path   => sanitized_path,
+                  env_path => sanitized_path,
                 },
               }).and_return(retobj)
               shell_out_obj.send(method, cmd, options)
@@ -118,11 +118,11 @@ describe Chef::Mixin::ShellOut do
               options = { env: { "HOME" => "/Users/morty" } }
               expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, {
                 env: {
-                  "HOME"     => "/Users/morty",
-                  "LC_ALL"   => Chef::Config[:internal_locale],
-                  "LANG"     => Chef::Config[:internal_locale],
+                  "HOME" => "/Users/morty",
+                  "LC_ALL" => Chef::Config[:internal_locale],
+                  "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path   => sanitized_path,
+                  env_path => sanitized_path,
                 },
               }).and_return(retobj)
               shell_out_obj.send(method, cmd, options)
@@ -132,11 +132,11 @@ describe Chef::Mixin::ShellOut do
               options = { env: { "HOME" => "/Users/morty" } }
               expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, {
                 env: {
-                  "HOME"     => "/Users/morty",
-                  "LC_ALL"   => Chef::Config[:internal_locale],
-                  "LANG"     => Chef::Config[:internal_locale],
+                  "HOME" => "/Users/morty",
+                  "LC_ALL" => Chef::Config[:internal_locale],
+                  "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path   => sanitized_path,
+                  env_path => sanitized_path,
                 },
               }).and_return(retobj)
               shell_out_obj.send(method, cmd, options)
@@ -150,10 +150,10 @@ describe Chef::Mixin::ShellOut do
               expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, {
                 user: "morty",
                 environment: {
-                  "LC_ALL"   => Chef::Config[:internal_locale],
-                  "LANG"     => Chef::Config[:internal_locale],
+                  "LC_ALL" => Chef::Config[:internal_locale],
+                  "LANG" => Chef::Config[:internal_locale],
                   "LANGUAGE" => Chef::Config[:internal_locale],
-                  env_path   => sanitized_path,
+                  env_path => sanitized_path,
                 },
               }).and_return(retobj)
               shell_out_obj.send(method, cmd, options)
@@ -165,10 +165,10 @@ describe Chef::Mixin::ShellOut do
           it "should set environment language settings to the configured internal locale" do
             expect(Chef::Mixin::ShellOut).to receive(:shell_out_command).with(cmd, {
               environment: {
-                "LC_ALL"   => Chef::Config[:internal_locale],
-                "LANG"     => Chef::Config[:internal_locale],
+                "LC_ALL" => Chef::Config[:internal_locale],
+                "LANG" => Chef::Config[:internal_locale],
                 "LANGUAGE" => Chef::Config[:internal_locale],
-                env_path   => sanitized_path,
+                env_path => sanitized_path,
               },
             }).and_return(retobj)
             shell_out_obj.send(method, cmd)
@@ -301,7 +301,7 @@ describe Chef::Mixin::ShellOut do
     end
 
     describe "deprecations" do
-      [ :shell_out_with_systems_locale, :shell_out_compact, :shell_out_compact_timeout, :shell_out_with_systems_locale!, :shell_out_compact!, :shell_out_compact_timeout! ].each do |method|
+      %i{shell_out_with_systems_locale shell_out_compact shell_out_compact_timeout shell_out_with_systems_locale! shell_out_compact! shell_out_compact_timeout!}.each do |method|
         it "should not respond to #{method} in Chef-15", chef: ">= 15" do
           expect(shell_out_obj.respond_to?(method)).to be false
         end
@@ -341,7 +341,7 @@ describe Chef::Mixin::ShellOut do
       end
 
       describe "on Chef-15", chef: ">= 15" do
-        [ :shell_out, :shell_out! ].each do |method|
+        %i{shell_out shell_out!}.each do |method|
           stubbed_method = (method == :shell_out) ? :shell_out_compacted : :shell_out_compacted!
           it "#{method} defaults to 900 seconds" do
             expect(provider).to receive(stubbed_method).with("foo", timeout: 900)
@@ -377,7 +377,7 @@ describe Chef::Mixin::ShellOut do
       let(:new_resource) { Chef::Resource::Package.new("foo") }
       let(:provider) { new_resource.provider_for_action(:install) }
 
-      [ :shell_out, :shell_out! ].each do |method|
+      %i{shell_out shell_out!}.each do |method|
         stubbed_method = (method == :shell_out) ? :shell_out_compacted : :shell_out_compacted!
         it "#{method} defaults to 900 seconds" do
           expect(provider).to receive(stubbed_method).with("foo", timeout: 900)
@@ -416,7 +416,7 @@ describe Chef::Mixin::ShellOut do
         Chef::Config[:treat_deprecation_warnings_as_errors] = false
       end
 
-      [ :shell_out_compact_timeout, :shell_out_compact_timeout! ].each do |method|
+      %i{shell_out_compact_timeout shell_out_compact_timeout!}.each do |method|
         stubbed_method = (method == :shell_out_compact_timeout) ? :shell_out_compacted : :shell_out_compacted!
         it "#{method} defaults to 900 seconds" do
           expect(provider).to receive(stubbed_method).with("foo", timeout: 900)

data/spec/unit/mixin/template_spec.rb

@@ -242,17 +242,13 @@ describe Chef::Mixin::Template, "render_template" do
 
       it "emits a warning when overriding 'core' methods" do
         mod = Module.new do
-          def render
-          end
+          def render; end
 
-          def node
-          end
+          def node; end
 
-          def render_template
-          end
+          def render_template; end
 
-          def render_template_from_string
-          end
+          def render_template_from_string; end
         end
         %w{node render render_template render_template_from_string}.each do |method_name|
           expect(Chef::Log).to receive(:warn).with(/^Core template method `#{method_name}' overridden by extension module/)

data/spec/unit/mixin/unformatter_spec.rb

@@ -22,8 +22,7 @@ require "chef/mixin/unformatter"
 class Chef::UnformatterTest
   include Chef::Mixin::Unformatter
 
-  def foo
-  end
+  def foo; end
 
 end
 

data/spec/unit/mixin/user_context_spec.rb

@@ -56,8 +56,7 @@ describe "a class that mixes in user_context" do
 
       let(:block_object) do
         class BlockClass
-          def block_method
-          end
+          def block_method; end
         end
         BlockClass.new
       end

data/spec/unit/mixin/which.rb

@@ -88,11 +88,13 @@ describe Chef::Mixin::Which do
 
       test_which("passes in the filename as the arg", "foo1", finds: "/dir1/foo1") do |f|
         raise "bad arg to block" unless f == "/dir1/foo1"
+
         true
       end
 
       test_which("arrays with blocks", "foo1", "foo2", finds: "/dir2/foo1", others: [ "/dir1/foo2" ]) do |f|
         raise "bad arg to block" unless f == "/dir2/foo1" || f == "/dir1/foo2"
+
         true
       end
     end