knife-windows 0.8.6.rc.0 → 0.8.6

data/spec/unit/knife/bootstrap_windows_winrm_spec.rb

@@ -1,106 +1,106 @@
-#
-# Author:: Adam Edwards(<adamed@getchef.com>)
-# Copyright:: Copyright (c) 2014 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::BootstrapWindowsWinrm do
-  before(:all) do
-    Chef::Config.reset
-  end
-
-  before do
-    #    Kernel.stub(:sleep).and_return 10
-    allow(bootstrap).to receive(:sleep).and_return(10)
-  end
-
-  after do
-    #    Kernel.unstub(:sleep)
-    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(: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.push(0)
-    allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
-
-    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.push(0)
-    allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
-
-    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.push(0)
-    allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
-
-    expect(bootstrap).to receive(:run_command).exactly(call_result_sequence.length).times
-    bootstrap.send(:wait_for_remote_response, 2)
-  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})
-   
-    #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)
-    
-    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')}
-    allow(bootstrap).to receive(:validate_name_args!).and_return(nil)
-    allow(bootstrap).to receive(:run_command).and_return(run_command_result)
-    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
-end
+#
+# Author:: Adam Edwards(<adamed@getchef.com>)
+# Copyright:: Copyright (c) 2014 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::BootstrapWindowsWinrm do
+  before(:all) do
+    Chef::Config.reset
+  end
+
+  before do
+    #    Kernel.stub(:sleep).and_return 10
+    allow(bootstrap).to receive(:sleep).and_return(10)
+  end
+
+  after do
+    #    Kernel.unstub(:sleep)
+    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(: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.push(0)
+    allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
+
+    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.push(0)
+    allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
+
+    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.push(0)
+    allow(bootstrap).to receive(:run_command).and_return(*call_result_sequence)
+
+    expect(bootstrap).to receive(:run_command).exactly(call_result_sequence.length).times
+    bootstrap.send(:wait_for_remote_response, 2)
+  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})
+   
+    #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)
+    
+    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')}
+    allow(bootstrap).to receive(:validate_name_args!).and_return(nil)
+    allow(bootstrap).to receive(:run_command).and_return(run_command_result)
+    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
+end

data/spec/unit/knife/core/windows_bootstrap_context_spec.rb

@@ -1,54 +1,54 @@
-#
-# Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright (c) 2014 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::Core::WindowsBootstrapContext do
-  let(:mock_bootstrap_context) { Chef::Knife::Core::WindowsBootstrapContext.new({ }, nil, { :knife => {} }) }
-
-  before do
-     allow(Chef::Knife::Core::WindowsBootstrapContext).to receive(:new).and_return(mock_bootstrap_context)
-   end
-
-  describe "latest_current_windows_chef_version_query" do
-    it "returns the major version of the current version of Chef" do
-      stub_const("Chef::VERSION", '11.1.2')
-      expect(mock_bootstrap_context.latest_current_windows_chef_version_query).to eq("&v=11")
-    end
-
-    it "does not add prerelease if the version of Chef installed is a prerelease" do
-      stub_const("Chef::VERSION", '42.0.1.alpha.1')
-      expect(mock_bootstrap_context.latest_current_windows_chef_version_query).not_to match(/&prerelease=true/)
-    end
-
-    it "does add prerelease if the version specified to be installed is a prerelease" do
-      allow(mock_bootstrap_context).to receive(:knife_config).and_return(Mash.new(:bootstrap_version => "12.0.0.alpha.1"))
-      expect(mock_bootstrap_context.latest_current_windows_chef_version_query).to eq("&v=12.0.0.alpha.1&prerelease=true")
-    end
-
-    context "when the prerelease config option is set" do
-      before do
-        mock_bootstrap_context.instance_variable_set(:@config, Mash.new(:prerelease => true))
-      end
-
-      it "sets prerelease to true in the returned string" do
-        expect(mock_bootstrap_context.latest_current_windows_chef_version_query).to eq("&prerelease=true")
-      end
-    end
-  end
-end
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Copyright:: Copyright (c) 2014 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::Core::WindowsBootstrapContext do
+  let(:mock_bootstrap_context) { Chef::Knife::Core::WindowsBootstrapContext.new({ }, nil, { :knife => {} }) }
+
+  before do
+     allow(Chef::Knife::Core::WindowsBootstrapContext).to receive(:new).and_return(mock_bootstrap_context)
+   end
+
+  describe "latest_current_windows_chef_version_query" do
+    it "returns the major version of the current version of Chef" do
+      stub_const("Chef::VERSION", '11.1.2')
+      expect(mock_bootstrap_context.latest_current_windows_chef_version_query).to eq("&v=11")
+    end
+
+    it "does not add prerelease if the version of Chef installed is a prerelease" do
+      stub_const("Chef::VERSION", '42.0.1.alpha.1')
+      expect(mock_bootstrap_context.latest_current_windows_chef_version_query).not_to match(/&prerelease=true/)
+    end
+
+    it "does add prerelease if the version specified to be installed is a prerelease" do
+      allow(mock_bootstrap_context).to receive(:knife_config).and_return(Mash.new(:bootstrap_version => "12.0.0.alpha.1"))
+      expect(mock_bootstrap_context.latest_current_windows_chef_version_query).to eq("&v=12.0.0.alpha.1&prerelease=true")
+    end
+
+    context "when the prerelease config option is set" do
+      before do
+        mock_bootstrap_context.instance_variable_set(:@config, Mash.new(:prerelease => true))
+      end
+
+      it "sets prerelease to true in the returned string" do
+        expect(mock_bootstrap_context.latest_current_windows_chef_version_query).to eq("&prerelease=true")
+      end
+    end
+  end
+end

