winrm 1.8.1 → 2.0.0

data/{spec → tests/integration}/issue_59_spec.rb

@@ -1,23 +1,26 @@
-# encoding: UTF-8
-describe 'issue 59', integration: true do
-  before(:all) do
-    @winrm = winrm_connection
-  end
-
-  describe 'long running script without output' do
-    let(:logged_output) { StringIO.new }
-    let(:logger)        { Logging.logger(logged_output) }
-
-    it 'should not error' do
-      @winrm.set_timeout(1)
-      @winrm.logger = logger
-
-      out = @winrm.powershell('$ProgressPreference="SilentlyContinue";sleep 3; Write-Host "Hello"')
-
-      expect(out).to have_exit_code 0
-      expect(out).to have_stdout_match(/Hello/)
-      expect(out).to have_no_stderr
-      expect(logged_output.string).to match(/retrying receive request/)
-    end
-  end
-end
+# encoding: UTF-8
+require_relative 'spec_helper'
+
+describe 'issue 59' do
+  describe 'long running script without output' do
+    let(:logged_output) { StringIO.new }
+    let(:logger)        { Logging.logger(logged_output) }
+
+    before do
+      opts = connection_opts.dup
+      opts[:operation_timeout] = 1
+      conn = WinRM::Connection.new(opts)
+      conn.logger = logger
+      @powershell = conn.shell(:powershell)
+    end
+
+    it 'should not error' do
+      out = @powershell.run('$ProgressPreference="SilentlyContinue";sleep 3; Write-Host "Hello"')
+
+      expect(out).to have_exit_code 0
+      expect(out).to have_stdout_match(/Hello/)
+      expect(out).to have_no_stderr
+      expect(logged_output.string).to match(/retrying receive request/)
+    end
+  end
+end

data/tests/integration/powershell_spec.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+require_relative 'spec_helper'
+
+describe 'winrm client powershell' do
+  before(:all) do
+    @powershell = winrm_connection.shell(:powershell)
+  end
+
+  describe 'ipconfig' do
+    subject(:output) { @powershell.run('ipconfig') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/Windows IP Configuration/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'exit' do
+    subject(:output) { @powershell.run('exit 5') }
+    it { should have_exit_code 5 }
+  end
+
+  describe 'echo \'hello world\' using apostrophes' do
+    subject(:output) { @powershell.run("echo 'hello world'") }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/hello world/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'handling special XML characters' do
+    subject(:output) { @powershell.run("echo 'hello & <world>'") }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/hello & <world>/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'dir with incorrect argument /z' do
+    subject(:output) { @powershell.run('dir /z') }
+    it { should have_stderr_match(/Cannot find path/) }
+    it { should have_no_stdout }
+  end
+
+  describe 'Math area calculation' do
+    subject(:output) do
+      @powershell.run <<-EOH
+        $diameter = 4.5
+        $area = [Math]::pow([Math]::PI * ($diameter/2), 2)
+        Write-Host $area
+      EOH
+    end
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/49.9648722805149/) }
+    it { should have_no_stderr }
+  end
+
+  describe 'ipconfig with a block' do
+    subject(:stdout) do
+      outvar = ''
+      @powershell.run('ipconfig') do |stdout, _stderr|
+        outvar << stdout
+      end
+      outvar
+    end
+    it { should match(/Windows IP Configuration/) }
+  end
+
+  describe 'capturing output from Write-Host and Write-Error' do
+    subject(:output) do
+      script = <<-eos
+      Write-Host 'Hello'
+      $host.ui.WriteErrorLine(', world!')
+      eos
+
+      @captured_stdout = ''
+      @captured_stderr = ''
+      @powershell.run(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 'capturing output from pipeline followed by Host' do
+    subject(:output) do
+      script = <<-eos
+      Write-Output 'output'
+      $host.UI.Writeline('host')
+      eos
+
+      @captured_stdout = ''
+      @captured_stderr = ''
+      @powershell.run(script) do |stdout, stderr|
+        @captured_stdout << stdout if stdout
+        @captured_stderr << stderr if stderr
+      end
+    end
+
+    it 'should print from the pipeline first' do
+      expect(output.stdout).to start_with("output\r\n")
+    end
+
+    it 'should write to host last' do
+      expect(output.stdout).to end_with("host\r\n")
+    end
+  end
+
+  describe 'it should handle utf-8 characters' do
+    subject(:output) { @powershell.run('echo "✓1234-äöü"') }
+    it { should have_exit_code 0 }
+    it { should have_stdout_match(/✓1234-äöü/) }
+  end
+
+  describe 'output exceeds a single fragment' do
+    subject(:output) { @powershell.run('Write-Output $("a"*600000)') }
+    it { should have_exit_code 0 }
+    it 'has assebled the output' do
+      expect(output.stdout).to eq('a' * 600000 + "\r\n")
+    end
+  end
+
+  describe 'command exceeds a single fragment' do
+    subject(:output) { @powershell.run("$var='#{'a' * 600000}';Write-Output 'long var'") }
+    it { should have_exit_code 0 }
+    it 'has sent the output' do
+      expect(output.stdout).to eq("long var\r\n")
+    end
+  end
+
+  describe 'reading pipeline messages' do
+    subject(:messages) { @powershell.send_pipeline_command('ipconfig') }
+
+    it 'returns multiple messages' do
+      expect(messages.length).to be > 1
+    end
+    it 'first message is pipeline output' do
+      expect(messages.first.type).to eq(WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output])
+    end
+    it 'last message is pipeline state' do
+      expect(messages.last.type).to eq(WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state])
+    end
+  end
+end

