winrm 2.3.0 → 2.3.5

data/tests/spec/output_spec.rb

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/pipeline_state'
-
-describe WinRM::PSRP::MessageData::PipelineState do
-  let(:test_data_xml_template) do
-    ERB.new(stubbed_clixml('pipeline_state.xml.erb'))
-  end
-  let(:pipeline_state) { WinRM::PSRP::MessageData::PipelineState::FAILED }
-  let(:error_message) { 'an error occured' }
-  let(:category_message) { 'category message' }
-  let(:error_id) { 'an error occured' }
-  let(:raw_data) { test_data_xml_template.result(binding) }
-  subject { described_class.new(raw_data) }
-
-  it 'returns the state' do
-    expect(subject.pipeline_state).to eq(pipeline_state)
-  end
-
-  it 'returns the exception' do
-    expect(subject.exception_as_error_record.exception[:message]).to eq(error_message)
-  end
-
-  it 'returns the FullyQualifiedErrorId' do
-    expect(subject.exception_as_error_record.fully_qualified_error_id).to eq(error_id)
-  end
-
-  it 'returns the error category message' do
-    expect(subject.exception_as_error_record.error_category_message).to eq(category_message)
-  end
-
-  context 'state is not failed' do
-    let(:pipeline_state) { WinRM::PSRP::MessageData::PipelineState::COMPLETED }
-
-    it 'has a nil exception' do
-      expect(subject.exception_as_error_record).to be(nil)
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/runspacepool_host_call'
-
-describe WinRM::PSRP::MessageData::RunspacepoolHostCall 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/runspacepool_state_spec.rb

@@ -1,14 +0,0 @@
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/runspacepool_state'
-
-describe WinRM::PSRP::MessageData::RunspacepoolState do
-  let(:raw_data) do
-    "\xEF\xBB\xBF<Obj RefId=\"0\"><MS><I32 N=\"RunspaceState\">2</I32></MS></Obj>"
-  end
-
-  subject { described_class.new(raw_data) }
-
-  it 'parses runspace state' do
-    expect(subject.runspace_state).to eq(WinRM::PSRP::MessageData::RunspacepoolState::OPENED)
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/session_capability'
-
-describe WinRM::PSRP::MessageData::SessionCapability do
-  let(:protocol_version) { '2.2' }
-  let(:ps_version) { '2.0' }
-  let(:serialization_version) { '1.1.0.1' }
-  let(:raw_data) do
-    "\xEF\xBB\xBF<Obj RefId=\"0\"><MS>"\
-      "<Version N=\"protocolversion\">#{protocol_version}</Version>"\
-      "<Version N=\"PSVersion\">#{ps_version}</Version>"\
-      "<Version N=\"SerializationVersion\">#{serialization_version}</Version></MS></Obj>"
-  end
-
-  subject { described_class.new(raw_data) }
-
-  it 'parses protocol version' do
-    expect(subject.protocol_version).to eq(protocol_version)
-  end
-
-  it 'parses ps version' do
-    expect(subject.ps_version).to eq(ps_version)
-  end
-
-  it 'parses serialization version' do
-    expect(subject.serialization_version).to eq(serialization_version)
-  end
-end

data/tests/spec/psrp/message_data_spec.rb

@@ -1,33 +0,0 @@
-require 'winrm/psrp/message'
-require 'winrm/psrp/message_data'
-
-describe WinRM::PSRP::MessageData do
-  describe '#parse' do
-    let(:raw_data) { 'raw_data' }
-    let(:message) do
-      WinRM::PSRP::Message.new(
-        '00000000-0000-0000-0000-000000000000',
-        message_type,
-        raw_data
-      )
-    end
-
-    subject { WinRM::PSRP::MessageData.parse(message) }
-
-    context 'defined message type' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
-
-      it 'creates correct message data type' do
-        expect(subject).to be_a(WinRM::PSRP::MessageData::PipelineOutput)
-      end
-    end
-
-    context 'undefined message type' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_input] }
-
-      it 'returns nill' do
-        expect(subject).to be nil
-      end
-    end
-  end
-end

data/tests/spec/psrp/message_defragmenter_spec.rb

@@ -1,45 +0,0 @@
-require 'winrm/psrp/message_defragmenter'
-
-describe WinRM::PSRP::MessageDefragmenter do
-  context 'a real life fragment' do
-    let(:bytes) do
-      "\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x01\x03\x00\x00\x00I\x01"\
-      "\x00\x00\x00\x04\x10\x04\x00Kk/=Z\xD3-E\x81v\xA0+6\xB1\xD3\x88\n\xED\x90\x9Cj\xE7PG"\
-      "\x9F\xA2\xB2\xC99to9\xEF\xBB\xBF<S>some data_x000D__x000A_</S>".to_byte_string
-    end
-    subject { described_class.new.defragment(Base64.encode64(bytes)) }
-
-    it 'parses the data' do
-      expect(subject.data).to eq("\xEF\xBB\xBF<S>some data_x000D__x000A_</S>".to_byte_string)
-    end
-
-    it 'parses the destination' do
-      expect(subject.destination).to eq(1)
-    end
-
-    it 'parses the message type' do
-      expect(subject.type).to eq(WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output])
-    end
-  end
-
-  context 'multiple fragments' do
-    let(:blob) do
-      WinRM::PSRP::Message.new(
-        'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
-        WinRM::PSRP::Message::MESSAGE_TYPES[:session_capability],
-        'This is a fragmented message'
-      )
-    end
-    let(:fragment1) { WinRM::PSRP::Fragment.new(1, blob.bytes[0..5], 0, true, false) }
-    let(:fragment2) { WinRM::PSRP::Fragment.new(1, blob.bytes[6..10], 1, false, false) }
-    let(:fragment3) { WinRM::PSRP::Fragment.new(1, blob.bytes[11..-1], 2, false, true) }
-
-    it 'pieces the message together' do
-      subject.defragment(Base64.strict_encode64(fragment1.bytes.pack('C*')))
-      subject.defragment(Base64.strict_encode64(fragment2.bytes.pack('C*')))
-      message = subject.defragment(Base64.strict_encode64(fragment3.bytes.pack('C*')))
-
-      expect(message.data[3..-1]).to eq(blob.data)
-    end
-  end
-end