python-pickle 0.1.0

data/spec/protocol1_read_instruction_examples.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+shared_examples_for "Protocol1#read_instruction examples" do
+  context "when the opcode is 41" do
+    let(:io) { StringIO.new(41.chr) }
+
+    it "must return Python::Pickle::Instructions::EMPTY_TUPLE" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::EMPTY_TUPLE
+      )
+    end
+  end
+
+  context "when the opcode is 71" do
+    let(:float)  { 1234.5678 }
+    let(:packed) { [float].pack('G') }
+
+    let(:io) { StringIO.new("#{71.chr}#{packed}\n") }
+
+    it "must return a Python::Pickle::Instructions::BinFloat object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinFloat.new(float)
+      )
+    end
+  end
+
+  context "when the opcode is 75" do
+    let(:int) { 0xff }
+    let(:io)  { StringIO.new("#{75.chr}#{int.chr}") }
+
+    it "must return a Python::Pickle::Instructions::BinInt1 object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinInt1.new(int)
+      )
+    end
+  end
+
+  context "when the opcode is 84" do
+    let(:string) { "hello\0world".b }
+    let(:length) { string.bytesize  }
+    let(:packed) { [length, string].pack('L<a*') }
+    let(:io)     { StringIO.new("#{84.chr}#{packed}") }
+
+    it "must return a Python::Pickle::Instructions::BinString object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinString.new(length,string)
+      )
+    end
+  end
+
+  context "when the opcode is 85" do
+    let(:string) { "hello\0world".b }
+    let(:length) { string.bytesize  }
+    let(:packed) { [length, string].pack('Ca*') }
+    let(:io)     { StringIO.new("#{85.chr}#{packed}") }
+
+    it "must return a Python::Pickle::Instructions::ShortBinString object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::ShortBinString.new(length,string)
+      )
+    end
+  end
+
+  context "when the opcode is 88" do
+    let(:string) { "hello world \u1234" }
+    let(:length) { string.bytesize  }
+    let(:packed) { [length, string].pack('L<a*') }
+    let(:io)     { StringIO.new("#{88.chr}#{packed}") }
+
+    it "must return a Python::Pickle::Instructions::BinUnicode object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinUnicode.new(length,string)
+      )
+    end
+
+    it "must set the encoding of the String to Encoding::UTF_8" do
+      expect(subject.read_instruction.value.encoding).to eq(
+        Encoding::UTF_8
+      )
+    end
+  end
+
+  context "when the opcode is 93" do
+    let(:io) { StringIO.new(93.chr) }
+
+    it "must return Python::Pickle::Instructions::EMPTY_LIST" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::EMPTY_LIST
+      )
+    end
+  end
+
+  context "when the opcode is 101" do
+    let(:io) { StringIO.new(101.chr) }
+
+    it "must return Python::Pickle::Instructions::APPENDS" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::APPENDS
+      )
+    end
+  end
+
+  context "when the opcode is 104" do
+    let(:index) { 2 }
+    let(:io)    { StringIO.new("#{104.chr}#{index.chr}".b) }
+
+    it "must return a Python::Pickle::Instructions::BinGet object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinGet.new(index)
+      )
+    end
+  end
+
+  context "when the opcode is 106" do
+    let(:index)  { 2 }
+    let(:packed) { [index].pack('L<') }
+    let(:io)     { StringIO.new("#{106.chr}#{packed}".b) }
+
+    it "must return a Python::Pickle::Instructions::LongBinGet object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::LongBinGet.new(index)
+      )
+    end
+  end
+
+  context "when the opcode is 113" do
+    let(:index) { 2 }
+    let(:io)    { StringIO.new("#{113.chr}#{index.chr}") }
+
+    it "must return a Python::Pickle::Instructions::BinPut object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinPut.new(index)
+      )
+    end
+  end
+
+  context "when the opcode is 117" do
+    let(:io) { StringIO.new(117.chr) }
+
+    it "must return Python::Pickle::Instructions::SETITEMS" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::SETITEMS
+      )
+    end
+  end
+
+  context "when the opcode is 125" do
+    let(:io) { StringIO.new(125.chr) }
+
+    it "must return Python::Pickle::Instructions::EMPTY_DICT" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::EMPTY_DICT
+      )
+    end
+  end
+end

