winrm 1.7.1 → 1.7.2

data/preamble

@@ -1,17 +1,17 @@
-=begin
-  This file is part of WinRM; the Ruby library for Microsoft WinRM.
-
-  Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
-
-  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.
-=end
+=begin
+  This file is part of WinRM; the Ruby library for Microsoft WinRM.
+
+  Copyright © 2010 Dan Wanek <dan.wanek@gmail.com>
+
+  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.
+=end

data/spec/auth_timeout_spec.rb

@@ -1,16 +1,16 @@
-# encoding: UTF-8
-# This test may only be meaningful with kerberos auth
-# Against server 2012, a kerberos connection will require reauth (get a 401)
-# if there are no requests for >= 15 seconds
-
-describe 'Verify kerberos will reauth when necessary', kerberos: true do
-  before(:all) do
-    @winrm = winrm_connection
-  end
-
-  it 'work with a 18 second sleep' do
-    ps_command = 'Start-Sleep -s 18'
-    output = @winrm.run_powershell_script(ps_command)
-    output[:exitcode].should == 0
-  end
-end
+# encoding: UTF-8
+# This test may only be meaningful with kerberos auth
+# Against server 2012, a kerberos connection will require reauth (get a 401)
+# if there are no requests for >= 15 seconds
+
+describe 'Verify kerberos will reauth when necessary', kerberos: true do
+  before(:all) do
+    @winrm = winrm_connection
+  end
+
+  it 'work with a 18 second sleep' do
+    ps_command = 'Start-Sleep -s 18'
+    output = @winrm.run_powershell_script(ps_command)
+    output[:exitcode].should == 0
+  end
+end

data/spec/cmd_spec.rb

