chef 15.17.4 → 16.0.257

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -21,7 +21,6 @@ require "chef/dsl/platform_introspection"
 
 class LanguageTester
   attr_reader :node
-
   def initialize(node)
     @node = node
   end

data/spec/unit/environment_spec.rb

@@ -402,8 +402,8 @@ describe Chef::Environment do
 
       it "should get the environment from the environment_path" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
+        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")).exactly(1).times.and_return(true)
         expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         expect(File).to receive(:file?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         role_dsl = "name \"foo\"\ndescription \"desc\"\n"
@@ -413,7 +413,7 @@ describe Chef::Environment do
 
       it "should return a Chef::Environment object from JSON" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(true)
+        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(true)
         environment_hash = {
           "name" => "foo",
           "default_attributes" => {
@@ -436,8 +436,8 @@ describe Chef::Environment do
 
       it "should return a Chef::Environment object from Ruby DSL" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
+        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")).exactly(1).times.and_return(true)
         expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         expect(File).to receive(:file?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         role_dsl = "name \"foo\"\ndescription \"desc\"\n"
@@ -459,8 +459,8 @@ describe Chef::Environment do
 
       it "should raise an error if the file does not exist" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(false)
+        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 do
           Chef::Environment.load("foo")

data/spec/unit/event_dispatch/dispatcher_spec.rb

@@ -61,7 +61,6 @@ describe Chef::EventDispatch::Dispatcher do
       let(:event_sink) do
         Class.new(Chef::EventDispatch::Base) do
           attr_reader :synchronized_cookbook_args
-
           def synchronized_cookbook(cookbook_name)
             @synchronized_cookbook_args = [cookbook_name]
           end
@@ -80,7 +79,6 @@ describe Chef::EventDispatch::Dispatcher do
     let(:event_sink_1) do
       Class.new(Chef::EventDispatch::Base) do
         attr_reader :synchronized_cookbook_args
-
         def synchronized_cookbook(cookbook_name)
           @synchronized_cookbook_args = [cookbook_name]
         end
@@ -89,7 +87,6 @@ describe Chef::EventDispatch::Dispatcher do
     let(:event_sink_2) do
       Class.new(Chef::EventDispatch::Base) do
         attr_reader :synchronized_cookbook_args
-
         def synchronized_cookbook(cookbook_name, cookbook)
           @synchronized_cookbook_args = [cookbook_name, cookbook]
         end

data/spec/unit/file_access_control_spec.rb

@@ -93,7 +93,7 @@ describe Chef::FileAccessControl do
     end
 
     it "wraps uids to their negative complements to correctly handle negative uids" do
-      # More: macOS (at least) has negative UIDs for 'nobody' and some other
+      # More: Mac OS X (at least) has negative UIDs for 'nobody' and some other
       # users. Ruby doesn't believe in negative UIDs so you get the diminished radix
       # complement (i.e., it wraps around the maximum size of C unsigned int) of these
       # uids. So we have to get ruby and negative uids to smoke the peace pipe

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

@@ -25,12 +25,12 @@ describe Chef::Knife::Bootstrap::ChefVaultHandler do
   let(:stdin) { StringIO.new }
   let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
 
-  let(:knife_config) { {} }
+  let(:config) { {} }
 
   let(:client) { Chef::ApiClient.new }
 
   let(:chef_vault_handler) do
-    chef_vault_handler = Chef::Knife::Bootstrap::ChefVaultHandler.new(knife_config: knife_config, ui: ui)
+    chef_vault_handler = Chef::Knife::Bootstrap::ChefVaultHandler.new(config: config, ui: ui)
     chef_vault_handler
   end
 
@@ -55,28 +55,28 @@ describe Chef::Knife::Bootstrap::ChefVaultHandler do
       expect(bootstrap_vault_item).to receive(:save).at_least(:once)
     end
 
-    context "from knife_config[:bootstrap_vault_item]" do
+    context "from config[:bootstrap_vault_item]" do
       it "sets a single item as a scalar" do
-        knife_config[:bootstrap_vault_item] = { "vault" => "item1" }
+        config[:bootstrap_vault_item] = { "vault" => "item1" }
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         chef_vault_handler.run(client)
       end
 
       it "sets a single item as an array" do
-        knife_config[:bootstrap_vault_item] = { "vault" => [ "item1" ] }
+        config[:bootstrap_vault_item] = { "vault" => [ "item1" ] }
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         chef_vault_handler.run(client)
       end
 
       it "sets two items as an array" do
-        knife_config[:bootstrap_vault_item] = { "vault" => %w{item1 item2} }
+        config[:bootstrap_vault_item] = { "vault" => %w{item1 item2} }
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
         chef_vault_handler.run(client)
       end
 
       it "sets two vaults from different hash keys" do
-        knife_config[:bootstrap_vault_item] = { "vault" => %w{item1 item2}, "vault2" => [ "item3" ] }
+        config[:bootstrap_vault_item] = { "vault" => %w{item1 item2}, "vault2" => [ "item3" ] }
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
@@ -84,28 +84,28 @@ describe Chef::Knife::Bootstrap::ChefVaultHandler do
       end
     end
 
-    context "from knife_config[:bootstrap_vault_json]" do
+    context "from config[:bootstrap_vault_json]" do
       it "sets a single item as a scalar" do
-        knife_config[:bootstrap_vault_json] = '{ "vault": "item1" }'
+        config[:bootstrap_vault_json] = '{ "vault": "item1" }'
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         chef_vault_handler.run(client)
       end
 
       it "sets a single item as an array" do
-        knife_config[:bootstrap_vault_json] = '{ "vault": [ "item1" ] }'
+        config[:bootstrap_vault_json] = '{ "vault": [ "item1" ] }'
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         chef_vault_handler.run(client)
       end
 
       it "sets two items as an array" do
-        knife_config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ] }'
+        config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ] }'
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
         chef_vault_handler.run(client)
       end
 
       it "sets two vaults from different hash keys" do
