winrm 2.1.0 → 2.1.1

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

@@ -1,16 +1,16 @@
-# 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
+# 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 +1,30 @@
-# 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
+# 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 +1,35 @@
-# 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
+# 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 +1,47 @@
-# 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
+# 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 +1,105 @@
-# 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
+# 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