data/spec/unit/knife/winrm_spec.rb

@@ -1,219 +1,219 @@
-#
-# Author:: Bryan McLellan <btm@opscode.com>
-# Copyright:: Copyright (c) 2013 Opscode, 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'
-
-Chef::Knife::Winrm.load_deps
-
-describe Chef::Knife::Winrm do
-  before(:all) do
-    @original_config = Chef::Config.hash_dup
-    @original_knife_config = Chef::Config[:knife].nil? ? nil : Chef::Config[:knife].dup
-  end
-
-  after(:all) do
-    Chef::Config.configuration = @original_config
-    Chef::Config[:knife] = @original_knife_config if @original_knife_config
-  end
-
-  before do
-    @knife = Chef::Knife::Winrm.new
-    @knife.config[:attribute] = "fqdn"
-    @node_foo = Chef::Node.new
-    @node_foo.automatic_attrs[:fqdn] = "foo.example.org"
-    @node_foo.automatic_attrs[:ipaddress] = "10.0.0.1"
-    @node_bar = Chef::Node.new
-    @node_bar.automatic_attrs[:fqdn] = "bar.example.org"
-    @node_bar.automatic_attrs[:ipaddress] = "10.0.0.2"
-    @node_bar.automatic_attrs[:ec2][:public_hostname] = "somewhere.com"
-  end
-
-  describe "#configure_session" do
-    before do
-      @query = double("Chef::Search::Query")
-    end
-
-    context "when there are some hosts found but they do not have an attribute to connect with" do
-      before do
-        @knife.config[:manual] = false
-        allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
-        @node_foo.automatic_attrs[:fqdn] = nil
-        @node_bar.automatic_attrs[:fqdn] = nil
-        allow(Chef::Search::Query).to receive(:new).and_return(@query)
-      end
-
-      it "should raise 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_session
-      end
-    end
-
-    context "when there are nested attributes" do
-      before do
-        @knife.config[:manual] = false
-        allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
-        allow(Chef::Search::Query).to receive(:new).and_return(@query)
-      end
-
-      it "should use nested attributes (KNIFE-276)" do
-        @knife.config[:attribute] = "ec2.public_hostname"
-        allow(@knife).to receive(:session_from_list)
-        @knife.configure_session
-
-      end
-    end
-
-    describe Chef::Knife::Winrm do
-      context "when executing the run command which sets the process exit code" do
-        before(:each) do
-          Chef::Config[:knife] = {:winrm_transport => :http}
-          @winrm = Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', 'echo helloworld'])
-        end
-
-        after(:each) do
-          Chef::Config.configuration = @original_config
-          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(:winrm_command).and_return(0)
-          exit_code = @winrm.run
-          expect(exit_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
-          command_status = 510
-          @winrm.config[:returns] = "0"
-          Chef::Config[:knife][:returns] = [0]
-          allow(@winrm).to receive(:winrm_command).and_return(command_status)
-          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})
-          begin
-            @winrm.run
-            expect(0).to eq(510)
-          rescue Exception => e
-            expect(e.status).to eq(command_status)
-          end
-        end
-
-        it "should exit the process 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]
-          allow(@winrm).to receive(:winrm_command).and_return(command_status)
-          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})
-          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
-          command_status = 53
-          Chef::Config[:knife][:returns] = [0,53]
-          allow(@winrm).to receive(:winrm_command).and_return(command_status)
-          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})
-          exit_code = @winrm.run
-          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
-          command_status = 53
-          Chef::Config[:knife][:returns] = [0,53]
-          allow(@winrm).to receive(:winrm_command).and_return(command_status)
-          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})
-          exit_code = @winrm.run
-          expect(exit_code).to be_zero
-        end
-
-        it "should exit the process with 100 if command execution raises an exception other than 401" do
-          allow(@winrm).to receive(:winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('500', '500'))
-          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
-          allow(@winrm).to receive(:winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('401', '401'))
-          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
-          @winrm.config[:suppress_auth_failure] = true
-          allow(@winrm).to receive(:winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('401', '401'))
-          exit_code = @winrm.run_with_pretty_exceptions
-          expect(exit_code).to eq(401)
-        end
-
-        context "validate sspinegotiate transport option" do
-          before do
-            Chef::Config[:knife] = {:winrm_transport => :plaintext}
-            allow(@winrm).to receive(:winrm_command).and_return(0)
-          end
-
-          it "should have winrm opts transport set to sspinegotiate for windows" do
-            @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.session).to receive(:use).with("localhost", {:user=>"domain\\testuser", :password=>"testpassword", :port=>nil, :operation_timeout=>1800, :basic_auth_only=>false, :transport=>:sspinegotiate, :disable_sspi=>false})
-            exit_code = @winrm.run
-          end
-
-          it "should use the winrm monkey patch for windows" do
-            @winrm.config[:winrm_user] = "domain\\testuser"
-            allow(Chef::Platform).to receive(:windows?).and_return(true)
-            expect(@winrm).to receive(:require).with('winrm-s')
-
-            exit_code = @winrm.run
-          end
-
-          context "when domain name not given" do
-            it "should skip winrm monkey patch for windows" do
-              @winrm.config[:winrm_user] = "testuser"
-              allow(Chef::Platform).to receive(:windows?).and_return(true)
-              expect(@winrm).to_not receive(:require).with('winrm-s')
-
-              exit_code = @winrm.run
-            end
-          end
-
-          context "when local domain name given"  do
-            it "should use the winrm monkey patch for windows" do
-              @winrm.config[:winrm_user] = ".\\testuser"
-              allow(Chef::Platform).to receive(:windows?).and_return(true)
-              expect(@winrm).to receive(:require).with('winrm-s')
-
-              exit_code = @winrm.run
-            end
-          end
-
-          it "should not have winrm opts transport set to sspinegotiate for unix" do
-            allow(Chef::Platform).to receive(:windows?).and_return(false)
-
-            expect(@winrm.session).to receive(:use).with("localhost", {:user=>"testuser", :password=>"testpassword", :port=>nil, :operation_timeout=>1800, :basic_auth_only=>true, :transport=>:plaintext, :disable_sspi=>true})
-            exit_code = @winrm.run
-          end
-        end
-
-      end
-    end
-  end
-end
+#
+# Author:: Bryan McLellan <btm@opscode.com>
+# Copyright:: Copyright (c) 2013 Opscode, 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'
+
+Chef::Knife::Winrm.load_deps
+
+describe Chef::Knife::Winrm do
+  before(:all) do
+    @original_config = Chef::Config.hash_dup
+    @original_knife_config = Chef::Config[:knife].nil? ? nil : Chef::Config[:knife].dup
+  end
+
+  after(:all) do
+    Chef::Config.configuration = @original_config
+    Chef::Config[:knife] = @original_knife_config if @original_knife_config
+  end
+
+  before do
+    @knife = Chef::Knife::Winrm.new
+    @knife.config[:attribute] = "fqdn"
+    @node_foo = Chef::Node.new
+    @node_foo.automatic_attrs[:fqdn] = "foo.example.org"
+    @node_foo.automatic_attrs[:ipaddress] = "10.0.0.1"
+    @node_bar = Chef::Node.new
+    @node_bar.automatic_attrs[:fqdn] = "bar.example.org"
+    @node_bar.automatic_attrs[:ipaddress] = "10.0.0.2"
+    @node_bar.automatic_attrs[:ec2][:public_hostname] = "somewhere.com"
+  end
+
+  describe "#configure_session" do
+    before do
+      @query = double("Chef::Search::Query")
+    end
+
+    context "when there are some hosts found but they do not have an attribute to connect with" do
+      before do
+        @knife.config[:manual] = false
+        allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
+        @node_foo.automatic_attrs[:fqdn] = nil
+        @node_bar.automatic_attrs[:fqdn] = nil
+        allow(Chef::Search::Query).to receive(:new).and_return(@query)
+      end
+
+      it "should raise 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_session
+      end
+    end
+
+    context "when there are nested attributes" do
+      before do
+        @knife.config[:manual] = false
+        allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
+        allow(Chef::Search::Query).to receive(:new).and_return(@query)
+      end
+
+      it "should use nested attributes (KNIFE-276)" do
+        @knife.config[:attribute] = "ec2.public_hostname"
+        allow(@knife).to receive(:session_from_list)
+        @knife.configure_session
+
+      end
+    end
+
+    describe Chef::Knife::Winrm do
+      context "when executing the run command which sets the process exit code" do
+        before(:each) do
+          Chef::Config[:knife] = {:winrm_transport => :http}
+          @winrm = Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', 'echo helloworld'])
+        end
+
+        after(:each) do
+          Chef::Config.configuration = @original_config
+          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(:winrm_command).and_return(0)
+          exit_code = @winrm.run
+          expect(exit_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
+          command_status = 510
+          @winrm.config[:returns] = "0"
+          Chef::Config[:knife][:returns] = [0]
+          allow(@winrm).to receive(:winrm_command).and_return(command_status)
+          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})
+          begin
+            @winrm.run
+            expect(0).to eq(510)
+          rescue Exception => e
+            expect(e.status).to eq(command_status)
+          end
+        end
+
+        it "should exit the process 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]
+          allow(@winrm).to receive(:winrm_command).and_return(command_status)
+          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})
+          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
+          command_status = 53
+          Chef::Config[:knife][:returns] = [0,53]
+          allow(@winrm).to receive(:winrm_command).and_return(command_status)
+          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})
+          exit_code = @winrm.run
+          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
+          command_status = 53
+          Chef::Config[:knife][:returns] = [0,53]
+          allow(@winrm).to receive(:winrm_command).and_return(command_status)
+          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})
+          exit_code = @winrm.run
+          expect(exit_code).to be_zero
+        end
+
+        it "should exit the process with 100 if command execution raises an exception other than 401" do
+          allow(@winrm).to receive(:winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('500', '500'))
+          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
+          allow(@winrm).to receive(:winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('401', '401'))
+          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
+          @winrm.config[:suppress_auth_failure] = true
+          allow(@winrm).to receive(:winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('401', '401'))
+          exit_code = @winrm.run_with_pretty_exceptions
+          expect(exit_code).to eq(401)
+        end
+
+        context "validate sspinegotiate transport option" do
+          before do
+            Chef::Config[:knife] = {:winrm_transport => :plaintext}
+            allow(@winrm).to receive(:winrm_command).and_return(0)
+          end
+
+          it "should have winrm opts transport set to sspinegotiate for windows" do
+            @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.session).to receive(:use).with("localhost", {:user=>"domain\\testuser", :password=>"testpassword", :port=>nil, :operation_timeout=>1800, :basic_auth_only=>false, :transport=>:sspinegotiate, :disable_sspi=>false})
+            exit_code = @winrm.run
+          end
+
+          it "should use the winrm monkey patch for windows" do
+            @winrm.config[:winrm_user] = "domain\\testuser"
+            allow(Chef::Platform).to receive(:windows?).and_return(true)
+            expect(@winrm).to receive(:require).with('winrm-s')
+
+            exit_code = @winrm.run
+          end
+
+          context "when domain name not given" do
+            it "should skip winrm monkey patch for windows" do
+              @winrm.config[:winrm_user] = "testuser"
+              allow(Chef::Platform).to receive(:windows?).and_return(true)
+              expect(@winrm).to_not receive(:require).with('winrm-s')
+
+              exit_code = @winrm.run
+            end
+          end
+
+          context "when local domain name given"  do
+            it "should use the winrm monkey patch for windows" do
+              @winrm.config[:winrm_user] = ".\\testuser"
+              allow(Chef::Platform).to receive(:windows?).and_return(true)
+              expect(@winrm).to receive(:require).with('winrm-s')
+
+              exit_code = @winrm.run
+            end
+          end
+
+          it "should not have winrm opts transport set to sspinegotiate for unix" do
+            allow(Chef::Platform).to receive(:windows?).and_return(false)
+
+            expect(@winrm.session).to receive(:use).with("localhost", {:user=>"testuser", :password=>"testpassword", :port=>nil, :operation_timeout=>1800, :basic_auth_only=>true, :transport=>:plaintext, :disable_sspi=>true})
+            exit_code = @winrm.run
+          end
+        end
+
+      end
+    end
+  end
+end