winrm 2.0.3 → 2.1.0

data/tests/integration/spec_helper.rb

@@ -1,65 +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
-  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
+# 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 +1,99 @@
-# 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
+# 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,16 +1,16 @@
-# 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
-end
+# 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
+end

data/tests/matchers.rb

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