winrm 2.2.3 → 2.3.6

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

@@ -1,40 +0,0 @@
-# encoding: UTF-8
-
-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,25 +0,0 @@
-# encoding: UTF-8
-
-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,16 +0,0 @@
-# encoding: UTF-8
-
-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,30 +0,0 @@
-# encoding: UTF-8
-
-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,35 +0,0 @@
-# encoding: UTF-8
-
-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,47 +0,0 @@
-# encoding: UTF-8
-
-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

data/tests/spec/psrp/message_fragmenter_spec.rb

@@ -1,105 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/message'
-require 'winrm/psrp/message_fragmenter'
-
-describe WinRM::PSRP::MessageFragmenter do
-  let(:message) do
-    WinRM::PSRP::Message.new(
-      'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
-      WinRM::PSRP::Message::MESSAGE_TYPES[:session_capability],
-      data
-    )
-  end
-
-  subject do
-    fragmenter = described_class.new(45)
-    fragments = []
-    fragmenter.fragment(message) do |fragment|
-      fragments.push(fragment)
-    end
-    fragments
-  end
-
-  context 'one fragment' do
-    let(:data) { 'th' }
-
-    it 'returns 1 fragment' do
-      expect(subject.length).to eq(1)
-    end
-
-    it 'has blob data equal to the message bytes' do
-      expect(subject[0].blob.length).to eq(message.bytes.length)
-    end
-
-    it 'identifies the fragment as start and end' do
-      expect(subject[0].start_fragment).to eq(true)
-      expect(subject[0].end_fragment).to eq(true)
-    end
-
-    it 'assigns fragment id correctly' do
-      expect(subject[0].fragment_id).to eq(0)
-    end
-  end
-
-  context 'two fragments' do
-    let(:data) { 'This is a fragmented message' }
-
-    it 'splits the message' do
-      expect(subject.length).to eq(2)
-    end
-
-    it 'has a sum of blob data equal to the message bytes' do
-      expect(subject[0].blob.length + subject[1].blob.length).to eq(message.bytes.length)
-    end
-
-    it 'identifies the first fragment as start and not end' do
-      expect(subject[0].start_fragment).to eq(true)
-      expect(subject[0].end_fragment).to eq(false)
-    end
-
-    it 'identifies the first fragment as start and not end' do
-      expect(subject[1].start_fragment).to eq(false)
-      expect(subject[1].end_fragment).to eq(true)
-    end
-
-    it 'assigns incementing fragment ids' do
-      expect(subject[0].fragment_id).to eq(0)
-      expect(subject[1].fragment_id).to eq(1)
-    end
-  end
-
-  context 'three fragments' do
-    let(:data) { 'This is a fragmented message because framents are lovely' }
-
-    it 'splits the message' do
-      expect(subject.length).to eq(3)
-    end
-
-    it 'has a sum of blob data equal to the message bytes' do
-      expect(subject[0].blob.length + subject[1].blob.length + subject[2].blob.length)
-        .to eq(message.bytes.length)
-    end
-
-    it 'identifies the first fragment as start and not end' do
-      expect(subject[0].start_fragment).to eq(true)
-      expect(subject[0].end_fragment).to eq(false)
-    end
-
-    it 'identifies the first fragment as start and not end' do
-      expect(subject[1].start_fragment).to eq(false)
-      expect(subject[1].end_fragment).to eq(false)
-    end
-
-    it 'identifies the third fragment as not start and end' do
-      expect(subject[2].start_fragment).to eq(false)
-      expect(subject[2].end_fragment).to eq(true)
-    end
-
-    it 'assigns incementing fragment ids' do
-      expect(subject[0].fragment_id).to eq(0)
-      expect(subject[1].fragment_id).to eq(1)
-      expect(subject[2].fragment_id).to eq(2)
-    end
-  end
-end

data/tests/spec/psrp/powershell_output_decoder_spec.rb

