knife-windows 1.0.0.rc.0 → 1.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e51a14571a819d9ff57f8ff5c1f9be04e45645a0
-  data.tar.gz: fd8710840fd171781b95ed291b2c2926aa503fdf
+  metadata.gz: 1c29e2359b9d358c5351eed09ce0cd3012f6252c
+  data.tar.gz: 86e873abc6246ca156e557dfa087e170d4ce53b3
 SHA512:
-  metadata.gz: f7e087bfadbb0825a9a3a27388df0e4262642b39aaa839eb9d7396dd1a83d8bf92d4f454881a979c938fbff7c12c9f7104b6f5ae38aabbab3759487fc5ec5888
-  data.tar.gz: 7cdddbaa21aff487fc7a2c4db10e26b52d8929a4c06d4b74db252ac1fbe2e6b38fdf94359ea3d10c490718d0c11917c08fbf96b488043771d276865ce82557e4
+  metadata.gz: 01daeb2230c7290c573a2401906a02929b54f82e3447289fe2bcd1bf0649133ebe41ff9830e7a5cc49f5c5b4b8b5b7deae3eb05a727419f97488b45298fa1398
+  data.tar.gz: 586c6301b29e79aec969a5b6aab3bf6cc45c90cdb0e38be7449a56148d7b98db1ee0f9cce1c1a0de1e49a4d82eed891dfff805f6a5b70afc688fabac9374b96a

data/CHANGELOG.md