-        knife_config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }'
+        config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }'
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
         expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
@@ -113,12 +113,12 @@ describe Chef::Knife::Bootstrap::ChefVaultHandler do
       end
     end
 
-    context "from knife_config[:bootstrap_vault_file]" do
+    context "from config[:bootstrap_vault_file]" do
 
       def setup_file_contents(json)
         stringio = StringIO.new(json)
-        knife_config[:bootstrap_vault_file] = "/foo/bar/baz"
-        expect(File).to receive(:read).with(knife_config[:bootstrap_vault_file]).and_return(stringio)
+        config[:bootstrap_vault_file] = "/foo/bar/baz"
+        expect(File).to receive(:read).with(config[:bootstrap_vault_file]).and_return(stringio)
       end
 
       it "sets a single item as a scalar" do

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

@@ -25,7 +25,7 @@ describe Chef::Knife::Bootstrap::ClientBuilder do
   let(:stdin) { StringIO.new }
   let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
 
-  let(:knife_config) { {} }
+  let(:config) { {} }
 
   let(:chef_config) { {} }
 
@@ -34,7 +34,7 @@ describe Chef::Knife::Bootstrap::ClientBuilder do
   let(:rest) { double("Chef::ServerAPI") }
 
   let(:client_builder) do
-    client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(knife_config: knife_config, chef_config: chef_config, ui: ui)
+    client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(config: 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
@@ -160,7 +160,7 @@ describe Chef::Knife::Bootstrap::ClientBuilder do
     it "adds tags to the node when given" do
       tag_receiver = []
 
-      knife_config[:tags] = %w{foo bar}
+      config[:tags] = %w{foo bar}
       allow(node).to receive(:run_list).with([])
       allow(node).to receive(:tags).and_return(tag_receiver)
       client_builder.run
@@ -168,34 +168,34 @@ describe Chef::Knife::Bootstrap::ClientBuilder do
     end
 
     it "builds a node when the run_list is a string" do
-      knife_config[:run_list] = "role[base],role[app]"
+      config[:run_list] = "role[base],role[app]"
       expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
       client_builder.run
     end
 
     it "builds a node when the run_list is an Array" do
-      knife_config[:run_list] = ["role[base]", "role[app]"]
+      config[:run_list] = ["role[base]", "role[app]"]
       expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
       client_builder.run
     end
 
     it "builds a node with first_boot_attributes if they're given" do
-      knife_config[:first_boot_attributes] = { baz: :quux }
+      config[:first_boot_attributes] = { baz: :quux }
       expect(node).to receive(:normal_attrs=).with({ baz: :quux })
       expect(node).to receive(:run_list).with([])
       client_builder.run
     end
 
     it "builds a node with an environment if its given" do
-      knife_config[:environment] = "production"
+      config[:environment] = "production"
       expect(node).to receive(:environment).with("production")
       expect(node).to receive(:run_list).with([])
       client_builder.run
     end
 
     it "builds a node with policy_name and policy_group when given" do
-      knife_config[:policy_name] = "my-app"
-      knife_config[:policy_group] = "staging"
+      config[:policy_name] = "my-app"
+      config[:policy_group] = "staging"
 
       expect(node).to receive(:run_list).with([])
       expect(node).to receive(:policy_name=).with("my-app")

data/spec/unit/knife/bootstrap_spec.rb

@@ -206,7 +206,7 @@ describe Chef::Knife::Bootstrap do
       end
 
       before(:each) do
-        expect(File).to receive(:exist?).with(bootstrap_template).and_return(false)
+        expect(File).to receive(:exists?).with(bootstrap_template).and_return(false)
       end
 
       context "when file is available everywhere" do
@@ -215,7 +215,7 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exist?).with(builtin_template_path).and_return(true)
+          expect(File).to receive(:exists?).with(builtin_template_path).and_return(true)
         end
 
         it "should load the template from built-in templates" do
