winrm 1.7.2 → 1.7.3

data/spec/issue_184_spec.rb

@@ -1,67 +1,67 @@
-# encoding: UTF-8
-require 'winrm/winrm_service'
-require 'rexml/document'
-require 'erb'
-require 'base64'
-
-describe 'issue 184', unit: true do
-  let(:shell_id)    { 'shell-123' }
-  let(:command_id)  { 123 }
-  let(:test_data_xml_template) do
-    ERB.new(File.read('spec/stubs/responses/get_command_output_response.xml.erb'))
-  end
-  let(:service) do
-    WinRM::WinRMWebService.new(
-      'http://dummy/wsman',
-      :plaintext,
-      user: 'dummy',
-      pass: 'dummy')
-  end
-
-  describe 'response doc stdout with invalid UTF-8 characters' do
-    let(:test_data_stdout) { 'ffff' } # Base64-decodes to '}\xF7\xDF', an invalid sequence
-    let(:test_data_stderr) { '' }
-    let(:test_data_xml)    { test_data_xml_template.result(binding) }
-
-    before do
-      allow(service).to receive(:send_get_output_message).and_return(
-        REXML::Document.new(test_data_xml)
-      )
-    end
-
-    it 'does not raise an ArgumentError: invalid byte sequence in UTF-8' do
-      begin
-        expect(
-          service.get_command_output(shell_id, command_id)
-        ).not_to raise_error
-      rescue RSpec::Expectations::ExpectationNotMetError => e
-        expect(e.message).not_to include 'ArgumentError'
-      end
-    end
-
-    it 'does not have an empty stdout' do
-      expect(
-        service.get_command_output(shell_id, command_id)[:data][0][:stdout]
-      ).not_to be_empty
-    end
-  end
-
-  describe 'response doc stdout with valid UTF-8' do
-    let(:test_data_raw)    { '✓1234-äöü' }
-    let(:test_data_stdout) { Base64.encode64(test_data_raw) }
-    let(:test_data_stderr) { '' }
-    let(:test_data_xml)    { test_data_xml_template.result(binding) }
-
-    before do
-      allow(service).to receive(:send_get_output_message).and_return(
-        REXML::Document.new(test_data_xml)
-      )
-    end
-
-    it 'decodes to match input data' do
-      expect(
-        service.get_command_output(shell_id, command_id)[:data][0][:stdout]
-      ).to eq(test_data_raw)
-    end
-  end
-end
+# encoding: UTF-8
+require 'winrm/winrm_service'
+require 'rexml/document'
+require 'erb'
+require 'base64'
+
+describe 'issue 184', unit: true do
+  let(:shell_id)    { 'shell-123' }
+  let(:command_id)  { 123 }
+  let(:test_data_xml_template) do
+    ERB.new(File.read('spec/stubs/responses/get_command_output_response.xml.erb'))
+  end
+  let(:service) do
+    WinRM::WinRMWebService.new(
+      'http://dummy/wsman',
+      :plaintext,
+      user: 'dummy',
+      pass: 'dummy')
+  end
+
+  describe 'response doc stdout with invalid UTF-8 characters' do
+    let(:test_data_stdout) { 'ffff' } # Base64-decodes to '}\xF7\xDF', an invalid sequence
+    let(:test_data_stderr) { '' }
+    let(:test_data_xml)    { test_data_xml_template.result(binding) }
+
+    before do
+      allow(service).to receive(:send_get_output_message).and_return(
+        REXML::Document.new(test_data_xml)
+      )
+    end
+
+    it 'does not raise an ArgumentError: invalid byte sequence in UTF-8' do
+      begin
+        expect(
+          service.get_command_output(shell_id, command_id)
+        ).not_to raise_error
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        expect(e.message).not_to include 'ArgumentError'
+      end
+    end
+
+    it 'does not have an empty stdout' do
+      expect(
+        service.get_command_output(shell_id, command_id)[:data][0][:stdout]
+      ).not_to be_empty
+    end
+  end
+
+  describe 'response doc stdout with valid UTF-8' do
+    let(:test_data_raw)    { '✓1234-äöü' }
+    let(:test_data_stdout) { Base64.encode64(test_data_raw) }
+    let(:test_data_stderr) { '' }
+    let(:test_data_xml)    { test_data_xml_template.result(binding) }
+
+    before do
+      allow(service).to receive(:send_get_output_message).and_return(
+        REXML::Document.new(test_data_xml)
+      )
+    end
+
+    it 'decodes to match input data' do
+      expect(
+        service.get_command_output(shell_id, command_id)[:data][0][:stdout]
+      ).to eq(test_data_raw)
+    end
+  end
+end

data/spec/issue_59_spec.rb

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

data/spec/matchers.rb