data/spec/protocol1_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'python/pickle/protocol1'
+
+require 'protocol0_read_instruction_examples'
+require 'protocol1_read_instruction_examples'
+
+describe Python::Pickle::Protocol1 do
+  let(:pickle) { '' }
+  let(:io) { StringIO.new(pickle) }
+
+  subject { described_class.new(io) }
+
+  describe "#read_float64_be" do
+    let(:float)  { 1234.5678 }
+    let(:packed) { [float].pack('G') }
+
+    let(:io) { StringIO.new(packed) }
+
+    it "must read eight bytes and decode a big-endian floating point number" do
+      expect(subject.read_float64_be).to eq(float)
+    end
+  end
+
+  describe "#read_uint8" do
+    let(:io) { StringIO.new("\xff".b) }
+
+    it "must read a single unsignd byte" do
+      expect(subject.read_uint8).to eq(0xff)
+    end
+  end
+
+  describe "#read_uint32_le" do
+    let(:uint32) { 0xffeeddcc }
+    let(:packed) { [uint32].pack('L<') }
+    let(:io)     { StringIO.new(packed) }
+
+    it "must read four bytes and return an unpacked uint32 in little-endian byte-order" do
+      expect(subject.read_uint32_le).to eq(uint32)
+    end
+  end
+
+  let(:fixtures_dir) { File.join(__dir__,'fixtures') }
+
+  describe "#read_instruction" do
+    include_context "Protocol0#read_instruction examples"
+    include_context "Protocol1#read_instruction examples"
+
+    context "when the opcode is not recognized" do
+      let(:opcode) { 255 }
+      let(:io)     { StringIO.new(opcode.chr) }
+
+      it do
+        expect {
+          subject.read_instruction
+        }.to raise_error(Python::Pickle::InvalidFormat,"invalid opcode (#{opcode.inspect}) for protocol 1")
+      end
+    end
+  end
+end