@@ -229,8 +229,8 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(true)
+          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(true)
 
           it "should load the template from chef_config_dir" do
             knife.find_template.should eq(chef_config_dir_template_path)
@@ -244,9 +244,9 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(env_home_template_path).and_return(true)
+          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(env_home_template_path).and_return(true)
         end
 
         it "should load the template from chef_config_dir" do
@@ -260,10 +260,10 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(env_home_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(gem_files_template_path).and_return(true)
+          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(env_home_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
         end
 
         it "should load the template from Gem files" do
@@ -277,9 +277,9 @@ describe Chef::Knife::Bootstrap do
           configure_gem_files
           allow(Chef::Util::PathHelper).to receive(:home).with(".chef", "bootstrap", "example.erb").and_return(nil)
 
-          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exist?).with(gem_files_template_path).and_return(true)
+          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
         end
 
         it "should load the template from Gem files" do
@@ -382,7 +382,7 @@ describe Chef::Knife::Bootstrap do
       k
     end
 
-    let(:options) { ["--bootstrap-no-proxy", setting, "-s", "foo"] }
+    let(:options) { ["--bootstrap-no-proxy", setting] }
 
     let(:template_file) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "no_proxy.erb")) }
 
@@ -518,6 +518,7 @@ describe Chef::Knife::Bootstrap do
 
     before do
       Chef::Config[:knife][:bootstrap_template] = template_file
+      knife.merge_configs
     end
 
     let(:rendered_template) do
@@ -530,7 +531,6 @@ describe Chef::Knife::Bootstrap do
       end
 
       it "renders 'fips true'" do
-        Chef::Config[:fips] = true
         expect(rendered_template).to match("fips")
       end
     end
@@ -617,6 +617,7 @@ describe Chef::Knife::Bootstrap do
       allow(knife).to receive(:host_descriptor).and_return host_descriptor
       if knife_connection_protocol
         Chef::Config[:knife][:connection_protocol] = knife_connection_protocol
+        knife.merge_configs
       end
     end
 