@@ -22,6 +22,7 @@
 * [knife-windows #125](https://github.com/opscode/knife-windows/issues/125) knife-windows should use PowerShell first before cscript to download the  Chef Client msi
 * [knife-windows #92](https://github.com/opscode/knife-windows/issues/92) EventMachine issue: knife bootstrap windows winrm error
 * [knife-windows #94](https://github.com/opscode/knife-windows/issues/94) Remove Eventmachine dependency
+* [knife-windows #252](https://github.com/chef/knife-windows/pull/252) Fail early on ECONNREFUSED, Closes #244.
 
 ## Release: 0.8.5
 * [knife-windows #228](https://github.com/chef/knife-windows/pull/228) make winrm-s dep more strict on knife-windows 0.8.x

data/README.md

@@ -103,7 +103,7 @@ The *.b64 is Base64 PKCS12 key pair. Contains both the public and private keys,
 The *.pem is Base64 encoded public certificate only. Required by the client to connect to the server.
 This command also displays the thumbprint of the generated certificate.
 
-    knife windows cert generate --cert-passphrase "strong_passphrase" --domain "cloudapp.net" --output-file "~/server_cert.pfx"
+    knife windows cert generate --cert-passphrase "strong_passphrase" --hostname "cloudapp.net" --output-file "~/server_cert.pfx"
     # This command will generate certificates at user's home directory with names server_cert.b64, server_cert.pfx and server_cert.pem.
 
 ### knife windows cert install
@@ -140,7 +140,7 @@ This bootstrap template does the following:
 * Writes a default config file for Chef (`C:\chef\client.rb`) using values from the `knife.rb`.
 * Creates a JSON attributes file containing the specified run list and run Chef.
 
-This is the default bootstrap template used by both of the `windows bootstrap` subcommands.
+This is the default bootstrap template used by both of the `knife windows bootstrap winrm` and `knife windows bootstrap ssh` subcommands.
 
 ## REQUIREMENTS/SETUP:
 

data/lib/chef/knife/bootstrap_windows_base.rb

@@ -58,28 +58,29 @@ class Chef
             :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
 
           option :bootstrap_no_proxy,
-            :long => "--bootstrap-no-proxy ",
-            :description => "Avoid a proxy server for the given addresses",
+            :long => "--bootstrap-no-proxy [NO_PROXY_URL|NO_PROXY_IP]",
+            :description => "Do not proxy locations for the node being bootstrapped; this option is used internally by Opscode",
             :proc => Proc.new { |np| Chef::Config[:knife][:bootstrap_no_proxy] = np }
 
           # DEPR: Remove this option in Chef 13
           option :distro,
             :short => "-d DISTRO",
             :long => "--distro DISTRO",
-            :description => "Bootstrap a distro using a template. [DEPRECATED] Use --bootstrap-template option instead.",
+            :description => "Bootstrap a distro using a template. [DEPRECATED] Use -t / --bootstrap-template option instead.",
             :proc        => Proc.new { |v|
               Chef::Log.warn("[DEPRECATED] -d / --distro option is deprecated. Use --bootstrap-template option instead.")
               v
             }
 
           option :bootstrap_template,
+            :short => "-t TEMPLATE",
             :long => "--bootstrap-template TEMPLATE",
             :description => "Bootstrap Chef using a built-in or custom template. Set to the full path of an erb template or use one of the built-in templates."
 
           # DEPR: Remove this option in Chef 13
           option :template_file,
             :long => "--template-file TEMPLATE",
-            :description => "Full path to location of template to use. [DEPRECATED] Use --bootstrap-template option instead.",
+            :description => "Full path to location of template to use. [DEPRECATED] Use -t / --bootstrap-template option instead.",
             :proc        => Proc.new { |v|
               Chef::Log.warn("[DEPRECATED] --template-file option is deprecated. Use --bootstrap-template option instead.")
               v
@@ -142,7 +143,7 @@ class Chef
 
           option :msi_url,
             :short => "-u URL",
-            :long => "--msi_url URL",
+            :long => "--msi-url URL",
             :description => "Location of the Chef Client MSI. The default templates will prefer to download from this location. The MSI will be downloaded from chef.io if not provided.",
             :default => ''
 
@@ -150,6 +151,25 @@ class Chef
             :long => "--install-as-service",
             :description => "Install chef-client as service in windows machine",
             :default => false
+
+          option :bootstrap_vault_file,
+          :long        => '--bootstrap-vault-file VAULT_FILE',
+          :description => 'A JSON file with a list of vault(s) and item(s) to be updated'
+
+          option :bootstrap_vault_json,
+            :long        => '--bootstrap-vault-json VAULT_JSON',
+            :description => 'A JSON string with the vault(s) and item(s) to be updated'
+
+          option :bootstrap_vault_item,
+            :long        => '--bootstrap-vault-item VAULT_ITEM',
+            :description => 'A single vault and item to update as "vault:item"',
+            :proc        => Proc.new { |i|
+              (vault, item) = i.split(/:/)
+              Chef::Config[:knife][:bootstrap_vault_item] ||= {}
+              Chef::Config[:knife][:bootstrap_vault_item][vault] ||= []
+              Chef::Config[:knife][:bootstrap_vault_item][vault].push(item)
+              Chef::Config[:knife][:bootstrap_vault_item]
+            }
         end
       end
 
@@ -236,6 +256,8 @@ class Chef
             exit 1
           end
 
+          chef_vault_handler.run(node_name: config[:chef_node_name]) if chef_vault_handler.doing_chef_vault?
+
           client_builder.run
           bootstrap_context.client_pem = client_builder.client_path
         else

data/lib/chef/knife/bootstrap_windows_ssh.rb

@@ -51,8 +51,7 @@ class Chef
         :short => "-p PORT",
         :long => "--ssh-port PORT",
         :description => "The ssh port",
-        :default => "22",
-        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key.strip }
 
       option :ssh_gateway,
         :short => "-G GATEWAY",
@@ -60,14 +59,31 @@ class Chef
         :description => "The ssh gateway",
         :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
 
+      option :forward_agent,
+        :short => "-A",
+        :long => "--forward-agent",
+        :description => "Enable SSH agent forwarding",
+        :boolean => true
+
       option :identity_file,
         :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
         :description => "The SSH identity file used for authentication"
 
+      # DEPR: Remove this option for the next release.
       option :host_key_verification,
-        :long => "--[no-]host-key-verification",
-        :description => "Disable host key verification",
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default. [DEPRECATED] Use --host-key-verify option instead.",
+        :boolean => true,
+        :default => true,
+        :proc => Proc.new { |key|
+          Chef::Log.warn("[DEPRECATED] --host-key-verification option is deprecated. Use --host-key-verify option instead.")
+          config[:host_key_verify] = key
+        }
+
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default.",
         :boolean => true,
         :default => true
 
@@ -83,6 +99,7 @@ class Chef
         ssh.config[:ssh_port] = locate_config_value(:ssh_port)
         ssh.config[:ssh_gateway] =  locate_config_value(:ssh_gateway)
         ssh.config[:identity_file] = config[:identity_file]
+        ssh.config[:forward_agent] = config[:forward_agent]
         ssh.config[:manual] = true
         ssh.config[:host_key_verify] = config[:host_key_verify]
         ssh.run

data/lib/chef/knife/bootstrap_windows_winrm.rb

@@ -89,10 +89,14 @@ class Chef
           raise RuntimeError, 'Command execution failed.' if status != 0
           ui.info(ui.color("Remote node responded after #{elapsed_time_in_minutes(wait_start_time)} minutes.", :magenta))
           return
-        rescue
+        rescue Errno::ECONNREFUSED => e
+          ui.error("Connection refused connecting to #{locate_config_value(:server_name)}:#{locate_config_value(:winrm_port)}.")
+          raise
+        rescue Exception => e
           retries_left -= 1
           if retries_left <= 0 || (elapsed_time_in_minutes(wait_start_time) > wait_max_minutes)
             ui.error("No response received from remote node after #{elapsed_time_in_minutes(wait_start_time)} minutes, giving up.")
+            ui.error("Exception: #{e.message}")
             raise
           end
           print '.'

data/lib/chef/knife/windows_cert_install.rb

@@ -37,24 +37,30 @@ class Chef
 
       def run
         STDOUT.sync = STDERR.sync = true
-        if @name_args.empty?
-          ui.error "Please specify the certificate path. e.g-  'knife windows cert install <path>"
-          exit 1
-        end
-        file_path = @name_args.first
-        config[:cert_passphrase] = get_cert_passphrase unless config[:cert_passphrase]
-
-        begin
-          ui.info "Adding certificate to the Windows Certificate Store..."
-          result = %x{powershell.exe -Command " '#{config[:cert_passphrase]}' | certutil -importPFX '#{file_path}' AT_KEYEXCHANGE"}
-          if $?.exitstatus == 0
-            ui.info "Certificate added to Certificate Store"
-          else
-            ui.info "Error adding the certificate. Use -VV option for details"
+
+        if Chef::Platform.windows?
+          if @name_args.empty?
+            ui.error "Please specify the certificate path. e.g-  'knife windows cert install <path>"
+            exit 1
           end
-          Chef::Log.debug "#{result}"
-        rescue => e
-          puts "ERROR: + #{e}"
+          file_path = @name_args.first
+          config[:cert_passphrase] = get_cert_passphrase unless config[:cert_passphrase]
+
+          begin
+            ui.info "Adding certificate to the Windows Certificate Store..."
+            result = %x{powershell.exe -Command " '#{config[:cert_passphrase]}' | certutil -importPFX '#{file_path}' AT_KEYEXCHANGE"}
+            if $?.exitstatus == 0
+              ui.info "Certificate added to Certificate Store"
+            else
+              ui.info "Error adding the certificate. Use -VV option for details"
+            end
+            Chef::Log.debug "#{result}"
+          rescue => e
+            puts "ERROR: + #{e}"
+          end
+        else
+          ui.error "Certificate can be installed on Windows system only"
+          exit 1
         end
       end
     end

data/lib/chef/knife/windows_listener_create.rb

@@ -61,40 +61,47 @@ class Chef
       def run
         STDOUT.sync = STDERR.sync = true
 
-        begin
-          if config[:cert_install]
-            config[:cert_passphrase] = get_cert_passphrase unless config[:cert_passphrase]
-            result = %x{powershell.exe -Command " '#{config[:cert_passphrase]}' | certutil  -importPFX '#{config[:cert_install]}' AT_KEYEXCHANGE"}
-            if $?.exitstatus
-              ui.info "Certificate installed to Certificate Store"
-              result = %x{powershell.exe -Command " echo (Get-PfxCertificate #{config[:cert_install]}).thumbprint "}
-              ui.info "Certificate Thumbprint: #{result}"
-              config[:cert_thumbprint] = result.strip
-            else
-              ui.error "Error installing certificate to Certificate Store"
-              ui.error result
+        if Chef::Platform.windows?
+          begin
+            if config[:cert_install]
+              config[:cert_passphrase] = get_cert_passphrase unless config[:cert_passphrase]
+              result = %x{powershell.exe -Command " '#{config[:cert_passphrase]}' | certutil  -importPFX '#{config[:cert_install]}' AT_KEYEXCHANGE"}
+              if $?.exitstatus
+                ui.info "Certificate installed to Certificate Store"
+                result = %x{powershell.exe -Command " echo (Get-PfxCertificate #{config[:cert_install]}).thumbprint "}
+                ui.info "Certificate Thumbprint: #{result}"
+                config[:cert_thumbprint] = result.strip
+              else
+                ui.error "Error installing certificate to Certificate Store"
+                ui.error result
+                exit 1
+              end
+            end
+
+            unless config[:cert_thumbprint]
+              ui.error "Please specify the --cert-thumbprint"
               exit 1
             end
-          end
 
-          unless config[:cert_thumbprint]
-            ui.error "Please specify the --cert-thumbprint"
-            exit 1
-          end
+            result = %x{winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname="#{config[:hostname]}";CertificateThumbprint="#{config[:cert_thumbprint]}";Port="#{config[:port]}"}}
+            Chef::Log.debug result
 
-          result = %x{winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname="#{config[:hostname]}";CertificateThumbprint="#{config[:cert_thumbprint]}";Port="#{config[:port]}"}}
-          Chef::Log.debug result
+            if ($?.exitstatus == 0)
+              ui.info "WinRM listener created with Port: #{config[:port]} and CertificateThumbprint: #{config[:cert_thumbprint]}"
+            else
+              ui.error "Error creating WinRM listener. use -VV for more details."
+              exit 1
+            end
 
-          if ($?.exitstatus == 0)
-            ui.info "WinRM listener created with Port: #{config[:port]} and CertificateThumbprint: #{config[:cert_thumbprint]}"
-          else
-            ui.error "Error creating WinRM listener. use -VV for more details."
+          rescue => e
+            puts "ERROR: + #{e}"
           end
-
-        rescue => e
-          puts "ERROR: + #{e}"
+        else
+          ui.error "WinRM listener can be created on Windows system only"
+          exit 1
         end
       end
+
     end
   end
 end

data/lib/chef/knife/winrm_knife_base.rb

@@ -125,8 +125,8 @@ class Chef
               @session_opts[:transport] = :sspinegotiate
               @session_opts[:disable_sspi] = false
             elsif negotiate_auth? && !Chef::Platform.windows?
-              ui.warn "The '--winrm-authentication-protocol = negotiate' with 'plaintext' transport is only supported when this tool is invoked from a Windows-based system."
-              ui.info "Try '--winrm-authentication-protocol = basic'"
+              ui.warn "\nUsing '--winrm-authentication-protocol negotiate' with '--winrm-transport plaintext' is only supported when this tool is invoked from a Windows system."
+              ui.warn "Switch to either '--winrm-transport ssl' or '--winrm-authentication-protocol basic'."
               exit 1
             end
           end

data/lib/knife-windows/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Windows
-    VERSION = "1.0.0.rc.0"
+    VERSION = "1.0.0.rc.1"
     MAJOR, MINOR, TINY = VERSION.split('.')
   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/bootstrap_windows_ssh'
 require_relative '../lib/chef/knife/wsman_test'
 
 if windows?

data/spec/unit/knife/bootstrap_options_spec.rb

@@ -0,0 +1,146 @@
+#
+# Author:: Kartik Null Cating-Subramanian(<ksubramanian@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 'spec_helper'
+
+describe Chef::Knife::Bootstrap, :chef_gte_12_only do
+  before(:all) do
+    Chef::Config.reset
+  end
+
+  let(:bootstrap) { Chef::Knife::Bootstrap.new }
+  let(:win_bootstrap) { nil }
+  let(:opt_map) { {} }
+  let(:ref_ignore) { [] }
+  let(:win_ignore) { [] }
+
+  def compare_property(sym)
+    win_bootstrap.options.each do |win_key, win_val|
+      unless win_ignore.include?(win_key) || opt_map.include?(win_key) then
+        actual = win_val[sym]
+        expected = bootstrap.options[win_key][sym]
+        expect(actual).to eq(expected),
+          "#{win_key} flag's #{sym} property doesn't match
+
+expected: #{expected}
+     got: #{actual}"
+      end
+    end
+  end
+
+  shared_examples 'compare_options' do
+    it 'contains the option flags' do
+      opt_map.default_proc = proc { |map, key| key }
+      filtered_keys = (win_bootstrap.options.keys - win_ignore).map! { |key| opt_map[key] }
+
+      expect(filtered_keys).to match_array(bootstrap.options.keys - ref_ignore)
+    end
+
+    it 'uses the same long-name' do
+      compare_property(:long)
+    end
+
+    it 'uses the same short-name' do
+      compare_property(:short)
+    end
+
+    it 'uses the same description' do
+      compare_property(:description)
+    end
+
+    it 'uses the same default value' do
+      compare_property(:default)
+    end
+  end
+
+  context 'when compared to BootstrapWindowsWinrm' do
+    let(:win_bootstrap) { Chef::Knife::BootstrapWindowsWinrm.new }
+
+    # opt_map: Hash of symbols in windows mapping to symbols in core.  Name checks are
+    #   ignored for these.
+    let(:opt_map) { {
+      :msi_url => :bootstrap_url,
+      :encrypted_data_bag_secret => :secret,
+      :encrypted_data_bag_secret_file => :secret_file,
+      :winrm_user => :ssh_user,
+      :winrm_password => :ssh_password,
+      :winrm_port => :ssh_port,
+      :winrm_ssl_verify_mode => :host_key_verify,
+    }}
+
+    # ref_ignore: Options in core that are not implemented here.
+    let(:ref_ignore) { [
+      # These are irrelevant to WinRM.
+      :bootstrap_curl_options,
+      :bootstrap_install_command,
+      :bootstrap_wget_options,
+      :forward_agent,
+      :ssh_gateway,
+      :use_sudo,
+      :use_sudo_password,
+      :encrypt, # irrelevant during bootstrap
+    ]}
+
+    # win_ignore: Options in windows that aren't relevant to core.
+    let(:win_ignore) { [
+      :attribute,
+      :auth_timeout,
+      :ca_trust_file,
+      :install_as_service,
+      :kerberos_keytab_file,
+      :kerberos_realm,
+      :kerberos_service,
+      :manual,
+      :session_timeout,
+      :winrm_authentication_protocol,
+      :winrm_transport,
+    ] }
+
+    include_examples 'compare_options'
+  end
+
+  context 'when compared to BootstrapWindowsSsh' do
+    let(:win_bootstrap) { Chef::Knife::BootstrapWindowsSsh.new }
+
+    # opt_map: Hash of symbols in windows mapping to symbols in core.  Name checks are
+    #   ignored for these.
+    let(:opt_map) { {
+      :msi_url => :bootstrap_url,
+      :encrypted_data_bag_secret => :secret,
+      :encrypted_data_bag_secret_file => :secret_file,
+    }}
+    # ref_ignore: Options in core that are not implemented here.
+    let(:ref_ignore) { [
+      :bootstrap_curl_options,
+      :bootstrap_install_command,
+      :bootstrap_wget_options,
+      :use_sudo,
+      :use_sudo_password,
+      :encrypt, # irrelevant during bootstrap
+    ]}
+    # win_ignore: Options in windows that aren't relevant to core.
+    let(:win_ignore) { [
+      :auth_timeout,
+      :install_as_service,
+      :host_key_verification,  # Deprecated - remove this when the flag is removed.
+    ] }
+
+    include_examples 'compare_options'
+  end
+
+end

data/spec/unit/knife/bootstrap_template_spec.rb

@@ -73,17 +73,17 @@ describe Chef::Knife::BootstrapWindowsWinrm do
     end
   end
 
-  describe "specifying msi_url" do
+  describe "specifying --msi-url" do
     subject(:knife) { described_class.new }
 
-    context "with explicitly provided msi_url" do
-      let(:options) { ["--msi_url", "file:///something.msi"] }
+    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
+    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

data/spec/unit/knife/bootstrap_windows_winrm_spec.rb

@@ -84,6 +84,17 @@ describe Chef::Knife::BootstrapWindowsWinrm do
     expect { bootstrap.bootstrap }.to raise_error(SystemExit)
   end
 
+  it 'should not a wait for timeout on Errno::ECONNREFUSED' do
+    allow(bootstrap).to receive(:run_command).and_raise(Errno::ECONNREFUSED.new)
+    allow(bootstrap.ui).to receive(:info)
+    bootstrap.config[:auth_timeout] = bootstrap.options[:auth_timeout][:default]
+    expect(bootstrap.ui).to receive(:error).with("Connection refused connecting to localhost:5985.")
+
+    # wait_for_remote_response is protected method, So define singleton test method to call it.
+    bootstrap.define_singleton_method(:test_wait_for_remote_response){wait_for_remote_response(bootstrap.options[:auth_timeout][:default])}
+    expect { bootstrap.test_wait_for_remote_response }.to raise_error(Errno::ECONNREFUSED)
+  end
+
   it "should exit bootstrap with non-zero status if the bootstrap fails" do
     command_status = 1
 

data/spec/unit/knife/windows_cert_install_spec.rb

@@ -20,16 +20,32 @@ require 'spec_helper'
 require 'chef/knife/windows_cert_install'
 
 describe Chef::Knife::WindowsCertInstall do
-  before(:all) do
-    @certinstall = Chef::Knife::WindowsCertInstall.new
+  context "on Windows" do
+    before do
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
+      @certinstall = Chef::Knife::WindowsCertInstall.new
+    end
+  
+    it "installs certificate" do
+      @certinstall.name_args = ["test-path"]
+      @certinstall.config[:cert_passphrase] = "your-secret!"
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
+      expect(@certinstall).to receive(:`).with("powershell.exe -Command \" 'your-secret!' | certutil -importPFX 'test-path' AT_KEYEXCHANGE\"")
+      expect(@certinstall.ui).to receive(:info).with("Certificate added to Certificate Store")
+      expect(@certinstall.ui).to receive(:info).with("Adding certificate to the Windows Certificate Store...")
+      @certinstall.run
+    end
   end
 
-  it "installs certificate" do
-    @certinstall.name_args = ["test-path"]
-    @certinstall.config[:cert_passphrase] = "your-secret!"
-    expect(@certinstall).to receive(:`).with("powershell.exe -Command \" 'your-secret!' | certutil -importPFX 'test-path' AT_KEYEXCHANGE\"")
-    expect(@certinstall.ui).to receive(:info).with("Certificate added to Certificate Store")
-    expect(@certinstall.ui).to receive(:info).with("Adding certificate to the Windows Certificate Store...")
-    @certinstall.run
+  context "not on Windows" do
+    before do
+      allow(Chef::Platform).to receive(:windows?).and_return(false)
+      @listener = Chef::Knife::WindowsListenerCreate.new
+    end
+
+    it "exits with an error" do
+      expect(@listener.ui).to receive(:error)
+      expect { @listener.run }.to raise_error(SystemExit)
+    end
   end
 end

data/spec/unit/knife/windows_listener_create_spec.rb

@@ -19,43 +19,58 @@
 require 'spec_helper'
 require 'chef/knife/windows_listener_create'
 
-describe Chef::Knife::WindowsListenerCreate, :windows_only do
-  before(:all) do
-    @listener = Chef::Knife::WindowsListenerCreate.new
+describe Chef::Knife::WindowsListenerCreate do
+  context "on Windows" do
+    before do
+      allow(Chef::Platform).to receive(:windows?).and_return(true)
+      @listener = Chef::Knife::WindowsListenerCreate.new
+    end
+  
+    it "creates winrm listener" do
+      @listener.config[:hostname] = "host"
+      @listener.config[:cert_thumbprint] = "CERT-THUMBPRINT"
+      @listener.config[:port] = "5986"
+      expect(@listener).to receive(:`).with("winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname=\"host\";CertificateThumbprint=\"CERT-THUMBPRINT\";Port=\"5986\"}")
+      expect(@listener.ui).to receive(:info).with("WinRM listener created with Port: 5986 and CertificateThumbprint: CERT-THUMBPRINT")
+      @listener.run
+    end
+  
+    it "raise an error on command failure" do
+      @listener.config[:hostname] = "host"
+      @listener.config[:cert_thumbprint] = "CERT-THUMBPRINT"
+      @listener.config[:port] = "5986"
+      @listener.config[:basic_auth] = true
+      expect(@listener).to receive(:`).with("winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname=\"host\";CertificateThumbprint=\"CERT-THUMBPRINT\";Port=\"5986\"}")
+      expect($?).to receive(:exitstatus).and_return(100)
+      expect(@listener.ui).to receive(:error).with("Error creating WinRM listener. use -VV for more details.")
+      expect(@listener.ui).to_not receive(:info).with("WinRM listener created with Port: 5986 and CertificateThumbprint: CERT-THUMBPRINT")
+      expect { @listener.run }.to raise_error(SystemExit)
+    end
+  
+    it "creates winrm listener with cert install option" do
+      @listener.config[:hostname] = "host"
+      @listener.config[:cert_thumbprint] = "CERT-THUMBPRINT"
+      @listener.config[:port] = "5986"
+      @listener.config[:cert_install] = true
+      allow(@listener).to receive(:get_cert_passphrase).and_return("your-secret!")
+      expect(@listener).to receive(:`).with("powershell.exe -Command \" 'your-secret!' | certutil  -importPFX 'true' AT_KEYEXCHANGE\"")
+      expect(@listener).to receive(:`).with("powershell.exe -Command \" echo (Get-PfxCertificate true).thumbprint \"")
+      expect(@listener.ui).to receive(:info).with("Certificate installed to Certificate Store")
+      expect(@listener.ui).to receive(:info).with("Certificate Thumbprint: ")
+      allow(@listener).to receive(:puts)
+      @listener.run
+    end
   end
 
-  it "creates winrm listener" do
-    @listener.config[:hostname] = "host"
-    @listener.config[:cert_thumbprint] = "CERT-THUMBPRINT"
-    @listener.config[:port] = "5986"
-    expect(@listener).to receive(:`).with("winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname=\"host\";CertificateThumbprint=\"CERT-THUMBPRINT\";Port=\"5986\"}")
-    expect(@listener.ui).to receive(:info).with("WinRM listener created with Port: 5986 and CertificateThumbprint: CERT-THUMBPRINT")
-    @listener.run
-  end
-
-  it "raise an error on command failure" do
-    @listener.config[:hostname] = "host"
-    @listener.config[:cert_thumbprint] = "CERT-THUMBPRINT"
-    @listener.config[:port] = "5986"
-    @listener.config[:basic_auth] = true
-    expect(@listener).to receive(:`).with("winrm create winrm/config/Listener?Address=*+Transport=HTTPS @{Hostname=\"host\";CertificateThumbprint=\"CERT-THUMBPRINT\";Port=\"5986\"}")
-    expect($?).to receive(:exitstatus).and_return(100)
-    expect(@listener.ui).to receive(:error).with("Error creating WinRM listener. use -VV for more details.")
-    expect(@listener.ui).to_not receive(:info).with("WinRM listener created with Port: 5986 and CertificateThumbprint: CERT-THUMBPRINT")
-    @listener.run
-  end
+  context "not on Windows" do
+    before do
+      allow(Chef::Platform).to receive(:windows?).and_return(false)
+      @listener = Chef::Knife::WindowsListenerCreate.new
+    end
 
-  it "creates winrm listener with cert install option" do
-    @listener.config[:hostname] = "host"
-    @listener.config[:cert_thumbprint] = "CERT-THUMBPRINT"
-    @listener.config[:port] = "5986"
-    @listener.config[:cert_install] = true
-    allow(@listener).to receive(:get_cert_passphrase).and_return("your-secret!")
-    expect(@listener).to receive(:`).with("powershell.exe -Command \" 'your-secret!' | certutil  -importPFX 'true' AT_KEYEXCHANGE\"")
-    expect(@listener).to receive(:`).with("powershell.exe -Command \" echo (Get-PfxCertificate true).thumbprint \"")
-    expect(@listener.ui).to receive(:info).with("Certificate installed to Certificate Store")
-    expect(@listener.ui).to receive(:info).with("Certificate Thumbprint: ")
-    allow(@listener).to receive(:puts)
-    @listener.run
+    it "exits with an error" do
+      expect(@listener.ui).to receive(:error)
+      expect { @listener.run }.to raise_error(SystemExit)
+    end
   end
-end
+end  

data/spec/unit/knife/winrm_spec.rb

@@ -58,7 +58,7 @@ describe Chef::Knife::Winrm do
         allow(Chef::Search::Query).to receive(:new).and_return(@query)
       end
 
-      it "should raise a specific error (KNIFE-222)" do
+      it "raises a specific error (KNIFE-222)" do
         expect(@knife.ui).to receive(:fatal).with(/does not have the required attribute/)
         expect(@knife).to receive(:exit).with(10)
         @knife.configure_chef
@@ -74,7 +74,7 @@ describe Chef::Knife::Winrm do
         allow(Chef::Search::Query).to receive(:new).and_return(@query)
       end
 
-      it "should use nested attributes (KNIFE-276)" do
+      it "uses the nested attributes (KNIFE-276)" do
         @knife.config[:attribute] = "ec2.public_hostname"
         @knife.configure_chef
         @knife.resolve_target_nodes
@@ -94,7 +94,7 @@ describe Chef::Knife::Winrm do
 
         context "on windows workstations" do
           let(:winrm_command_windows_http) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword',  'echo helloworld'])        }
-          it "should default to negotiate when on a Windows host" do
+          it "defaults to negotiate when on a Windows host" do
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             expect(winrm_command_windows_http).to receive(:load_windows_specific_gems)
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :sspinegotiate)).and_call_original
@@ -109,15 +109,16 @@ describe Chef::Knife::Winrm do
             allow(Chef::Platform).to receive(:windows?).and_return(false)
           end
 
-          let(:winrm_command_http) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '-t', 'plaintext', '--winrm-authentication-protocol', 'basic', 'echo helloworld'])        }
-          it "should default to the http uri scheme" do
+          let(:winrm_command_http) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '-t', 'plaintext', '--winrm-authentication-protocol', 'basic', 'echo helloworld']) }
+
+          it "defaults to the http uri scheme" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with('http://localhost:5985/wsman', anything, anything).and_return(@winrm_session)
             winrm_command_http.configure_chef
             winrm_command_http.configure_session
           end
 
