chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

data/spec/unit/mixin/deprecation_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/mixin/deprecation'
+require "spec_helper"
+require "chef/mixin/deprecation"
 
 describe Chef::Mixin do
   describe "deprecating constants (Class/Module)" do
@@ -46,7 +46,7 @@ describe Chef::Mixin::Deprecation::DeprecatedInstanceVariable do
   before do
     Chef::Log.logger = Logger.new(StringIO.new)
 
-    @deprecated_ivar = Chef::Mixin::Deprecation::DeprecatedInstanceVariable.new('value', 'an_ivar')
+    @deprecated_ivar = Chef::Mixin::Deprecation::DeprecatedInstanceVariable.new("value", "an_ivar")
   end
 
   it "forward method calls to the target object" do

data/spec/unit/mixin/enforce_ownership_and_permissions_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Mark Mzyk (<mmzyk@opscode.com>)
-# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Author:: Mark Mzyk (<mmzyk@chef.io>)
+# Copyright:: Copyright 2011-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,9 +16,9 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'etc'
-require 'ostruct'
+require "spec_helper"
+require "etc"
+require "ostruct"
 
 describe Chef::Mixin::EnforceOwnershipAndPermissions do
 
@@ -52,8 +52,8 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
       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')
+                                     :uid => 0, :gid => 0, :dir => "/root",
+                                     :shell => "/bin/bash")
 
       group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
       allow(Etc).to receive(:getpwuid).and_return(passwd_struct)
@@ -76,8 +76,8 @@ describe Chef::Mixin::EnforceOwnershipAndPermissions do
       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')
+                                     :uid => 0, :gid => 0, :dir => "/root",
+                                     :shell => "/bin/bash")
 
       group_struct = OpenStruct.new(:name => "root", :passwd => "x", :gid => 0)
       allow(Etc).to receive(:getpwuid).and_return(passwd_struct)

data/spec/unit/mixin/homebrew_user_spec.rb

@@ -1,7 +1,7 @@
 #
-# Author:: Joshua Timberman (<joshua@getchef.com>)
+# Author:: Joshua Timberman (<joshua@chef.io>)
 #
-# Copyright 2014, Chef Software, Inc <legal@getchef.com>
+# Copyright 2014-2016, Chef Software, Inc <legal@chef.io>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,8 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
-require 'chef/mixin/homebrew_user'
+require "spec_helper"
+require "chef/mixin/homebrew_user"
 
 class ExampleHomebrewUser
   include Chef::Mixin::HomebrewUser
@@ -24,22 +24,22 @@ end
 
 describe Chef::Mixin::HomebrewUser do
   before(:each) do
-    node.default['homebrew']['owner'] = nil
+    node.default["homebrew"]["owner"] = nil
   end
 
   let(:homebrew_user) { ExampleHomebrewUser.new }
   let(:node) { Chef::Node.new }
 
-  describe 'when the homebrew user is provided' do
+  describe "when the homebrew user is provided" do
     let(:uid) { 1001 }
     let(:user) { "foo" }
 
-    it 'returns the homebrew user without looking at the file when uid is provided' do
+    it "returns the homebrew user without looking at the file when uid is provided" do
       expect(File).to receive(:exist?).exactly(0).times
       expect(homebrew_user.find_homebrew_uid(uid)).to eq(uid)
     end
 
-    it 'returns the homebrew user without looking at the file when name is provided' do
+    it "returns the homebrew user without looking at the file when name is provided" do
       expect(File).to receive(:exist?).exactly(0).times
       allow(Etc).to receive_message_chain(:getpwnam, :uid).and_return(uid)
       expect(homebrew_user.find_homebrew_uid(user)).to eq(uid)
@@ -50,7 +50,7 @@ describe Chef::Mixin::HomebrewUser do
   shared_examples "successfully find executable" do
     let(:user) { nil }
     let(:brew_owner) { 2001 }