@@ -1,100 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/powershell_output_decoder'
-
-describe WinRM::PSRP::PowershellOutputDecoder do
-  let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:error_record] }
-  let(:data) { 'blah' }
-  let(:message) do
-    WinRM::PSRP::Message.new(
-      'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
-      message_type,
-      data,
-      '4218a578-0f18-4b19-82c3-46b433319126'
-    )
-  end
-
-  subject { described_class.new.decode(message) }
-
-  context 'undecodable message type' do
-    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:public_key] }
-
-    it 'ignores message' do
-      expect(subject).to be nil
-    end
-  end
-
-  context 'undecodable method identifier' do
-    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
-    let(: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>WriteProgress</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>some_x000D__x000A_data</S></LST></Obj></MS></Obj>'
-    end
-
-    it 'ignores message' do
-      expect(subject).to be nil
-    end
-  end
-
-  context 'receiving pipeline output' do
-    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
-    let(:data) { '<obj><S>some data</S></obj>' }
-
-    it 'decodes output' do
-      expect(subject).to eq("some data\r\n")
-    end
-  end
-
-  context 'writeline with new line in middle' do
-    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
-    let(: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>some_x000D__x000A_data</S></LST></Obj></MS></Obj>'
-    end
-
-    it 'decodes and replaces newline' do
-      expect(subject).to eq("some\r\ndata\r\n")
-    end
-  end
-
-  context 'receiving error record' do
-    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:error_record] }
-    let(:test_data_error_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(:data) { test_data_error_xml_template.result(binding) }
-
-    it 'decodes error record' do
-      expect(subject).to match(/#{error_message}/)
-    end
-  end
-
-  context 'receiving error record in pipeline state' do
-    let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state] }
-    let(:test_data_error_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' }
-    let(:category_message) { 'category message' }
-    let(:error_id) { 'an error' }
-    let(:data) { test_data_error_xml_template.result(binding) }
-
-    it 'decodes error record' do
-      expect(subject).to match(/#{error_message}/)
-    end
-  end
-end

data/tests/spec/psrp/psrp_message_spec.rb

@@ -1,70 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/message'
-
-describe WinRM::PSRP::Message do
-  context 'all fields provided' do
-    let(:payload) { 'this is my payload' }
-    subject do
-      described_class.new(
-        'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
-        WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output],
-        payload,
-        '4218a578-0f18-4b19-82c3-46b433319126')
-    end
-
-    it 'sets the destination to server LE' do
-      expect(subject.bytes[0..3]).to eq([2, 0, 0, 0])
-    end
-    it 'sets the message type LE' do
-      expect(subject.bytes[4..7]).to eq([4, 16, 4, 0])
-    end
-    it 'sets the runspace pool id' do
-      expect(subject.bytes[8..23]).to eq(
-        [186, 251, 27, 188, 21, 130, 4, 74, 178, 223, 122, 58, 192, 49, 14, 22])
-    end
-    it 'sets the pipeline id' do
-      expect(subject.bytes[24..39]).to eq(
-        [120, 165, 24, 66, 24, 15, 25, 75, 130, 195, 70, 180, 51, 49, 145, 38])
-    end
-    it 'prefixes the blob with BOM' do
-      expect(subject.bytes[40..42]).to eq([239, 187, 191])
-    end
-    it 'contains at least the first 8 bytes of the XML payload' do
-      expect(subject.bytes[43..-1]).to eq(payload.bytes)
-    end
-    it 'parses the data' do
-      expect(subject.parsed_data).to be_a(WinRM::PSRP::MessageData::PipelineOutput)
-    end
-  end
-
-  context 'create' do
-    it 'raises error when message type is not valid' do
-      expect do
-        WinRM::PSRP::Message.new(
-          'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
-          0x00000000,
-          %(<Obj RefId="0"/>),
-          '4218a578-0f18-4b19-82c3-46b433319126')
-      end.to raise_error(RuntimeError)
-    end
-  end
-
-  context 'no command id' do
-    subject(:msg) do
-      payload = <<-HERE.unindent
-        <Obj RefId="0"><MS><Version N="protocolversion">2.3</Version>
-        <Version N="PSVersion">2.0</Version><Version N="SerializationVersion">1.1.0.1</Version></MS>
-        </Obj>
-      HERE
-      WinRM::PSRP::Message.new(
-        'bc1bfbba-8215-4a04-b2df-7a3ac0310e16',
-        WinRM::PSRP::Message::MESSAGE_TYPES[:session_capability],
-        payload)
-    end
-
-    it 'sets the pipeline id to empty' do
-      expect(msg.bytes[24..39]).to eq([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-    end
-  end
-end

data/tests/spec/psrp/recieve_response_reader_spec.rb

@@ -1,172 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/receive_response_reader'
-
-describe WinRM::PSRP::ReceiveResponseReader do
-  let(:shell_id) { 'F4A2622B-B842-4EB8-8A78-0225C8A993DF' }
-  let(:command_id) { 'A2A2622B-B842-4EB8-8A78-0225C8A993DF' }
-  let(:output_message) { double('output_message', build: 'output_message') }
-  let(:test_data_xml_template) do
-    ERB.new(stubbed_response('get_powershell_output_response.xml.erb'))
-  end
-  let(:test_data_xml_template_not_done) do
-    ERB.new(stubbed_response('get_powershell_output_response_not_done.xml.erb'))
-  end
-  let(:test_data_text) { 'some data' }
-  let(:test_data) { "<obj><S>#{test_data_text}</S></obj>" }
-  let(:message) do
-    WinRM::PSRP::Message.new(
-      shell_id,
-      message_type,
-      test_data,
-      command_id
-    )
-  end
-  let(:fragment) { WinRM::PSRP::Fragment.new(1, message.bytes) }
-  let(:test_data_stdout) { Base64.strict_encode64(fragment.bytes.pack('C*')) }
-  let(:transport) { {} }
-
-  before do
-    allow(transport).to receive(:send_request).and_return(
-      REXML::Document.new(test_data_xml_template.result(binding))
-    )
-  end
-
-  subject do
-    described_class.new(
-      transport,
-      Logging.logger['test']
-    )
-  end
-
-  describe '#read_output' do
-    context 'response doc stdout with pipeline output' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
-
-      it 'outputs to stdout' do
-        expect(
-          subject.read_output(output_message).stdout
-        ).to eq("#{test_data_text}\r\n")
-      end
-    end
-
-    context 'response doc stdout error record' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:error_record] }
-      let(:test_data_error_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(:test_data) { test_data_error_xml_template.result(binding) }
-
-      it 'outputs to stderr' do
-        expect(
-          subject.read_output(output_message).stderr
-        ).to match(/#{error_message}/)
-      end
-    end
-
-    context 'response doc failed pipeline state' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_state] }
-      let(:test_data_error_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' }
-      let(:category_message) { 'category message' }
-      let(:error_id) { 'Microsoft.PowerShell.Commands.WriteErrorException' }
-      let(:test_data) { test_data_error_xml_template.result(binding) }
-
-      it 'outputs to stderr' do
-        expect(
-          subject.read_output(output_message).stderr
-        ).to match(/#{error_message}/)
-      end
-    end
-
-    context 'response doc writing error to host' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
-      let(:test_data) do
-        "<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>WriteErrorLine</ToString>' \
-        "<I32>18</I32></Obj><Obj N='mp' RefId='2'><TN RefId='1'>" \
-        '<T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST><S>errors</S></LST>' \
-        '</Obj></MS></Obj>'
-      end
-
-      it 'outputs to stderr' do
-        expect(
-          subject.read_output(output_message).stderr
-        ).to eq("errors\r\n")
-      end
-    end
-
-    context 'response doc writing output to host' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_host_call] }
-      let(:test_data) do
-        "<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>WriteLine</ToString>' \
-        "<I32>18</I32></Obj><Obj N='mp' RefId='2'><TN RefId='1'>" \
-        '<T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST><S>output</S></LST>' \
-        '</Obj></MS></Obj>'
-      end
-
-      it 'outputs to stdout' do
-        expect(
-          subject.read_output(output_message).stdout
-        ).to eq("output\r\n")
-      end
-    end
-  end
-
-  describe '#read_message' do
-    context 'do not wait for done state' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
-
-      it 'outputs the message in an array' do
-        expect(subject.read_message(output_message).length).to eq(1)
-        expect(subject.read_message(output_message)[0].data).to end_with(message.data)
-      end
-    end
-
-    context 'read in a block' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
-
-      it 'outputs the message in an array' do
-        subject.read_message(output_message) do |msg|
-          expect(msg.data).to end_with(message.data)
-        end
-      end
-    end
-
-    context 'wait for done state' do
-      let(:message_type) { WinRM::PSRP::Message::MESSAGE_TYPES[:pipeline_output] }
-      let(:test_data_xml_not_done) { test_data_xml_template_not_done.result(binding) }
-      let(:test_data_xml_done) { test_data_xml_template.result(binding) }
-
-      before do
-        allow(transport).to receive(:send_request).and_return(
-          REXML::Document.new(test_data_xml_not_done),
-          REXML::Document.new(test_data_xml_done)
-        )
-      end
-
-      it 'outputs two messages' do
-        expect(subject.read_message(output_message, true).length).to eq(2)
-      end
-
-      it 'outputs the first message' do
-        expect(subject.read_message(output_message, true)[0].data).to end_with(message.data)
-      end
-
-      it 'outputs the second message' do
-        expect(subject.read_message(output_message, true)[1].data).to end_with(message.data)
-      end
-    end
-  end
-end

data/tests/spec/psrp/uuid_spec.rb

@@ -1,28 +0,0 @@
-# encoding: UTF-8
-describe WinRM::PSRP::UUID do
-  subject(:uuid_helper) do
-    Object.new.extend(WinRM::PSRP::UUID)
-  end
-  context 'uuid is nil' do
-    uuid = nil
-    it 'should return an empty byte array' do
-      bytes = uuid_helper.uuid_to_windows_guid_bytes(uuid)
-      expect(bytes).to eq([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-    end
-  end
-  context 'uuid 08785e96-eb1b-4a74-a767-7b56e8f13ea9 with lower case letters' do
-    uuid = '08785e96-eb1b-4a74-a767-7b56e8f13ea9'
-    it 'should return a Windows GUID struct compatible little endian byte array' do
-      bytes = uuid_helper.uuid_to_windows_guid_bytes(uuid)
-      expect(bytes).to eq([150, 94, 120, 8, 27, 235, 116, 74, 167, 103, 123, 86, 232, 241, 62, 169])
-    end
-  end
-  context 'uuid 045F9E19D-8B77-4394-AB0C-197497661668 with upper case letters' do
-    uuid = '45F9E19D-8B77-4394-AB0C-197497661668'
-    it 'should return a Windows GUID struct compatible little endian byte array' do
-      bytes = uuid_helper.uuid_to_windows_guid_bytes(uuid)
-      expect(bytes).to eq(
-        [157, 225, 249, 69, 119, 139, 148, 67, 171, 12, 25, 116, 151, 102, 22, 104])
-    end
-  end
-end