-          it "set operation timeout and verify default" do
+          it "sets the operation timeout and verifes default" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with('http://localhost:5985/wsman', anything, anything).and_return(@winrm_session)
             expect(@winrm_session).to receive(:set_timeout).with(1800)
@@ -125,7 +126,7 @@ describe Chef::Knife::Winrm do
             winrm_command_http.configure_session
           end
 
-          it "should set user specified winrm port" do
+          it "sets the user specified winrm port" do
             Chef::Config[:knife] = {winrm_port: "5988"}
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with('http://localhost:5988/wsman', anything, anything).and_return(@winrm_session)
@@ -133,9 +134,9 @@ describe Chef::Knife::Winrm do
             winrm_command_http.configure_session
           end
 
-          let(:winrm_command_timeout) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-authentication-protocol', 'basic', '--session-timeout', '10', 'echo helloworld'])        }
+          let(:winrm_command_timeout) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-authentication-protocol', 'basic', '--session-timeout', '10', 'echo helloworld']) }
 
-          it "set operation timeout and verify 10 Minute timeout" do
+          it "sets operation timeout and verify 10 Minute timeout" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with('http://localhost:5985/wsman', anything, anything).and_return(@winrm_session)
             expect(@winrm_session).to receive(:set_timeout).with(600)
@@ -143,9 +144,9 @@ describe Chef::Knife::Winrm do
             winrm_command_timeout.configure_session
           end
 