-    let(:default_brew_path) { '/usr/local/bin/brew' }
+    let(:default_brew_path) { "/usr/local/bin/brew" }
     let(:stat_double) {
       d = double()
       expect(d).to receive(:uid).and_return(brew_owner)
@@ -63,13 +63,13 @@ describe Chef::Mixin::HomebrewUser do
         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
+      it "returns the owner of the brew executable when it is at a default location" do
         expect(File).to receive(:exist?).with(default_brew_path).and_return(true)
         expect(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
-      it 'returns the owner of the brew executable when it is not at a default location' do
+      it "returns the owner of the brew executable when it is not at a default location" do
         expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
         allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("/foo")
         expect(File).to receive(:stat).with("/foo").and_return(stat_double)
@@ -79,9 +79,9 @@ describe Chef::Mixin::HomebrewUser do
     end
   end
 
-  describe 'when the homebrew user is not provided' do
+  describe "when the homebrew user is not provided" do
 
-    it 'raises an error if no executable is found' do
+    it "raises an error if no executable is found" do
       expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
       allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("")
       expect { homebrew_user.find_homebrew_uid(user) }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewOwner)

data/spec/unit/mixin/params_validate_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,25 +16,25 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 class TinyClass
   include Chef::Mixin::ParamsValidate
 
   attr_reader :name
 
-  def music(is_good=true)
+  def music(is_good = true)
     is_good
   end
 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
-    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,39 +42,39 @@ 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 {
       @vo.validate(
-        {:one => "string"},
+        { :one => "string" },
         {
           :one => {
             :kind_of => String
           }
-        }
+        },
       )
     }.not_to raise_error
 
     expect {
       @vo.validate(
-        {:one => "string"},
+        { :one => "string" },
         {
           :one => {
             :kind_of => Array
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
@@ -82,34 +82,34 @@ describe Chef::Mixin::ParamsValidate do
   it "should allow you to specify an argument is required with required" do
     expect {
       @vo.validate(
-        {:one => "string"},
+        { :one => "string" },
         {
           :one => {
             :required => true
           }
-        }
+        },
       )
     }.not_to raise_error
 
     expect {
       @vo.validate(
-        {:two => "string"},
+        { :two => "string" },
         {
           :one => {
             :required => true
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
 
     expect {
       @vo.validate(
-        {:two => "string"},
+        { :two => "string" },
         {
           :one => {
             :required => false
           }
-        }
+        },
       )
     }.not_to raise_error
   end
@@ -117,23 +117,23 @@ describe Chef::Mixin::ParamsValidate do
   it "should allow you to specify whether an object has a method with respond_to" do
     expect {
       @vo.validate(
-        {:one => @vo},
+        { :one => @vo },
         {
           :one => {
             :respond_to => "validate"
           }
-        }
+        },
       )
     }.not_to raise_error
 
     expect {
       @vo.validate(
-        {:one => @vo},
+        { :one => @vo },
         {
           :one => {
             :respond_to => "monkey"
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
@@ -141,23 +141,23 @@ 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 {
       @vo.validate(
-        {:one => @vo},
+        { :one => @vo },
         {
           :one => {
             :respond_to => ["validate", "music"]
           }
-        }
+        },
       )
     }.not_to raise_error
 
     expect {
       @vo.validate(
-        {:one => @vo},
+        { :one => @vo },
         {
           :one => {
             :respond_to => ["monkey", "validate"]
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
@@ -168,7 +168,7 @@ describe Chef::Mixin::ParamsValidate do
       :one => {
         :default => "is the loneliest number"
       }
-    })
+    },)
     expect(arguments[:one]).to eq("is the loneliest number")
   end
 
@@ -180,7 +180,7 @@ describe Chef::Mixin::ParamsValidate do
           :one => {
             :regex => /^is good$/
           }
-        }
+        },
       )
     }.not_to raise_error
 
@@ -191,7 +191,7 @@ describe Chef::Mixin::ParamsValidate do
           :one => {
             :regex => /^is bad$/
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
@@ -205,10 +205,10 @@ describe Chef::Mixin::ParamsValidate do
             :callbacks => {
               "should be equal to is good" => lambda { |a|
                 a == "is good"
-              },
+              }
             }
           }
-        }
+        },
       )
     }.not_to raise_error
 
