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

data/spec/unit/knife/ssl_check_spec.rb

@@ -67,11 +67,11 @@ describe Chef::Knife::SslCheck do
 
     it "prints an error and exits" do
       expect { ssl_check.run }.to raise_error(SystemExit)
-      expected_stdout = <<-E
-USAGE: knife ssl check [URL] (options)
+      expected_stdout = <<~E
+        USAGE: knife ssl check [URL] (options)
 E
-      expected_stderr = <<-E
-ERROR: Given URI: `foo.test' is invalid
+      expected_stderr = <<~E
+        ERROR: Given URI: `foo.test' is invalid
 E
       expect(stdout_io.string).to eq(expected_stdout)
       expect(stderr_io.string).to eq(expected_stderr)
@@ -83,11 +83,11 @@ E
 
       it "prints an error and exits" do
         expect { ssl_check.run }.to raise_error(SystemExit)
-        expected_stdout = <<-E
-USAGE: knife ssl check [URL] (options)
+        expected_stdout = <<~E
+          USAGE: knife ssl check [URL] (options)
 E
-        expected_stderr = <<-E
-ERROR: Given URI: `#{name_args[0]}' is invalid
+        expected_stderr = <<~E
+          ERROR: Given URI: `#{name_args[0]}' is invalid
 E
         expect(stdout_io.string).to eq(expected_stdout)
         expect(stderr_io.string).to eq(expected_stderr)
@@ -168,8 +168,8 @@ E
     def run
       ssl_check.run
     rescue Exception
-      #puts "OUT: #{stdout_io.string}"
-      #puts "ERR: #{stderr_io.string}"
+      # puts "OUT: #{stdout_io.string}"
+      # puts "ERR: #{stderr_io.string}"
       raise
     end
 
@@ -199,12 +199,12 @@ E
       before do
         @old_signal = trap(:INT, "DEFAULT")
 
-        expect(ssl_check).to receive(:proxified_socket).
-          with("foo.example.com", 8443).
-          and_return(tcp_socket_for_debug)
-        expect(OpenSSL::SSL::SSLSocket).to receive(:new).
-          with(tcp_socket_for_debug, ssl_check.noverify_peer_ssl_context).
-          and_return(ssl_socket_for_debug)
+        expect(ssl_check).to receive(:proxified_socket)
+          .with("foo.example.com", 8443)
+          .and_return(tcp_socket_for_debug)
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new)
+          .with(tcp_socket_for_debug, ssl_check.noverify_peer_ssl_context)
+          .and_return(ssl_socket_for_debug)
       end
 
       after do
@@ -215,9 +215,9 @@ E
         before do
           expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs
           expect(ssl_socket).to receive(:connect) # no error
-          expect(ssl_socket).to receive(:post_connection_check).
-            with("foo.example.com").
-            and_raise(OpenSSL::SSL::SSLError)
+          expect(ssl_socket).to receive(:post_connection_check)
+            .with("foo.example.com")
+            .and_raise(OpenSSL::SSL::SSLError)
           expect(ssl_socket).to receive(:hostname=).with("foo.example.com") # no error
           expect(ssl_socket_for_debug).to receive(:connect)
           expect(ssl_socket_for_debug).to receive(:peer_cert).and_return(self_signed_crt)
@@ -235,10 +235,10 @@ E
       context "when the cert is not signed by any trusted authority" do
         before do
           expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs
-          expect(ssl_socket).to receive(:connect).
-            and_raise(OpenSSL::SSL::SSLError)
-          expect(ssl_socket).to receive(:hostname=).
-            with("foo.example.com") # no error
+          expect(ssl_socket).to receive(:connect)
+            .and_raise(OpenSSL::SSL::SSLError)
+          expect(ssl_socket).to receive(:hostname=)
+            .with("foo.example.com") # no error
           expect(ssl_socket_for_debug).to receive(:connect)
           expect(ssl_socket_for_debug).to receive(:peer_cert).and_return(self_signed_crt)
         end