-          let(:winrm_command_https) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', 'echo helloworld'])       }
+          let(:winrm_command_https) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', 'echo helloworld']) }
 
-          it "should use the https uri scheme if the ssl transport is specified" do
+          it "uses the https uri scheme if the ssl transport is specified" do
             Chef::Config[:knife] = {:winrm_transport => 'ssl'}
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with('https://localhost:5986/wsman', anything, anything).and_return(@winrm_session)
@@ -153,7 +154,7 @@ describe Chef::Knife::Winrm do
             winrm_command_https.configure_session
           end
 
-          it "should use the winrm port '5986' by default for ssl transport" do
+          it "uses the winrm port '5986' by default for ssl transport" do
             Chef::Config[:knife] = {:winrm_transport => 'ssl'}
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with('https://localhost:5986/wsman', anything, anything).and_return(@winrm_session)
@@ -161,7 +162,7 @@ describe Chef::Knife::Winrm do
             winrm_command_https.configure_session
           end
 
-          it "should default to validating the server when the ssl transport is used" do
+          it "defaults to validating the server when the ssl transport is used" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with(anything, anything, hash_including(:no_ssl_peer_verification => false)).and_return(@winrm_session)
             winrm_command_https.configure_chef
@@ -169,7 +170,8 @@ describe Chef::Knife::Winrm do
           end
 
           let(:winrm_command_verify_peer) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', '--winrm-ssl-verify-mode', 'verify_peer', 'echo helloworld'])}
