chef 15.1.36 → 15.2.20

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! ].each do |method|
+    %i{shell_out shell_out!}.each do |method|
       describe "##{method}" do
 
         describe "when the last argument is a Hash" do
@@ -248,7 +248,7 @@ describe Chef::Mixin::ShellOut do
       let(:provider) { new_resource.provider_for_action(:install) }
 
       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)
@@ -284,7 +284,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)

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

data/spec/unit/mixin/windows_architecture_helper_spec.rb

@@ -23,7 +23,7 @@ describe Chef::Mixin::WindowsArchitectureHelper do
   include Chef::Mixin::WindowsArchitectureHelper
 
   before do
-    @valid_architectures = [ :i386, :x86_64 ]
+    @valid_architectures = %i{i386 x86_64}
     @invalid_architectures = [ "i386", "x86_64", :x64, :x86, :arm ]
 
     @node_i386 = Chef::Node.new
@@ -67,14 +67,14 @@ describe Chef::Mixin::WindowsArchitectureHelper do
   it "returns true only when forced_32bit_override_required? has 64-bit node architecture and 32-bit desired architecture" do
     with_node_architecture_combinations do |node, desired_arch|
       expect(forced_32bit_override_required?(node, desired_arch)).to be true if (node_windows_architecture(node) == :x86_64) && (desired_arch == :i386) && !is_i386_process_on_x86_64_windows?
-      expect(forced_32bit_override_required?(node, desired_arch)).to be false if ! ((node_windows_architecture(node) == :x86_64) && (desired_arch == :i386))
+      expect(forced_32bit_override_required?(node, desired_arch)).to be false unless (node_windows_architecture(node) == :x86_64) && (desired_arch == :i386)
     end
   end
 
   def with_node_architecture_combinations
     @valid_architectures.each do |node_architecture|
       new_node = Chef::Node.new
-      new_node.default["kernel"] = Hash.new
+      new_node.default["kernel"] = {}
       new_node.default["kernel"][:machine] = node_architecture.to_s
 
       @valid_architectures.each do |architecture|

data/spec/unit/node/attribute_spec.rb

@@ -80,9 +80,9 @@ describe Chef::Node::Attribute do
                                                     "mtu" => "1500",
                                                     "media" => { "supported" => { "autoselect" => { "options" => [] },
                                                                                   "none" => { "options" => [] },
-                                                                                  "1000baseT" => { "options" => ["full-duplex", "flow-control", "hw-loopback"] },
-                                                                                  "10baseT/UTP" => { "options" => ["half-duplex", "full-duplex", "flow-control", "hw-loopback"] },
-                                                                                  "100baseTX" => { "options" => ["half-duplex", "full-duplex", "flow-control", "hw-loopback"] } },
+                                                                                  "1000baseT" => { "options" => %w{full-duplex flow-control hw-loopback} },
+                                                                                  "10baseT/UTP" => { "options" => %w{half-duplex full-duplex flow-control hw-loopback} },
+                                                                                  "100baseTX" => { "options" => %w{half-duplex full-duplex flow-control hw-loopback} } },
                                                                  "selected" => { "autoselect" => { "options" => [] } } },
                                                     "type" => "en",
                                                     "encapsulation" => "Ethernet" },
@@ -182,7 +182,7 @@ describe Chef::Node::Attribute do
       expect { Chef::Node::Attribute.new({}, {}, {}, {}) }.not_to raise_error
     end
 
-    [ :normal, :default, :override, :automatic ].each do |accessor|
+    %i{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 })
         expect(na.send(accessor)).to eq({ accessor.to_s => true })
@@ -546,7 +546,7 @@ describe Chef::Node::Attribute do
       expect(@attributes["music"]["this"]).not_to have_key("must")
     end
 
-    [:include?, :key?, :member?].each do |method|
+    %i{include? key? member?}.each do |method|
       it "should alias the method #{method} to itself" do
         expect(@attributes).to respond_to(method)
       end
@@ -589,7 +589,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield each top level key" do
-      collect = Array.new
+      collect = []
       @attributes.each_key do |k|
         collect << k
       end
@@ -602,7 +602,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield lower if we go deeper" do
-      collect = Array.new
+      collect = []
       @attributes["one"].each_key do |k|
         collect << k
       end