@@ -827,6 +828,7 @@ describe Chef::Knife::Bootstrap do
           before do
             # Set everything to easily identifiable and obviously fake values
             # to verify that Chef::Config is being sourced instead of knife.config
+            knife.config = {}
             Chef::Config[:knife][:max_wait] = 9999
             Chef::Config[:knife][:winrm_user] = "winbob"
             Chef::Config[:knife][:winrm_port] = 9999
@@ -841,21 +843,7 @@ describe Chef::Knife::Bootstrap do
             Chef::Config[:knife][:winrm_ssl_peer_fingerprint] = "ABCDEF"
           end
 
-          context "and unsupported Chef::Config options are given in Chef::Config, not in CLI" do
-            before do
-              Chef::Config[:knife][:connection_password] = "blah"
-              Chef::Config[:knife][:winrm_password] = "blah"
-            end
-            it "does not include the corresponding option in the connection options" do
-              expect(knife.connection_opts.key?(:password)).to eq false
-            end
-          end
-
           context "and no CLI options have been given" do
-            before do
-              knife.config = {}
-              knife.merge_configs
-            end
             let(:expected_result) do
               {
                 logger: Chef::Log, # not configurable
@@ -875,6 +863,7 @@ describe Chef::Knife::Bootstrap do
             end
 
             it "generates a config hash using the Chef::Config values" do
+              knife.merge_configs
               expect(knife.connection_opts).to match expected_result
             end
 
@@ -886,7 +875,7 @@ describe Chef::Knife::Bootstrap do
                 logger: Chef::Log, # not configurable
                 ca_trust_path: "no trust",
                 max_wait_until_ready: 9999,
-                operation_timeout: 60,
+                operation_timeout: 9999,
                 ssl_peer_fingerprint: "ABCDEF",
                 winrm_transport: "kerberos",
                 winrm_basic_auth_only: true,
@@ -906,10 +895,10 @@ describe Chef::Knife::Bootstrap do
               knife.config[:connection_port] = 12
               knife.config[:winrm_port] = "13" # indirectly verify we're not looking for the wrong CLI flag
               knife.config[:connection_password] = "lobster"
-              knife.merge_configs
             end
 
             it "generates a config hash using the CLI options when available and falling back to Chef::Config values" do
+              knife.merge_configs
               expect(knife.connection_opts).to match expected_result
             end
           end
@@ -956,6 +945,7 @@ describe Chef::Knife::Bootstrap do
               }
             end
             it "generates a config hash using the CLI options and pulling nothing from Chef::Config" do
+              knife.merge_configs
               expect(knife.connection_opts).to match expected_result
             end
           end
@@ -965,7 +955,6 @@ describe Chef::Knife::Bootstrap do
           before do
             # We will use knife's actual config since these tests
             # have assumptions based on CLI default values
-            knife.merge_configs
           end
           let(:expected_result) do
             {
@@ -979,6 +968,7 @@ describe Chef::Knife::Bootstrap do
             }
           end
           it "populates appropriate defaults" do
+            knife.merge_configs
             expect(knife.connection_opts).to match expected_result
           end
         end
@@ -992,6 +982,7 @@ describe Chef::Knife::Bootstrap do
           before do
             # Set everything to easily identifiable and obviously fake values
             # to verify that Chef::Config is being sourced instead of knife.config
+            knife.config = {}
             Chef::Config[:knife][:max_wait] = 9999
             Chef::Config[:knife][:session_timeout] = 9999
             Chef::Config[:knife][:ssh_user] = "sshbob"
@@ -1004,10 +995,6 @@ describe Chef::Knife::Bootstrap do
           end
 
           context "and no CLI options have been given" do
-            before do
-              knife.config = {}
-              knife.merge_configs
-            end
             let(:expected_result) do
               {
                 logger: Chef::Log, # not configurable
@@ -1021,13 +1008,14 @@ describe Chef::Knife::Bootstrap do
                 keys_only: true,
                 key_files: ["/identity.pem", "/gateway.pem"],
                 sudo: false,
-                verify_host_key: false,
+                verify_host_key: "always",
                 port: 9999,
                 non_interactive: true,
               }
             end
 
             it "generates a correct config hash using the Chef::Config values" do
