chef 12.6.0 → 12.7.2

data/spec/unit/rest_spec.rb

@@ -1,9 +1,9 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Brown (<cb@opscode.com>)
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Brown (<cb@chef.io>)
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,12 +19,12 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'uri'
-require 'net/https'
-require 'stringio'
+require "spec_helper"
+require "uri"
+require "net/https"
+require "stringio"
 
-SIGNING_KEY_DOT_PEM="-----BEGIN RSA PRIVATE KEY-----
+SIGNING_KEY_DOT_PEM = "-----BEGIN RSA PRIVATE KEY-----
 MIIEpAIBAAKCAQEA49TA0y81ps0zxkOpmf5V4/c4IeR5yVyQFpX3JpxO4TquwnRh
 8VSUhrw8kkTLmB3cS39Db+3HadvhoqCEbqPE6915kXSuk/cWIcNozujLK7tkuPEy
 YVsyTioQAddSdfe+8EhQVf3oHxaKmUd6waXrWqYCnhxgOjxocenREYNhZ/OETIei
@@ -59,7 +59,7 @@ describe Chef::REST do
 
   let(:log_stringio) { StringIO.new }
 
-  let(:request_id) {"1234"}
+  let(:request_id) { "1234" }
 
   let(:rest) do
     allow(Chef::REST::CookieJar).to receive(:instance).and_return({})
@@ -69,11 +69,12 @@ describe Chef::REST do
     rest
   end
 