@@ -1,102 +1,102 @@
-# encoding: UTF-8
-describe 'winrm client cmd', integration: true do
-  before(:all) do
-    @winrm = winrm_connection
-  end
-
-  describe 'empty string' do
-    subject(:output) { @winrm.cmd('') }
-    it { should have_exit_code 0 }
-    it { should have_no_stdout }
-    it { should have_no_stderr }
-  end
-
-  describe 'ipconfig' do
-    subject(:output) { @winrm.cmd('ipconfig') }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/Windows IP Configuration/) }
-    it { should have_no_stderr }
-  end
-
-  describe 'echo \'hello world\' using apostrophes' do
-    subject(:output) { @winrm.cmd("echo 'hello world'") }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/'hello world'/) }
-    it { should have_no_stderr }
-  end
-
-  describe 'echo "string with trailing \\" using double quotes' do
-    # This is a regression test for #131.  " is converted to " when serializing
-    # the command to SOAP/XML.  Any naive substitution performed on such a serialized
-    # string can result in any \& sequence being interpreted as a back-substitution.
-    subject(:output) { @winrm.cmd('echo "string with trailing \\"') }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/string with trailing \\/) }
-    it { should have_no_stderr }
-  end
-
-  describe 'capturing output from stdout and stderr' do
-    subject(:output) do
-      # Note: Multiple lines doesn't work:
-      # script = <<-eos
-      # echo Hello
-      # echo , world! 1>&2
-      # eos
-
-      script = 'echo Hello & echo , world! 1>&2'
-
-      @captured_stdout = ''
-      @captured_stderr = ''
-      @winrm.cmd(script) do |stdout, stderr|
-        @captured_stdout << stdout if stdout
-        @captured_stderr << stderr if stderr
-      end
-    end
-
-    it 'should have stdout' do
-      expect(output.stdout).to eq("Hello \r\n")
-      expect(output.stdout).to eq(@captured_stdout)
-    end
-
-    it 'should have stderr' do
-      expect(output.stderr).to eq(", world! \r\n")
-      expect(output.stderr).to eq(@captured_stderr)
-    end
-
-    it 'should have output' do
-      expect(output.output).to eq("Hello \r\n, world! \r\n")
-    end
-  end
-
-  describe 'ipconfig with /all argument' do
-    subject(:output) { @winrm.cmd('ipconfig', %w(/all)) }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/Windows IP Configuration/) }
-    it { should have_no_stderr }
-  end
-
-  describe 'dir with incorrect argument /z' do
-    subject(:output) { @winrm.cmd('dir /z') }
-    it { should have_exit_code 1 }
-    it { should have_no_stdout }
-    it { should have_stderr_match(/Invalid switch/) }
-  end
-
-  describe 'ipconfig && echo error 1>&2' do
-    subject(:output) { @winrm.cmd('ipconfig && echo error 1>&2') }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/Windows IP Configuration/) }
-    it { should have_stderr_match(/error/) }
-  end
-
-  describe 'ipconfig with a block' do
-    subject(:stdout) do
-      outvar = ''
-      @winrm.cmd('ipconfig') do |stdout, _stderr|
-        outvar << stdout
-      end
-      outvar
-    end
-    it { should match(/Windows IP Configuration/) }
-  end
-end
+# encoding: UTF-8
+describe 'winrm client cmd', integration: true do
+  before(:all) do
+    @winrm = winrm_connection
+  end
+
+  describe 'empty string' do
+    subject(:output) { @winrm.cmd('') }
+    it { should have_exit_code 0 }
+    it { should have_no_stdout }
+    it { should have_no_stderr }
+  end
+
+  describe 'ipconfig' do
+    subject(:output) { @winrm.cmd('ipconfig') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/Windows IP Configuration/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'echo \'hello world\' using apostrophes' do
+    subject(:output) { @winrm.cmd("echo 'hello world'") }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/'hello world'/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'echo "string with trailing \\" using double quotes' do
+    # This is a regression test for #131.  " is converted to &quot; when serializing
+    # the command to SOAP/XML.  Any naive substitution performed on such a serialized
+    # string can result in any \& sequence being interpreted as a back-substitution.
+    subject(:output) { @winrm.cmd('echo "string with trailing \\"') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/string with trailing \\/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'capturing output from stdout and stderr' do
+    subject(:output) do
+      # Note: Multiple lines doesn't work:
+      # script = <<-eos
+      # echo Hello
+      # echo , world! 1>&2
+      # eos
+
+      script = 'echo Hello & echo , world! 1>&2'
+
+      @captured_stdout = ''
+      @captured_stderr = ''
+      @winrm.cmd(script) do |stdout, stderr|
+        @captured_stdout << stdout if stdout
+        @captured_stderr << stderr if stderr
+      end
+    end
+
+    it 'should have stdout' do
+      expect(output.stdout).to eq("Hello \r\n")
+      expect(output.stdout).to eq(@captured_stdout)
+    end
+
+    it 'should have stderr' do
+      expect(output.stderr).to eq(", world! \r\n")
+      expect(output.stderr).to eq(@captured_stderr)
+    end
+
+    it 'should have output' do
+      expect(output.output).to eq("Hello \r\n, world! \r\n")
+    end
+  end
+
+  describe 'ipconfig with /all argument' do
+    subject(:output) { @winrm.cmd('ipconfig', %w(/all)) }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/Windows IP Configuration/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'dir with incorrect argument /z' do
+    subject(:output) { @winrm.cmd('dir /z') }
+    it { should have_exit_code 1 }
+    it { should have_no_stdout }
+    it { should have_stderr_match(/Invalid switch/) }
+  end
+
+  describe 'ipconfig && echo error 1>&2' do
+    subject(:output) { @winrm.cmd('ipconfig && echo error 1>&2') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/Windows IP Configuration/) }
+    it { should have_stderr_match(/error/) }
+  end
+
+  describe 'ipconfig with a block' do
+    subject(:stdout) do
+      outvar = ''
+      @winrm.cmd('ipconfig') do |stdout, _stderr|
+        outvar << stdout
+      end
+      outvar
+    end
+    it { should match(/Windows IP Configuration/) }
+  end
+end

data/spec/command_executor_spec.rb

@@ -1,429 +1,429 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Fletcher (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2015, Fletcher Nichol
-#
-# 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 'winrm/command_executor'
-
-require 'base64'
-require 'securerandom'
-
-describe WinRM::CommandExecutor, unit: true do
-  let(:logged_output)   { StringIO.new }
-  let(:shell_id)        { 'shell-123' }
-  let(:executor_args)   { [service, logger] }
-  let(:executor) { WinRM::CommandExecutor.new(service) }
-  let(:service) do
-    double(
-      'winrm_service',
-      logger: Logging.logger['test'],
-      retry_limit: 1,
-      retry_delay: 1
-    )
-  end
-
-  let(:version_output) { { xml_fragment: [{ version: '6.3.9600' }] } }
-
-  before do
-    allow(service).to receive(:open_shell).and_return(shell_id)
-    allow(service).to receive(:run_wql).and_return(version_output)
-  end
-
-  describe '#close' do
-    it 'calls service#close_shell' do
-      executor.open
-      expect(service).to receive(:close_shell).with(shell_id)
-
-      executor.close
-    end
-
-    it 'only calls service#close_shell once for multiple calls' do
-      executor.open
-      expect(service).to receive(:close_shell).with(shell_id).once
-
-      executor.close
-      executor.close
-      executor.close
-    end
-
-    it 'undefines finalizer' do
-      allow(service).to receive(:close_shell)
-      allow(ObjectSpace).to receive(:define_finalizer) { |e, _| e == executor }
-      expect(ObjectSpace).to receive(:undefine_finalizer).with(executor)
-      executor.open
-
-      executor.close
-    end
-  end
-
-  describe '#open' do
-    it 'calls service#open_shell' do
-      expect(service).to receive(:open_shell).and_return(shell_id)
-
-      executor.open
-    end
-
-    it 'defines a finalizer' do
-      expect(ObjectSpace).to receive(:define_finalizer) do |e, _|
-        expect(e).to eq(executor)
-      end
-
-      executor.open
-    end
-
-    it 'returns a shell id as a string' do
-      expect(executor.open).to eq shell_id
-    end
-
-    describe 'failed connection attempts' do
-      let(:error) { HTTPClient::ConnectTimeoutError }
-      let(:limit) { 3 }
-      let(:delay) { 0.1 }
-
-      before do
-        allow(service).to receive(:open_shell).and_raise(error)
-        allow(service).to receive(:retry_delay).and_return(delay)
-        allow(service).to receive(:retry_limit).and_return(limit)
-      end
-
-      it 'attempts to connect :retry_limit times' do
-        begin
-          allow(service).to receive(:open_shell).exactly.times(limit)
-          executor.open
-        rescue # rubocop:disable Lint/HandleExceptions
-          # the raise is not what is being tested here, rather its side-effect
-        end
-      end
-
-      it 'raises the inner error after retries' do
-        expect { executor.open }.to raise_error(error)
-      end
-    end
-
-    describe 'for modern windows distributions' do
-      let(:version_output) { { xml_fragment: [{ version: '10.0.10586.63' }] } }
-
-      it 'sets #max_commands to 1500 - 2' do
-        expect(executor.max_commands).to eq(1500 - 2)
-      end
-
-      it 'sets code_page to UTF-8' do
-        expect(executor.code_page).to eq 65_001
-      end
-    end
-
-    describe 'for older/legacy windows distributions' do
-      let(:version_output) { { xml_fragment: [{ version: '6.1.8500' }] } }
-
-      it 'sets #max_commands to 15 - 2' do
-        expect(executor.max_commands).to eq(15 - 2)
-      end
-
-      it 'sets code_page to UTF-8' do
-        expect(executor.code_page).to eq 65_001
-      end
-    end
-
-    describe 'for super duper older/legacy windows distributions' do
-      let(:version_output) { { xml_fragment: [{ version: '6.0.8500' }] } }
-
-      it 'sets #max_commands to 15 - 2' do
-        expect(executor.max_commands).to eq(15 - 2)
-      end
-
-      it 'sets code_page to MS-DOS' do
-        expect(executor.code_page).to eq 437
-      end
-    end
-
-    describe 'when unable to find os version' do
-      let(:version_output) { { xml_fragment: [{ funny_clowns: 'haha' }] } }
-
-      it 'raises WinRMError' do
-        expect { executor.code_page }.to raise_error(
-          ::WinRM::WinRMError,
-          'Unable to determine endpoint os version'
-        )
-      end
-    end
-  end
-
-  describe '#run_cmd' do
-    describe 'when #open has not been previously called' do
-      it 'raises a WinRMError error' do
-        expect { executor.run_cmd('nope') }.to raise_error(
-          ::WinRM::WinRMError,
-          "#{executor.class}#open must be called before any run methods are invoked"
-        )
-      end
-    end
-
-    describe 'when #open has been previously called' do
-      let(:command_id) { 'command-123' }
-
-      let(:echo_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o[:data].concat([
-          { stdout: 'Hello\r\n' },
-          { stderr: 'Psst\r\n' }
-        ])
-        o
-      end
-
-      before do
-        stub_cmd(shell_id, 'echo', ['Hello'], echo_output, command_id)
-
-        executor.open
-      end
-
-      it 'calls service#run_command' do
-        expect(service).to receive(:run_command).with(shell_id, 'echo', ['Hello'])
-
-        executor.run_cmd('echo', ['Hello'])
-      end
-
-      it 'calls service#get_command_output to get results' do
-        expect(service).to receive(:get_command_output).with(shell_id, command_id)
-
-        executor.run_cmd('echo', ['Hello'])
-      end
-
-      it 'calls service#get_command_output with a block to get results' do
-        blk = proc { |_, _| 'something' }
-        expect(service).to receive(:get_command_output).with(shell_id, command_id, &blk)
-
-        executor.run_cmd('echo', ['Hello'], &blk)
-      end
-
-      it 'returns an Output object hash' do
-        expect(executor.run_cmd('echo', ['Hello'])).to eq echo_output
-      end
-
-      it 'runs the block  in #get_command_output when given' do
-        io_out = StringIO.new
-        io_err = StringIO.new
-        stub_cmd(
-          shell_id,
-          'echo',
-          ['Hello'],
-          echo_output,
-          command_id
-        ).and_yield(echo_output.stdout, echo_output.stderr)
-        output = executor.run_cmd('echo', ['Hello']) do |stdout, stderr|
-          io_out << stdout if stdout
-          io_err << stderr if stderr
-        end
-
-        expect(io_out.string).to eq 'Hello\r\n'
-        expect(io_err.string).to eq 'Psst\r\n'
-        expect(output).to eq echo_output
-      end
-    end
-
-    describe 'when called many times over time' do
-      # use a 'old' version of windows with lower max_commands threshold
-      # to trigger quicker shell recyles
-      let(:version_output) { { xml_fragment: [{ version: '6.1.8500' }] } }
-
-      let(:echo_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o[:data].concat([{ stdout: 'Hello\r\n' }])
-        o
-      end
-
-      before do
-        allow(service).to receive(:open_shell).and_return('s1', 's2')
-        allow(service).to receive(:close_shell)
-        allow(service).to receive(:run_command).and_yield('command-xxx')
-        allow(service).to receive(:get_command_output).and_return(echo_output)
-        allow(service).to receive(:run_wql).with('select version from Win32_OperatingSystem')
-          .and_return(version_output)
-      end
-
-      it 'resets the shell when #max_commands threshold is tripped' do
-        iterations = 35
-        reset_times = iterations / (15 - 2)
-
-        expect(service).to receive(:close_shell).exactly(reset_times).times
-        executor.open
-        iterations.times { executor.run_cmd('echo', ['Hello']) }
-      end
-    end
-  end
-
-  describe '#run_powershell_script' do
-    describe 'when #open has not been previously called' do
-      it 'raises a WinRMError error' do
-        expect { executor.run_powershell_script('nope') }.to raise_error(
-          ::WinRM::WinRMError,
-          "#{executor.class}#open must be called before any run methods are invoked"
-        )
-      end
-    end
-
-    describe 'when #open has been previously called' do
-      let(:command_id) { 'command-123' }
-
-      let(:echo_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o[:data].concat([
-          { stdout: 'Hello\r\n' },
-          { stderr: 'Psst\r\n' }
-        ])
-        o
-      end
-
-      before do
-        stub_powershell_script(
-          shell_id,
-          'echo Hello',
-          echo_output,
-          command_id
-        )
-
-        executor.open
-      end
-
-      it 'calls service#run_command' do
-        expect(service).to receive(:run_command).with(
-          shell_id,
-          'powershell',
-          [
-            '-encodedCommand',
-            ::WinRM::PowershellScript.new('echo Hello')
-              .encoded
-          ]
-        )
-
-        executor.run_powershell_script('echo Hello')
-      end
-
-      it 'calls service#get_command_output to get results' do
-        expect(service).to receive(:get_command_output).with(shell_id, command_id)
-
-        executor.run_powershell_script('echo Hello')
-      end
-
-      it 'calls service#get_command_output with a block to get results' do
-        blk = proc { |_, _| 'something' }
-        expect(service).to receive(:get_command_output).with(shell_id, command_id, &blk)
-
-        executor.run_powershell_script('echo Hello', &blk)
-      end
-
-      it 'returns an Output object hash' do
-        expect(executor.run_powershell_script('echo Hello')).to eq echo_output
-      end
-
-      it 'runs the block  in #get_command_output when given' do
-        io_out = StringIO.new
-        io_err = StringIO.new
-        stub_cmd(shell_id, 'echo', ['Hello'], echo_output, command_id)
-          .and_yield(echo_output.stdout, echo_output.stderr)
-        output = executor.run_powershell_script('echo Hello') do |stdout, stderr|
-          io_out << stdout if stdout
-          io_err << stderr if stderr
-        end
-
-        expect(io_out.string).to eq 'Hello\r\n'
-        expect(io_err.string).to eq 'Psst\r\n'
-        expect(output).to eq echo_output
-      end
-    end
-
-    describe 'when called many times over time' do
-      # use a 'old' version of windows with lower max_commands threshold
-      # to trigger quicker shell recyles
-      let(:version_output) { { xml_fragment: [{ version: '6.1.8500' }] } }
-
-      let(:echo_output) do
-        o = ::WinRM::Output.new
-        o[:exitcode] = 0
-        o[:data].concat([{ stdout: 'Hello\r\n' }])
-        o
-      end
-
-      before do
-        allow(service).to receive(:open_shell).and_return('s1', 's2')
-        allow(service).to receive(:close_shell)
-        allow(service).to receive(:run_command).and_yield('command-xxx')
-        allow(service).to receive(:get_command_output).and_return(echo_output)
-        allow(service).to receive(:wsman_identify).with('select version from Win32_OperatingSystem')
-          .and_return(version_output)
-      end
-
-      it 'resets the shell when #max_commands threshold is tripped' do
-        iterations = 35
-        reset_times = iterations / (15 - 2)
-
-        expect(service).to receive(:close_shell).exactly(reset_times).times
-        executor.open
-        iterations.times { executor.run_powershell_script('echo Hello') }
-      end
-    end
-  end
-
-  describe '#shell' do
-    it 'is initially nil' do
-      expect(executor.shell).to eq nil
-    end
-
-    it 'is set after #open is called' do
-      executor.open
-
-      expect(executor.shell).to eq shell_id
-    end
-  end
-
-  def decode(powershell)
-    Base64.strict_decode64(powershell).encode('UTF-8', 'UTF-16LE')
-  end
-
-  def debug_line_with(msg)
-    /^D, .* : #{Regexp.escape(msg)}/
-  end
-
-  def regexify(string)
-    Regexp.new(Regexp.escape(string))
-  end
-
-  def regexify_line(string)
-    Regexp.new("^#{Regexp.escape(string)}$")
-  end
-
-  # rubocop:disable Metrics/ParameterLists
-  def stub_cmd(shell_id, cmd, args, output, command_id = nil, &block)
-    command_id ||= SecureRandom.uuid
-
-    allow(service).to receive(:run_command).with(shell_id, cmd, args).and_yield(command_id)
-    allow(service).to receive(:get_command_output).with(shell_id, command_id, &block)
-      .and_return(output)
-  end
-
-  def stub_powershell_script(shell_id, script, output, command_id = nil)
-    stub_cmd(
-      shell_id,
-      'powershell',
-      ['-encodedCommand', ::WinRM::PowershellScript.new(script).encoded],
-      output,
-      command_id
-    )
-  end
-  # rubocop:enable Metrics/ParameterLists
-end
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# 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 'winrm/command_executor'
+
+require 'base64'
+require 'securerandom'
+
+describe WinRM::CommandExecutor, unit: true do
+  let(:logged_output)   { StringIO.new }
+  let(:shell_id)        { 'shell-123' }
+  let(:executor_args)   { [service, logger] }
+  let(:executor) { WinRM::CommandExecutor.new(service) }
+  let(:service) do
+    double(
+      'winrm_service',
+      logger: Logging.logger['test'],
+      retry_limit: 1,
+      retry_delay: 1
+    )
+  end
+
+  let(:version_output) { { xml_fragment: [{ version: '6.3.9600' }] } }
+
+  before do
+    allow(service).to receive(:open_shell).and_return(shell_id)
+    allow(service).to receive(:run_wql).and_return(version_output)
+  end
+
+  describe '#close' do
+    it 'calls service#close_shell' do
+      executor.open
+      expect(service).to receive(:close_shell).with(shell_id)
+
+      executor.close
+    end
+
+    it 'only calls service#close_shell once for multiple calls' do
+      executor.open
+      expect(service).to receive(:close_shell).with(shell_id).once
+
+      executor.close
+      executor.close
+      executor.close
+    end
+
+    it 'undefines finalizer' do
+      allow(service).to receive(:close_shell)
+      allow(ObjectSpace).to receive(:define_finalizer) { |e, _| e == executor }
+      expect(ObjectSpace).to receive(:undefine_finalizer).with(executor)
+      executor.open
+
+      executor.close
+    end
+  end
+
+  describe '#open' do
+    it 'calls service#open_shell' do
+      expect(service).to receive(:open_shell).and_return(shell_id)
+
+      executor.open
+    end
+
+    it 'defines a finalizer' do
+      expect(ObjectSpace).to receive(:define_finalizer) do |e, _|
+        expect(e).to eq(executor)
+      end
+
+      executor.open
+    end
+
+    it 'returns a shell id as a string' do
+      expect(executor.open).to eq shell_id
+    end
+
+    describe 'failed connection attempts' do
+      let(:error) { HTTPClient::ConnectTimeoutError }
+      let(:limit) { 3 }
+      let(:delay) { 0.1 }
+
+      before do
+        allow(service).to receive(:open_shell).and_raise(error)
+        allow(service).to receive(:retry_delay).and_return(delay)
+        allow(service).to receive(:retry_limit).and_return(limit)
+      end
+
+      it 'attempts to connect :retry_limit times' do
+        begin
+          allow(service).to receive(:open_shell).exactly.times(limit)
+          executor.open
+        rescue # rubocop:disable Lint/HandleExceptions
+          # the raise is not what is being tested here, rather its side-effect
+        end
+      end
+
+      it 'raises the inner error after retries' do
+        expect { executor.open }.to raise_error(error)
+      end
+    end
+
+    describe 'for modern windows distributions' do
+      let(:version_output) { { xml_fragment: [{ version: '10.0.10586.63' }] } }
+
+      it 'sets #max_commands to 1500 - 2' do
+        expect(executor.max_commands).to eq(1500 - 2)
+      end
+
+      it 'sets code_page to UTF-8' do
+        expect(executor.code_page).to eq 65_001
+      end
+    end
+
+    describe 'for older/legacy windows distributions' do
+      let(:version_output) { { xml_fragment: [{ version: '6.1.8500' }] } }
+
+      it 'sets #max_commands to 15 - 2' do
+        expect(executor.max_commands).to eq(15 - 2)
+      end
+
+      it 'sets code_page to UTF-8' do
+        expect(executor.code_page).to eq 65_001
+      end
+    end
+
+    describe 'for super duper older/legacy windows distributions' do
+      let(:version_output) { { xml_fragment: [{ version: '6.0.8500' }] } }
+
+      it 'sets #max_commands to 15 - 2' do
+        expect(executor.max_commands).to eq(15 - 2)
+      end
+
+      it 'sets code_page to MS-DOS' do
+        expect(executor.code_page).to eq 437
+      end
+    end
+
+    describe 'when unable to find os version' do
+      let(:version_output) { { xml_fragment: [{ funny_clowns: 'haha' }] } }
+
+      it 'raises WinRMError' do
+        expect { executor.code_page }.to raise_error(
+          ::WinRM::WinRMError,
+          'Unable to determine endpoint os version'
+        )
+      end
+    end
+  end
+
+  describe '#run_cmd' do
+    describe 'when #open has not been previously called' do
+      it 'raises a WinRMError error' do
+        expect { executor.run_cmd('nope') }.to raise_error(
+          ::WinRM::WinRMError,
+          "#{executor.class}#open must be called before any run methods are invoked"
+        )
+      end
+    end
+
+    describe 'when #open has been previously called' do
+      let(:command_id) { 'command-123' }
+
+      let(:echo_output) do
+        o = ::WinRM::Output.new
+        o[:exitcode] = 0
+        o[:data].concat([
+          { stdout: 'Hello\r\n' },
+          { stderr: 'Psst\r\n' }
+        ])
+        o
+      end
+
+      before do
+        stub_cmd(shell_id, 'echo', ['Hello'], echo_output, command_id)
+
+        executor.open
+      end
+
+      it 'calls service#run_command' do
+        expect(service).to receive(:run_command).with(shell_id, 'echo', ['Hello'])
+
+        executor.run_cmd('echo', ['Hello'])
+      end
+
+      it 'calls service#get_command_output to get results' do
+        expect(service).to receive(:get_command_output).with(shell_id, command_id)
+
+        executor.run_cmd('echo', ['Hello'])
+      end
+
+      it 'calls service#get_command_output with a block to get results' do
+        blk = proc { |_, _| 'something' }
+        expect(service).to receive(:get_command_output).with(shell_id, command_id, &blk)
+
+        executor.run_cmd('echo', ['Hello'], &blk)
+      end
+
+      it 'returns an Output object hash' do
+        expect(executor.run_cmd('echo', ['Hello'])).to eq echo_output
+      end
+
+      it 'runs the block  in #get_command_output when given' do
+        io_out = StringIO.new
+        io_err = StringIO.new
+        stub_cmd(
+          shell_id,
+          'echo',
+          ['Hello'],
+          echo_output,
+          command_id
+        ).and_yield(echo_output.stdout, echo_output.stderr)
+        output = executor.run_cmd('echo', ['Hello']) do |stdout, stderr|
+          io_out << stdout if stdout
+          io_err << stderr if stderr
+        end
+
+        expect(io_out.string).to eq 'Hello\r\n'
+        expect(io_err.string).to eq 'Psst\r\n'
+        expect(output).to eq echo_output
+      end
+    end
+
+    describe 'when called many times over time' do
+      # use a 'old' version of windows with lower max_commands threshold
+      # to trigger quicker shell recyles
+      let(:version_output) { { xml_fragment: [{ version: '6.1.8500' }] } }
+
+      let(:echo_output) do
+        o = ::WinRM::Output.new
+        o[:exitcode] = 0
+        o[:data].concat([{ stdout: 'Hello\r\n' }])
+        o
+      end
+
+      before do
+        allow(service).to receive(:open_shell).and_return('s1', 's2')
+        allow(service).to receive(:close_shell)
+        allow(service).to receive(:run_command).and_yield('command-xxx')
+        allow(service).to receive(:get_command_output).and_return(echo_output)
+        allow(service).to receive(:run_wql).with('select version from Win32_OperatingSystem')
+          .and_return(version_output)
+      end
+
+      it 'resets the shell when #max_commands threshold is tripped' do
+        iterations = 35
+        reset_times = iterations / (15 - 2)
+
+        expect(service).to receive(:close_shell).exactly(reset_times).times
+        executor.open
+        iterations.times { executor.run_cmd('echo', ['Hello']) }
+      end
+    end
+  end
+
+  describe '#run_powershell_script' do
+    describe 'when #open has not been previously called' do
+      it 'raises a WinRMError error' do
+        expect { executor.run_powershell_script('nope') }.to raise_error(
+          ::WinRM::WinRMError,
+          "#{executor.class}#open must be called before any run methods are invoked"
+        )
+      end
+    end
+
+    describe 'when #open has been previously called' do
+      let(:command_id) { 'command-123' }
+
+      let(:echo_output) do
+        o = ::WinRM::Output.new
+        o[:exitcode] = 0
+        o[:data].concat([
+          { stdout: 'Hello\r\n' },
+          { stderr: 'Psst\r\n' }
+        ])
+        o
+      end
+
+      before do
+        stub_powershell_script(
+          shell_id,
+          'echo Hello',
+          echo_output,
+          command_id
+        )
+
+        executor.open
+      end
+
+      it 'calls service#run_command' do
+        expect(service).to receive(:run_command).with(
+          shell_id,
+          'powershell',
+          [
+            '-encodedCommand',
+            ::WinRM::PowershellScript.new('echo Hello')
+              .encoded
+          ]
+        )
+
+        executor.run_powershell_script('echo Hello')
+      end
+
+      it 'calls service#get_command_output to get results' do
+        expect(service).to receive(:get_command_output).with(shell_id, command_id)
+
+        executor.run_powershell_script('echo Hello')
+      end
+
+      it 'calls service#get_command_output with a block to get results' do
+        blk = proc { |_, _| 'something' }
+        expect(service).to receive(:get_command_output).with(shell_id, command_id, &blk)
+
+        executor.run_powershell_script('echo Hello', &blk)
+      end
+
+      it 'returns an Output object hash' do
+        expect(executor.run_powershell_script('echo Hello')).to eq echo_output
+      end
+
+      it 'runs the block  in #get_command_output when given' do
+        io_out = StringIO.new
+        io_err = StringIO.new
+        stub_cmd(shell_id, 'echo', ['Hello'], echo_output, command_id)
+          .and_yield(echo_output.stdout, echo_output.stderr)
+        output = executor.run_powershell_script('echo Hello') do |stdout, stderr|
+          io_out << stdout if stdout
+          io_err << stderr if stderr
+        end
+
+        expect(io_out.string).to eq 'Hello\r\n'
+        expect(io_err.string).to eq 'Psst\r\n'
+        expect(output).to eq echo_output
+      end
+    end
+
+    describe 'when called many times over time' do
+      # use a 'old' version of windows with lower max_commands threshold
+      # to trigger quicker shell recyles
+      let(:version_output) { { xml_fragment: [{ version: '6.1.8500' }] } }
+
+      let(:echo_output) do
+        o = ::WinRM::Output.new
+        o[:exitcode] = 0
+        o[:data].concat([{ stdout: 'Hello\r\n' }])
+        o
+      end
+
+      before do
+        allow(service).to receive(:open_shell).and_return('s1', 's2')
+        allow(service).to receive(:close_shell)
+        allow(service).to receive(:run_command).and_yield('command-xxx')
+        allow(service).to receive(:get_command_output).and_return(echo_output)
+        allow(service).to receive(:wsman_identify).with('select version from Win32_OperatingSystem')
+          .and_return(version_output)
+      end
+
+      it 'resets the shell when #max_commands threshold is tripped' do
+        iterations = 35
+        reset_times = iterations / (15 - 2)
+
+        expect(service).to receive(:close_shell).exactly(reset_times).times
+        executor.open
+        iterations.times { executor.run_powershell_script('echo Hello') }
+      end
+    end
+  end
+
+  describe '#shell' do
+    it 'is initially nil' do
+      expect(executor.shell).to eq nil
+    end
+
+    it 'is set after #open is called' do
+      executor.open
+
+      expect(executor.shell).to eq shell_id
+    end
+  end
+
+  def decode(powershell)
+    Base64.strict_decode64(powershell).encode('UTF-8', 'UTF-16LE')
+  end
+
+  def debug_line_with(msg)
+    /^D, .* : #{Regexp.escape(msg)}/
+  end
+
+  def regexify(string)
+    Regexp.new(Regexp.escape(string))
+  end
+
+  def regexify_line(string)
+    Regexp.new("^#{Regexp.escape(string)}$")
+  end
+
+  # rubocop:disable Metrics/ParameterLists
+  def stub_cmd(shell_id, cmd, args, output, command_id = nil, &block)
+    command_id ||= SecureRandom.uuid
+
+    allow(service).to receive(:run_command).with(shell_id, cmd, args).and_yield(command_id)
+    allow(service).to receive(:get_command_output).with(shell_id, command_id, &block)
+      .and_return(output)
+  end
+
+  def stub_powershell_script(shell_id, script, output, command_id = nil)
+    stub_cmd(
+      shell_id,
+      'powershell',
+      ['-encodedCommand', ::WinRM::PowershellScript.new(script).encoded],
+      output,
+      command_id
+    )
+  end
+  # rubocop:enable Metrics/ParameterLists
+end