data/{spec → tests/integration}/spec_helper.rb

@@ -1,73 +1,65 @@
-# encoding: UTF-8
-require 'rubygems'
-require 'bundler/setup'
-require 'winrm'
-require 'json'
-require_relative 'matchers'
-
-# Creates a WinRM connection for integration tests
-module ConnectionHelper
-  # rubocop:disable AbcSize
-  def winrm_connection
-    winrm = WinRM::WinRMWebService.new(
-      config[:endpoint], config[:auth_type].to_sym, config[:options])
-    winrm.logger.level = :error
-    winrm
-  end
-  # rubocop:enable AbcSize
-
-  def config
-    @config ||= begin
-      cfg = symbolize_keys(YAML.load(File.read(winrm_config_path)))
-      cfg[:options].merge!(basic_auth_only: true) unless cfg[:auth_type].eql? :kerberos
-      merge_environment!(cfg)
-      cfg
-    end
-  end
-
-  def merge_environment!(config)
-    merge_config_option_from_environment(config, 'user')
-    merge_config_option_from_environment(config, 'pass')
-    merge_config_option_from_environment(config, 'no_ssl_peer_verification')
-    if ENV['use_ssl_peer_fingerprint']
-      config[:options][:ssl_peer_fingerprint] = ENV['winrm_cert']
-    end
-    config[:endpoint] = ENV['winrm_endpoint'] if ENV['winrm_endpoint']
-  end
-
-  def merge_config_option_from_environment(config, key)
-    env_key = 'winrm_' + key
-    config[:options][key.to_sym] = ENV[env_key] if ENV[env_key]
-  end
-
-  def winrm_config_path
-    # Copy config-example.yml to config.yml and edit for your local configuration
-    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
-    unless File.exist?(path)
-      # user hasn't done this, so use sane defaults for unit tests
-      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
-    end
-    path
-  end
-
-  # rubocop:disable Metrics/MethodLength
-  def symbolize_keys(hash)
-    hash.each_with_object({}) do |(key, value), result|
-      new_key = case key
-                when String then key.to_sym
-                else key
-                end
-      new_value = case value
-                  when Hash then symbolize_keys(value)
-                  else value
-                  end
-      result[new_key] = new_value
-      result
-    end
-  end
-  # rubocop:enable Metrics/MethodLength
-end
-
-RSpec.configure do |config|
-  config.include(ConnectionHelper)
-end
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler/setup'
+require 'winrm'
+require 'json'
+require_relative '../matchers'
+
+# Creates a WinRM connection for integration tests
+module ConnectionHelper
+  def winrm_connection
+    WinRM::Connection.new(connection_opts)
+  end
+
+  def connection_opts
+    @config ||= begin
+      cfg = symbolize_keys(YAML.load(File.read(winrm_config_path)))
+      merge_environment(cfg)
+    end
+  end
+
+  def merge_environment(config)
+    merge_config_option_from_environment(config, 'user')
+    merge_config_option_from_environment(config, 'password')
+    merge_config_option_from_environment(config, 'no_ssl_peer_verification')
+    if ENV['use_ssl_peer_fingerprint']
+      config[:ssl_peer_fingerprint] = ENV['winrm_cert']
+    end
+    config[:endpoint] = ENV['winrm_endpoint'] if ENV['winrm_endpoint']
+    config
+  end
+
+  def merge_config_option_from_environment(config, key)
+    env_key = 'winrm_' + key
+    config[key.to_sym] = ENV[env_key] if ENV[env_key]
+  end
+
+  def winrm_config_path
+    # Copy config-example.yml to config.yml and edit for your local ConnectionOpts
+    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
+    unless File.exist?(path)
+      # user hasn't done this, so use sane defaults for unit tests
+      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
+    end
+    path
+  end
+
+  def symbolize_keys(hash)
+    hash.each_with_object({}) do |(key, value), result|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(ConnectionHelper)
+end