@@ -1,74 +1,74 @@
-# encoding: UTF-8
-require 'rspec/expectations'
-
-# rspec matchers
-module WinRMSpecs
-  def self.stdout(output)
-    output[:data].collect do |i|
-      i[:stdout]
-    end.join('\r\n').gsub(/(\\r\\n)+$/, '')
-  end
-
-  def self.stderr(output)
-    output[:data].collect do |i|
-      i[:stderr]
-    end.join('\r\n').gsub(/(\\r\\n)+$/, '')
-  end
-end
-
-RSpec::Matchers.define :have_stdout_match do |expected_stdout|
-  match do |actual_output|
-    !expected_stdout.match(WinRMSpecs.stdout(actual_output)).nil?
-  end
-  failure_message do |actual_output|
-    "expected that '#{WinRMSpecs.stdout(actual_output)}' would match #{expected_stdout}"
-  end
-end
-
-RSpec::Matchers.define :have_stderr_match do |expected_stderr|
-  match do |actual_output|
-    !expected_stderr.match(WinRMSpecs.stderr(actual_output)).nil?
-  end
-  failure_message do |actual_output|
-    "expected that '#{WinRMSpecs.stderr(actual_output)}' would match #{expected_stderr}"
-  end
-end
-
-RSpec::Matchers.define :have_no_stdout do
-  match do |actual_output|
-    stdout = WinRMSpecs.stdout(actual_output)
-    stdout == '\r\n' || stdout == ''
-  end
-  failure_message do |actual_output|
-    "expected that '#{WinRMSpecs.stdout(actual_output)}' would have no stdout"
-  end
-end
-
-RSpec::Matchers.define :have_no_stderr do
-  match do |actual_output|
-    stderr = WinRMSpecs.stderr(actual_output)
-    stderr == '\r\n' || stderr == ''
-  end
-  failure_message do |actual_output|
-    "expected that '#{WinRMSpecs.stderr(actual_output)}' 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
+module WinRMSpecs
+  def self.stdout(output)
+    output[:data].collect do |i|
+      i[:stdout]
+    end.join('\r\n').gsub(/(\\r\\n)+$/, '')
+  end
+
+  def self.stderr(output)
+    output[:data].collect do |i|
+      i[:stderr]
+    end.join('\r\n').gsub(/(\\r\\n)+$/, '')
+  end
+end
+
+RSpec::Matchers.define :have_stdout_match do |expected_stdout|
+  match do |actual_output|
+    !expected_stdout.match(WinRMSpecs.stdout(actual_output)).nil?
+  end
+  failure_message do |actual_output|
+    "expected that '#{WinRMSpecs.stdout(actual_output)}' would match #{expected_stdout}"
+  end
+end
+
+RSpec::Matchers.define :have_stderr_match do |expected_stderr|
+  match do |actual_output|
+    !expected_stderr.match(WinRMSpecs.stderr(actual_output)).nil?
+  end
+  failure_message do |actual_output|
+    "expected that '#{WinRMSpecs.stderr(actual_output)}' would match #{expected_stderr}"
+  end
+end
+
+RSpec::Matchers.define :have_no_stdout do
+  match do |actual_output|
+    stdout = WinRMSpecs.stdout(actual_output)
+    stdout == '\r\n' || stdout == ''
+  end
+  failure_message do |actual_output|
+    "expected that '#{WinRMSpecs.stdout(actual_output)}' would have no stdout"
+  end
+end
+
+RSpec::Matchers.define :have_no_stderr do
+  match do |actual_output|
+    stderr = WinRMSpecs.stderr(actual_output)
+    stderr == '\r\n' || stderr == ''
+  end
+  failure_message do |actual_output|
+    "expected that '#{WinRMSpecs.stderr(actual_output)}' 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

data/spec/output_spec.rb