-          it "should validate the server when the ssl transport is used and the :winrm_ssl_verify_mode option is not configured to :verify_none" do
+
+          it "validates the server when the ssl transport is used and the :winrm_ssl_verify_mode option is not configured to :verify_none" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with(anything, anything, hash_including(:no_ssl_peer_verification => false)).and_return(@winrm_session)
             winrm_command_verify_peer.configure_chef
@@ -178,14 +180,14 @@ describe Chef::Knife::Winrm do
 
           let(:winrm_command_no_verify) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', '--winrm-ssl-verify-mode', 'verify_none', 'echo helloworld'])}
 
-          it "should not validate the server when the ssl transport is used and the :winrm_ssl_verify_mode option is set to :verify_none" do
+          it "does not validate the server when the ssl transport is used and the :winrm_ssl_verify_mode option is set to :verify_none" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with(anything, anything, hash_including(:no_ssl_peer_verification => true)).and_return(@winrm_session)
             winrm_command_no_verify.configure_chef
             winrm_command_no_verify.configure_session
           end
 
-          it "should provide warning output when the :winrm_ssl_verify_mode set to :verify_none to disable server validation" do
+          it "prints warning output when the :winrm_ssl_verify_mode set to :verify_none to disable server validation" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with(anything, anything, hash_including(:no_ssl_peer_verification => true)).and_return(@winrm_session)
             expect(winrm_command_no_verify).to receive(:warn_no_ssl_peer_verification)
