knife-windows 0.8.6 → 1.0.0.rc.0

data/lib/chef/knife/wsman_test.rb

@@ -0,0 +1,96 @@
+#
+# Author:: Steven Murawski (<smurawski@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'httpclient'
+require 'nokogiri'
+require 'chef/knife'
+require 'chef/knife/winrm_knife_base'
+require 'chef/knife/wsman_endpoint'
+require 'pry'
+
+class Chef
+  class Knife
+    class WsmanTest < Knife
+
+      include Chef::Knife::WinrmCommandSharedFunctions
+
+      deps do
+        require 'chef/search/query'
+      end
+
+      banner "knife wsman test QUERY (options)"
+
+      def run
+        @config[:winrm_authentication_protocol] = 'basic'
+        configure_session
+        verify_wsman_accessiblity_for_nodes
+      end
+
+      def verify_wsman_accessiblity_for_nodes
+        error_count = 0
+        @winrm_sessions.each do |item|
+          Chef::Log.debug("checking for WSMAN availability at #{item.endpoint}")
+
+          xml = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:wsmid="http://schemas.dmtf.org/wbem/wsman/identity/1/wsmanidentity.xsd"><s:Header/><s:Body><wsmid:Identify/></s:Body></s:Envelope>'
+          header = {
+            'WSMANIDENTIFY' => 'unauthenticated',
+            'Content-Type' => 'application/soap+xml; charset=UTF-8'
+          }
+          output_object = Chef::Knife::WsmanEndpoint.new(item.host, item.port, item.endpoint)
+          error_message = nil
+          begin
+            client = HTTPClient.new
+            response = client.post(item.endpoint, xml, header)
+          rescue Exception => e
+            error_message = e.message
+          else
+            ui.msg "Connected successfully to #{item.host} at #{item.endpoint}."
+            output_object.response_status_code = response.status_code
+          end
+
+          if response.nil? || output_object.response_status_code != 200
+            error_message = "No valid WSMan endoint listening at #{item.endpoint}."
+          else
+            doc = Nokogiri::XML response.body
+            namespace = 'http://schemas.dmtf.org/wbem/wsman/identity/1/wsmanidentity.xsd'
+            output_object.protocol_version = doc.xpath('//wsmid:ProtocolVersion', 'wsmid' => namespace).text
+            output_object.product_version  = doc.xpath('//wsmid:ProductVersion',  'wsmid' => namespace).text
+            output_object.product_vendor  = doc.xpath('//wsmid:ProductVendor',   'wsmid' => namespace).text
+            if output_object.protocol_version.to_s.strip.length == 0
+              error_message = "Endpoint #{item.endpoint} on #{item.host} does not appear to be a WSMAN endpoint."
+            end
+          end
+
+          unless error_message.nil?
+            ui.warn "Failed to connect to #{item.host} at #{item.endpoint}."
+            output_object.error_message = error_message
+            error_count += 1
+          end
+
+          if config[:verbosity] >= 1
+            output(output_object)
+          end
+        end
+        if error_count > 0
+          ui.error "Failed to connect to #{error_count} nodes."
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/knife-windows/path_helper.rb

@@ -148,6 +148,83 @@ module Knife
       def self.relative_path_from(from, to)
         pathname = Pathname.new(Chef::Util::PathHelper.cleanpath(to)).relative_path_from(Pathname.new(Chef::Util::PathHelper.cleanpath(from)))
       end