data/spec/protocol2_read_instruction_examples.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+shared_examples_for "Protocol2#read_instruction examples" do
+  context "when the opcode is 128" do
+    let(:version) { 0x02 }
+    let(:io)  { StringIO.new("#{128.chr}#{version.chr}") }
+
+    it "must return a Python::Pickle::Instructions::Proto object" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Proto.new(version)
+      )
+    end
+  end
+
+  context "when the opcode is 129" do
+    let(:io) { StringIO.new(129.chr) }
+
+    it "must return Python::Pickle::Instructions::NEWOBJ" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::NEWOBJ
+      )
+    end
+  end
+
+  context "when the opcode is 130" do
+    let(:code) { 0xfe }
+    let(:io)   { StringIO.new("#{130.chr}#{code.chr}") }
+
+    it "must return Python::Pickle::Instructions::Ext1" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Ext1.new(code)
+      )
+    end
+  end
+
+  context "when the opcode is 131" do
+    let(:code)   { 0xfffe }
+    let(:packed) { [code].pack('S<') }
+    let(:io)     { StringIO.new("#{131.chr}#{packed}") }
+
+    it "must return Python::Pickle::Instructions::Ext2" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Ext2.new(code)
+      )
+    end
+  end
+
+  context "when the opcode is 132" do
+    let(:code)   { 0xfffffffe }
+    let(:packed) { [code].pack('L<') }
+    let(:io)     { StringIO.new("#{132.chr}#{packed}") }
+
+    it "must return Python::Pickle::Instructions::Ext4" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Ext4.new(code)
+      )
+    end
+  end
+
+  context "when the opcode is 133" do
+    let(:io) { StringIO.new(133.chr) }
+
+    it "must return Python::Pickle::Instructions::TUPLE1" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::TUPLE1
+      )
+    end
+  end
+
+  context "when the opcode is 134" do
+    let(:io) { StringIO.new(134.chr) }
+
+    it "must return Python::Pickle::Instructions::TUPLE2" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::TUPLE2
+      )
+    end
+  end
+
+  context "when the opcode is 135" do
+    let(:io) { StringIO.new(135.chr) }
+
+    it "must return Python::Pickle::Instructions::TUPLE3" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::TUPLE3
+      )
+    end
+  end
+
+  context "when the opcode is 136" do
+    let(:io) { StringIO.new(136.chr) }
+
+    it "must return Python::Pickle::Instructions::NEWTRUE" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::NEWTRUE
+      )
+    end
+  end
+
+  context "when the opcode is 137" do
+    let(:io) { StringIO.new(137.chr) }
+
+    it "must return Python::Pickle::Instructions::NEWFALSE" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::NEWFALSE
+      )
+    end
+  end
+
+  describe "when the opcode is 138" do
+    let(:length) { 2 }
+    let(:uint)   { 0x1234 }
+    let(:packed) { [length, uint].pack('CS<') }
+    let(:io)     { StringIO.new("#{138.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::Long1" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Long1.new(length,uint)
+      )
+    end
+  end
+
+  describe "when the opcode is 139" do
+    let(:length) { 4 }
+    let(:uint)   { 0x12345678 }
+    let(:packed) { [length, uint].pack('L<L<') }
+    let(:io)     { StringIO.new("#{139.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::Long4" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Long4.new(length,uint)
+      )
+    end
+  end
+end

data/spec/protocol2_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'python/pickle/protocol2'
+
+require 'protocol0_read_instruction_examples'
+require 'protocol1_read_instruction_examples'
+require 'protocol2_read_instruction_examples'
+
+describe Python::Pickle::Protocol2 do
+  let(:pickle) { '' }
+  let(:io) { StringIO.new(pickle) }
+
+  subject { described_class.new(io) }
+
+  describe "#read_uint16_le" do
+    let(:uint16) { 0xfffe }
+    let(:packed) { [uint16].pack('S<') }
+    let(:io)     { StringIO.new(packed) }
+
+    it "must read two bytes and return an unpacked unsigned 16bit integer" do
+      expect(subject.read_uint16_le).to eq(uint16)
+    end
+  end
+
+  describe "#unpack_int_le" do
+    context "when given an empty String" do
+      it "must return 0" do
+        expect(subject.unpack_int_le("".b)).to eq(0)
+      end
+    end
+
+    context "when given a single byte String" do
+      it "must return the first byte" do
+        expect(subject.unpack_int_le("\x01".b)).to eq(0x01)
+      end
+
+      context "but the most significant bits are set" do
+        it "must return a negative integer" do
+          expect(subject.unpack_int_le("\xff".b)).to eq(-1)
+        end
+      end
+    end
+
+    context "when given a two byte string" do
+      it "must decode the string and return an integer" do
+        expect(subject.unpack_int_le("\x00\x01".b)).to eq(0x100)
+      end
+
+      context "but the most significant bits are set" do
+        it "must return a negative integer" do
+          expect(subject.unpack_int_le("\x00\xff".b)).to eq(-256)
+        end
+      end
+    end
+
+    context "when given a three byte string" do
+      it "must decode the string and return an integer" do
+        expect(subject.unpack_int_le("\x00\x00\xff".b)).to eq(-65536)
+      end
+    end
+  end
+
+  describe "#read_int_le" do
+    context "when called with 0" do
+      let(:io) { StringIO.new("".b) }
+
+      it "must read zero bytes return 0" do
+        expect(subject.read_int_le(0)).to eq(0)
+      end
+    end
+
+    context "when called with 1" do
+      let(:io) { StringIO.new("\x01".b) }
+
+      it "must read one byte return the first byte" do
+        expect(subject.read_int_le(1)).to eq(0x01)
+      end
+
+      context "but the most significant bits are set" do
+        let(:io) { StringIO.new("\xff".b) }
+
+        it "must read one byte return a negative integer" do
+          expect(subject.read_int_le(1)).to eq(-1)
+        end
+      end
+    end
+
+    context "when called with 2" do
+      let(:io) { StringIO.new("\x00\x01".b) }
+
+      it "must read two bytes and decode the string and return an integer" do
+        expect(subject.read_int_le(2)).to eq(0x100)
+      end
+
+      context "but the most significant bits are set" do
+        let(:io) { StringIO.new("\x00\xff".b) }
+
+        it "must read two bytes and return a negative integer" do
+          expect(subject.read_int_le(2)).to eq(-256)
+        end
+      end
+    end
+
+    context "when called with 3" do
+      let(:io) { StringIO.new("\x00\x00\xff".b) }
+
+      it "must read three bytes and decode the string and return an integer" do
+        expect(subject.read_int_le(3)).to eq(-65536)
+      end
+    end
+  end
+
+  describe "#read_instruction" do
+    include_context "Protocol0#read_instruction examples"
+    include_context "Protocol1#read_instruction examples"
+    include_context "Protocol2#read_instruction examples"
+
+    context "when the opcode is not recognized" do
+      let(:opcode) { 255 }
+      let(:io)     { StringIO.new(opcode.chr) }
+
+      it do
+        expect {
+          subject.read_instruction
+        }.to raise_error(Python::Pickle::InvalidFormat,"invalid opcode (#{opcode.inspect}) for protocol 2")
+      end
+    end
+  end
+end

data/spec/protocol3_read_instruction_examples.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+shared_examples_for "Protocol3#read_instruction examples" do
+  describe "when the opcode is 66" do
+    let(:length) { 12 }
+    let(:bytes)  { "hello world\0".b }
+    let(:packed) { [length, bytes].pack('L<a*') }
+    let(:io)     { StringIO.new("#{66.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::BinBytes" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinBytes.new(length,bytes)
+      )
+    end
+  end
+
+  describe "when the opcode is 67" do
+    let(:length) { 12 }
+    let(:bytes)  { "hello world\0".b }
+    let(:packed) { [length, bytes].pack('Ca*') }
+    let(:io)     { StringIO.new("#{67.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::ShortBinBytes" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::ShortBinBytes.new(length,bytes)
+      )
+    end
+  end
+end

data/spec/protocol3_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'python/pickle/protocol3'
+
+require 'protocol0_read_instruction_examples'
+require 'protocol1_read_instruction_examples'
+require 'protocol2_read_instruction_examples'
+require 'protocol3_read_instruction_examples'
+
+describe Python::Pickle::Protocol3 do
+  let(:pickle) { '' }
+  let(:io) { StringIO.new(pickle) }
+
+  subject { described_class.new(io) }
+
+  describe "#read_instruction" do
+    include_context "Protocol0#read_instruction examples"
+    include_context "Protocol1#read_instruction examples"
+    include_context "Protocol2#read_instruction examples"
+    include_context "Protocol3#read_instruction examples"
+
+    context "when the opcode is not recognized" do
+      let(:opcode) { 255 }
+      let(:io)     { StringIO.new(opcode.chr) }
+
+      it do
+        expect {
+          subject.read_instruction
+        }.to raise_error(Python::Pickle::InvalidFormat,"invalid opcode (#{opcode.inspect}) for protocol 3")
+      end
+    end
+  end
+end

data/spec/protocol4_read_instruction_examples.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+shared_examples_for "Protocol4#read_instruction examples" do
+  describe "when the opcode is 140" do
+    let(:string) { "hello world\u1234" }
+    let(:length) { string.bytesize }
+    let(:packed) { [length, *string.codepoints].pack('CU*') }
+    let(:io)     { StringIO.new("#{140.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::ShortBinUnicode" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::ShortBinUnicode.new(length,string)
+      )
+    end
+  end
+
+  describe "when the opcode is 141" do
+    let(:string) { "hello world\u1234" }
+    let(:length) { string.bytesize }
+    let(:packed) { [length, *string.codepoints].pack('Q<U*') }
+    let(:io)     { StringIO.new("#{141.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::BinUnicode8" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinUnicode8.new(length,string)
+      )
+    end
+  end
+
+  describe "when the opcode is 142" do
+    let(:length) { 12 }
+    let(:bytes)  { "hello world\0".b }
+    let(:packed) { [length, bytes].pack('Q<a*') }
+    let(:io)     { StringIO.new("#{142.chr}#{packed}".b) }
+
+    it "must return Python::Pickle::Instructions::BinBytes8" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::BinBytes8.new(length,bytes)
+      )
+    end
+  end
+
+  describe "when the opcode is 143" do
+    let(:io) { StringIO.new(143.chr) }
+
+    it "must return Python::Pickle::Instructions::EMPTY_SET" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::EMPTY_SET
+      )
+    end
+  end
+
+  describe "when the opcode is 144" do
+    let(:io) { StringIO.new(144.chr) }
+
+    it "must return Python::Pickle::Instructions::ADDITEMS" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::ADDITEMS
+      )
+    end
+  end
+
+  describe "when the opcode is 145" do
+    let(:io) { StringIO.new(145.chr) }
+
+    it "must return Python::Pickle::Instructions::FROZENSET" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::FROZENSET
+      )
+    end
+  end
+
+  describe "when the opcode is 146" do
+    let(:io) { StringIO.new(146.chr) }
+
+    it "must return Python::Pickle::Instructions::NEWOBJ_EX" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::NEWOBJ_EX
+      )
+    end
+  end
+
+  describe "when the opcode is 147" do
+    let(:io) { StringIO.new(147.chr) }
+
+    it "must return Python::Pickle::Instructions::STACK_GLOBAL" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::STACK_GLOBAL
+      )
+    end
+  end
+
+  describe "when the opcode is 148" do
+    let(:io) { StringIO.new(148.chr) }
+
+    it "must return Python::Pickle::Instructions::MEMOIZE" do
+      expect(subject.read_instruction).to be(
+        Python::Pickle::Instructions::MEMOIZE
+      )
+    end
+  end
+
+  describe "when the opcode is 149" do
+    let(:frame)  { "\x8C\x03ABC\x94.".b }
+    let(:length) { frame.bytesize }
+    let(:packed) { [length, frame].pack('Q<a*') }
+    let(:io)    { StringIO.new("#{149.chr}#{packed}") }
+
+    it "must return Python::Pickle::Instructions::Frame" do
+      expect(subject.read_instruction).to eq(
+        Python::Pickle::Instructions::Frame.new(length)
+      )
+    end
+
+    context "after a Python::Pickle::Instructions::Frame has been returned" do
+      it "must change #io to be a StringIO pointing to the frame's contents" do
+        subject.read_instruction
+
+        expect(subject.io).to be_kind_of(StringIO)
+        expect(subject.io.string).to eq(frame)
+      end
+
+      it "must then read instructions from inside of a frame" do
+        expect(subject.read_instruction).to eq(
+          Python::Pickle::Instructions::Frame.new(length)
+        )
+
+        expect(subject.read_instruction).to eq(
+          Python::Pickle::Instructions::ShortBinUnicode.new(3,'ABC')
+        )
+
+        expect(subject.read_instruction).to eq(
+          Python::Pickle::Instructions::MEMOIZE
+        )
+
+        expect(subject.read_instruction).to eq(
+          Python::Pickle::Instructions::STOP
+        )
+      end
+    end
+  end
+end