chef 12.13.37-universal-mingw32 → 12.14.60-universal-mingw32

data/spec/unit/dsl/audit_spec.rb

@@ -21,14 +21,14 @@ describe Chef::DSL::Audit do
   end
 
   it "raises an error when no audit name is given" do
-    expect { auditor.control_group do end }.to raise_error(Chef::Exceptions::AuditNameMissing)
+    expect { auditor.control_group {} }.to raise_error(Chef::Exceptions::AuditNameMissing)
   end
 
   context "audits already populated" do
     let(:audits) { { "unique" => {} } }
 
     it "raises an error if the audit name is a duplicate" do
-      expect { auditor.control_group "unique" do end }.to raise_error(Chef::Exceptions::AuditControlGroupDuplicate)
+      expect { auditor.control_group("unique") {} }.to raise_error(Chef::Exceptions::AuditControlGroupDuplicate)
     end
   end
 
@@ -36,7 +36,7 @@ describe Chef::DSL::Audit do
     let(:auditor) { BadAuditDSLTester.new }
 
     it "fails because it relies on the recipe DSL existing" do
-      expect { auditor.control_group "unique" do end }.to raise_error(NoMethodError, /undefined method `cookbook_name'/)
+      expect { auditor.control_group("unique") {} }.to raise_error(NoMethodError, /undefined method `cookbook_name'/)
     end
   end
 

data/spec/unit/dsl/data_query_spec.rb

@@ -60,14 +60,15 @@ describe Chef::DSL::DataQuery do
 
     let(:item_name) { "item_name" }
 
-    let(:raw_data) {{
+    let(:raw_data) do
+      {
       "id" => item_name,
       "greeting" => "hello",
       "nested" => {
         "a1" => [1, 2, 3],
         "a2" => { "b1" => true },
       },
-    }}
+    } end
 
     let(:item) do
       item = Chef::DataBagItem.new

data/spec/unit/dsl/declare_resource_spec.rb

@@ -50,17 +50,17 @@ describe Chef::ResourceCollection do
 
   describe "#edit_resource!" do
     it "raises if nothing is found" do
-      expect {
+      expect do
         recipe.edit_resource!(:zen_master, "monkey") do
           something true
         end
-      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+      end.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
 
     it "raises if nothing is found and no block is given" do
-      expect {
+      expect do
         recipe.edit_resource!(:zen_master, "monkey")
-      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+      end.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
 
     it "edits the resource if it finds one" do
@@ -131,20 +131,20 @@ describe Chef::ResourceCollection do
 
   describe "#find_resource!" do
     it "raises if nothing is found" do
-      expect {
+      expect do
         recipe.find_resource!(:zen_master, "monkey")
-      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+      end.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
 
     it "raises if given a block" do
       resource = recipe.declare_resource(:zen_master, "monkey") do
         something false
       end
-      expect {
+      expect do
         recipe.find_resource!(:zen_master, "monkey") do
           something false
         end
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "returns the resource if it finds one" do
@@ -221,9 +221,9 @@ describe Chef::ResourceCollection do
 
   describe "#delete_resource!" do
     it "raises if nothing is found" do
-      expect {
+      expect do
         recipe.delete_resource!(:zen_master, "monkey")
-      }.to raise_error(Chef::Exceptions::ResourceNotFound)
+      end.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
 
     it "deletes and returns the resource if it finds one" do

data/spec/unit/encrypted_data_bag_item/check_encrypted_spec.rb

@@ -39,14 +39,15 @@ describe Chef::EncryptedDataBagItem::CheckEncrypted do
 
     let(:default_secret) { "abc123SECRET" }
     let(:item_name) { "item_name" }
-    let(:raw_data) {{
+    let(:raw_data) do
+      {
         "id" => item_name,
         "greeting" => "hello",
         "nested" => {
             "a1" => [1, 2, 3],
             "a2" => { "b1" => true },
         },
-    }}
+    } end
 
     let(:version) { 1 }
     let(:encoded_data) do

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -320,11 +320,12 @@ end
 describe Chef::EncryptedDataBagItem do
   subject { described_class }
   let(:encrypted_data_bag_item) { subject.new(encoded_data, secret) }
-  let(:plaintext_data) {{
+  let(:plaintext_data) do
+    {
       "id" => "item_name",
       "greeting" => "hello",
       "nested" => { "a1" => [1, 2, 3], "a2" => { "b1" => true } },
-  }}
+  } end
   let(:secret) { "abc123SECRET" }
   let(:encoded_data) { subject.encrypt_data_bag_item(plaintext_data, secret) }
 

data/spec/unit/environment_spec.rb

@@ -296,9 +296,9 @@ describe Chef::Environment do
       end
 
       it "should raise and exception" do
-        expect {
+        expect do
           Chef::Environment.validate_cookbook_version("= 1.2.3.4")
-        }.to raise_error Chef::Exceptions::IllegalVersionConstraint,
+        end.to raise_error Chef::Exceptions::IllegalVersionConstraint,
                              "Environment cookbook version constraints not allowed in chef-solo"
       end
     end
@@ -450,9 +450,9 @@ describe Chef::Environment do
       it "should raise an error if the configured environment_path is invalid" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(false)
 
-        expect {
+        expect do
           Chef::Environment.load("foo")
-        }.to raise_error Chef::Exceptions::InvalidEnvironmentPath, "Environment path '/var/chef/environments' is invalid"
+        end.to raise_error Chef::Exceptions::InvalidEnvironmentPath, "Environment path '/var/chef/environments' is invalid"
       end
 
       it "should raise an error if the file does not exist" do
@@ -460,9 +460,9 @@ describe Chef::Environment do
         expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
         expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(false)
 
-        expect {
+        expect do
           Chef::Environment.load("foo")
-        }.to raise_error Chef::Exceptions::EnvironmentNotFound, "Environment 'foo' could not be loaded from disk"
+        end.to raise_error Chef::Exceptions::EnvironmentNotFound, "Environment 'foo' could not be loaded from disk"
       end
     end
   end

data/spec/unit/event_dispatch/dispatcher_spec.rb

@@ -52,8 +52,8 @@ describe Chef::EventDispatch::Dispatcher do
       dispatcher.synchronized_cookbook("apache2", cookbook_version)
 
       exception = StandardError.new("foo")
-      expect(event_sink).to receive(:recipe_file_load_failed).with("/path/to/file.rb", exception)
-      dispatcher.recipe_file_load_failed("/path/to/file.rb", exception)
+      expect(event_sink).to receive(:recipe_file_load_failed).with("/path/to/file.rb", exception, "myrecipe")
+      dispatcher.recipe_file_load_failed("/path/to/file.rb", exception, "myrecipe")
     end
 
     context "when an event sink has fewer arguments for an event" do

data/spec/unit/file_access_control_spec.rb

@@ -43,7 +43,7 @@ describe Chef::FileAccessControl do
     end
 
     describe "class methods" do
-      it 'responds to #writable?' do
+      it "responds to #writable?" do
         expect(Chef::FileAccessControl).to respond_to(:writable?)
       end
     end
@@ -67,7 +67,7 @@ describe Chef::FileAccessControl do
 
     it "raises a Chef::Exceptions::UserIDNotFound error when Etc can't find the user's name" do
       expect(Etc).to receive(:getpwnam).with("toor").and_raise(ArgumentError)
-      expect { @fac.target_uid ; @provider_requirements.run(:create) }.to raise_error(Chef::Exceptions::UserIDNotFound, "cannot determine user id for 'toor', does the user exist on this system?")
+      expect { @fac.target_uid; @provider_requirements.run(:create) }.to raise_error(Chef::Exceptions::UserIDNotFound, "cannot determine user id for 'toor', does the user exist on this system?")
     end
 
     it "does not attempt to resolve the uid if the user is not specified" do
@@ -84,7 +84,7 @@ describe Chef::FileAccessControl do
 
     it "raises an ArgumentError if the resource's owner is set to something wack" do
       @resource.instance_variable_set(:@owner, :diaf)
-      expect { @fac.target_uid ; @provider_requirements.run(:create) }.to raise_error(ArgumentError)
+      expect { @fac.target_uid; @provider_requirements.run(:create) }.to raise_error(ArgumentError)
     end
 
     it "uses the resource's uid for the target uid when the resource's owner is specified by an integer" do

data/spec/unit/file_content_management/tempfile_spec.rb

@@ -19,11 +19,11 @@
 require "spec_helper"
 
 describe Chef::FileContentManagement::Tempfile do
-  let(:resource) {
+  let(:resource) do
     r = Chef::Resource::File.new("new_file")
     r.path "/foo/bar/new_file"
     r
-  }
+  end
 
   subject { described_class.new(resource) }
 

data/spec/unit/formatters/error_inspectors/api_error_formatting_spec.rb

@@ -32,13 +32,13 @@ describe Chef::Formatters::APIErrorFormatting do
       let(:min_version) { "2" }
       let(:max_version) { "5" }
       let(:request_version) { "30" }
-      let(:return_hash) {
+      let(:return_hash) do
         {
           "min_version" => min_version,
           "max_version" => max_version,
           "request_version" => request_version,
         }
-      }
+      end
 
       before do
         # mock out the header

data/spec/unit/guard_interpreter/resource_guard_interpreter_spec.rb

@@ -105,9 +105,9 @@ describe Chef::GuardInterpreter::ResourceGuardInterpreter do
             parent_resource
           end
 
-          let(:shell_out) {
+          let(:shell_out) do
             instance_double(Mixlib::ShellOut, :live_stream => true, :run_command => true, :error! => nil)
-          }
+          end
 
           before do
             # TODO for some reason Windows is failing on executing a ruby script

data/spec/unit/http/basic_client_spec.rb

@@ -29,6 +29,26 @@ describe "HTTP Connection" do
     end
   end
 
+  describe "#initialize" do
+    it "calls .start when doing keepalives" do
+      basic_client = Chef::HTTP::BasicClient.new(uri, keepalives: true)
+      expect(basic_client).to receive(:configure_ssl)
+      net_http_mock = instance_double(Net::HTTP, proxy_address: nil, "proxy_port=" => nil, "read_timeout=" => nil, "open_timeout=" => nil)
+      expect(net_http_mock).to receive(:start).and_return(net_http_mock)
+      expect(Net::HTTP).to receive(:new).and_return(net_http_mock)
+      expect(basic_client.http_client).to eql(net_http_mock)
+    end
+
+    it "does not call .start when not doing keepalives" do
+      basic_client = Chef::HTTP::BasicClient.new(uri)
+      expect(basic_client).to receive(:configure_ssl)
+      net_http_mock = instance_double(Net::HTTP, proxy_address: nil, "proxy_port=" => nil, "read_timeout=" => nil, "open_timeout=" => nil)
+      expect(net_http_mock).not_to receive(:start)
+      expect(Net::HTTP).to receive(:new).and_return(net_http_mock)
+      expect(basic_client.http_client).to eql(net_http_mock)
+    end
+  end
+
   describe "#build_http_client" do
     it "should build an http client" do
       subject.build_http_client

data/spec/unit/http/validate_content_length_spec.rb

@@ -37,25 +37,25 @@ describe Chef::HTTP::ValidateContentLength do
   let(:content_length_value) { 23 }
   let(:streaming_length) { 23 }
   let(:response_body) { "Thanks for checking in." }
-  let(:response_headers) {
+  let(:response_headers) do
     {
       "content-length" => content_length_value,
     }
-  }
+  end
 
-  let(:response) {
+  let(:response) do
     m = double("HttpResponse", :body => response_body)
     allow(m).to receive(:[]) do |key|
       response_headers[key]
     end
 
     m
-  }
+  end
 
-  let(:middleware) {
+  let(:middleware) do
     client = TestClient.new(url)
     client.middlewares[0]
-  }
+  end
 
   def run_content_length_validation
     stream_handler = middleware.stream_response_handler(response)
@@ -169,12 +169,12 @@ describe Chef::HTTP::ValidateContentLength do
   end
 
   describe "when Transfer-Encoding & Content-Length is set" do
-    let(:response_headers) {
+    let(:response_headers) do
       {
         "content-length" => content_length_value,
         "transfer-encoding" => "chunked",
       }
-    }
+    end
 
     %w{direct streaming}.each do |req_type|
       describe "when running #{req_type} request" do

data/spec/unit/http_spec.rb

@@ -43,6 +43,20 @@ describe Chef::HTTP do
 
   end
 
+  describe "#intialize" do
+    it "accepts a keepalive option and passes it to the http_client" do
+      http = Chef::HTTP.new(uri, keepalives: true)
+      expect(Chef::HTTP::BasicClient).to receive(:new).with(uri, ssl_policy: Chef::HTTP::APISSLPolicy, keepalives: true).and_call_original
+      expect(http.http_client).to be_a_kind_of(Chef::HTTP::BasicClient)
+    end
+
+    it "the default is not to use keepalives" do
+      http = Chef::HTTP.new(uri)
+      expect(Chef::HTTP::BasicClient).to receive(:new).with(uri, ssl_policy: Chef::HTTP::APISSLPolicy, keepalives: false).and_call_original
+      expect(http.http_client).to be_a_kind_of(Chef::HTTP::BasicClient)
+    end
+  end
+
   describe "create_url" do
 
     it "should return a correctly formatted url 1/3 CHEF-5261" do

data/spec/unit/knife/bootstrap/chef_vault_handler_spec.rb

@@ -29,10 +29,10 @@ describe Chef::Knife::Bootstrap::ChefVaultHandler do
 
   let(:client) { Chef::ApiClient.new }
 
-  let(:chef_vault_handler) {
+  let(:chef_vault_handler) do
     chef_vault_handler = Chef::Knife::Bootstrap::ChefVaultHandler.new(knife_config: knife_config, ui: ui)
     chef_vault_handler
-  }
+  end
 
   context "when there's no vault option" do
     it "should report its not doing anything" do

data/spec/unit/knife/bootstrap/client_builder_spec.rb

@@ -33,12 +33,12 @@ describe Chef::Knife::Bootstrap::ClientBuilder do
 
   let(:rest) { double("Chef::ServerAPI") }
 
-  let(:client_builder) {
+  let(:client_builder) do
     client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(knife_config: knife_config, chef_config: chef_config, ui: ui)
     allow(client_builder).to receive(:rest).and_return(rest)
     allow(client_builder).to receive(:node_name).and_return(node_name)
     client_builder
-  }
+  end
 
   context "#sanity_check!" do
     let(:response_404) { OpenStruct.new(:code => "404") }

data/spec/unit/knife/bootstrap_spec.rb

@@ -236,11 +236,11 @@ describe Chef::Knife::Bootstrap do
     end
 
     context "with bootstrap_attribute options" do
-      let(:jsonfile) {
+      let(:jsonfile) do
         file = Tempfile.new (["node", ".json"])
         File.open(file.path, "w") { |f| f.puts '{"foo":{"bar":"baz"}}' }
         file
-      }
+      end
 
       it "should have foo => {bar => baz} in the first_boot from cli" do
         knife.parse_options(["-j", '{"foo":{"bar":"baz"}}'])
@@ -478,8 +478,9 @@ describe Chef::Knife::Bootstrap do
     end
 
     context "when client_d_dir is set" do
-      let(:client_d_dir) { Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../data/client.d_00")) }
+      let(:client_d_dir) do
+        Chef::Util::PathHelper.cleanpath(
+        File.join(File.dirname(__FILE__), "../../data/client.d_00")) end
 
       it "creates /etc/chef/client.d" do
         expect(rendered_template).to match("mkdir -p /etc/chef/client\.d")
@@ -497,8 +498,9 @@ describe Chef::Knife::Bootstrap do
       end
 
       context "a nested directory structure" do
-        let(:client_d_dir) { Chef::Util::PathHelper.cleanpath(
-          File.join(File.dirname(__FILE__), "../../data/client.d_01")) }
+        let(:client_d_dir) do
+          Chef::Util::PathHelper.cleanpath(
+          File.join(File.dirname(__FILE__), "../../data/client.d_01")) end
         it "creates a file foo/bar.rb" do
           expect(rendered_template).to match("cat > /etc/chef/client.d/foo/bar.rb <<'EOP'")
           expect(rendered_template).to match("1 / 0")

data/spec/unit/knife/client_bulk_delete_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Knife::ClientBulkDelete do
   let(:stderr_io) { StringIO.new }
   let(:stderr) { stderr_io.string }
 
-  let(:knife) {
+  let(:knife) do
     k = Chef::Knife::ClientBulkDelete.new
     k.name_args = name_args
     k.config = option_args
@@ -33,7 +33,7 @@ describe Chef::Knife::ClientBulkDelete do
     allow(k.ui).to receive(:confirm).and_return(knife_confirm)
     allow(k.ui).to receive(:confirm_without_exit).and_return(knife_confirm)
     k
-  }
+  end
 
   let(:name_args) { [ "." ] }
   let(:option_args) { {} }
@@ -41,7 +41,7 @@ describe Chef::Knife::ClientBulkDelete do
   let(:knife_confirm) { true }
 
   let(:nonvalidator_client_names) { %w{tim dan stephen} }
-  let(:nonvalidator_clients) {
+  let(:nonvalidator_clients) do
     clients = Hash.new
 
     nonvalidator_client_names.each do |client_name|
@@ -52,10 +52,10 @@ describe Chef::Knife::ClientBulkDelete do
     end
 
     clients
-  }
+  end
 
   let(:validator_client_names) { %w{myorg-validator} }
-  let(:validator_clients) {
+  let(:validator_clients) do
     clients = Hash.new
 
     validator_client_names.each do |validator_client_name|
@@ -67,12 +67,12 @@ describe Chef::Knife::ClientBulkDelete do
     end
 
     clients
-  }
+  end
 
   let(:client_names) { nonvalidator_client_names + validator_client_names }
-  let(:clients) {
+  let(:clients) do
     nonvalidator_clients.merge(validator_clients)
-  }
+  end
 
   before(:each) do
     allow(Chef::ApiClientV1).to receive(:list).and_return(clients)