+
+      # Retrieves the "home directory" of the current user while trying to ascertain the existence
+      # of said directory.  The path returned uses / for all separators (the ruby standard format).
+      # If the home directory doesn't exist or an error is otherwise encountered, nil is returned.
+      # 
+      # If a set of path elements is provided, they are appended as-is to the home path if the
+      # homepath exists. 
+      # 
+      # If an optional block is provided, the joined path is passed to that block if the home path is
+      # valid and the result of the block is returned instead.
+      #
+      # Home-path discovery is performed once.  If a path is discovered, that value is memoized so
+      # that subsequent calls to home_dir don't bounce around.
+      #
+      # See self.all_homes.
+      def self.home(*args)
+        @@home_dir ||= self.all_homes { |p| break p }
+        if @@home_dir
+          path = File.join(@@home_dir, *args)
+          block_given? ? (yield path) : path
+        end
+      end
+
+      # See self.home.  This method performs a similar operation except that it yields all the different
+      # possible values of 'HOME' that one could have on this platform.  Hence, on windows, if
+      # HOMEDRIVE\HOMEPATH and USERPROFILE are different, the provided block will be called twice.
+      # This method goes out and checks the existence of each location at the time of the call.
+      #
+      # The return is a list of all the returned values from each block invocation or a list of paths
+      # if no block is provided.
+      def self.all_homes(*args)
+        paths = []
+        if Chef::Platform.windows?
+          # By default, Ruby uses the the following environment variables to determine Dir.home:
+          # HOME
+          # HOMEDRIVE HOMEPATH
+          # USERPROFILE
+          # Ruby only checks to see if the variable is specified - not if the directory actually exists.
+          # On Windows, HOMEDRIVE HOMEPATH can point to a different location (such as an unavailable network mounted drive)
+          # while USERPROFILE points to the location where the user application settings and profile are stored.  HOME
+          # is not defined as an environment variable (usually).  If the home path actually uses UNC, then the prefix is
+          # HOMESHARE instead of HOMEDRIVE.
+          #
+          # We instead walk down the following and only include paths that actually exist.
+          # HOME
+          # HOMEDRIVE HOMEPATH
+          # HOMESHARE HOMEPATH
+          # USERPROFILE
+
+          paths << ENV['HOME']
+          paths << ENV['HOMEDRIVE'] + ENV['HOMEPATH'] if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+          paths << ENV['HOMESHARE'] + ENV['HOMEPATH'] if ENV['HOMESHARE'] && ENV['HOMEPATH']
+          paths << ENV['USERPROFILE']
+        end
+        paths << Dir.home if ENV['HOME']
+
+        # Depending on what environment variables we're using, the slashes can go in any which way.
+        # Just change them all to / to keep things consistent.
+        # Note: Maybe this is a bad idea on some unixy systems where \ might be a valid character depending on
+        # the particular brand of kool-aid you consume.  This code assumes that \ and / are both
+        # path separators on any system being used.
+        paths = paths.map { |home_path| home_path.gsub(path_separator, ::File::SEPARATOR) if home_path }
+        
+        # Filter out duplicate paths and paths that don't exist.
+        valid_paths = paths.select { |home_path| home_path && Dir.exists?(home_path) }
+        valid_paths = valid_paths.uniq
+        
+        # Join all optional path elements at the end.
+        # If a block is provided, invoke it - otherwise just return what we've got.
+        joined_paths = valid_paths.map { |home_path| File.join(home_path, *args) }
+        if block_given?
+          joined_paths.each { |p| yield p }
+        else
+          joined_paths
+        end
+      end
+
     end
   end
 end

data/lib/knife-windows/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Windows
-    VERSION = "0.8.6"
+    VERSION = "1.0.0.rc.0"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

data/spec/functional/bootstrap_download_spec.rb

@@ -25,7 +25,7 @@ require 'tmpdir'
 # Windows nodes. The test modifies the Windows batch file generated
 # from an erb template in the plugin source in order to enable execution
 # of only the download functionality contained in the bootstrap template.
-# The test relies on knowledge of the fields of the template itself and 
+# The test relies on knowledge of the fields of the template itself and
 # also on knowledge of the contents and structure of the Windows batch
 # file generated by the template.
 #
@@ -34,7 +34,7 @@ require 'tmpdir'
 # occur, the bootstrap code should be refactored to explicitly expose
 # the download funcitonality separately from other tasks to make the
 # test more robust.
-describe 'Knife::Windows::Core msi download functionality for knife Windows winrm bootstrap template' do 
+describe 'Knife::Windows::Core msi download functionality for knife Windows winrm bootstrap template' do
 
   before(:all) do
     # Since we're always running 32-bit Ruby, fix the
@@ -43,7 +43,7 @@ describe 'Knife::Windows::Core msi download functionality for knife Windows winr
     if ENV["PROCESSOR_ARCHITEW6432"]
       ENV["PROCESSOR_ARCHITECTURE"] = ENV["PROCESSOR_ARCHITEW6432"]
     end
-    
+
     # All file artifacts from this test will be written into this directory
     @temp_directory = Dir.mktmpdir("bootstrap_test")
 
@@ -51,8 +51,8 @@ describe 'Knife::Windows::Core msi download functionality for knife Windows winr
     # the downloaded msi
     @local_file_download_destination = "#{@temp_directory}/chef-client-latest.msi"
 