@@ -196,7 +198,7 @@ describe Chef::Knife::Winrm do
 
           let(:winrm_command_ca_trust) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', '--ca-trust-file', '~/catrustroot', '--winrm-ssl-verify-mode', 'verify_none', 'echo helloworld'])}
 
-          it "should validate the server when the ssl transport is used and the :ca_trust_file option is specified even if the :winrm_ssl_verify_mode option is set to :verify_none" do
+          it "validates the server when the ssl transport is used and the :ca_trust_file option is specified even if the :winrm_ssl_verify_mode option is set to :verify_none" do
             expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
             expect(WinRM::WinRMWebService).to receive(:new).with(anything, anything, hash_including(:no_ssl_peer_verification => false)).and_return(@winrm_session)
             winrm_command_ca_trust.configure_chef
@@ -216,14 +218,13 @@ describe Chef::Knife::Winrm do
           Chef::Config[:knife] = @original_knife_config if @original_knife_config
         end
 
-        it "should return with 0 if the command succeeds" do
-          allow(@winrm).to receive(:exit)
+        it "returns with 0 if the command succeeds" do
           allow(@winrm).to receive(:relay_winrm_command).and_return(0)
-          exit_code = @winrm.run
-          expect(exit_code).to be_zero
+          return_code = @winrm.run
+          expect(return_code).to be_zero
         end
 
