winrm 1.8.1 → 2.0.0

data/tests/spec/http/transport_spec.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+require 'rubyntlm'
+require 'winrm/http/transport'
+
+describe WinRM::HTTP::HttpNegotiate 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

data/{spec → tests/spec}/output_spec.rb

@@ -1,110 +1,127 @@
-# 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 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 << { stdout: 'foo' }
+        expect(subject.stdout).to eq('foo')
+      end
+    end
+
+    describe '#stderr' do
+      it 'is equal to that line' do
+        subject << { stderr: 'foo' }
+        expect(subject.stderr).to eq('foo')
+      end
+    end
+
+    describe '#output' do
+      it 'is equal to stdout' do
+        subject << { stdout: 'foo' }
+        expect(subject.output).to eq('foo')
+      end
+
+      it 'is equal to stderr' do
+        subject << { 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 << { stdout: 'foo' }
+      subject << { 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 << { stdout: 'I can have a newline\nanywhere, ' }
+      subject << { stderr: 'I can also have stderr' }
+      subject << { stdout: 'or stdout', stderr: ' and stderr' }
+      subject << {}
+      subject << { 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
+
+  describe '#exitcode' do
+    let(:exitcode) { 0 }
+
+    context 'when a valid exit code is set' do
+      it 'sets the exit code' do
+        subject.exitcode = exitcode
+        expect(subject.exitcode).to eq exitcode
+      end
+    end
+
+    context 'when an invalid exit code is set' do
+      let(:exitcode) { 'bad' }
+
+      it 'sets the exit code' do
+        expect { subject.exitcode = exitcode }.to raise_error WinRM::InvalidExitCode
+      end
+    end
+  end
+end

data/tests/spec/psrp/fragment_spec.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+require 'winrm/psrp/fragment'
+
+describe WinRM::PSRP::Fragment do
+  let(:id) { 1 }
+  let(:message) { 'blah blah blah' }
+
+  context 'called with just id and blob' do
+    subject { described_class.new(id, message.bytes) }
+
+    it 'sets the message id to 1' do
+      expect(subject.bytes[0..7]).to eq([0, 0, 0, 0, 0, 0, 0, id])
+    end
+    it 'sets the fragment id to 0' do
+      expect(subject.bytes[8..15]).to eq([0, 0, 0, 0, 0, 0, 0, 0])
+    end
+    it 'sets the last 2 bits of the end/start fragment' do
+      expect(subject.bytes[16]).to eq(3)
+    end
+    it 'sets message blob length to 3640' do
+      expect(subject.bytes[17..20]).to eq([0, 0, 0, message.bytes.length])
+    end
+    it 'sets message blob' do
+      expect(subject.bytes[21..-1]).to eq(message.bytes)
+    end
+  end
+
+  context 'specifying a fragment id' do
+    let(:fragment_id) { 1 }
+
+    subject { described_class.new(id, message.bytes, fragment_id) }
+
+    it 'sets the fragment id' do
+      expect(subject.bytes[8..15]).to eq([0, 0, 0, 0, 0, 0, 0, fragment_id])
+    end
+  end
+
+  context 'middle fragment' do
+    subject { described_class.new(id, message.bytes, 1, false, false) }
+
+    it 'sets the last 2 bits of the end/start fragment to 0' do
+      expect(subject.bytes[16]).to eq(0)
+    end
+  end
+
+  context 'end fragment' do
+    subject { described_class.new(id, message.bytes, 1, true, false) }
+
+    it 'sets the end fragment bit' do
+      expect(subject.bytes[16]).to eq(1)
+    end
+  end
+
+  context 'start fragment' do
+    subject { described_class.new(id, message.bytes, 1, false, true) }
+
+    it 'sets the start fragment bit' do
+      expect(subject.bytes[16]).to eq(2)
+    end
+  end
+end

data/tests/spec/psrp/message_data/base_spec.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require 'winrm/psrp/message_data/base'
+
+describe WinRM::PSRP::MessageData::Base do
+  let(:raw_data) { 'raw_data' }
+
+  subject { WinRM::PSRP::MessageData::Base.new(raw_data) }
+
+  it 'holds raw message data' do
+    expect(subject.raw).to eq(raw_data)
+  end
+end

data/tests/spec/psrp/message_data/error_record_spec.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+require 'winrm/psrp/message_data/base'
+require 'winrm/psrp/message_data/error_record'
+
+describe WinRM::PSRP::MessageData::ErrorRecord do
+  let(:test_data_xml_template) do
+    ERB.new(stubbed_clixml('error_record.xml.erb'))
+  end
+  let(:error_message) { 'an error' }
+  let(:script_root) { 'script_root' }
+  let(:category_message) { 'category message' }
+  let(:stack_trace) { 'stack trace' }
+  let(:error_id) { 'Microsoft.PowerShell.Commands.WriteErrorException' }
+  let(:raw_data) { test_data_xml_template.result(binding) }
+  subject { described_class.new(raw_data) }
+
+  it 'returns the exception' do
+    expect(subject.exception[:message]).to eq(error_message)
+  end
+
+  it 'returns the FullyQualifiedErrorId' do
+    expect(subject.fully_qualified_error_id).to eq(error_id)
+  end
+
+  it 'returns the invocation info' do
+    expect(subject.invocation_info[:line]).to eq("write-error '#{error_message}'")
+  end
+
+  it 'converts camel case properties to underscore' do
+    expect(subject.invocation_info[:ps_script_root]).to eq(script_root)
+  end
+
+  it 'returns the error category message' do
+    expect(subject.error_category_message).to eq(category_message)
+  end
+
+  it 'returns the script stack trace' do
+    expect(subject.error_details_script_stack_trace).to eq(stack_trace)
+  end
+end

data/tests/spec/psrp/message_data/pipeline_host_call_spec.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+require 'winrm/psrp/message_data/base'
+require 'winrm/psrp/message_data/pipeline_host_call'
+
+describe WinRM::PSRP::MessageData::PipelineHostCall do
+  let(:raw_data) do
+    "\xEF\xBB\xBF<Obj RefId=\"0\"><MS><I64 N=\"ci\">-100</I64><Obj N=\"mi\" RefId=\"1\">"\
+    '<TN RefId="0"><T>System.Management.Automation.Remoting.RemoteHostMethodId</T>'\
+    '<T>System.Enum</T><T>System.ValueType</T><T>System.Object</T></TN>'\
+    '<ToString>WriteLine3</ToString><I32>17</I32></Obj><Obj N="mp" RefId="2">'\
+    '<TN RefId="1"><T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST>'\
+    '<I32>7</I32><I32>0</I32><S>hello</S></LST></Obj></MS></Obj>'
+  end
+
+  subject { described_class.new(raw_data) }
+
+  it 'parses method identifier' do
+    expect(subject.method_identifier).to eq('WriteLine3')
+  end
+
+  it 'parses method parameters' do
+    expect(subject.method_parameters[:s]).to eq('hello')
+  end
+end

data/tests/spec/psrp/message_data/pipeline_output_spec.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require 'winrm/psrp/message_data/base'
+require 'winrm/psrp/message_data/pipeline_output'
+
+describe WinRM::PSRP::MessageData::PipelineOutput do
+  subject { described_class.new(raw_data) }
+
+  context 'receiving output with BOM and no new line' do
+    let(:raw_data) { "\xEF\xBB\xBF<obj><S>some data</S></obj>" }
+
+    it 'output removes BOM and adds newline' do
+      expect(subject.output).to eq("some data\r\n")
+    end
+  end
+
+  context 'receiving output with encoded new line' do
+    let(:raw_data) { '<obj><S>some data_x000D__x000A_</S></obj>' }
+
+    it 'decodes without double newline' do
+      expect(subject.output).to eq("some data\r\n")
+    end
+  end
+
+  context 'receiving output with new line in middle' do
+    let(:raw_data) { '<obj><S>some_x000D__x000A_data</S></obj>' }
+
+    it 'decodes and replaces newline' do
+      expect(subject.output).to eq("some\r\ndata\r\n")
+    end
+  end
+end