winrm 2.2.3 → 2.3.6

data/preamble

@@ -1,17 +0,0 @@
-=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/tests/integration/auth_timeout_spec.rb

@@ -1,18 +0,0 @@
-# encoding: UTF-8
-require_relative 'spec_helper'
-
-# 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
-    @powershell = winrm_connection.shell(:powershell)
-  end
-
-  it 'work with a 18 second sleep' do
-    ps_command = 'Start-Sleep -s 18'
-    output = @powershell.run(ps_command)
-    expect(output.exitcode).to eq(0)
-  end
-end

data/tests/integration/cmd_spec.rb

@@ -1,131 +0,0 @@
-# encoding: UTF-8
-require_relative 'spec_helper'
-
-describe 'winrm client cmd' do
-  before(:all) do
-    @cmd_shell = winrm_connection.shell(:cmd)
-  end
-
-  describe 'empty string' do
-    subject(:output) { @cmd_shell.run('') }
-    it { should have_exit_code 0 }
-    it { should have_no_stdout }
-    it { should have_no_stderr }
-  end
-
-  describe 'ipconfig' do
-    subject(:output) { @cmd_shell.run('ipconfig') }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/Windows IP Configuration/) }
-    it { should have_no_stderr }
-  end
-
-  describe 'codepage' do
-    let(:options) { Hash.new }
-    let(:shell) { winrm_connection.shell(:cmd, options) }
-
-    after { shell.close }
-
-    subject(:output) { shell.run('chcp') }
-
-    it 'should default to UTF-8 (65001)' do
-      should have_stdout_match(/Active code page: 65001/)
-    end
-
-    context 'when changing the codepage' do
-      let(:options) { { codepage: 437 } }
-
-      it 'sets the codepage to the one given' do
-        should have_stdout_match(/Active code page: 437/)
-      end
-    end
-  end
-
-  describe 'echo \'hello world\' using apostrophes' do
-    subject(:output) { @cmd_shell.run("echo 'hello world'") }
-    it { should have_exit_code 0 }
-    it { should have_stdout_match(/'hello world'/) }
-    it { should have_no_stderr }
-  end
-
-  describe 'multi stream output from large file' do
-    subject(:output) { @cmd_shell.run('type c:\windows\logs\dism\dism.log') }
-    it { should have_exit_code 0 }
-    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) { @cmd_shell.run('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 = ''
-      @cmd_shell.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 'ipconfig with /all argument' do
-    subject(:output) { @cmd_shell.run('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) { @cmd_shell.run('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) { @cmd_shell.run('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 = ''
-      @cmd_shell.run('ipconfig') do |stdout, _stderr|
-        outvar << stdout
-      end
-      outvar
-    end
-    it { should match(/Windows IP Configuration/) }
-  end
-end

data/tests/integration/config-example.yml

@@ -1,16 +0,0 @@
-# Copy this file to config.yml and edit the settings below.
-# This should work out of the box for vagrant provisioned boxes.
-
-## Kerberos
-#  auth_type: kerberos
-#  realm: "your.realm"
-#  endpoint: "http://<yourserver>:5985/wsman"
-
-# If you are running this in a vagrant provisioned box using NAT,
-# this will be the forwarded WinRM HTTP port to your VM.
-# If you are running this on the VM, the default HTTP port is 5985.
-# See README.md#Troubleshooting.
-
-endpoint: "http://localhost:55985/wsman"
-user: vagrant
-password: vagrant

data/tests/integration/issue_59_spec.rb

@@ -1,26 +0,0 @@
-# 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

@@ -1,165 +0,0 @@
-# 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 'ipconfig with invalid args' do
-    subject(:output) { @powershell.run('ipconfig blah') }
-    it { should have_exit_code 1 }
-  end
-
-  describe 'throw' do
-    subject(:output) { @powershell.run("throw 'an error occured'") }
-    it { should have_exit_code 0 }
-    it { should have_stderr_match(/an error occured/) }
-  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/tests/integration/spec_helper.rb

@@ -1,65 +0,0 @@
-# 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/tests/integration/transport_spec.rb

@@ -1,99 +0,0 @@
-# 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

data/tests/integration/wql_spec.rb

@@ -1,34 +0,0 @@
-# encoding: UTF-8
-require_relative 'spec_helper'
-
-describe 'winrm client wql' do
-  before(:all) do
-    @winrm = winrm_connection
-  end
-
-  it 'should query Win32_OperatingSystem' do
-    output = @winrm.run_wql('select * from Win32_OperatingSystem')
-    expect(output).to_not be_empty
-    output_caption = output[:win32_operating_system][0][:caption]
-    expect(output_caption).to include('Microsoft')
-    expect(output_caption).to include('Windows')
-  end
-
-  it 'should query Win32_Process' do
-    output = @winrm.run_wql('select * from Win32_Process')
-    expect(output).to_not be_empty
-    process_count = output[:win32_process].count
-    expect(process_count).to be > 1
-    expect(output[:win32_process]).to all(include(:command_line))
-  end
-
-  it 'should query Win32_Process with block' do
-    count = 0
-    @winrm.run_wql('select * from Win32_Process') do |type, item|
-      expect(type).to eq(:win32_process)
-      expect(item).to include(:command_line)
-      count += 1
-    end
-    expect(count).to be > 1
-  end
-end

data/tests/matchers.rb

@@ -1,60 +0,0 @@
-# encoding: UTF-8
-require 'rspec/expectations'
-
-# rspec matchers
-RSpec::Matchers.define :have_stdout_match do |expected_stdout|
-  match do |actual_output|
-    !expected_stdout.match(actual_output.stdout).nil?
-  end
-  failure_message do |actual_output|
-    "expected that '#{actual_output.stdout}' would match #{expected_stdout}"
-  end
-end
-
-RSpec::Matchers.define :have_stderr_match do |expected_stderr|
-  match do |actual_output|
-    !expected_stderr.match(actual_output.stderr).nil?
-  end
-  failure_message do |actual_output|
-    "expected that '#{actual_output.stderr}' would match #{expected_stderr}"
-  end
-end
-
-RSpec::Matchers.define :have_no_stdout do
-  match do |actual_output|
-    stdout = actual_output.stdout
-    stdout == '\r\n' || stdout == ''
-  end
-  failure_message do |actual_output|
-    "expected that '#{actual_output.stdout}' would have no stdout"
-  end
-end
-
-RSpec::Matchers.define :have_no_stderr do
-  match do |actual_output|
-    stderr = actual_output.stderr
-    stderr == '\r\n' || stderr == ''
-  end
-  failure_message do |actual_output|
-    "expected that '#{actual_output.stderr}' would have no stderr"
-  end
-end
-
-RSpec::Matchers.define :have_exit_code do |expected_exit_code|
-  match do |actual_output|
-    expected_exit_code == actual_output.exitcode
-  end
-  failure_message do |actual_output|
-    "expected exit code #{expected_exit_code}, but got #{actual_output.exitcode}"
-  end
-end
-
-RSpec::Matchers.define :be_a_uid do
-  match do |actual|
-    # WinRM1.1 returns uuid's prefixed with 'uuid:' where as later versions do not
-    actual && actual.to_s.match(/^(uuid:)*\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$/)
-  end
-  failure_message do |actual|
-    "expected a uid, but got '#{actual}'"
-  end
-end