data/spec/unit/knife/ssl_fetch_spec.rb

@@ -68,11 +68,11 @@ describe Chef::Knife::SslFetch do
 
     it "prints an error and exits" do
       expect { ssl_fetch.run }.to raise_error(SystemExit)
-      expected_stdout = <<-E
-USAGE: knife ssl fetch [URL] (options)
+      expected_stdout = <<~E
+        USAGE: knife ssl fetch [URL] (options)
 E
-      expected_stderr = <<-E
-ERROR: Given URI: `foo.test' is invalid
+      expected_stderr = <<~E
+        ERROR: Given URI: `foo.test' is invalid
 E
       expect(stdout_io.string).to eq(expected_stdout)
       expect(stderr_io.string).to eq(expected_stderr)
@@ -84,11 +84,11 @@ E
 
       it "prints an error and exits" do
         expect { ssl_fetch.run }.to raise_error(SystemExit)
-        expected_stdout = <<-E
-USAGE: knife ssl fetch [URL] (options)
+        expected_stdout = <<~E
+          USAGE: knife ssl fetch [URL] (options)
 E
-        expected_stderr = <<-E
-ERROR: Given URI: `#{name_args[0]}' is invalid
+        expected_stderr = <<~E
+          ERROR: Given URI: `#{name_args[0]}' is invalid
 E
         expect(stdout_io.string).to eq(expected_stdout)
         expect(stderr_io.string).to eq(expected_stderr)
@@ -187,9 +187,9 @@ E
       end
 
       it "tells the user their URL is for a non-ssl service" do
-        expected_error_text = <<-ERROR_TEXT
-ERROR: The service at the given URI (http://foo.example.com) does not accept SSL connections
-ERROR: Perhaps you meant to connect to 'https://foo.example.com'?
+        expected_error_text = <<~ERROR_TEXT
+          ERROR: The service at the given URI (http://foo.example.com) does not accept SSL connections
+          ERROR: Perhaps you meant to connect to 'https://foo.example.com'?
 ERROR_TEXT
 
         run

data/spec/unit/knife/user_delete_spec.rb

@@ -51,7 +51,7 @@ describe Chef::Knife::UserDelete do
   end
 
   it "deletes the user" do
-    #expect(knife).to receive(:delete_object).with(Chef::UserV1, 'my_user')
+    # expect(knife).to receive(:delete_object).with(Chef::UserV1, 'my_user')
     expect(knife).to receive(:delete_object).with("my_user")
     knife.run
   end

data/spec/unit/knife/user_reregister_spec.rb

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Knife::UserReregister do
   let(:knife) { Chef::Knife::UserReregister.new }
-  let(:user_mock) { double("user_mock", :private_key => "private_key") }
+  let(:user_mock) { double("user_mock", private_key: "private_key") }
   let(:stdout) { StringIO.new }
 
   before do

data/spec/unit/knife_spec.rb

@@ -37,7 +37,7 @@ describe Chef::Knife do
     instance_double("WorkstationConfigLoader",
                     load: nil, no_config_found?: false,
                     config_location: config_location,
-                    :chef_config_dir => "/etc/chef")
+                    chef_config_dir: "/etc/chef")
   end
 
   before(:each) do
@@ -225,10 +225,10 @@ describe Chef::Knife do
 
     it "merges the global knife CLI options" do
       extra_opts = {}
-      extra_opts[:editor] = { :long => "--editor EDITOR",
-                              :description => "Set the editor to use for interactive commands",
-                              :short => "-e EDITOR",
-                              :default => "/usr/bin/vim" }
+      extra_opts[:editor] = { long: "--editor EDITOR",
+                              description: "Set the editor to use for interactive commands",
+                              short: "-e EDITOR",
+                              default: "/usr/bin/vim" }
 
       # there is special hackery to return the subcommand instance going on here.
       command = Chef::Knife.run(%w{test yourself}, extra_opts)
@@ -283,8 +283,8 @@ describe Chef::Knife do
     describe "merging configuration options" do
       before do
         KnifeSpecs::TestYourself.option(:opt_with_default,
-                                        :short => "-D VALUE",
-                                        :default => "default-value")
+                                        short: "-D VALUE",
+                                        default: "default-value")
       end
 
       it "sets the default log_location to STDERR for Chef::Log warnings" do