@@ -637,7 +637,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield each top level key and value, post merge rules" do
-      collect = Hash.new
+      collect = {}
       @attributes.each do |k, v|
         collect[k] = v
       end
@@ -679,7 +679,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield each top level key, post merge rules" do
-      collect = Array.new
+      collect = []
       @attributes.each_key do |k|
         collect << k
       end
@@ -715,7 +715,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield each top level key and value pair, post merge rules" do
-      collect = Hash.new
+      collect = {}
       @attributes.each_pair do |k, v|
         collect[k] = v
       end
@@ -751,7 +751,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield each value, post merge rules" do
-      collect = Array.new
+      collect = []
       @attributes.each_value do |v|
         collect << v
       end
@@ -762,7 +762,7 @@ describe Chef::Node::Attribute do
     end
 
     it "should yield four elements" do
-      collect = Array.new
+      collect = []
       @attributes.each_value do |v|
         collect << v
       end

data/spec/unit/node/immutable_collections_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2018, Chef Software Inc.
+# Copyright:: Copyright 2012-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -145,25 +145,25 @@ describe Chef::Node::ImmutableMash do
     end
   end
 
-  [
-    :[]=,
-    :clear,
-    :default=,
-    :default_proc=,
-    :delete,
-    :delete_if,
-    :keep_if,
-    :merge!,
-    :update,
-    :reject!,
-    :replace,
-    :select!,
-    :shift,
-    :write,
-    :write!,
-    :unlink,
-    :unlink!,
-  ].each do |mutator|
+  %i{
+    []=
+    clear
+    default=
+    default_proc=
+    delete
+    delete_if
+    keep_if
+    merge!
+    update
+    reject!
+    replace
+    select!
+    shift
+    write
+    write!
+    unlink
+    unlink!
+  }.each do |mutator|
     it "doesn't allow mutation via `#{mutator}'" do
       expect { @immutable_mash.send(mutator) }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end
@@ -190,36 +190,36 @@ describe Chef::Node::ImmutableArray do
   # with ImmutableMash, above
   ###
 
-  [
-    :<<,
-    :[]=,
-    :clear,
-    :collect!,
-    :compact!,
-    :default=,
-    :default_proc=,
-    :delete,
-    :delete_at,
-    :delete_if,
-    :fill,
-    :flatten!,
-    :insert,
-    :keep_if,
-    :map!,
-    :merge!,
-    :pop,
-    :push,
-    :reject!,
-    :reverse!,
-    :replace,
-    :select!,
-    :shift,
-    :slice!,
-    :sort!,
-    :sort_by!,
-    :uniq!,
-    :unshift,
-  ].each do |mutator|
+  %i{
+    <<
+    []=
+    clear
+    collect!
+    compact!
+    default=
+    default_proc=
+    delete
+    delete_at
+    delete_if
+    fill
+    flatten!
+    insert
+    keep_if
+    map!
+    merge!
+    pop
+    push
+    reject!
+    reverse!
+    replace
+    select!
+    shift
+    slice!
+    sort!
+    sort_by!
+    uniq!
+    unshift
+  }.each do |mutator|
     it "does not allow mutation via `#{mutator}" do
       expect { @immutable_array.send(mutator) }.to raise_error(Chef::Exceptions::ImmutableAttributeModification)
     end

data/spec/unit/node/vivid_mash_spec.rb

@@ -421,8 +421,8 @@ describe Chef::Node::AttrArray do
   context "#compact!" do
     it "VividMashes remain VividMashes" do
       array = Chef::Node::AttrArray.new(
-          [ nil, { "one" => "two" }, nil ],
-          root
+        [ nil, { "one" => "two" }, nil ],
+        root
       )
       expect(array[1].class).to eql(Chef::Node::VividMash)
       array.compact!
@@ -440,8 +440,8 @@ describe Chef::Node::AttrArray do
   context "#flatten!" do
     it "flattens sub-arrays maintaining VividMashes in them" do
       array = Chef::Node::AttrArray.new(
-          [ [ { "one" => "two" } ], [ { "one" => "two" } ] ],
-          root
+        [ [ { "one" => "two" } ], [ { "one" => "two" } ] ],
+        root
       )
       expect(array[0][0].class).to eql(Chef::Node::VividMash)
       array.flatten!