-        it "should exit the process with exact exit status if the command fails and returns config is set to 0" do
+        it "exits with exact exit status if the command fails and returns config is set to 0" do
           command_status = 510
           session_mock = Chef::Knife::WinrmSession.new({:transport => :plaintext, :host => 'localhost', :port => '5985'})
 
@@ -237,7 +238,7 @@ describe Chef::Knife::Winrm do
           expect { @winrm.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(command_status) }
         end
 
-        it "should exit the process with non-zero status if the command fails and returns config is set to 0" do
+        it "exits with non-zero status if the command fails and returns config is set to 0" do
           command_status = 1
           @winrm.config[:returns] = "0,53"
           Chef::Config[:knife][:returns] = [0,53]
@@ -249,7 +250,7 @@ describe Chef::Knife::Winrm do
           expect { @winrm.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(command_status) }
         end
 
-        it "should exit the process with a zero status if the command returns an expected non-zero status" do
+        it "exits with a zero status if the command returns an expected non-zero status" do
           command_status = 53
           Chef::Config[:knife][:returns] = [0,53]
           allow(@winrm).to receive(:relay_winrm_command).and_return(command_status)
@@ -260,7 +261,7 @@ describe Chef::Knife::Winrm do
           expect(exit_code).to be_zero
         end
 
-        it "should exit the process with a zero status if the command returns an expected non-zero status" do
+        it "exits with a zero status if the command returns an expected non-zero status" do
           command_status = 53
           @winrm.config[:returns] = '0,53'
           allow(@winrm).to receive(:relay_winrm_command).and_return(command_status)
@@ -271,20 +272,20 @@ describe Chef::Knife::Winrm do
           expect(exit_code).to be_zero
         end
 
-        it "should exit the process with 100 if command execution raises an exception other than 401" do
+        it "exits with 100 if command execution raises an exception other than 401" do
           allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('', '500'))
           allow(@winrm.ui).to receive(:error)
           expect { @winrm.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(100) }
         end
 
-        it "should exit the process with 100 if command execution raises a 401" do
+        it "exits with 100 if command execution raises a 401" do
           allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('', '401'))
           allow(@winrm.ui).to receive(:info)
           allow(@winrm.ui).to receive(:error)
           expect { @winrm.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(100) }
         end
 
-        it "should exit the process with 0 if command execution raises a 401 and suppress_auth_failure is set to true" do
+        it "exits with 0 if command execution raises a 401 and suppress_auth_failure is set to true" do
           @winrm.config[:suppress_auth_failure] = true
           allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('', '401'))
           exit_code = @winrm.run_with_pretty_exceptions
@@ -297,16 +298,15 @@ describe Chef::Knife::Winrm do
             allow(@winrm).to receive(:relay_winrm_command).and_return(0)
           end
 
-          it "set sspinegotiate transport on windows for 'negotiate' authentication" do
+          it "sets sspinegotiate transport on windows for 'negotiate' authentication" do
             @winrm.config[:winrm_authentication_protocol] = "negotiate"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             allow(@winrm).to receive(:require).with('winrm-s').and_return(true)