@@ -300,14 +300,14 @@ describe Chef::Knife do
       end
 
       it "prefers the default value if no config or command line value is present" do
-        knife_command = KnifeSpecs::TestYourself.new([]) #empty argv
+        knife_command = KnifeSpecs::TestYourself.new([]) # empty argv
         knife_command.configure_chef
         expect(knife_command.config[:opt_with_default]).to eq("default-value")
       end
 
       it "prefers a value in Chef::Config[:knife] to the default" do
         Chef::Config[:knife][:opt_with_default] = "from-knife-config"
-        knife_command = KnifeSpecs::TestYourself.new([]) #empty argv
+        knife_command = KnifeSpecs::TestYourself.new([]) # empty argv
         knife_command.configure_chef
         expect(knife_command.config[:opt_with_default]).to eq("from-knife-config")
       end
@@ -330,7 +330,7 @@ describe Chef::Knife do
         before do
           knife.config[:verbosity] = 1
           knife.config[:config_file] = fake_config
-          config_loader = double("Chef::WorkstationConfigLoader", :load => true, :no_config_found? => false, :chef_config_dir => "/etc/chef", :config_location => fake_config)
+          config_loader = double("Chef::WorkstationConfigLoader", load: true, no_config_found?: false, chef_config_dir: "/etc/chef", config_location: fake_config)
           allow(config_loader).to receive(:explicit_config_file=).with(fake_config).and_return(fake_config)
           allow(config_loader).to receive(:profile=)
           allow(Chef::WorkstationConfigLoader).to receive(:new).and_return(config_loader)
@@ -423,7 +423,7 @@ describe Chef::Knife do
     it "formats 401s nicely" do
       response = Net::HTTPUnauthorized.new("1.1", "401", "Unauthorized")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no syncronize your clock?"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "y u no syncronize your clock?"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("401 Unauthorized", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(/ERROR: Failed to authenticate to/)
@@ -433,7 +433,7 @@ describe Chef::Knife do
     it "formats 403s nicely" do
       response = Net::HTTPForbidden.new("1.1", "403", "Forbidden")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no administrator"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "y u no administrator"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("403 Forbidden", response))
       allow(knife).to receive(:username).and_return("sadpanda")
       knife.run_with_pretty_exceptions
@@ -453,7 +453,7 @@ describe Chef::Knife do
       it "formats proxy errors nicely" do
         response = Net::HTTPForbidden.new("1.1", "403", "Forbidden")
         response.instance_variable_set(:@read, true)
-        allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no administrator"))
+        allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "y u no administrator"))
         allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("403 Forbidden", response))
         allow(knife).to receive(:username).and_return("sadpanda")
         knife.run_with_pretty_exceptions
@@ -466,7 +466,7 @@ describe Chef::Knife do
     it "formats 400s nicely" do
       response = Net::HTTPBadRequest.new("1.1", "400", "Bad Request")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u search wrong"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "y u search wrong"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("400 Bad Request", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: The data in your request was invalid})
@@ -476,7 +476,7 @@ describe Chef::Knife do
     it "formats 404s nicely" do
       response = Net::HTTPNotFound.new("1.1", "404", "Not Found")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "nothing to see here"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "nothing to see here"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("404 Not Found", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: The object you are looking for could not be found})
@@ -488,9 +488,9 @@ describe Chef::Knife do
       response.instance_variable_set(:@read, true) # I hate you, net/http.
 
       # set the header