@@ -220,10 +220,10 @@ describe Chef::Mixin::ParamsValidate do
             :callbacks => {
               "should be equal to 'is good'" => lambda { |a|
                 a == "is good"
-              },
+              }
             }
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
@@ -243,14 +243,14 @@ describe Chef::Mixin::ParamsValidate do
                 a == "is good"
               }
             },
-            :required => true
+            :required => true,
           },
           :two => {
             :kind_of => String,
-            :required => false
+            :required => false,
           },
-          :three => { :default => "neato mosquito" }
-        }
+          :three => { :default => "neato mosquito" },
+        },
       )
     }.not_to raise_error
     expect(args[:three]).to eq("neato mosquito")
@@ -267,14 +267,14 @@ describe Chef::Mixin::ParamsValidate do
                 a == "is good"
               }
             },
-            :required => true
+            :required => true,
           },
           :two => {
             :kind_of => Hash,
-            :required => false
+            :required => false,
           },
-          :three => { :default => "neato mosquito" }
-        }
+          :three => { :default => "neato mosquito" },
+        },
       )
     }.to raise_error(ArgumentError)
   end
@@ -286,58 +286,58 @@ describe Chef::Mixin::ParamsValidate do
           :one => {
             :busted => "check"
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
 
   it "should accept keys that are strings in the options" do
     expect {
-      @vo.validate({ "one" => "two" }, { :one => { :regex => /^two$/ }})
+      @vo.validate({ "one" => "two" }, { :one => { :regex => /^two$/ } })
     }.not_to raise_error
   end
 
   it "should allow an array to kind_of" do
     expect {
       @vo.validate(
-        {:one => "string"},
+        { :one => "string" },
         {
           :one => {
             :kind_of => [ String, Array ]
           }
-        }
+        },
       )
     }.not_to raise_error
     expect {
       @vo.validate(
-        {:one => ["string"]},
+        { :one => ["string"] },
         {
           :one => {
             :kind_of => [ String, Array ]
           }
-        }
+        },
       )
     }.not_to raise_error
     expect {
       @vo.validate(
-        {:one => Hash.new},
+        { :one => Hash.new },
         {
           :one => {
             :kind_of => [ String, Array ]
           }
-        }
+        },
       )
     }.to raise_error(ArgumentError)
   end
 
   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
 
@@ -367,40 +367,40 @@ describe Chef::Mixin::ParamsValidate do
 
   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(: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)
   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})
+    value = Chef::DelayedEvaluator.new { "test" }
+    @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})
+    value = Chef::DelayedEvaluator.new { "test" }
+    @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
 
   it "should create DelayedEvaluator instance when #lazy is used" do
-    @vo.set_or_return(:delayed, @vo.lazy{ 'test' }, {})
+    @vo.set_or_return(:delayed, @vo.lazy { "test" }, {})
     expect(@vo.instance_variable_get(:@delayed)).to be_a(Chef::DelayedEvaluator)
   end
 
   it "should execute block on each call when DelayedEvaluator" do
-    value = 'fubar'
-    @vo.set_or_return(:test, @vo.lazy{ value }, {})
-    expect(@vo.set_or_return(:test, nil, {})).to eq('fubar')
-    value = 'foobar'
-    expect(@vo.set_or_return(:test, nil, {})).to eq('foobar')
-    value = 'fauxbar'
-    expect(@vo.set_or_return(:test, nil, {})).to eq('fauxbar')
+    value = "fubar"
+    @vo.set_or_return(:test, @vo.lazy { value }, {})
+    expect(@vo.set_or_return(:test, nil, {})).to eq("fubar")
+    value = "foobar"
+    expect(@vo.set_or_return(:test, nil, {})).to eq("foobar")
+    value = "fauxbar"
+    expect(@vo.set_or_return(:test, nil, {})).to eq("fauxbar")
   end
 
   it "should not evaluate non DelayedEvaluator instances" do
-    value = lambda{ 'test' }
+    value = lambda { "test" }
     @vo.set_or_return(:test, value, {})
     expect(@vo.set_or_return(:test, nil, {}).object_id).to eq(value.object_id)
     expect(@vo.set_or_return(:test, nil, {})).to be_a(Proc)