-    source_code_directory = File.dirname(__FILE__)    
-    @template_file_path ="#{source_code_directory}/../../lib/chef/knife/bootstrap/windows-chef-client-msi.erb"    
+    source_code_directory = File.dirname(__FILE__)
+    @template_file_path ="#{source_code_directory}/../../lib/chef/knife/bootstrap/windows-chef-client-msi.erb"
   end
 
   after(:all) do
@@ -71,7 +71,7 @@ describe 'Knife::Windows::Core msi download functionality for knife Windows winr
       # from being populated, i.e. chef installation and first chef
       # run sections
       allow(mock_bootstrap_context).to receive(:validation_key).and_return("echo.validation_key")
-      allow(mock_bootstrap_context).to receive(:encrypted_data_bag_secret).and_return("echo.encrypted_data_bag_secret")
+      allow(mock_bootstrap_context).to receive(:secret).and_return("echo.encrypted_data_bag_secret")
       allow(mock_bootstrap_context).to receive(:config_content).and_return("echo.config_content")
       allow(mock_bootstrap_context).to receive(:start_chef).and_return("echo.echo start_chef_command")
       allow(mock_bootstrap_context).to receive(:run_list).and_return("echo.run_list")
@@ -86,25 +86,19 @@ describe 'Knife::Windows::Core msi download functionality for knife Windows winr
       allow(Chef::Knife::Winrm).to receive(:new).and_return(mock_winrm)
 
       allow(Chef::Knife::Core::WindowsBootstrapContext).to receive(:new).and_return(mock_bootstrap_context)
+      Chef::Config[:knife] = {:winrm_transport => 'plaintext', :chef_node_name => 'foo.example.com', :winrm_authentication_protocol => 'negotiate'}
     end
 
-    it "downloads the chef-client MSI during winrm bootstrap" do
-
-      clean_test_case
-
-      winrm_bootstrapper = Chef::Knife::BootstrapWindowsWinrm.new([ "127.0.0.1" ])
-      allow(winrm_bootstrapper).to receive(:wait_for_remote_response)
-      winrm_bootstrapper.config[:template_file] = @template_file_path      
+    it "downloads the chef-client MSI from the default location during winrm bootstrap" do
+      run_download_scenario
+    end
 
-      # Execute the commands locally that would normally be executed via WinRM
-      allow(winrm_bootstrapper).to receive(:run_command) do |command|
-        system(command)
+    context "when provided a custom msi_url to fetch from" do
+      let(:mock_bootstrap_context) { Chef::Knife::Core::WindowsBootstrapContext.new(
+        { :msi_url => "file:///C:/Windows/System32/xcopy.exe" }, nil, { :knife => {} }) }
+      it "downloads the chef-client MSI from a custom path during winrm bootstrap" do
+        run_download_scenario
       end
-
-      winrm_bootstrapper.run
-
-      # Download should succeed
-      expect(download_succeeded?).to be true
     end
   end
 
@@ -118,5 +112,29 @@ describe 'Knife::Windows::Core msi download functionality for knife Windows winr
       File.delete(@local_file_download_destination)
     end
   end
-  
-end 
+
+  def run_download_scenario
+    clean_test_case
+
+    winrm_bootstrapper = Chef::Knife::BootstrapWindowsWinrm.new([ "127.0.0.1" ])
+
+    if chef_gte_12?
+      winrm_bootstrapper.client_builder = instance_double("Chef::Knife::Bootstrap::ClientBuilder", :run => nil, :client_path => nil)
+    elsif chef_lt_12?
+      allow(File).to receive(:exist?).with(File.expand_path(Chef::Config[:validation_key])).and_return(true)
+    end
+
+    allow(winrm_bootstrapper).to receive(:wait_for_remote_response)
+    winrm_bootstrapper.config[:template_file] = @template_file_path
+
+    # Execute the commands locally that would normally be executed via WinRM
+    allow(winrm_bootstrapper).to receive(:run_command) do |command|
+      system(command)
+    end
+
+    winrm_bootstrapper.run
+
+    # Download should succeed
+    expect(download_succeeded?).to be true
+  end
+end

data/spec/spec_helper.rb

@@ -23,6 +23,7 @@ end
 
 require_relative '../lib/chef/knife/core/windows_bootstrap_context'
 require_relative '../lib/chef/knife/bootstrap_windows_winrm'
+require_relative '../lib/chef/knife/wsman_test'
 
 if windows?
   require 'ruby-wmi'