-  let(:standard_read_headers) {{"Accept"=>"application/json", "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "X-REMOTE-REQUEST-ID"=>request_id, 'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION}}
-  let(:standard_write_headers) {{"Accept"=>"application/json", "Content-Type"=>"application/json", "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "X-REMOTE-REQUEST-ID"=>request_id, 'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION}}
+  let(:standard_read_headers) { { "Accept" => "application/json", "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "X-REMOTE-REQUEST-ID" => request_id, "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION } }
+  let(:standard_write_headers) { { "Accept" => "application/json", "Content-Type" => "application/json", "Accept-Encoding" => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "X-REMOTE-REQUEST-ID" => request_id, "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION } }
 
   before(:each) do
     Chef::Log.init(log_stringio)
+    Chef::Config[:treat_deprecation_warnings_as_errors] = false
   end
 
   it "should have content length validation middleware after compressor middleware" do
@@ -92,7 +93,13 @@ describe Chef::REST do
     Chef::REST.new(base_url, nil, nil, options)
   end
 
-  context 'when created with a chef zero URL' do
+  it "emits a deprecation warning" do
+    Chef::Config[:treat_deprecation_warnings_as_errors] = true
+    expect { Chef::REST.new(base_url) }.to raise_error Chef::Exceptions::DeprecatedFeatureError,
+      /Chef::REST is deprecated. Please use Chef::ServerAPI, or investigate Ridley or ChefAPI./
+  end
+
+  context "when created with a chef zero URL" do
 
     let(:url) { "chefzero://localhost:1" }
 
@@ -113,41 +120,41 @@ describe Chef::REST do
     it "makes a :GET request with the composed url object" do
       expect(rest).to receive(:send_http_request).
         with(:GET, monkey_uri, standard_read_headers, false).
-        and_return([1,2,3])
-      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
-      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
+        and_return([1, 2, 3])
+      expect(rest).to receive(:apply_response_middleware).with(1, 2, 3).and_return([1, 2, 3])
+      expect(rest).to receive("success_response?".to_sym).with(1).and_return(true)
       rest.get_rest("monkey")
     end
 
     it "makes a :GET reqest for a streaming download with the composed url" do
-      expect(rest).to receive(:streaming_request).with('monkey', {})
+      expect(rest).to receive(:streaming_request).with("monkey", {})
       rest.get_rest("monkey", true)
     end
 
     it "makes a :DELETE request with the composed url object" do
       expect(rest).to receive(:send_http_request).
         with(:DELETE, monkey_uri, standard_read_headers, false).
-        and_return([1,2,3])
-      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
-      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
+        and_return([1, 2, 3])
+      expect(rest).to receive(:apply_response_middleware).with(1, 2, 3).and_return([1, 2, 3])
+      expect(rest).to receive("success_response?".to_sym).with(1).and_return(true)
       rest.delete_rest("monkey")
     end
 
     it "makes a :POST request with the composed url object and data" do
       expect(rest).to receive(:send_http_request).
         with(:POST, monkey_uri, standard_write_headers, "\"data\"").
-        and_return([1,2,3])
-      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
-      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
+        and_return([1, 2, 3])
+      expect(rest).to receive(:apply_response_middleware).with(1, 2, 3).and_return([1, 2, 3])
+      expect(rest).to receive("success_response?".to_sym).with(1).and_return(true)
       rest.post_rest("monkey", "data")
     end
 
     it "makes a :PUT request with the composed url object and data" do
       expect(rest).to receive(:send_http_request).
         with(:PUT, monkey_uri, standard_write_headers, "\"data\"").
-        and_return([1,2,3])
-      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
-      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
+        and_return([1, 2, 3])
+      expect(rest).to receive(:apply_response_middleware).with(1, 2, 3).and_return([1, 2, 3])
+      expect(rest).to receive("success_response?".to_sym).with(1).and_return(true)
       rest.put_rest("monkey", "data")
     end
   end
@@ -162,38 +169,37 @@ describe Chef::REST do
       Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
     end
 
-    it 'responds to raw_http_request as a public method' do
+    it "responds to raw_http_request as a public method" do
       expect(rest.public_methods.map(&:to_s)).to include("raw_http_request")
     end
 
-    it 'calls the authn middleware' do
+    it "calls the authn middleware" do
       data = "\"secure data\""
 
-      auth_headers = standard_write_headers.merge({"auth_done"=>"yep"})
+      auth_headers = standard_write_headers.merge({ "auth_done" => "yep" })
 
       expect(rest.authenticator).to receive(:handle_request).
         with(:POST, monkey_uri, standard_write_headers, data).
         and_return([:POST, monkey_uri, auth_headers, data])
       expect(rest).to receive(:send_http_request).
         with(:POST, monkey_uri, auth_headers, data).
-        and_return([1,2,3])
-      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
+        and_return([1, 2, 3])
+      expect(rest).to receive("success_response?".to_sym).with(1).and_return(true)
       rest.raw_http_request(:POST, monkey_uri, standard_write_headers, data)
     end
 
-    it 'sets correct authn headers' do
+    it "sets correct authn headers" do
       data = "\"secure data\""
       method, uri, auth_headers, d = rest.authenticator.handle_request(:POST, monkey_uri, standard_write_headers, data)
 
       expect(rest).to receive(:send_http_request).
         with(:POST, monkey_uri, auth_headers, data).
-        and_return([1,2,3])
-      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
+        and_return([1, 2, 3])
+      expect(rest).to receive("success_response?".to_sym).with(1).and_return(true)
       rest.raw_http_request(:POST, monkey_uri, standard_write_headers, data)
     end
   end
 
-
   describe "when configured to authenticate to the Chef server" do
     let(:base_url) { URI.parse("http://chef.example.com:4000") }
 
@@ -227,12 +233,12 @@ describe Chef::REST do
     end
 
     it "raises PrivateKeyMissing when the key file doesn't exist" do
-      expect {Chef::REST.new(base_url, "client-name", "/dev/null/nothing_here")}.to raise_error(Chef::Exceptions::PrivateKeyMissing)
+      expect { Chef::REST.new(base_url, "client-name", "/dev/null/nothing_here") }.to raise_error(Chef::Exceptions::PrivateKeyMissing)
     end
 
     it "raises InvalidPrivateKey when the key file doesnt' look like a key" do
       invalid_key_file = CHEF_SPEC_DATA + "/bad-config.rb"
-      expect {Chef::REST.new(base_url, "client-name", invalid_key_file)}.to raise_error(Chef::Exceptions::InvalidPrivateKey)
+      expect { Chef::REST.new(base_url, "client-name", invalid_key_file) }.to raise_error(Chef::Exceptions::InvalidPrivateKey)
     end
 
     it "can take private key as a sting :raw_key in options during initializaton" do
@@ -240,7 +246,7 @@ describe Chef::REST do
     end
 
     it "raises InvalidPrivateKey when the key passed as string :raw_key in options doesnt' look like a key" do
-      expect {Chef::REST.new(base_url, "client-name", nil, :raw_key => "bad key string")}.to raise_error(Chef::Exceptions::InvalidPrivateKey)
+      expect { Chef::REST.new(base_url, "client-name", nil, :raw_key => "bad key string") }.to raise_error(Chef::Exceptions::InvalidPrivateKey)
     end
 
   end
@@ -285,14 +291,14 @@ describe Chef::REST do
     describe "as JSON API requests" do
       let(:request_mock) { {} }
 
-      let(:base_headers) do  #FIXME: huh?
+      let(:base_headers) do #FIXME: huh?
         {
-          'Accept' => 'application/json',
-          'X-Chef-Version' => Chef::VERSION,
-          'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-          'Host' => host_header,
-          'X-REMOTE-REQUEST-ID' => request_id,
-          'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION
+          "Accept" => "application/json",
+          "X-Chef-Version" => Chef::VERSION,
+          "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
+          "Host" => host_header,
+          "X-REMOTE-REQUEST-ID" => request_id,
+          "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION,
         }
       end
 
@@ -314,7 +320,7 @@ describe Chef::REST do
         # XXX: must reset to default b/c knife changes the UA
         Chef::REST::RESTRequest.user_agent = Chef::REST::RESTRequest::DEFAULT_UA
         rest.request(:GET, url, {})
-        expect(request_mock['User-Agent']).to match(/^Chef Client\/#{Chef::VERSION}/)
+        expect(request_mock["User-Agent"]).to match(/^Chef Client\/#{Chef::VERSION}/)
       end
 
       # CHEF-3140
@@ -340,8 +346,8 @@ describe Chef::REST do
       context "when configured with custom http headers" do
         let(:custom_headers) do
           {
-            'X-Custom-ChefSecret' => 'sharpknives',
-            'X-Custom-RequestPriority' => 'extremely low'
+            "X-Custom-ChefSecret" => "sharpknives",
+            "X-Custom-RequestPriority" => "extremely low",
           }
         end
 
@@ -371,7 +377,7 @@ describe Chef::REST do
         end
 
         it "should set the cookie for this request if one exists for the given host:port" do
-          expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", base_headers.merge('Cookie' => "cookie monster")).and_return(request_mock)
+          expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", base_headers.merge("Cookie" => "cookie monster")).and_return(request_mock)
           rest.request(:GET, url, {})
         end
       end
@@ -383,18 +389,18 @@ describe Chef::REST do
 
       it "should build a new HTTP POST request" do
         request = Net::HTTP::Post.new(url.path)
-        expected_headers = base_headers.merge("Content-Type" => 'application/json', 'Content-Length' => '13')
+        expected_headers = base_headers.merge("Content-Type" => "application/json", "Content-Length" => "13")
 
         expect(Net::HTTP::Post).to receive(:new).with("/?foo=bar", expected_headers).and_return(request)
-        rest.request(:POST, url, {}, {:one=>:two})
+        rest.request(:POST, url, {}, { :one => :two })
         expect(request.body).to eq('{"one":"two"}')
       end
 
       it "should build a new HTTP PUT request" do
         request = Net::HTTP::Put.new(url.path)
-        expected_headers = base_headers.merge("Content-Type" => 'application/json', 'Content-Length' => '13')
-        expect(Net::HTTP::Put).to receive(:new).with("/?foo=bar",expected_headers).and_return(request)
-        rest.request(:PUT, url, {}, {:one=>:two})
+        expected_headers = base_headers.merge("Content-Type" => "application/json", "Content-Length" => "13")
+        expect(Net::HTTP::Put).to receive(:new).with("/?foo=bar", expected_headers).and_return(request)
+        rest.request(:PUT, url, {}, { :one => :two })
         expect(request.body).to eq('{"one":"two"}')
       end
 
@@ -419,18 +425,18 @@ describe Chef::REST do
       context "when JSON is returned" do
         let(:body) { '{"ohai2u":"json_api"}' }
         it "should inflate the body as to an object" do
-          http_response.add_field('content-type', "application/json")
-          expect(rest.request(:GET, url, {})).to eq({"ohai2u"=>"json_api"})
+          http_response.add_field("content-type", "application/json")
+          expect(rest.request(:GET, url, {})).to eq({ "ohai2u" => "json_api" })
         end
 
         it "should fail if the response is truncated" do
-          http_response.add_field('content-type', "application/json")
+          http_response.add_field("content-type", "application/json")
           http_response["Content-Length"] = (body.bytesize + 99).to_s
           expect { rest.request(:GET, url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
         end
       end
 
-      %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |resp_name|
+      %w{ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice }.each do |resp_name|
         describe "when encountering a #{resp_name} redirect" do
           let(:http_response) do
             resp_cls  = Net.const_get(resp_name)
@@ -485,8 +491,8 @@ describe Chef::REST do
           it "should show the JSON error message" do
             allow(rest).to receive(:sleep)
 
-            expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
-            expect(log_stringio.string).to match(Regexp.escape('INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
+            expect { rest.request(:GET, url) }.to raise_error(Net::HTTPFatalError)
+            expect(log_stringio.string).to match(Regexp.escape("INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four"))
           end
         end
 
@@ -510,13 +516,13 @@ describe Chef::REST do
           end
 
           it "decompresses the JSON error message" do
-            expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
-            expect(log_stringio.string).to match(Regexp.escape('INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
+            expect { rest.request(:GET, url) }.to raise_error(Net::HTTPFatalError)
+            expect(log_stringio.string).to match(Regexp.escape("INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four"))
           end
 
           it "fails when the compressed body is truncated" do
             http_response["Content-Length"] = (body.bytesize + 99).to_s
-            expect {rest.request(:GET, url)}.to raise_error(Chef::Exceptions::ContentLengthMismatch)
+            expect { rest.request(:GET, url) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
           end
         end
 
@@ -530,7 +536,7 @@ describe Chef::REST do
 
           it "retries then throws an exception" do
             allow(rest).to receive(:sleep)
-            expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
+            expect { rest.request(:GET, url) }.to raise_error(Net::HTTPFatalError)
             count = Chef::Config[:http_retry_count]
             expect(log_stringio.string).to match(Regexp.escape("ERROR: Server returned error 500 for #{url}, retrying #{count}/#{count}"))
           end
@@ -544,7 +550,7 @@ describe Chef::REST do
       let(:request_mock) { {} }
 
       let(:http_response) do
-        http_response = Net::HTTPSuccess.new("1.1",'200', "it-works")
+        http_response = Net::HTTPSuccess.new("1.1", "200", "it-works")
 
         allow(http_response).to receive(:read_body)
         expect(http_response).not_to receive(:body)
@@ -570,24 +576,24 @@ describe Chef::REST do
       end
 
       it " build a new HTTP GET request without the application/json accept header" do
-        expected_headers = {'Accept' => "*/*",
-                            'X-Chef-Version' => Chef::VERSION,
-                            'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                            'Host' => host_header,
-                            'X-REMOTE-REQUEST-ID'=> request_id,
-                            'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION
+        expected_headers = { "Accept" => "*/*",
+                             "X-Chef-Version" => Chef::VERSION,
+                             "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
+                             "Host" => host_header,
+                             "X-REMOTE-REQUEST-ID" => request_id,
+                             "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION,
                             }
         expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
         rest.streaming_request(url, {})
       end
 
       it "build a new HTTP GET request with the X-Remote-Request-Id header" do
-        expected_headers = {'Accept' => "*/*",
-                            'X-Chef-Version' => Chef::VERSION,
-                            'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                            'Host' => host_header,
-                            'X-REMOTE-REQUEST-ID'=> request_id,
-                            'X-Ops-Server-API-Version' => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION
+        expected_headers = { "Accept" => "*/*",
+                             "X-Chef-Version" => Chef::VERSION,
+                             "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
+                             "Host" => host_header,
+                             "X-REMOTE-REQUEST-ID" => request_id,
+                             "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION,
                             }
         expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
         rest.streaming_request(url, {})
@@ -622,13 +628,13 @@ describe Chef::REST do
       end
 
       it "does not raise a divide by zero exception if the content's actual size is 0" do
-        http_response['Content-Length'] = "5"
-        allow(http_response).to receive(:read_body).and_yield('')
+        http_response["Content-Length"] = "5"
+        allow(http_response).to receive(:read_body).and_yield("")
         expect { rest.streaming_request(url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
       end
 
       it "does not raise a divide by zero exception when the Content-Length is 0" do
-        http_response['Content-Length'] = "0"
+        http_response["Content-Length"] = "0"
         allow(http_response).to receive(:read_body).and_yield("ninja")
         expect { rest.streaming_request(url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
       end
@@ -654,7 +660,7 @@ describe Chef::REST do
         path = tempfile.path
         expect(path).not_to be_nil
         allow(tempfile).to receive(:write).and_raise(IOError)
-        rest.fetch("cookbooks/a_cookbook") {|tmpfile| "shouldn't get here"}
+        rest.fetch("cookbooks/a_cookbook") { |tmpfile| "shouldn't get here" }
         expect(File.exists?(path)).to be_falsey
       end
 
@@ -669,12 +675,12 @@ describe Chef::REST do
 
         expect(http_client).to receive(:request).and_yield(redirect).and_return(redirect)
         expect(http_client).to receive(:request).and_yield(http_response).and_return(http_response)
-        rest.fetch("cookbooks/a_cookbook") {|tmpfile| "shouldn't get here"}
+        rest.fetch("cookbooks/a_cookbook") { |tmpfile| "shouldn't get here" }
       end
 
       it "passes the original block to the redirected request" do
         http_redirect = Net::HTTPFound.new("1.1", "302", "bob is taking care of that one for me today")
-        http_redirect.add_field("location","/that-thing-is-here-now")
+        http_redirect.add_field("location", "/that-thing-is-here-now")
         allow(http_redirect).to receive(:read_body)
 
         block_called = false
@@ -698,8 +704,8 @@ describe Chef::REST do
     end
 
     it "raises a RedirectLimitExceeded when redirected more than 10 times" do
-      redirected = lambda {rest.follow_redirect { redirected.call }}
-      expect {redirected.call}.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      redirected = lambda { rest.follow_redirect { redirected.call } }
+      expect { redirected.call }.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
     end
 
     it "does not count redirects from previous calls against the redirect limit" do
@@ -710,9 +716,9 @@ describe Chef::REST do
           redirected.call unless total_redirects >= 9
         end
       end
-      expect {redirected.call}.not_to raise_error
+      expect { redirected.call }.not_to raise_error
       total_redirects = 0
-      expect {redirected.call}.not_to raise_error
+      expect { redirected.call }.not_to raise_error
     end
 
     it "does not sign the redirected request when sign_on_redirect is false" do
@@ -736,11 +742,11 @@ describe Chef::REST do
           redirected.call unless total_redirects >= 9
         end
       end
-      expect {redirected.call}.not_to raise_error
+      expect { redirected.call }.not_to raise_error
 
       total_redirects = 0
       rest.redirect_limit = 3
-      expect {redirected.call}.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      expect { redirected.call }.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
     end
 
   end

data/spec/unit/role_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,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/role'
+require "spec_helper"
+require "chef/role"
 
 describe Chef::Role do
   before(:each) do
@@ -44,7 +44,6 @@ describe Chef::Role do
       @role.run_list(%w{ nginx recipe[ree] role[base]})
     end
 
-
     it "returns the run list" do
       expect(@role.run_list).to eq(%w{ nginx recipe[ree] role[base]})
     end
@@ -79,12 +78,11 @@ describe Chef::Role do
 
       it "env_run_lists can only be set with _default run list in it" do
         long_exception_name = Chef::Exceptions::InvalidEnvironmentRunListSpecification
-        expect {@role.env_run_lists({})}.to raise_error(long_exception_name)
+        expect { @role.env_run_lists({}) }.to raise_error(long_exception_name)
       end
 
     end
 
-
     describe "using the old #recipes API" do
       it "should let you set the recipe array" do
         expect(@role.recipes([ "one", "two" ])).to eq([ "one", "two" ])
@@ -104,16 +102,14 @@ describe Chef::Role do
 
   end
 
-
-
   describe "default_attributes" do
     it "should let you set the default attributes hash explicitly" do
-      expect(@role.default_attributes({ :one => 'two' })).to eq({ :one => 'two' })
+      expect(@role.default_attributes({ :one => "two" })).to eq({ :one => "two" })
     end
 
     it "should let you return the default attributes hash" do
-      @role.default_attributes({ :one => 'two' })
-      expect(@role.default_attributes).to eq({ :one => 'two' })
+      @role.default_attributes({ :one => "two" })
+      expect(@role.default_attributes).to eq({ :one => "two" })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
@@ -123,12 +119,12 @@ describe Chef::Role do
 
   describe "override_attributes" do
     it "should let you set the override attributes hash explicitly" do
-      expect(@role.override_attributes({ :one => 'two' })).to eq({ :one => 'two' })
+      expect(@role.override_attributes({ :one => "two" })).to eq({ :one => "two" })
     end
 
     it "should let you return the override attributes hash" do
-      @role.override_attributes({ :one => 'two' })
-      expect(@role.override_attributes).to eq({ :one => 'two' })
+      @role.override_attributes({ :one => "two" })
+      expect(@role.override_attributes).to eq({ :one => "two" })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
@@ -138,18 +134,18 @@ describe Chef::Role do
 
   describe "update_from!" do
     before(:each) do
-      @role.name('mars_volta')
-      @role.description('Great band!')
-      @role.run_list('one', 'two', 'role[a]')
-      @role.default_attributes({ :el_groupo => 'nuevo' })
-      @role.override_attributes({ :deloused => 'in the comatorium' })
+      @role.name("mars_volta")
+      @role.description("Great band!")
+      @role.run_list("one", "two", "role[a]")
+      @role.default_attributes({ :el_groupo => "nuevo" })
+      @role.override_attributes({ :deloused => "in the comatorium" })
 
       @example = Chef::Role.new
-      @example.name('newname')
-      @example.description('Really Great band!')
-      @example.run_list('alpha', 'bravo', 'role[alpha]')
-      @example.default_attributes({ :el_groupo => 'nuevo dos' })
-      @example.override_attributes({ :deloused => 'in the comatorium XOXO' })
+      @example.name("newname")
+      @example.description("Really Great band!")
+      @example.run_list("alpha", "bravo", "role[alpha]")
+      @example.default_attributes({ :el_groupo => "nuevo dos" })
+      @example.override_attributes({ :deloused => "in the comatorium XOXO" })
     end
 
     it "should update all fields except for name" do
@@ -164,11 +160,11 @@ describe Chef::Role do
 
   describe "when serialized as JSON", :json => true do
     before(:each) do
-      @role.name('mars_volta')
-      @role.description('Great band!')
-      @role.run_list('one', 'two', 'role[a]')
-      @role.default_attributes({ :el_groupo => 'nuevo' })
-      @role.override_attributes({ :deloused => 'in the comatorium' })
+      @role.name("mars_volta")
+      @role.description("Great band!")
+      @role.run_list("one", "two", "role[a]")
+      @role.default_attributes({ :el_groupo => "nuevo" })
+      @role.override_attributes({ :deloused => "in the comatorium" })
       @serialized_role = Chef::JSONCompat.to_json(@role)
     end
 
@@ -200,14 +196,14 @@ describe Chef::Role do
 
     describe "and it has per-environment run lists" do
       before do
-        @role.env_run_lists("_default" => ['one', 'two', 'role[a]'], "production" => ['role[monitoring]', 'role[auditing]', 'role[apache]'], "dev" => ["role[nginx]"])
-        @serialized_role = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@role), :create_additions => false)
+        @role.env_run_lists("_default" => ["one", "two", "role[a]"], "production" => ["role[monitoring]", "role[auditing]", "role[apache]"], "dev" => ["role[nginx]"])
+        @serialized_role = Chef::JSONCompat.parse(Chef::JSONCompat.to_json(@role), :create_additions => false)
       end
 
       it "includes the per-environment run lists" do
         #Activesupport messes with Chef json formatting
         #This test should pass with and without activesupport
-        expect(@serialized_role["env_run_lists"]["production"]).to eq(['role[monitoring]', 'role[auditing]', 'role[apache]'])
+        expect(@serialized_role["env_run_lists"]["production"]).to eq(["role[monitoring]", "role[auditing]", "role[apache]"])
         expect(@serialized_role["env_run_lists"]["dev"]).to eq(["role[nginx]"])
       end
 
@@ -224,12 +220,12 @@ describe Chef::Role do
 
   describe "when created from JSON", :json => true do
     before(:each) do
-      @role.name('mars_volta')
-      @role.description('Great band!')
-      @role.run_list('one', 'two', 'role[a]')
-      @role.default_attributes({ 'el_groupo' => 'nuevo' })
-      @role.override_attributes({ 'deloused' => 'in the comatorium' })
-      @deserial = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@role))
+      @role.name("mars_volta")
+      @role.description("Great band!")
+      @role.run_list("one", "two", "role[a]")
+      @role.default_attributes({ "el_groupo" => "nuevo" })
+      @role.override_attributes({ "deloused" => "in the comatorium" })
+      @deserial = Chef::Role.from_hash(Chef::JSONCompat.parse(Chef::JSONCompat.to_json(@role)))
     end
 
     it "should deserialize to a Chef::Role object" do
@@ -249,20 +245,20 @@ describe Chef::Role do
     end
   end
 
-  ROLE_DSL=<<-EOR
+  ROLE_DSL = <<-EOR
 name "ceiling_cat"
 description "like Aliens, but furry"
 EOR
 
   describe "when loading from disk" do
     before do
-      default_cache_path = windows? ? 'C:\chef' : '/var/chef'
+      default_cache_path = windows? ? 'C:\chef' : "/var/chef"
       allow(Chef::Config).to receive(:cache_path).and_return(default_cache_path)
     end
 
     it "should return a Chef::Role object from JSON" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.json"])
-      file_path = File.join(Chef::Config[:role_path], 'memes/lolcat.json')
+      file_path = File.join(Chef::Config[:role_path], "memes/lolcat.json")
       expect(File).to receive(:exists?).with(file_path).exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with(file_path).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
@@ -271,7 +267,7 @@ EOR
 
     it "should return a Chef::Role object from a Ruby DSL" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.rb"])
-      rb_path = File.join(Chef::Config[:role_path], 'memes/lolcat.rb')
+      rb_path = File.join(Chef::Config[:role_path], "memes/lolcat.rb")
       expect(File).to receive(:exists?).with(rb_path).exactly(2).times.and_return(true)
       expect(File).to receive(:readable?).with(rb_path).exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with(rb_path).and_return(ROLE_DSL)
@@ -281,8 +277,8 @@ EOR
 
     it "should prefer a Chef::Role Object from JSON over one from a Ruby DSL" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.json", "#{Chef::Config[:role_path]}/memes/lolcat.rb"])
-      js_path = File.join(Chef::Config[:role_path], 'memes/lolcat.json')
-      rb_path = File.join(Chef::Config[:role_path], 'memes/lolcat.rb')
+      js_path = File.join(Chef::Config[:role_path], "memes/lolcat.json")
+      rb_path = File.join(Chef::Config[:role_path], "memes/lolcat.rb")
       expect(File).to receive(:exists?).with(js_path).exactly(1).times.and_return(true)
       expect(File).not_to receive(:exists?).with(rb_path)
       expect(IO).to receive(:read).with(js_path).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
@@ -293,69 +289,69 @@ EOR
     it "should raise an exception if the file does not exist" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/meme.rb"])
       expect(File).not_to receive(:exists?)
-      expect {@role.class.from_disk("lolcat")}.to raise_error(Chef::Exceptions::RoleNotFound)
+      expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::RoleNotFound)
     end
 
     it "should raise an exception if two files exist with the same name" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes/lolcat.rb", "#{Chef::Config[:role_path]}/lolcat.rb"])
       expect(File).not_to receive(:exists?)
-      expect {@role.class.from_disk("lolcat")}.to raise_error(Chef::Exceptions::DuplicateRole)
+      expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::DuplicateRole)
     end
 
     it "should not raise an exception if two files exist with a similar name" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes/lolcat.rb", "#{Chef::Config[:role_path]}/super_lolcat.rb"])
       expect(File).to receive(:exists?).with("#{Chef::Config[:role_path]}/memes/lolcat.rb").and_return(true)
       allow_any_instance_of(Chef::Role).to receive(:from_file).with("#{Chef::Config[:role_path]}/memes/lolcat.rb")
-      expect{ @role.class.from_disk("lolcat") }.not_to raise_error
+      expect { @role.class.from_disk("lolcat") }.not_to raise_error
     end
   end
 
   describe "when loading from disk and role_path is an array" do
 
     before(:each) do
-      Chef::Config[:role_path] = ['/path1', '/path/path2']
+      Chef::Config[:role_path] = ["/path1", "/path/path2"]
     end
 
     it "should return a Chef::Role object from JSON" do
-      expect(Dir).to receive(:glob).with(File.join('/path1', '**', '**')).exactly(1).times.and_return(['/path1/lolcat.json'])
-      expect(File).to receive(:exists?).with('/path1/lolcat.json').exactly(1).times.and_return(true)
-      expect(IO).to receive(:read).with('/path1/lolcat.json').and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return(["/path1/lolcat.json"])
+      expect(File).to receive(:exists?).with("/path1/lolcat.json").exactly(1).times.and_return(true)
+      expect(IO).to receive(:read).with("/path1/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from JSON when role is in the second path" do
-      expect(Dir).to receive(:glob).with(File.join('/path1', '**', '**')).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join('/path/path2', '**', '**')).exactly(1).times.and_return(['/path/path2/lolcat.json'])
-      expect(File).to receive(:exists?).with('/path/path2/lolcat.json').exactly(1).times.and_return(true)
-      expect(IO).to receive(:read).with('/path/path2/lolcat.json').and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return(["/path/path2/lolcat.json"])
+      expect(File).to receive(:exists?).with("/path/path2/lolcat.json").exactly(1).times.and_return(true)
+      expect(IO).to receive(:read).with("/path/path2/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from a Ruby DSL" do
-      expect(Dir).to receive(:glob).with(File.join('/path1', '**', '**')).exactly(1).times.and_return(['/path1/lolcat.rb'])
-      expect(File).to receive(:exists?).with('/path1/lolcat.rb').exactly(2).times.and_return(true)
-      expect(File).to receive(:readable?).with('/path1/lolcat.rb').and_return(true)
-      expect(IO).to receive(:read).with('/path1/lolcat.rb').exactly(1).times.and_return(ROLE_DSL)
+      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return(["/path1/lolcat.rb"])
+      expect(File).to receive(:exists?).with("/path1/lolcat.rb").exactly(2).times.and_return(true)
+      expect(File).to receive(:readable?).with("/path1/lolcat.rb").and_return(true)
+      expect(IO).to receive(:read).with("/path1/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from a Ruby DSL when role is in the second path" do
-      expect(Dir).to receive(:glob).with(File.join('/path1', '**', '**')).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join('/path/path2', '**', '**')).exactly(1).times.and_return(['/path/path2/lolcat.rb'])
-      expect(File).to receive(:exists?).with('/path/path2/lolcat.rb').exactly(2).times.and_return(true)
-      expect(File).to receive(:readable?).with('/path/path2/lolcat.rb').and_return(true)
-      expect(IO).to receive(:read).with('/path/path2/lolcat.rb').exactly(1).times.and_return(ROLE_DSL)
+      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return(["/path/path2/lolcat.rb"])
+      expect(File).to receive(:exists?).with("/path/path2/lolcat.rb").exactly(2).times.and_return(true)
+      expect(File).to receive(:readable?).with("/path/path2/lolcat.rb").and_return(true)
+      expect(IO).to receive(:read).with("/path/path2/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should raise an exception if the file does not exist" do
-      expect(Dir).to receive(:glob).with(File.join('/path1', '**', '**')).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join('/path/path2', '**', '**')).exactly(1).times.and_return([])
-      expect {@role.class.from_disk("lolcat")}.to raise_error(Chef::Exceptions::RoleNotFound)
+      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return([])
+      expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::RoleNotFound)
     end
 
   end