-            expect(@winrm).to receive(:create_winrm_session).with({:user=>"domain\\testuser", :password=>"testpassword", :port=>"5985", :no_ssl_peer_verification => false, :basic_auth_only=>false, :operation_timeout=>1800, :transport=>:sspinegotiate, :disable_sspi=>false, :host=>"localhost"})
+            expect(@winrm).to receive(:create_winrm_session).with({:user=>"testuser", :password=>"testpassword", :port=>"5985", :no_ssl_peer_verification => false, :basic_auth_only=>false, :operation_timeout=>1800, :transport=>:sspinegotiate, :disable_sspi=>false, :host=>"localhost"})
             exit_code = @winrm.run
           end
 
-          it "should not have winrm opts transport set to sspinegotiate for unix" do
+          it "does not have winrm opts transport set to sspinegotiate for unix" do
             @winrm.config[:winrm_authentication_protocol] = "negotiate"
             allow(Chef::Platform).to receive(:windows?).and_return(false)
             allow(@winrm).to receive(:exit)
@@ -314,69 +314,60 @@ describe Chef::Knife::Winrm do
             exit_code = @winrm.run
           end
 
-          it "apply winrm monkey patch on windows if 'negotiate' authentication and 'plaintext' transport is specified", :windows_only => true do
+          it "applies winrm monkey patch on windows if 'negotiate' authentication and 'plaintext' transport is specified", :windows_only => true do
             @winrm.config[:winrm_authentication_protocol] = "negotiate"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             allow(@winrm.ui).to receive(:warn)
             expect(@winrm).to receive(:require).with('winrm-s').and_call_original
-            exit_code = @winrm.run
+            @winrm.run
           end
 
-          it "raise an error if value is other than [basic, negotiate, kerberos]" do
+          it "raises an error if value is other than [basic, negotiate, kerberos]" do
             @winrm.config[:winrm_authentication_protocol] = "invalid"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             expect(@winrm.ui).to receive(:error)
-            expect(@winrm).to receive(:exit)
-            exit_code = @winrm.run
+            expect { @winrm.run }.to raise_error(SystemExit)
           end
 
-          it "skip winrm monkey patch for 'basic' authentication" do
+          it "skips the winrm monkey patch for 'basic' authentication" do
             @winrm.config[:winrm_authentication_protocol] = "basic"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             expect(@winrm).to_not receive(:require).with('winrm-s')
-            exit_code = @winrm.run
+            @winrm.run
           end
 
-          it "skip winrm monkey patch for 'kerberos' authentication" do
+          it "skips the winrm monkey patch for 'kerberos' authentication" do
             @winrm.config[:winrm_authentication_protocol] = "kerberos"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             expect(@winrm).to_not receive(:require).with('winrm-s')
-            exit_code = @winrm.run
+            @winrm.run
           end
 
-          it "skip winrm monkey patch for 'ssl' transport and 'negotiate' authentication" do
+          it "skips the winrm monkey patch for 'ssl' transport and 'negotiate' authentication" do
             @winrm.config[:winrm_authentication_protocol] = "negotiate"
             @winrm.config[:winrm_transport] = "ssl"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
             expect(@winrm).to_not receive(:require).with('winrm-s')
-            exit_code = @winrm.run
+            @winrm.run
           end
 
-          it "disable sspi and skip winrm monkey patch for 'ssl' transport and 'basic' authentication" do
+          it "disables sspi and skips the winrm monkey patch for 'ssl' transport and 'basic' authentication" do
             @winrm.config[:winrm_authentication_protocol] = "basic"
             @winrm.config[:winrm_transport] = "ssl"
-            @winrm.config[:winrm_user] = "domain\\testuser"
             @winrm.config[:winrm_port] = "5986"
             allow(Chef::Platform).to receive(:windows?).and_return(true)
-            expect(@winrm).to receive(:create_winrm_session).with({:user=>"domain\\testuser", :password=>"testpassword", :port=>"5986", :no_ssl_peer_verification=>false, :basic_auth_only=>true, :operation_timeout=>1800, :transport=>:ssl, :disable_sspi=>true, :host=>"localhost"})
+            expect(@winrm).to receive(:create_winrm_session).with({:user=>"testuser", :password=>"testpassword", :port=>"5986", :no_ssl_peer_verification=>false, :basic_auth_only=>true, :operation_timeout=>1800, :transport=>:ssl, :disable_sspi=>true, :host=>"localhost"})
             expect(@winrm).to_not receive(:require).with('winrm-s')
-            exit_code = @winrm.run
+            @winrm.run
           end
 
-          it "raise error on linux for 'negotiate' authentication" do
+          it "prints a warning and exits on linux for unencrypted negotiate authentication" do
             @winrm.config[:winrm_authentication_protocol] = "negotiate"
             @winrm.config[:winrm_transport] = "plaintext"
-            @winrm.config[:winrm_user] = "domain\\testuser"
-            allow(@winrm).to receive(:exit)
             allow(Chef::Platform).to receive(:windows?).and_return(false)
             expect(@winrm).to_not receive(:require).with('winrm-s')
-            expect(@winrm.ui).to receive(:warn)
-            exit_code = @winrm.run
+            expect(@winrm.ui).to receive(:warn).twice
+            expect { @winrm.run }.to raise_error(SystemExit)
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-windows
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc.0
+  version: 1.0.0.rc.1
 platform: ruby
 authors:
 - Seth Chisamore
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-03 00:00:00.000000000 Z
+date: 2015-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: winrm
@@ -109,6 +109,7 @@ files:
 - lib/knife-windows/version.rb
 - spec/functional/bootstrap_download_spec.rb
 - spec/spec_helper.rb
+- spec/unit/knife/bootstrap_options_spec.rb
 - spec/unit/knife/bootstrap_template_spec.rb
 - spec/unit/knife/bootstrap_windows_winrm_spec.rb
 - spec/unit/knife/core/windows_bootstrap_context_spec.rb