@@ -30,7 +31,7 @@ end
 
 def windows2012?
   is_win2k12 = false
-  
+
   if  windows?
     this_operating_system = WMI::Win32_OperatingSystem.find(:first)
     os_version = this_operating_system.send('Version')
@@ -53,9 +54,18 @@ def windows2012?
   is_win2k12
 end
 
+def chef_gte_12?
+  Chef::VERSION.split('.').first.to_i >= 12
+end
+
+def chef_lt_12?
+  Chef::VERSION.split('.').first.to_i < 12
+end
 
 RSpec.configure do |config|
   config.filter_run_excluding :windows_only => true unless windows?
   config.filter_run_excluding :windows_2012_only => true unless windows2012?
+  config.filter_run_excluding :chef_gte_12_only => true unless chef_gte_12?
+  config.filter_run_excluding :chef_lt_12_only => true unless chef_lt_12?
 end
 

data/spec/unit/knife/bootstrap_template_spec.rb

@@ -20,25 +20,17 @@ TEMPLATE_FILE = File.expand_path(File.dirname(__FILE__)) + "/../../../lib/chef/k
 
 require 'spec_helper'
 
-describe "While Windows Bootstrapping" do
-  context "the default Windows bootstrapping template" do
-    bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
-    bootstrap.config[:template_file] = TEMPLATE_FILE
-
-    template = bootstrap.load_template
-    template_file_lines = template.split('\n')
-    it "should download Platform specific MSI" do
-      download_url=template_file_lines.find {|l| l.include?("url=")}
-      download_url.include?("%MACHINE_OS%") && download_url.include?("%MACHINE_ARCH%")
-    end
-    it "should download specific version of MSI if supplied" do
-      download_url_ext= template_file_lines.find {|l| l.include?("url +=")}
-      download_url_ext.include?("[:bootstrap_version]")
-    end
+describe Chef::Knife::BootstrapWindowsWinrm do
+  let(:template_file) { TEMPLATE_FILE }
+  let(:options) { [] }
+  let(:rendered_template) do
+    knife.instance_variable_set("@template_file", template_file)
+    knife.parse_options(options)
+    # Avoid referencing a validation keyfile we won't find during #render_template
+    template = IO.read(template_file).chomp
+    knife.render_template(template)
   end
-end
 
-describe Chef::Knife::BootstrapWindowsWinrm do
   before(:all) do
     @original_config = Chef::Config.hash_dup
     @original_knife_config = Chef::Config[:knife].dup
@@ -54,7 +46,7 @@ describe Chef::Knife::BootstrapWindowsWinrm do
     @knife = Chef::Knife::BootstrapWindowsWinrm.new
     # Merge default settings in.
     @knife.merge_configs
-    @knife.config[:template_file] = TEMPLATE_FILE
+    @knife.config[:template_file] = template_file
     @stdout = StringIO.new
     allow(@knife.ui).to receive(:stdout).and_return(@stdout)
     @stderr = StringIO.new
@@ -64,15 +56,6 @@ describe Chef::Knife::BootstrapWindowsWinrm do
   describe "specifying no_proxy with various entries" do
     subject(:knife) { described_class.new }
     let(:options){ ["--bootstrap-proxy", "", "--bootstrap-no-proxy", setting] }
-    let(:template_file) { TEMPLATE_FILE }
-    let(:rendered_template) do
-      knife.instance_variable_set("@template_file", template_file)
-      knife.parse_options(options)
-      # Avoid referencing a validation keyfile we won't find during #render_template
-      template = IO.read(template_file).chomp
-      template_string = template.gsub(/^.*[Vv]alidation_key.*$/, '')
-      knife.render_template(template_string)
-    end
 
     context "via --bootstrap-no-proxy" do
       let(:setting) { "api.opscode.com" }
@@ -89,4 +72,21 @@ describe Chef::Knife::BootstrapWindowsWinrm do
       end
     end
   end
