vagrant-unbundled 2.1.4.0 → 2.2.0.0

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/psrp/powershell_output_decoder_spec.rb

@@ -0,0 +1,98 @@
+require 'winrm/psrp/powershell_output_decoder'
+
+describe WinRM::PSRP::PowershellOutputDecoder do
+  let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:error_record] }
+  let(:data) { 'blah' }
+  let(:message) do
+    WinRM::PSRP::Message.new(
+      'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
+      message_type,
+      data,
+      '4218a578-0f18-4b19-82c3-46b433319126'
+    )
+  end
+
+  subject { described_class.new.decode(message) }
+
+  context 'undecodable message type' do
+    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:public_key] }
+
+    it 'ignores message' do
+      expect(subject).to be nil
+    end
+  end
+
+  context 'undecodable method identifier' do
+    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
+    let(:data) do
+      "\xEF\xBB\xBF<Obj RefId=\"0\"><MS><I64 N=\"ci\">-100</I64><Obj N=\"mi\" RefId=\"1\">"\
+      '<TN RefId="0"><T>System.Management.Automation.Remoting.RemoteHostMethodId</T>'\
+      '<T>System.Enum</T><T>System.ValueType</T><T>System.Object</T></TN>'\
+      '<ToString>WriteProgress</ToString><I32>17</I32></Obj><Obj N="mp" RefId="2">'\
+      '<TN RefId="1"><T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST>'\
+      '<I32>7</I32><I32>0</I32><S>some_x000D__x000A_data</S></LST></Obj></MS></Obj>'
+    end
+
+    it 'ignores message' do
+      expect(subject).to be nil
+    end
+  end
+
+  context 'receiving pipeline output' do
+    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
+    let(:data) { '<obj><S>some data</S></obj>' }
+
+    it 'decodes output' do
+      expect(subject).to eq("some data\r\n")
+    end
+  end
+
+  context 'writeline with new line in middle' do
+    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
+    let(:data) do
+      "\xEF\xBB\xBF<Obj RefId=\"0\"><MS><I64 N=\"ci\">-100</I64><Obj N=\"mi\" RefId=\"1\">"\
+      '<TN RefId="0"><T>System.Management.Automation.Remoting.RemoteHostMethodId</T>'\
+      '<T>System.Enum</T><T>System.ValueType</T><T>System.Object</T></TN>'\
+      '<ToString>WriteLine3</ToString><I32>17</I32></Obj><Obj N="mp" RefId="2">'\
+      '<TN RefId="1"><T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST>'\
+      '<I32>7</I32><I32>0</I32><S>some_x000D__x000A_data</S></LST></Obj></MS></Obj>'
+    end
+
+    it 'decodes and replaces newline' do
+      expect(subject).to eq("some\r\ndata\r\n")
+    end
+  end
+
+  context 'receiving error record' do
+    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:error_record] }
+    let(:test_data_error_xml_template) do
+      ERB.new(stubbed_clixml('error_record.xml.erb'))
+    end
+    let(:error_message) { 'an error' }
+    let(:script_root) { 'script_root' }
+    let(:category_message) { 'category message' }
+    let(:stack_trace) { 'stack trace' }
+    let(:error_id) { 'Microsoft.PowerShell.Commands.WriteErrorException' }
+    let(:data) { test_data_error_xml_template.result(binding) }
+
+    it 'decodes error record' do
+      expect(subject).to match(/#{error_message}/)
+    end
+  end
+
+  context 'receiving error record in pipeline state' do
+    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state] }
+    let(:test_data_error_xml_template) do
+      ERB.new(stubbed_clixml('pipeline_state.xml.erb'))
+    end
+    let(:pipeline_state) { WinRM::PSRP::MessageData::PipelineState::FAILED }
+    let(:error_message) { 'an error' }
+    let(:category_message) { 'category message' }
+    let(:error_id) { 'an error' }
+    let(:data) { test_data_error_xml_template.result(binding) }
+
+    it 'decodes error record' do
+      expect(subject).to match(/#{error_message}/)
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/psrp/psrp_message_spec.rb

@@ -0,0 +1,73 @@
+require 'winrm/psrp/message'
+
+describe WinRM::PSRP::Message do
+  context 'all fields provided' do
+    let(:payload) { 'this is my payload' }
+    subject do
+      described_class.new(
+        'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
+        WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output],
+        payload,
+        '4218a578-0f18-4b19-82c3-46b433319126'
+      )
+    end
+
+    it 'sets the destination to server LE' do
+      expect(subject.bytes[0..3]).to eq([2, 0, 0, 0])
+    end
+    it 'sets the message type LE' do
+      expect(subject.bytes[4..7]).to eq([4, 16, 4, 0])
+    end
+    it 'sets the runspace pool id' do
+      expect(subject.bytes[8..23]).to eq(
+        [186, 251, 27, 188, 21, 130, 4, 74, 178, 223, 122, 58, 192, 49, 14, 22]
+      )
+    end
+    it 'sets the pipeline id' do
+      expect(subject.bytes[24..39]).to eq(
+        [120, 165, 24, 66, 24, 15, 25, 75, 130, 195, 70, 180, 51, 49, 145, 38]
+      )
+    end
+    it 'prefixes the blob with BOM' do
+      expect(subject.bytes[40..42]).to eq([239, 187, 191])
+    end
+    it 'contains at least the first 8 bytes of the XML payload' do
+      expect(subject.bytes[43..-1]).to eq(payload.bytes)
+    end
+    it 'parses the data' do
+      expect(subject.parsed_data).to be_a(WinRM::PSRP::MessageData::PipelineOutput)
+    end
+  end
+
+  context 'create' do
+    it 'raises error when message type is not valid' do
+      expect do
+        WinRM::PSRP::Message.new(
+          'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
+          0x00000000,
+          %(<Obj RefId="0"/>),
+          '4218a578-0f18-4b19-82c3-46b433319126'
+        )
+      end.to raise_error(RuntimeError)
+    end
+  end
+
+  context 'no command id' do
+    subject(:msg) do
+      payload = <<-HERE.unindent
+        <Obj RefId="0"><MS><Version N="protocolversion">2.3</Version>
+        <Version N="PSVersion">2.0</Version><Version N="SerializationVersion">1.1.0.1</Version></MS>
+        </Obj>
+      HERE
+      WinRM::PSRP::Message.new(
+        'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
+        WinRM::PSRP::Message::MESSAGE_TYPES[:session_capability],
+        payload
+      )
+    end
+
+    it 'sets the pipeline id to empty' do
+      expect(msg.bytes[24..39]).to eq([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/psrp/recieve_response_reader_spec.rb

@@ -0,0 +1,170 @@
+require 'winrm/psrp/receive_response_reader'
+
+describe WinRM::PSRP::ReceiveResponseReader do
+  let(:shell_id) { 'F4A2622B-B842-4EB8-8A78-0225C8A993DF' }
+  let(:command_id) { 'A2A2622B-B842-4EB8-8A78-0225C8A993DF' }
+  let(:output_message) { double('output_message', build: 'output_message') }
+  let(:test_data_xml_template) do
+    ERB.new(stubbed_response('get_powershell_output_response.xml.erb'))
+  end
+  let(:test_data_xml_template_not_done) do
+    ERB.new(stubbed_response('get_powershell_output_response_not_done.xml.erb'))
+  end
+  let(:test_data_text) { 'some data' }
+  let(:test_data) { "<obj><S>#{test_data_text}</S></obj>" }
+  let(:message) do
+    WinRM::PSRP::Message.new(
+      shell_id,
+      message_type,
+      test_data,
+      command_id
+    )
+  end
+  let(:fragment) { WinRM::PSRP::Fragment.new(1, message.bytes) }
+  let(:test_data_stdout) { Base64.strict_encode64(fragment.bytes.pack('C*')) }
+  let(:transport) { {} }
+
+  before do
+    allow(transport).to receive(:send_request).and_return(
+      REXML::Document.new(test_data_xml_template.result(binding))
+    )
+  end
+
+  subject do
+    described_class.new(
+      transport,
+      Logging.logger['test']
+    )
+  end
+
+  describe '#read_output' do
+    context 'response doc stdout with pipeline output' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
+
+      it 'outputs to stdout' do
+        expect(
+          subject.read_output(output_message).stdout
+        ).to eq("#{test_data_text}\r\n")
+      end
+    end
+
+    context 'response doc stdout error record' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:error_record] }
+      let(:test_data_error_xml_template) do
+        ERB.new(stubbed_clixml('error_record.xml.erb'))
+      end
+      let(:error_message) { 'an error' }
+      let(:script_root) { 'script_root' }
+      let(:category_message) { 'category message' }
+      let(:stack_trace) { 'stack trace' }
+      let(:error_id) { 'Microsoft.PowerShell.Commands.WriteErrorException' }
+      let(:test_data) { test_data_error_xml_template.result(binding) }
+
+      it 'outputs to stderr' do
+        expect(
+          subject.read_output(output_message).stderr
+        ).to match(/#{error_message}/)
+      end
+    end
+
+    context 'response doc failed pipeline state' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state] }
+      let(:test_data_error_xml_template) do
+        ERB.new(stubbed_clixml('pipeline_state.xml.erb'))
+      end
+      let(:pipeline_state) { WinRM::PSRP::MessageData::PipelineState::FAILED }
+      let(:error_message) { 'an error' }
+      let(:category_message) { 'category message' }
+      let(:error_id) { 'Microsoft.PowerShell.Commands.WriteErrorException' }
+      let(:test_data) { test_data_error_xml_template.result(binding) }
+
+      it 'outputs to stderr' do
+        expect(
+          subject.read_output(output_message).stderr
+        ).to match(/#{error_message}/)
+      end
+    end
+
+    context 'response doc writing error to host' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
+      let(:test_data) do
+        "<Obj RefId='0'><MS><I64 N='ci'>-100</I64><Obj N='mi' RefId='1'><TN RefId='0'>" \
+        '<T>System.Management.Automation.Remoting.RemoteHostMethodId</T><T>System.Enum</T>' \
+        '<T>System.ValueType</T><T>System.Object</T></TN><ToString>WriteErrorLine</ToString>' \
+        "<I32>18</I32></Obj><Obj N='mp' RefId='2'><TN RefId='1'>" \
+        '<T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST><S>errors</S></LST>' \
+        '</Obj></MS></Obj>'
+      end
+
+      it 'outputs to stderr' do
+        expect(
+          subject.read_output(output_message).stderr
+        ).to eq("errors\r\n")
+      end
+    end
+
+    context 'response doc writing output to host' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
+      let(:test_data) do
+        "<Obj RefId='0'><MS><I64 N='ci'>-100</I64><Obj N='mi' RefId='1'><TN RefId='0'>" \
+        '<T>System.Management.Automation.Remoting.RemoteHostMethodId</T><T>System.Enum</T>' \
+        '<T>System.ValueType</T><T>System.Object</T></TN><ToString>WriteLine</ToString>' \
+        "<I32>18</I32></Obj><Obj N='mp' RefId='2'><TN RefId='1'>" \
+        '<T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST><S>output</S></LST>' \
+        '</Obj></MS></Obj>'
+      end
+
+      it 'outputs to stdout' do
+        expect(
+          subject.read_output(output_message).stdout
+        ).to eq("output\r\n")
+      end
+    end
+  end
+
+  describe '#read_message' do
+    context 'do not wait for done state' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
+
+      it 'outputs the message in an array' do
+        expect(subject.read_message(output_message).length).to eq(1)
+        expect(subject.read_message(output_message)[0].data).to end_with(message.data)
+      end
+    end
+
+    context 'read in a block' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
+
+      it 'outputs the message in an array' do
+        subject.read_message(output_message) do |msg|
+          expect(msg.data).to end_with(message.data)
+        end
+      end
+    end
+
+    context 'wait for done state' do
+      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
+      let(:test_data_xml_not_done) { test_data_xml_template_not_done.result(binding) }
+      let(:test_data_xml_done) { test_data_xml_template.result(binding) }
+
+      before do
+        allow(transport).to receive(:send_request).and_return(
+          REXML::Document.new(test_data_xml_not_done),
+          REXML::Document.new(test_data_xml_done)
+        )
+      end
+
+      it 'outputs two messages' do
+        expect(subject.read_message(output_message, true).length).to eq(2)
+      end
+
+      it 'outputs the first message' do
+        expect(subject.read_message(output_message, true)[0].data).to end_with(message.data)
+      end
+
+      it 'outputs the second message' do
+        expect(subject.read_message(output_message, true)[1].data).to end_with(message.data)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/psrp/uuid_spec.rb

@@ -0,0 +1,28 @@
+describe WinRM::PSRP::UUID do
+  subject(:uuid_helper) do
+    Object.new.extend(WinRM::PSRP::UUID)
+  end
+  context 'uuid is nil' do
+    uuid = nil
+    it 'should return an empty byte array' do
+      bytes = uuid_helper.uuid_to_windows_guid_bytes(uuid)
+      expect(bytes).to eq([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    end
+  end
+  context 'uuid 08785e96-eb1b-4a74-a767-7b56e8f13ea9 with lower case letters' do
+    uuid = '08785e96-eb1b-4a74-a767-7b56e8f13ea9'
+    it 'should return a Windows GUID struct compatible little endian byte array' do
+      bytes = uuid_helper.uuid_to_windows_guid_bytes(uuid)
+      expect(bytes).to eq([150, 94, 120, 8, 27, 235, 116, 74, 167, 103, 123, 86, 232, 241, 62, 169])
+    end
+  end
+  context 'uuid 045F9E19D-8B77-4394-AB0C-197497661668 with upper case letters' do
+    uuid = '45F9E19D-8B77-4394-AB0C-197497661668'
+    it 'should return a Windows GUID struct compatible little endian byte array' do
+      bytes = uuid_helper.uuid_to_windows_guid_bytes(uuid)
+      expect(bytes).to eq(
+        [157, 225, 249, 69, 119, 139, 148, 67, 171, 12, 25, 116, 151, 102, 22, 104]
+      )
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/response_handler_spec.rb

@@ -0,0 +1,69 @@
+require 'winrm/http/response_handler'
+
+describe 'response handler', unit: true do
+  %w[v1 v2 omi].each do |winrm_version|
+    context "winrm_version #{winrm_version}" do
+      let(:soap_fault) { stubbed_response("soap_fault_#{winrm_version}.xml") }
+      let(:open_shell) { stubbed_response("open_shell_#{winrm_version}.xml") }
+
+      describe "successful 200 #{winrm_version} response" do
+        it 'returns an xml doc' do
+          handler = WinRM::ResponseHandler.new(open_shell, 200)
+          xml_doc = handler.parse_to_xml
+          expect(xml_doc).to be_instance_of(REXML::Document)
+          expect(xml_doc.to_s).to eq(REXML::Document.new(open_shell).to_s)
+        end
+      end
+
+      describe "failed 500 #{winrm_version} response" do
+        it 'raises a WinRMHTTPTransportError' do
+          handler = WinRM::ResponseHandler.new('', 500)
+          expect { handler.parse_to_xml }.to raise_error(WinRM::WinRMHTTPTransportError)
+        end
+      end
+
+      describe "failed 401 #{winrm_version} response" do
+        it 'raises a WinRMAuthorizationError' do
+          handler = WinRM::ResponseHandler.new('', 401)
+          expect { handler.parse_to_xml }.to raise_error(WinRM::WinRMAuthorizationError)
+        end
+      end
+
+      describe "failed 400 #{winrm_version} response" do
+        it 'raises a WinRMWSManFault' do
+          handler = WinRM::ResponseHandler.new(soap_fault, 400)
+          begin
+            handler.parse_to_xml
+          # PowerShell
+          rescue WinRM::WinRMWSManFault => e
+            expect(e.fault_code).to eq('2150858778')
+            expect(e.fault_description).to include(
+              'The specified class does not exist in the given namespace'
+            )
+          # OMI
+          rescue WinRM::WinRMSoapFault => e
+            expect(e.code).to eq('SOAP-ENV:Receiver')
+            expect(e.subcode).to eq('wsman:InternalError')
+            expect(e.reason).to eq(
+              'get-instance: instance name parameter is missing'
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe 'failed 500 WMI error response' do
+    let(:wmi_error) { stubbed_response('wmi_error_v2.xml') }
+
+    it 'raises a WinRMWMIError' do
+      handler = WinRM::ResponseHandler.new(wmi_error, 500)
+      begin
+        handler.parse_to_xml
+      rescue WinRM::WinRMWMIError => e
+        expect(e.error_code).to eq('2150859173')
+        expect(e.error).to include('The WS-Management service cannot process the request.')
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/shells/base_spec.rb

@@ -0,0 +1,227 @@
+require 'winrm/shells/base'
+
+# Dummy shell class
+class DummyShell < WinRM::Shells::Base
+  class << self
+    def finalize(connection_opts, transport, shell_id)
+      proc { DummyShell.close_shell(connection_opts, transport, shell_id) }
+    end
+
+    def close_shell(_connection_opts, _transport, _shell_id)
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+  end
+
+  def open_shell
+    @closed = false
+    'shell_id'
+  end
+
+  def send_command(_command, _arguments)
+    'command_id'
+  end
+
+  def out_streams
+    %w[std]
+  end
+end
+
+describe DummyShell do
+  let(:retry_limit) { 1 }
+  let(:shell_id) { 'shell_id' }
+  let(:output) { 'output' }
+  let(:command_id) { 'command_id' }
+  let(:payload) { 'message_payload' }
+  let(:command) { 'command' }
+  let(:arguments) { ['args'] }
+  let(:output_message) { double('output_message', build: 'output_message') }
+  let(:connection_options) { { max_commands: 100, retry_limit: retry_limit, retry_delay: 0 } }
+  let(:transport) { double('transport') }
+  let(:reader) { double('reader') }
+
+  before do
+    allow(subject).to receive(:response_reader).and_return(reader)
+    allow(subject).to receive(:command_output_message)
+      .with(shell_id, command_id)
+      .and_return(output_message)
+    allow(reader).to receive(:read_output).with(output_message).and_return(output)
+    allow(transport).to receive(:send_request)
+  end
+
+  subject { described_class.new(connection_options, transport, Logging.logger['test']) }
+
+  shared_examples 'retry shell command' do
+    it 'only closes the shell if there are too many' do
+      if fault == WinRM::Shells::Base::TOO_MANY_COMMANDS
+        expect(DummyShell).to receive(:close_shell)
+      else
+        expect(DummyShell).not_to receive(:close_shell)
+      end
+
+      subject.run(command, arguments)
+    end
+
+    it 'opens a new shell' do
+      expect(subject).to receive(:open).and_call_original.twice
+
+      subject.run(command, arguments)
+    end
+
+    it 'retries the command once' do
+      expect(subject).to receive(:send_command).twice
+
+      subject.run(command, arguments)
+    end
+  end
+
+  describe '#run' do
+    it 'opens a shell' do
+      subject.run(command, arguments)
+      expect(subject.shell_id).not_to be nil
+    end
+
+    it 'returns output from generated command' do
+      expect(subject.run(command, arguments)).to eq output
+    end
+
+    it 'sends cleanup message through transport' do
+      allow(SecureRandom).to receive(:uuid).and_return('uuid')
+      expect(transport).to receive(:send_request)
+        .with(
+          WinRM::WSMV::CleanupCommand.new(
+            connection_options,
+            shell_uri: nil,
+            shell_id: shell_id,
+            command_id: command_id
+          ).build
+        )
+      subject.run(command, arguments)
+    end
+
+    it 'does not error if cleanup is aborted' do
+      allow(SecureRandom).to receive(:uuid).and_return('uuid')
+      expect(transport).to receive(:send_request)
+        .with(
+          WinRM::WSMV::CleanupCommand.new(
+            connection_options,
+            shell_uri: nil,
+            shell_id: shell_id,
+            command_id: command_id
+          ).build
+        ).and_raise(WinRM::WinRMWSManFault.new('oops', '995'))
+      subject.run(command, arguments)
+    end
+
+    it 'does not error if shell is not present anymore' do
+      allow(SecureRandom).to receive(:uuid).and_return('uuid')
+      expect(transport).to receive(:send_request)
+        .with(
+          WinRM::WSMV::CleanupCommand.new(
+            connection_options,
+            shell_uri: nil,
+            shell_id: shell_id,
+            command_id: command_id
+          ).build
+        ).and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
+      subject.run(command, arguments)
+    end
+
+    it 'opens a shell only once when shell is already open' do
+      expect(subject).to receive(:open_shell).and_call_original.once
+      subject.run(command, arguments)
+      subject.run(command, arguments)
+    end
+
+    describe 'connection resets' do
+      before do
+        @times_called = 0
+
+        allow(subject).to receive(:send_command) do
+          @times_called += 1
+          raise WinRM::WinRMWSManFault.new('oops', fault) if @times_called == 1
+
+          command_id
+        end
+      end
+
+      context 'when shell is closed on server' do
+        let(:fault) { '2150858843' }
+
+        include_examples 'retry shell command'
+      end
+
+      context 'when shell accesses a deleted registry key' do
+        let(:fault) { '2147943418' }
+
+        include_examples 'retry shell command'
+      end
+
+      context 'when maximum number of concurrent shells is exceeded' do
+        let(:fault) { '2150859174' }
+
+        include_examples 'retry shell command'
+      end
+    end
+
+    context 'open_shell fails' do
+      let(:retry_limit) { 2 }
+      let(:output_message2) { double('message') }
+
+      it 'retries and raises failure if it never succeeds' do
+        expect(subject).to receive(:open_shell)
+          .and_raise(Errno::ECONNREFUSED).exactly(retry_limit).times
+        expect { subject.run(command) }.to raise_error(Errno::ECONNREFUSED)
+      end
+
+      it 'retries and returns shell on success' do
+        @times = 0
+        allow(subject).to receive(:command_output_message)
+          .with('shell_id 2', command_id)
+          .and_return(output_message2)
+        allow(reader).to receive(:read_output)
+          .with(output_message2).and_return(output)
+        allow(subject).to receive(:open_shell) do
+          @times += 1
+          raise(Errno::ECONNREFUSED) if @times == 1
+
+          "shell_id #{@times}"
+        end
+
+        subject.run(command, arguments)
+        expect(subject.shell_id).to eq 'shell_id 2'
+      end
+    end
+  end
+
+  describe '#close' do
+    it 'does not close if not opened' do
+      expect(DummyShell).not_to receive(:close_shell)
+      subject.close
+    end
+
+    it 'close shell if opened' do
+      subject.run(command, arguments)
+      subject.close
+      expect(DummyShell.closed?).to be(true)
+    end
+
+    it 'nils out the shell_id' do
+      subject.run(command, arguments)
+      subject.close
+      expect(subject.shell_id).to be(nil)
+    end
+
+    context 'when shell was not found' do
+      it 'does not raise' do
+        subject.run(command, arguments)
+        expect(DummyShell).to receive(:close_shell)
+          .and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
+        expect { subject.close }.not_to raise_error
+      end
+    end
+  end
+end