-      response["x-ops-server-api-version"] = Chef::JSONCompat.to_json(:min_version => "0", :max_version => "1", :request_version => "10000000")
+      response["x-ops-server-api-version"] = Chef::JSONCompat.to_json(min_version: "0", max_version: "1", request_version: "10000000")
 
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "sad trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("406 Not Acceptable", response))
 
       knife.run_with_pretty_exceptions
@@ -502,7 +502,7 @@ describe Chef::Knife do
     it "formats 500s nicely" do
       response = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "sad trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("500 Internal Server Error", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: internal server error})
@@ -512,7 +512,7 @@ describe Chef::Knife do
     it "formats 502s nicely" do
       response = Net::HTTPBadGateway.new("1.1", "502", "Bad Gateway")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sadder trombone"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "sadder trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("502 Bad Gateway", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: bad gateway})
@@ -522,7 +522,7 @@ describe Chef::Knife do
     it "formats 503s nicely" do
       response = Net::HTTPServiceUnavailable.new("1.1", "503", "Service Unavailable")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "saddest trombone"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "saddest trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("503 Service Unavailable", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: Service temporarily unavailable})
@@ -532,7 +532,7 @@ describe Chef::Knife do
     it "formats other HTTP errors nicely" do
       response = Net::HTTPPaymentRequired.new("1.1", "402", "Payment Required")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "nobugfixtillyoubuy"))
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "nobugfixtillyoubuy"))
       allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("402 Payment Required", response))
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: Payment Required})
@@ -571,11 +571,11 @@ describe Chef::Knife do
 
       knife.run_with_pretty_exceptions
 
-      expected_message = <<-MSG
-ERROR: Could not establish a secure connection to the server.
-Use `knife ssl check` to troubleshoot your SSL configuration.
-If your Chef Server uses a self-signed certificate, you can use
-`knife ssl fetch` to make knife trust the server's certificates.
+      expected_message = <<~MSG
+        ERROR: Could not establish a secure connection to the server.
+        Use `knife ssl check` to troubleshoot your SSL configuration.
+        If your Chef Server uses a self-signed certificate, you can use
+        `knife ssl fetch` to make knife trust the server's certificates.
 MSG
       expect(stderr.string).to include(expected_message)
     end

data/spec/unit/log/syslog_spec.rb

@@ -18,7 +18,7 @@
 
 require "spec_helper"
 
-describe "Chef::Log::Syslog", :unix_only => true do
+describe "Chef::Log::Syslog", unix_only: true do
   let(:syslog) { Chef::Log::Syslog.new }
 
   before do

data/spec/unit/lwrp_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Christopher Walters (<cw@chef.io>)
-# Copyright:: Copyright 2009-2017, Chef Software Inc.
+# Copyright:: Copyright 2009-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -243,8 +243,8 @@ describe "LWRP" do
         let(:klass) do
           Class.new(Chef::Resource::LWRPBase) do
             self.resource_name = :sample_resource
-            attribute :food,  :default => lazy { "BACON!" * 3 }
-            attribute :drink, :default => lazy { |r| "Drink after #{r.food}!" }
+            attribute :food,  default: lazy { "BACON!" * 3 }
+            attribute :drink, default: lazy { |r| "Drink after #{r.food}!" }
           end
         end
 
@@ -520,7 +520,7 @@ describe "LWRP" do
       resource.provider(get_dynamic_lwrp_provider(:lwrp_embedded_resource_accesses_providers_scope))
 
       provider = resource.provider_for_action(:twiddle_thumbs)
-      #provider = @runner.build_provider(resource)
+      # provider = @runner.build_provider(resource)
       provider.action_twiddle_thumbs
 
       expect(provider.enclosed_resource.monkey).to eq("bob, the monkey")

data/spec/unit/mash_spec.rb

@@ -21,7 +21,7 @@ require "chef/mash"
 
 describe Mash do
   it "should duplicate a simple key/value mash to a new mash" do