@@ -1,110 +1,110 @@
-# encoding: UTF-8
-describe WinRM::Output, unit: true do
-  subject { WinRM::Output.new }
-
-  context 'when there is no output' do
-    describe '#stdout' do
-      it 'is empty' do
-        expect(subject.stdout).to be_empty
-      end
-    end
-
-    describe '#stderr' do
-      it 'is empty' do
-        expect(subject.stderr).to be_empty
-      end
-    end
-
-    describe '#output' do
-      it 'is empty' do
-        expect(subject.output).to be_empty
-      end
-    end
-  end
-
-  context 'when there is only one line' do
-    describe '#stdout' do
-      it 'is equal to that line' do
-        subject[:data] << { stdout: 'foo' }
-        expect(subject.stdout).to eq('foo')
-      end
-    end
-
-    describe '#stderr' do
-      it 'is equal to that line' do
-        subject[:data] << { stderr: 'foo' }
-        expect(subject.stderr).to eq('foo')
-      end
-    end
-
-    describe '#output' do
-      it 'is equal to stdout' do
-        subject[:data] << { stdout: 'foo' }
-        expect(subject.output).to eq('foo')
-      end
-
-      it 'is equal to stderr' do
-        subject[:data] << { stderr: 'foo' }
-        expect(subject.output).to eq('foo')
-      end
-    end
-  end
-
-  context 'when there is one line of each type' do
-    before(:each) do
-      subject[:data] << { stdout: 'foo' }
-      subject[:data] << { stderr: 'bar' }
-    end
-
-    describe '#stdout' do
-      it 'is equal to that line' do
-        expect(subject.stdout).to eq('foo')
-      end
-    end
-
-    describe '#stderr' do
-      it 'is equal to that line' do
-        expect(subject.stderr).to eq('bar')
-      end
-    end
-
-    describe '#output' do
-      it 'is equal to stdout + stderr' do
-        expect(subject.output).to eq('foobar')
-      end
-    end
-  end
-
-  context 'when there are multiple lines' do
-    before(:each) do
-      subject[:data] << { stdout: 'I can have a newline\nanywhere, ' }
-      subject[:data] << { stderr: 'I can also have stderr' }
-      subject[:data] << { stdout: 'or stdout', stderr: ' and stderr' }
-      subject[:data] << {}
-      subject[:data] << { stdout: ' or nothing! (above)' }
-    end
-
-    describe '#stdout' do
-      it 'is equal to that line' do
-        expect(subject.stdout).to eq(
-          'I can have a newline\nanywhere, or stdout or nothing! (above)')
-      end
-    end
-
-    describe '#stderr' do
-      it 'is equal to that line' do
-        expect(subject.stderr).to eq('I can also have stderr and stderr')
-      end
-    end
-
-    describe '#output' do
-      it 'is equal to stdout + stderr' do
-        expect(subject.output).to eq(
-          'I can have a newline\nanywhere, I can also have stderror stdout ' \
-            'and stderr or nothing! (above)')
-      end
-    end
-  end
-
-  pending 'parse CLIXML errors and convert to Strings and/or Exceptions'
-end
+# encoding: UTF-8
+describe WinRM::Output, unit: true do
+  subject { WinRM::Output.new }
+
+  context 'when there is no output' do
+    describe '#stdout' do
+      it 'is empty' do
+        expect(subject.stdout).to be_empty
+      end
+    end
+
+    describe '#stderr' do
+      it 'is empty' do
+        expect(subject.stderr).to be_empty
+      end
+    end
+
+    describe '#output' do
+      it 'is empty' do
+        expect(subject.output).to be_empty
+      end
+    end
+  end
+
+  context 'when there is only one line' do
+    describe '#stdout' do
+      it 'is equal to that line' do
+        subject[:data] << { stdout: 'foo' }
+        expect(subject.stdout).to eq('foo')
+      end
+    end
+
+    describe '#stderr' do
+      it 'is equal to that line' do
+        subject[:data] << { stderr: 'foo' }
+        expect(subject.stderr).to eq('foo')
+      end
+    end
+
+    describe '#output' do
+      it 'is equal to stdout' do
+        subject[:data] << { stdout: 'foo' }
+        expect(subject.output).to eq('foo')
+      end
+
+      it 'is equal to stderr' do
+        subject[:data] << { stderr: 'foo' }
+        expect(subject.output).to eq('foo')
+      end
+    end
+  end
+
+  context 'when there is one line of each type' do
+    before(:each) do
+      subject[:data] << { stdout: 'foo' }
+      subject[:data] << { stderr: 'bar' }
+    end
+
+    describe '#stdout' do
+      it 'is equal to that line' do
+        expect(subject.stdout).to eq('foo')
+      end
+    end
+
+    describe '#stderr' do
+      it 'is equal to that line' do
+        expect(subject.stderr).to eq('bar')
+      end
+    end
+
+    describe '#output' do
+      it 'is equal to stdout + stderr' do
+        expect(subject.output).to eq('foobar')
+      end
+    end
+  end
+
+  context 'when there are multiple lines' do
+    before(:each) do
+      subject[:data] << { stdout: 'I can have a newline\nanywhere, ' }
+      subject[:data] << { stderr: 'I can also have stderr' }
+      subject[:data] << { stdout: 'or stdout', stderr: ' and stderr' }
+      subject[:data] << {}
+      subject[:data] << { stdout: ' or nothing! (above)' }
+    end
+
+    describe '#stdout' do
+      it 'is equal to that line' do
+        expect(subject.stdout).to eq(
+          'I can have a newline\nanywhere, or stdout or nothing! (above)')
+      end
+    end
+
+    describe '#stderr' do
+      it 'is equal to that line' do
+        expect(subject.stderr).to eq('I can also have stderr and stderr')
+      end
+    end
+
+    describe '#output' do
+      it 'is equal to stdout + stderr' do
+        expect(subject.output).to eq(
+          'I can have a newline\nanywhere, I can also have stderror stdout ' \
+            'and stderr or nothing! (above)')
+      end
+    end
+  end
+
+  pending 'parse CLIXML errors and convert to Strings and/or Exceptions'
+end