+              knife.merge_configs
               expect(knife.connection_opts).to match expected_result
             end
           end
@@ -1041,6 +1029,7 @@ describe Chef::Knife::Bootstrap do
               Chef::Config[:knife][:ssh_forward_agent] = "blah"
             end
             it "does not include the corresponding option in the connection options" do
+              knife.merge_configs
               expect(knife.connection_opts.key?(:password)).to eq false
               expect(knife.connection_opts.key?(:ssh_forward_agent)).to eq false
               expect(knife.connection_opts.key?(:use_sudo)).to eq false
@@ -1050,6 +1039,7 @@ describe Chef::Knife::Bootstrap do
 
           context "and some CLI options have been given" do
             before do
+              knife.config = {}
               knife.config[:connection_user] = "sshalice"
               knife.config[:connection_port] = 12
               knife.config[:ssh_port] = "13" # canary to indirectly verify we're not looking for the wrong CLI flag
@@ -1059,7 +1049,6 @@ describe Chef::Knife::Bootstrap do
               knife.config[:use_sudo] = true
               knife.config[:use_sudo_pasword] = true
               knife.config[:ssh_forward_agent] = true
-              knife.merge_configs
             end
 
             let(:expected_result) do
@@ -1076,19 +1065,21 @@ describe Chef::Knife::Bootstrap do
                 keys_only: false, # implied false from config password present
                 key_files: ["/identity.pem", "/gateway.pem"], # Config
                 sudo: true, # ccli
-                verify_host_key: false, # Config
+                verify_host_key: "always", # Config
                 port: 12, # cli
                 non_interactive: true,
               }
             end
 
             it "generates a config hash using the CLI options when available and falling back to Chef::Config values" do
+              knife.merge_configs
               expect(knife.connection_opts).to match expected_result
             end
           end
 
           context "and all CLI options have been given" do
             before do
+              knife.config = {}
               knife.config[:max_wait] = 150
               knife.config[:session_timeout] = 120
               knife.config[:connection_user] = "sshroot"
@@ -1133,6 +1124,7 @@ describe Chef::Knife::Bootstrap do
               }
             end
             it "generates a config hash using the CLI options and pulling nothing from Chef::Config" do
+              knife.merge_configs
               expect(knife.connection_opts).to match expected_result
             end
           end
@@ -1141,7 +1133,7 @@ describe Chef::Knife::Bootstrap do
           before do
             # We will use knife's actual config since these tests
             # have assumptions based on CLI default values
-            knife.merge_configs
+            config = {}
           end
 
           let(:expected_result) do
@@ -1157,6 +1149,7 @@ describe Chef::Knife::Bootstrap do
             }
           end
           it "populates appropriate defaults" do
+            knife.merge_configs
             expect(knife.connection_opts).to match expected_result
           end
         end
@@ -1173,17 +1166,6 @@ describe Chef::Knife::Bootstrap do
       allow(knife).to receive(:connection_protocol).and_return connection_protocol
     end
 
-    context "when determining knife config keys for user and port" do
-      let(:connection_protocol) { "fake" }
-      it "uses the protocol name to resolve the knife config keys" do
-        allow(knife).to receive(:config_value).with(:max_wait)
-
-        expect(knife).to receive(:config_value).with(:connection_port, :fake_port)
-        expect(knife).to receive(:config_value).with(:connection_user, :fake_user)
-        knife.base_opts
-      end
-    end
-
     context "for all protocols" do
       context "when password is provided" do
         before do
@@ -1747,8 +1729,8 @@ describe Chef::Knife::Bootstrap do
         allow(vault_handler_mock).to receive(:doing_chef_vault?).and_return false
       end
 
-      it "shows a warning message" do
-        expect(knife.ui).to receive(:warn).twice
+      it "shows a message" do
+        expect(knife.ui).to receive(:info)
         knife.register_client
       end
     end