-    data = { :x => "one", :y => "two", :z => "three" }
+    data = { x: "one", y: "two", z: "three" }
     @orig = Mash.new(data)
     @copy = @orig.dup
     expect(@copy.to_hash).to eq(Mash.new(data).to_hash)
@@ -30,7 +30,7 @@ describe Mash do
   end
 
   it "should duplicate a mash with an array to a new mash" do
-    data = { :x => "one", :y => "two", :z => [1, 2, 3] }
+    data = { x: "one", y: "two", z: [1, 2, 3] }
     @orig = Mash.new(data)
     @copy = @orig.dup
     expect(@copy.to_hash).to eq(Mash.new(data).to_hash)
@@ -39,7 +39,7 @@ describe Mash do
   end
 
   it "should duplicate a nested mash to a new mash" do
-    data = { :x => "one", :y => "two", :z => Mash.new({ :a => [1, 2, 3] }) }
+    data = { x: "one", y: "two", z: Mash.new({ a: [1, 2, 3] }) }
     @orig = Mash.new(data)
     @copy = @orig.dup
     expect(@copy.to_hash).to eq(Mash.new(data).to_hash)

data/spec/unit/mixin/api_version_request_handling_spec.rb

@@ -26,24 +26,24 @@ describe Chef::Mixin::ApiVersionRequestHandling do
     let(:default_supported_client_versions) { [0, 1, 2] }
 
     context "when the response code is not 406" do
-      let(:response) { OpenStruct.new(:code => "405") }
+      let(:response) { OpenStruct.new(code: "405") }
       let(:exception) { Net::HTTPServerException.new("405 Something Else", response) }
 
       it "returns nil" do
-        expect(object.server_client_api_version_intersection(exception, default_supported_client_versions)).
-          to be_nil
+        expect(object.server_client_api_version_intersection(exception, default_supported_client_versions))
+          .to be_nil
       end
 
     end # when the response code is not 406
 
     context "when the response code is 406" do
-      let(:response) { OpenStruct.new(:code => "406") }
+      let(:response) { OpenStruct.new(code: "406") }
       let(:exception) { Net::HTTPServerException.new("406 Not Acceptable", response) }
 
       context "when x-ops-server-api-version header does not exist" do
         it "returns nil" do
-          expect(object.server_client_api_version_intersection(exception, default_supported_client_versions)).
-            to be_nil
+          expect(object.server_client_api_version_intersection(exception, default_supported_client_versions))
+            .to be_nil
         end
       end # when x-ops-server-api-version header does not exist
 
@@ -64,13 +64,13 @@ describe Chef::Mixin::ApiVersionRequestHandling do
         context "when there is no intersection between client and server versions" do
           shared_examples_for "no intersection between client and server versions" do
             it "return an array" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions)).
-                to be_a_kind_of(Array)
+              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
+                .to be_a_kind_of(Array)
             end
 
             it "returns an empty array" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions).length).
-                to eq(0)
+              expect(object.server_client_api_version_intersection(exception, supported_client_versions).length)
+                .to eq(0)
             end
 
           end
@@ -94,8 +94,8 @@ describe Chef::Mixin::ApiVersionRequestHandling do
             let(:supported_client_versions) { [1, 2, 3, 4, 5] }
 
             it "includes all of the intersection" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions)).
-                to eq([2, 3, 4])
+              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
+                .to eq([2, 3, 4])
             end
           end # when multiple versions intersect
 
@@ -103,8 +103,8 @@ describe Chef::Mixin::ApiVersionRequestHandling do
             let(:supported_client_versions) { [0, 1, 2] }
 
             it "includes the intersection" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions)).
-                to eq([2])
+              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
+                .to eq([2])
             end
           end # when only the min client version intersects
 
@@ -112,8 +112,8 @@ describe Chef::Mixin::ApiVersionRequestHandling do
             let(:supported_client_versions) { [4, 5, 6] }
 
             it "includes the intersection" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions)).
-                to eq([4])
+              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
+                .to eq([4])
             end
           end # when only the max client version intersects