+
+  describe "specifying msi_url" do
+    subject(:knife) { described_class.new }
+
+    context "with explicitly provided msi_url" do
+      let(:options) { ["--msi_url", "file:///something.msi"] }
+
+      it "bootstrap batch file must fetch from provided url" do
+        expect(rendered_template).to match(%r{.*REMOTE_SOURCE_MSI_URL=file:///something\.msi.*})
+      end
+    end
+    context "with no provided msi_url" do
+      it "bootstrap batch file must fetch from provided url" do
+        expect(rendered_template).to match(%r{.*REMOTE_SOURCE_MSI_URL=https://www\.chef\.io/.*})
+      end
+    end
+  end
 end

data/spec/unit/knife/bootstrap_windows_winrm_spec.rb

@@ -18,6 +18,7 @@
 
 require 'spec_helper'
 
+Chef::Knife::Winrm.load_deps
 
 describe Chef::Knife::BootstrapWindowsWinrm do
   before(:all) do
@@ -27,6 +28,7 @@ describe Chef::Knife::BootstrapWindowsWinrm do
   before do
     #    Kernel.stub(:sleep).and_return 10
     allow(bootstrap).to receive(:sleep).and_return(10)
+    allow(File).to receive(:exist?).with(File.expand_path(Chef::Config[:validation_key])).and_return(true)
   end
 
   after do
@@ -34,73 +36,115 @@ describe Chef::Knife::BootstrapWindowsWinrm do
     allow(bootstrap).to receive(:sleep).and_return(10)
   end
 
-  let (:bootstrap) { Chef::Knife::BootstrapWindowsWinrm.new(['winrm', '-d', 'windows-chef-client-msi',  '-x', 'Administrator', 'localhost']) }
+  let(:bootstrap) { Chef::Knife::BootstrapWindowsWinrm.new(['winrm', '-d', 'windows-chef-client-msi',  '-x', 'Administrator', 'localhost']) }
+  let(:session) { Chef::Knife::Winrm::WinrmSession.new({ :host => 'winrm.cloudapp.net', :port => '5986', :transport => :ssl }) }
+
+  let(:initial_fail_count) { 4 }
 
-  let(:initial_fail_count) { 4 }  
   it 'should retry if a 401 is received from WinRM' do
-    call_result_sequence = Array.new(initial_fail_count) {lambda {raise WinRM::WinRMHTTPTransportError.new('401', '401')}}
+    call_result_sequence = Array.new(initial_fail_count) {lambda {raise WinRM::WinRMHTTPTransportError.new('', '401')}}
     call_result_sequence.push(0)
     allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
+    allow(bootstrap).to receive(:print)
+    allow(bootstrap.ui).to receive(:info)
 
     expect(bootstrap).to receive(:run_command).exactly(call_result_sequence.length).times
     bootstrap.send(:wait_for_remote_response, 2)
   end
 
   it 'should retry if something other than a 401 is received from WinRM' do
-    call_result_sequence = Array.new(initial_fail_count) {lambda {raise WinRM::WinRMHTTPTransportError.new('500', '500')}}
+    call_result_sequence = Array.new(initial_fail_count) {lambda {raise WinRM::WinRMHTTPTransportError.new('', '500')}}
     call_result_sequence.push(0)
     allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
+    allow(bootstrap).to receive(:print)
+    allow(bootstrap.ui).to receive(:info)
 
     expect(bootstrap).to receive(:run_command).exactly(call_result_sequence.length).times
     bootstrap.send(:wait_for_remote_response, 2)
   end
 
-  it 'should have a wait timeout of 2 minutes by default' do
-    allow(bootstrap).to receive(:run_command).and_raise(WinRM::WinRMHTTPTransportError.new('',''))
-    allow(bootstrap).to receive(:create_bootstrap_bat_command).and_raise(SystemExit)
-    expect(bootstrap).to receive(:wait_for_remote_response).with(2)
-    allow(bootstrap).to receive(:validate_name_args!).and_return(nil)
-    bootstrap.config[:auth_timeout] = bootstrap.options[:auth_timeout][:default]
-    expect { bootstrap.bootstrap }.to raise_error(SystemExit)
-  end
-
   it 'should keep retrying at 10s intervals if the timeout in minutes has not elapsed' do
-    call_result_sequence = Array.new(initial_fail_count) {lambda {raise WinRM::WinRMHTTPTransportError.new('500', '500')}}
+    call_result_sequence = Array.new(initial_fail_count) {lambda {raise WinRM::WinRMHTTPTransportError.new('', '500')}}
     call_result_sequence.push(0)
     allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
+    allow(bootstrap).to receive(:print)
+    allow(bootstrap.ui).to receive(:info)
 
     expect(bootstrap).to receive(:run_command).exactly(call_result_sequence.length).times
     bootstrap.send(:wait_for_remote_response, 2)
   end
 
+  it 'should have a wait timeout of 2 minutes by default' do
+    allow(bootstrap).to receive(:run_command).and_raise(WinRM::WinRMHTTPTransportError.new('','500'))
+    allow(bootstrap).to receive(:create_bootstrap_bat_command).and_raise(SystemExit)
+    expect(bootstrap).to receive(:wait_for_remote_response).with(2)
+    allow(bootstrap).to receive(:validate_name_args!).and_return(nil)
+    allow(bootstrap.ui).to receive(:info)
+    bootstrap.config[:auth_timeout] = bootstrap.options[:auth_timeout][:default]
+    expect { bootstrap.bootstrap }.to raise_error(SystemExit)
+  end
+
   it "should exit bootstrap with non-zero status if the bootstrap fails" do
     command_status = 1
 
     #Stub out calls to create the session and just get the exit codes back
     winrm_mock = Chef::Knife::Winrm.new
     allow(Chef::Knife::Winrm).to receive(:new).and_return(winrm_mock)
-    allow(winrm_mock).to receive(:configure_session)
-    allow(winrm_mock).to receive(:winrm_command)
-    session_mock = EventMachine::WinRM::Session.new
-    allow(EventMachine::WinRM::Session).to receive(:new).and_return(session_mock)
-    allow(session_mock).to receive(:exit_codes).and_return({"thishost" => command_status})
-   
+    allow(winrm_mock).to receive(:run).and_raise(SystemExit.new(command_status))
     #Skip over templating stuff and checking with the remote end
     allow(bootstrap).to receive(:create_bootstrap_bat_command)
     allow(bootstrap).to receive(:wait_for_remote_response)
-    
+    allow(bootstrap.ui).to receive(:info)
+
     expect { bootstrap.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(command_status) }
   end
 
-
   it 'should stop retrying if more than 2 minutes has elapsed' do
     times = [ Time.new(2014, 4, 1, 22, 25), Time.new(2014, 4, 1, 22, 51), Time.new(2014, 4, 1, 22, 28) ]
     allow(Time).to receive(:now).and_return(*times)
-    run_command_result = lambda {raise WinRM::WinRMHTTPTransportError.new('401', '401')}
+    run_command_result = lambda {raise WinRM::WinRMHTTPTransportError, '401'}
     allow(bootstrap).to receive(:validate_name_args!).and_return(nil)
     allow(bootstrap).to receive(:run_command).and_return(run_command_result)
+    allow(bootstrap).to receive(:print)
+    allow(bootstrap.ui).to receive(:info)
+    allow(bootstrap.ui).to receive(:error)
     expect(bootstrap).to receive(:run_command).exactly(1).times
     bootstrap.config[:auth_timeout] = bootstrap.options[:auth_timeout][:default]
     expect { bootstrap.bootstrap }.to raise_error RuntimeError
   end
+
+  context "when validation_key is not present" do
+    context "using chef 11", :chef_lt_12_only do
+      before do
+        allow(File).to receive(:exist?).with(File.expand_path(Chef::Config[:validation_key])).and_return(false)
+      end
+
+      it 'raises an exception if validation_key is not present in chef 11' do
+        expect(bootstrap.ui).to receive(:error)
+        expect { bootstrap.bootstrap }.to raise_error(SystemExit)
+      end
+    end
+
+    context "using chef 12", :chef_gte_12_only do
+      before do
+        allow(File).to receive(:exist?).with(File.expand_path(Chef::Config[:validation_key])).and_return(false)
+        bootstrap.client_builder = instance_double("Chef::Knife::Bootstrap::ClientBuilder", :run => nil, :client_path => nil)
+        Chef::Config[:knife] = {:chef_node_name => 'foo.example.com'}
+      end
+
+      it 'raises an exception if winrm_authentication_protocol is basic and transport is plaintext' do
+        Chef::Config[:knife] = {:winrm_authentication_protocol => 'basic', :winrm_transport => 'plaintext', :chef_node_name => 'foo.example.com'}
+        expect(bootstrap.ui).to receive(:error)
+        expect { bootstrap.run }.to raise_error(SystemExit)
+      end
+
+      it 'raises an exception if chef_node_name is not present ' do
+        Chef::Config[:knife] = {:chef_node_name => nil}
+        expect(bootstrap.client_builder).not_to receive(:run)
+        expect(bootstrap.client_builder).not_to receive(:client_path)
+        expect(bootstrap.ui).to receive(:error)
+        expect { bootstrap.bootstrap }.to raise_error(SystemExit)
+      end
+    end
+  end
 end