python-pickle 0.1.0

data/spec/integration/load/protocol4_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'python/pickle'
+
+describe Python::Pickle do
+  let(:fixtures_dir) { File.join(__dir__,'..','..','fixtures') }
+
+  describe ".load" do
+    context "when given a Pickle protocol 4 stream" do
+      let(:io) { File.open(file) }
+
+      context "and it contains a serialized None" do
+        let(:file) { File.join(fixtures_dir,'none_v4.pkl') }
+
+        it "must return nil" do
+          expect(subject.load(io)).to be(nil)
+        end
+      end
+
+      context "and it contains a serialized True" do
+        let(:file) { File.join(fixtures_dir,'true_v4.pkl') }
+
+        it "must return true" do
+          expect(subject.load(io)).to be(true)
+        end
+      end
+
+      context "and it contains a serialized False" do
+        let(:file) { File.join(fixtures_dir,'false_v4.pkl') }
+
+        it "must return false" do
+          expect(subject.load(io)).to be(false)
+        end
+      end
+
+      context "and it contains a serialized integer" do
+        let(:file) { File.join(fixtures_dir,'int_v4.pkl') }
+
+        it "must return an Integer object" do
+          expect(subject.load(io)).to eq(42)
+        end
+      end
+
+      context "and it contains a long integer" do
+        let(:file) { File.join(fixtures_dir,'long_v4.pkl') }
+
+        it "must return an Integer object" do
+          expect(subject.load(io)).to eq((2 ** 64) - 1)
+        end
+      end
+
+      context "and it contains a serialized floating-point number" do
+        let(:float) { 3.141592653589793 }
+        let(:file)  { File.join(fixtures_dir,'float_v4.pkl') }
+
+        it "must return a Float object" do
+          expect(subject.load(io)).to eq(float)
+        end
+      end
+
+      context "and it contains a plain string" do
+        let(:string) { "ABC" }
+        let(:file)   { File.join(fixtures_dir,'str_v4.pkl') }
+
+        it "must return a String object" do
+          expect(subject.load(io)).to eq(string)
+        end
+
+        context "and it contains a UTF string" do
+          let(:string) { "ABC\u265E\u265F\u{1F600}" }
+          let(:file)   { File.join(fixtures_dir,'unicode_str_v4.pkl') }
+
+          it "must return a UTF-8 encoded String object" do
+            expect(subject.load(io).encoding).to be(Encoding::UTF_8)
+          end
+        end
+      end
+
+      context "and it contains a bytearray type" do
+        let(:string) { "ABC" }
+        let(:file)   { File.join(fixtures_dir,'bytearray_v4.pkl') }
+
+        it "must return a Python::Pickle::ByteArray object" do
+          expect(subject.load(io)).to eq(Python::Pickle::ByteArray.new(string))
+        end
+      end
+
+      context "and it contains a list type" do
+        let(:file) { File.join(fixtures_dir,'list_v4.pkl') }
+
+        it "must return an Array object" do
+          expect(subject.load(io)).to eq(
+            [nil, true, false, 42, "ABC"]
+          )
+        end
+
+        context "but the list object contains other list objects" do
+          let(:file) { File.join(fixtures_dir,'nested_list_v4.pkl') }
+
+          it "must return a nested Array object" do
+            expect(subject.load(io)).to eq(
+              [1, [2, [3, [4]]]]
+            )
+          end
+        end
+      end
+
+      context "and it contains a dict type" do
+        let(:file) { File.join(fixtures_dir,'dict_v4.pkl') }
+
+        it "must return an Array object" do
+          expect(subject.load(io)).to eq(
+            {"foo" => "bar"}
+          )
+        end
+
+        context "but the dict object contains other dict objects" do
+          let(:file) { File.join(fixtures_dir,'nested_dict_v4.pkl') }
+
+          it "must return a nested Hash object" do
+            expect(subject.load(io)).to eq(
+              {"a" => {"b" => {"c" => "d"}}}
+            )
+          end
+        end
+      end
+
+      context "and it contains a function type" do
+        let(:file) { File.join(fixtures_dir,'function_v4.pkl') }
+
+        context "but there is no constant mapping for the function name" do
+          it "must return a Python::Pickle::PyClass object of the given name" do
+            object = subject.load(io)
+
+            expect(object).to be_kind_of(Python::Pickle::PyClass)
+            expect(object.namespace).to eq('__main__')
+            expect(object.name).to eq('func')
+          end
+        end
+
+        context "but there is a constant mapping for the function name" do
+          module TestPickleLoad
+            def self.func
+            end
+          end
+
+          it "must return a mapped Ruby method" do
+            object = subject.load(io, constants: {
+              '__main__' => {
+                'func' => TestPickleLoad.method(:func)
+              }
+            })
+
+            expect(object).to eq(TestPickleLoad.method(:func))
+          end
+        end
+      end
+
+      context "and it contains a class type" do
+        let(:file) { File.join(fixtures_dir,'class_v4.pkl') }
+
+        context "but there is no constant mapping for the class name" do
+          it "must return a Python::Pickle::PyClass object of the given name" do
+            object = subject.load(io)
+
+            expect(object).to be_kind_of(Python::Pickle::PyClass)
+            expect(object.namespace).to eq('__main__')
+            expect(object.name).to eq('MyClass')
+          end
+        end
+
+        context "but there is a constant mapping for the class name" do
+          module TestPickleLoad
+            class MyClass
+            end
+          end
+
+          it "must return a new Ruby object for the mapped class" do
+            object = subject.load(io, constants: {
+              '__main__' => {
+                'MyClass' => TestPickleLoad::MyClass
+              }
+            })
+
+            expect(object).to be(TestPickleLoad::MyClass)
+          end
+        end
+      end
+
+      context "and it contains an object type" do
+        let(:file) { File.join(fixtures_dir,'object_v1.pkl') }
+
+        context "but there is no constant mapping for the class name" do
+          it "must return a Python::Pickle::PyObject object of the given name" do
+            object = subject.load(io)
+
+            expect(object).to be_kind_of(Python::Pickle::PyObject)
+            expect(object.py_class).to be_kind_of(Python::Pickle::PyClass)
+            expect(object.py_class.namespace).to eq('__main__')
+            expect(object.py_class.name).to eq('MyClass')
+            expect(object.attributes).to eq(
+              {
+                'x' => 0x41,
+                'y' => 0x42
+              }
+            )
+          end
+        end
+
+        context "but there is a constant mapping for the class name" do
+          context "and the Ruby class defines a __setstate__ method" do
+            module TestPickleLoad
+              class MyClassWithSetState
+                attr_reader :x
+                attr_reader :y
+
+                def __setstate__(attributes)
+                  @x = attributes['x']
+                  @y = attributes['y']
+                end
+              end
+            end
+
+            it "must return a new Ruby object for the mapped class" do
+              object = subject.load(io, constants: {
+                '__main__' => {
+                  'MyClass' => TestPickleLoad::MyClassWithSetState
+                }
+              })
+
+              expect(object).to be_kind_of(TestPickleLoad::MyClassWithSetState)
+              expect(object.x).to eq(0x41)
+              expect(object.y).to eq(0x42)
+            end
+          end
+
+          context "but the Ruby class does not define a __setstate__ method" do
+            module TestPickleLoad
+              class MyClassWithoutSetState
+              end
+            end
+
+            it do
+              expect {
+                subject.load(io, constants: {
+                  '__main__' => {
+                    'MyClass' => TestPickleLoad::MyClassWithoutSetState
+                  }
+                })
+              }.to raise_error(Python::Pickle::DeserializationError).with_message(
+                /\Acannot execute BUILD on an object that does not define a __setstate__ method or is not a Hash: #<TestPickleLoad::MyClassWithoutSetState:0x[0-9a-f]+>\z/
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/load/protocol5_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'python/pickle'
+
+describe Python::Pickle do
+  let(:fixtures_dir) { File.join(__dir__,'..','..','fixtures') }
+
+  describe ".load" do
+    context "when given a Pickle protocol 5 stream" do
+      let(:io) { File.open(file) }
+
+      context "and it contains a serialized None" do
+        let(:file) { File.join(fixtures_dir,'none_v5.pkl') }
+
+        it "must return nil" do
+          expect(subject.load(io)).to be(nil)
+        end
+      end
+
+      context "and it contains a serialized True" do
+        let(:file) { File.join(fixtures_dir,'true_v5.pkl') }
+
+        it "must return true" do
+          expect(subject.load(io)).to be(true)
+        end
+      end
+
+      context "and it contains a serialized False" do
+        let(:file) { File.join(fixtures_dir,'false_v5.pkl') }
+
+        it "must return false" do
+          expect(subject.load(io)).to be(false)
+        end
+      end
+
+      context "and it contains a serialized integer" do
+        let(:file) { File.join(fixtures_dir,'int_v5.pkl') }
+
+        it "must return an Integer object" do
+          expect(subject.load(io)).to eq(42)
+        end
+      end
+
+      context "and it contains a long integer" do
+        let(:file) { File.join(fixtures_dir,'long_v5.pkl') }
+
+        it "must return an Integer object" do
+          expect(subject.load(io)).to eq((2 ** 64) - 1)
+        end
+      end
+
+      context "and it contains a serialized floating-point number" do
+        let(:float) { 3.141592653589793 }
+        let(:file)  { File.join(fixtures_dir,'float_v5.pkl') }
+
+        it "must return a Float object" do
+          expect(subject.load(io)).to eq(float)
+        end
+      end
+
+      context "and it contains a plain string" do
+        let(:string) { "ABC" }
+        let(:file)   { File.join(fixtures_dir,'str_v5.pkl') }
+
+        it "must return a String object" do
+          expect(subject.load(io)).to eq(string)
+        end
+
+        context "and it contains a UTF string" do
+          let(:string) { "ABC\u265E\u265F\u{1F600}" }
+          let(:file)   { File.join(fixtures_dir,'unicode_str_v5.pkl') }
+
+          it "must return a UTF-8 encoded String object" do
+            expect(subject.load(io).encoding).to be(Encoding::UTF_8)
+          end
+        end
+      end
+
+      context "and it contains a bytearray type" do
+        let(:string) { "ABC" }
+        let(:file)   { File.join(fixtures_dir,'bytearray_v5.pkl') }
+
+        it "must return a Python::Pickle::ByteArray object" do
+          expect(subject.load(io)).to eq(Python::Pickle::ByteArray.new(string))
+        end
+      end
+
+      context "and it contains a list type" do
+        let(:file) { File.join(fixtures_dir,'list_v5.pkl') }
+
+        it "must return an Array object" do
+          expect(subject.load(io)).to eq(
+            [nil, true, false, 42, "ABC"]
+          )
+        end
+
+        context "but the list object contains other list objects" do
+          let(:file) { File.join(fixtures_dir,'nested_list_v5.pkl') }
+
+          it "must return a nested Array object" do
+            expect(subject.load(io)).to eq(
+              [1, [2, [3, [4]]]]
+            )
+          end
+        end
+      end
+
+      context "and it contains a dict type" do
+        let(:file) { File.join(fixtures_dir,'dict_v5.pkl') }
+
+        it "must return an Array object" do
+          expect(subject.load(io)).to eq(
+            {"foo" => "bar"}
+          )
+        end
+
+        context "but the dict object contains other dict objects" do
+          let(:file) { File.join(fixtures_dir,'nested_dict_v5.pkl') }
+
+          it "must return a nested Hash object" do
+            expect(subject.load(io)).to eq(
+              {"a" => {"b" => {"c" => "d"}}}
+            )
+          end
+        end
+      end
+
+      context "and it contains a function type" do
+        let(:file) { File.join(fixtures_dir,'function_v5.pkl') }
+
+        context "but there is no constant mapping for the function name" do
+          it "must return a Python::Pickle::PyClass object of the given name" do
+            object = subject.load(io)
+
+            expect(object).to be_kind_of(Python::Pickle::PyClass)
+            expect(object.namespace).to eq('__main__')
+            expect(object.name).to eq('func')
+          end
+        end
+
+        context "but there is a constant mapping for the function name" do
+          module TestPickleLoad
+            def self.func
+            end
+          end
+
+          it "must return a mapped Ruby method" do
+            object = subject.load(io, constants: {
+              '__main__' => {
+                'func' => TestPickleLoad.method(:func)
+              }
+            })
+
+            expect(object).to eq(TestPickleLoad.method(:func))
+          end
+        end
+      end
+
+      context "and it contains a class type" do
+        let(:file) { File.join(fixtures_dir,'class_v5.pkl') }
+
+        context "but there is no constant mapping for the class name" do
+          it "must return a Python::Pickle::PyClass object of the given name" do
+            object = subject.load(io)
+
+            expect(object).to be_kind_of(Python::Pickle::PyClass)
+            expect(object.namespace).to eq('__main__')
+            expect(object.name).to eq('MyClass')
+          end
+        end
+
+        context "but there is a constant mapping for the class name" do
+          module TestPickleLoad
+            class MyClass
+            end
+          end
+
+          it "must return a new Ruby object for the mapped class" do
+            object = subject.load(io, constants: {
+              '__main__' => {
+                'MyClass' => TestPickleLoad::MyClass
+              }
+            })
+
+            expect(object).to be(TestPickleLoad::MyClass)
+          end
+        end
+      end
+
+      context "and it contains an object type" do
+        let(:file) { File.join(fixtures_dir,'object_v1.pkl') }
+
+        context "but there is no constant mapping for the class name" do
+          it "must return a Python::Pickle::PyObject object of the given name" do
+            object = subject.load(io)
+
+            expect(object).to be_kind_of(Python::Pickle::PyObject)
+            expect(object.py_class).to be_kind_of(Python::Pickle::PyClass)
+            expect(object.py_class.namespace).to eq('__main__')
+            expect(object.py_class.name).to eq('MyClass')
+            expect(object.attributes).to eq(
+              {
+                'x' => 0x41,
+                'y' => 0x42
+              }
+            )
+          end
+        end
+
+        context "but there is a constant mapping for the class name" do
+          context "and the Ruby class defines a __setstate__ method" do
+            module TestPickleLoad
+              class MyClassWithSetState
+                attr_reader :x
+                attr_reader :y
+
+                def __setstate__(attributes)
+                  @x = attributes['x']
+                  @y = attributes['y']
+                end
+              end
+            end
+
+            it "must return a new Ruby object for the mapped class" do
+              object = subject.load(io, constants: {
+                '__main__' => {
+                  'MyClass' => TestPickleLoad::MyClassWithSetState
+                }
+              })
+
+              expect(object).to be_kind_of(TestPickleLoad::MyClassWithSetState)
+              expect(object.x).to eq(0x41)
+              expect(object.y).to eq(0x42)
+            end
+          end
+
+          context "but the Ruby class does not define a __setstate__ method" do
+            module TestPickleLoad
+              class MyClassWithoutSetState
+              end
+            end
+
+            it do
+              expect {
+                subject.load(io, constants: {
+                  '__main__' => {
+                    'MyClass' => TestPickleLoad::MyClassWithoutSetState
+                  }
+                })
+              }.to raise_error(Python::Pickle::DeserializationError).with_message(
+                /\Acannot execute BUILD on an object that does not define a __setstate__ method or is not a Hash: #<TestPickleLoad::MyClassWithoutSetState:0x[0-9a-f]+>\z/
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end