data/{spec → tests/integration}/transport_spec.rb

@@ -1,139 +1,99 @@
-# encoding: UTF-8
-require 'rubyntlm'
-require 'winrm/http/transport'
-
-describe WinRM::HTTP::HttpNegotiate, unit: true do
-  describe '#init' do
-    let(:endpoint) { 'some_endpoint' }
-    let(:domain) { 'some_domain' }
-    let(:user) { 'some_user' }
-    let(:password) { 'some_password' }
-    let(:options) { {} }
-
-    context 'user is not domain prefixed' do
-      it 'does not pass a domain to the NTLM client' do
-        expect(Net::NTLM::Client).to receive(:new).with(user, password, options)
-        WinRM::HTTP::HttpNegotiate.new(endpoint, user, password, options)
-      end
-    end
-
-    context 'user is domain prefixed' do
-      it 'passes prefixed domain to the NTLM client' do
-        expect(Net::NTLM::Client).to receive(:new) do |passed_user, passed_password, passed_options|
-          expect(passed_user).to eq user
-          expect(passed_password).to eq password
-          expect(passed_options[:domain]).to eq domain
-        end
-        WinRM::HTTP::HttpNegotiate.new(endpoint, "#{domain}\\#{user}", password, options)
-      end
-    end
-
-    context 'option is passed with a domain' do
-      let(:options) { { domain: domain } }
-
-      it 'passes domain option to the NTLM client' do
-        expect(Net::NTLM::Client).to receive(:new) do |passed_user, passed_password, passed_options|
-          expect(passed_user).to eq user
-          expect(passed_password).to eq password
-          expect(passed_options[:domain]).to eq domain
-        end
-        WinRM::HTTP::HttpNegotiate.new(endpoint, user, password, options)
-      end
-    end
-  end
-end
-
-describe 'WinRM connection', integration: true do
-  let(:winrm_connection) do
-    endpoint = config[:endpoint].dup
-    if auth_type == :ssl
-      endpoint.sub!('5985', '5986')
-      endpoint.sub!('http', 'https')
-    end
-    winrm = WinRM::WinRMWebService.new(
-      endpoint, auth_type, options)
-    winrm.logger.level = :error
-    winrm
-  end
-  let(:options) do
-    opts = {}
-    opts[:user] = config[:options][:user]
-    opts[:pass] = config[:options][:pass]
-    opts[:basic_auth_only] = basic_auth_only
-    opts[:no_ssl_peer_verification] = no_ssl_peer_verification
-    opts[:ssl_peer_fingerprint] = ssl_peer_fingerprint
-    opts[:client_cert] = user_cert
-    opts[:client_key] = user_key
-    opts
-  end
-  let(:basic_auth_only) { false }
-  let(:no_ssl_peer_verification) { false }
-  let(:ssl_peer_fingerprint) { nil }
-  let(:user_cert) { nil }
-  let(:user_key) { nil }
-
-  subject(:output) do
-    executor = winrm_connection.create_executor
-    executor.run_cmd('ipconfig')
-  end
-
-  shared_examples 'a valid_connection' do
-    it 'has a 0 exit code' do
-      expect(subject).to have_exit_code 0
-    end
-
-    it 'includes command output' do
-      expect(subject).to have_stdout_match(/Windows IP Configuration/)
-    end
-
-    it 'has no errors' do
-      expect(subject).to have_no_stderr
-    end
-  end
-
-  context 'HttpPlaintext' do
-    let(:basic_auth_only) { true }
-    let(:auth_type) { :plaintext }
-
-    it_behaves_like 'a valid_connection'
-  end
-
-  context 'HttpNegotiate' do
-    let(:auth_type) { :negotiate }
-
-    it_behaves_like 'a valid_connection'
-  end
-
-  context 'BasicAuthSSL', skip: ENV['winrm_cert'].nil? do
-    let(:basic_auth_only) { true }
-    let(:auth_type) { :ssl }
-    let(:no_ssl_peer_verification) { true }
-
-    it_behaves_like 'a valid_connection'
-  end
-
-  context 'ClientCertAuthSSL', skip: ENV['user_cert'].nil? do
-    let(:auth_type) { :ssl }
-    let(:no_ssl_peer_verification) { true }
-    let(:user_cert) { ENV['user_cert'] }
-    let(:user_key) { ENV['user_key'] }
-
-    before { options[:pass] = nil }
-
-    it_behaves_like 'a valid_connection'
-  end
-
-  context 'Negotiate over SSL', skip: ENV['winrm_cert'].nil? do
-    let(:auth_type) { :ssl }
-    let(:no_ssl_peer_verification) { true }
-
-    it_behaves_like 'a valid_connection'
-  end
-
-  context 'SSL fingerprint', skip: ENV['winrm_cert'].nil? do
-    let(:auth_type) { :ssl }
-    let(:ssl_peer_fingerprint) { ENV['winrm_cert'] }
-
-    it_behaves_like 'a valid_connection'
-  end
-end
+# encoding: UTF-8
+require_relative 'spec_helper'
+
+describe 'WinRM connection' do
+  let(:connection) do
+    endpoint = connection_opts[:endpoint].dup
+    if auth_type == :ssl
+      endpoint.sub!('5985', '5986')
+      endpoint.sub!('http', 'https')
+    end
+    conn_options = {
+      transport: auth_type,
+      endpoint: endpoint
+    }.merge(options)
+    WinRM::Connection.new(conn_options).shell(:cmd)
+  end
+  let(:options) do
+    opts = {}
+    opts[:user] = connection_opts[:user]
+    opts[:password] = connection_opts[:password]
+    opts[:basic_auth_only] = basic_auth_only
+    opts[:no_ssl_peer_verification] = no_ssl_peer_verification
+    opts[:ssl_peer_fingerprint] = ssl_peer_fingerprint
+    opts[:client_cert] = user_cert
+    opts[:client_key] = user_key
+    opts
+  end
+  let(:basic_auth_only) { false }
+  let(:no_ssl_peer_verification) { false }
+  let(:ssl_peer_fingerprint) { nil }
+  let(:user_cert) { nil }
+  let(:user_key) { nil }
+
+  subject(:output) { connection.run('ipconfig') }
+
+  after(:each) do
+    connection.close
+  end
+
+  shared_examples 'a valid_connection' do
+    it 'has a 0 exit code' do
+      expect(subject).to have_exit_code 0
+    end
+
+    it 'includes command output' do
+      expect(subject).to have_stdout_match(/Windows IP Configuration/)
+    end
+
+    it 'has no errors' do
+      expect(subject).to have_no_stderr
+    end
+  end
+
+  context 'HttpPlaintext' do
+    let(:basic_auth_only) { true }
+    let(:auth_type) { :plaintext }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'HttpNegotiate' do
+    let(:auth_type) { :negotiate }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'BasicAuthSSL', skip: ENV['winrm_cert'].nil? do
+    let(:basic_auth_only) { true }
+    let(:auth_type) { :ssl }
+    let(:no_ssl_peer_verification) { true }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'ClientCertAuthSSL', skip: ENV['user_cert'].nil? do
+    let(:auth_type) { :ssl }
+    let(:no_ssl_peer_verification) { true }
+    let(:user_cert) { ENV['user_cert'] }
+    let(:user_key) { ENV['user_key'] }
+
+    before { options[:pass] = nil }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'Negotiate over SSL', skip: ENV['winrm_cert'].nil? do
+    let(:auth_type) { :ssl }
+    let(:no_ssl_peer_verification) { true }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'SSL fingerprint', skip: ENV['winrm_cert'].nil? do
+    let(:auth_type) { :ssl }
+    let(:ssl_peer_fingerprint) { ENV['winrm_cert'] }
+
+    it_behaves_like 'a valid_connection'
+  end
+end