hessian2 1.1.1 → 2.0.1

data/spec/map_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when map" do
+      hash = { born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write map with type ('M') ::= M type (value value)* Z" do
+        type = 'Monkey'
+        bin = Hessian2.write(Hessian2::TypeWrapper.new(type, hash))
+
+        bytes = bin.each_byte
+        expect([ bytes.next ].pack('C')).to eq('M')
+        expect(Hessian2.parse_string(bytes)).to eq(type)
+        _hash = Hessian2.parse(bin)
+        expect([ _hash['born_at'], _hash['name'], _hash['price'] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        _hash2 = Hessian2.parse(bin, nil, symbolize_keys: true)
+        expect(_hash2).to eq(hash)
+      end
+
+
+      it "should write untyped map ::= 'H' (value value)* 'Z'" do
+        bin = Hessian2.write(hash)
+
+        bytes = bin.each_byte
+        expect(bin[0]).to eq('H')
+        expect(bin[-1]).to eq('Z')
+        _hash = Hessian2.parse(bin)
+        expect([ _hash['born_at'], _hash['name'], _hash['price'] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        _hash2 = Hessian2.parse(bin, nil, symbolize_keys: true)
+        expect(_hash2).to eq(hash)
+      end
+
+    end
+  end
+end

data/spec/null_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when null" do
+      
+      it "should write null ('N') ::= 'N'" do
+        val = nil
+        bin = Hessian2.write(val)
+
+        expect(bin).to eq('N')
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when object" do
+      hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write object type definition ('C') ::= 'C' string int string* and object with direct type ::= [x60-x6f] value*" do
+        [ 'Monkey', 'AnotherMonkey' ].each do |klass|
+          bin = Hessian2.write(Kernel.const_get(klass).new(hash))
+
+          bytes = bin.each_byte
+          expect([ bytes.next ].pack('C')).to eq('C')
+          expect(Hessian2.parse_string(bytes)).to eq(klass)
+          expect(Hessian2.parse_int(bytes)).to eq(4)
+          4.times{ Hessian2.parse_string(bytes) }
+          expect(bytes.next - 0x60).to eq(0)
+          _monkey = Hessian2.parse(bin)
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        end
+      end
+
+
+      it "should write object instance ('O') ::= 'O' int value*" do
+        arr = []
+        17.times do |i|
+          arr << Hessian2::ClassWrapper.new("com.sun.java.Monkey#{i}", hash)
+        end
+        bin = Hessian2.write(arr)
+
+        bytes = bin.each_byte
+
+        # skip x58 int
+        bytes.next
+        Hessian2.parse_int(bytes)
+
+        # skip top 16
+        16.times do
+          bytes.next
+          Hessian2.parse_string(bytes)
+          Hessian2.parse_int(bytes)
+          4.times{ Hessian2.parse_string(bytes) }
+          bytes.next
+          4.times{ Hessian2.parse_bytes(bytes) }
+        end
+
+        # skip 17th class definition
+        bytes.next
+        Hessian2.parse_string(bytes)
+        Hessian2.parse_int(bytes)
+        4.times{ Hessian2.parse_string(bytes) }
+
+        expect([ bytes.next ].pack('C')).to eq('O')
+        expect(Hessian2.parse_int(bytes)).to eq(16)
+
+        _monkeys = Hessian2.parse(bin)
+        expect(_monkeys.size).to eq(17)
+        _monkeys.each do |_monkey|
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        end
+      end
+
+    end
+  end
+end

data/spec/ref_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when ref" do
+      hash1 = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write reference to map/list/object - integer ('Q') ::= x51 int" do
+        monkey1 = Monkey.new(hash1)
+        monkey2 = Hessian2::ClassWrapper.new("com.sun.java.Monkey", hash1)
+        monkey3 = Hessian2::TypeWrapper.new("com.sun.java.Monkey", hash1)
+        monkeys1 = [ monkey1, monkey2, monkey3 ]
+        monkeys2 = Hessian2::ClassWrapper.new("[com.sun.java.Monkey", monkeys1)
+        monkeys3 = Hessian2::TypeWrapper.new("[com.sun.java.Monkey", monkeys1)
+
+        arr = [ hash1, monkey1, monkey2, monkey3, monkeys1, monkeys2, monkeys3 ] * 2
+        
+        bin = Hessian2.write(arr)
+
+        _hash1, _monkey1, _monkey2, _monkey3, _monkeys1, _monkeys2, _monkeys3, \
+        _hash1r, _monkey1r, _monkey2r, _monkey3r, _monkeys1r, _monkeys2r, _monkeys3r = Hessian2.parse(bin, nil, symbolize_keys: true)
+
+        [ _hash1, _hash1r, _monkey3, _monkey3r ].each do |_hash|
+          expect([ _hash[:born_at], _hash[:name], _hash[:price] ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+        end
+
+        [ _monkey1, _monkey2, _monkey1r, _monkey2r ].each do |_monkey|
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+        end
+        
+        [ _monkeys1, _monkeys2, _monkeys3, _monkeys1r, _monkeys2r, _monkeys3r ].each do |_monkeys|
+          [ _monkeys[0], _monkeys[1] ].each do |_monkey|
+            expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+          end
+          last = _monkeys.last
+          expect([ last[:born_at], last[:name], last[:price] ]).to eq([ hash1[:born_at], hash1[:name], hash1[:price] ])
+        end
+
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+
+require 'hessian2'
+
+require 'active_record'
+require 'mysql2'
+
+MonkeyStruct = Struct.new(:born_at, :id, :name, :price)
+
+options = YAML.load_file(File.expand_path('../database.yml', __FILE__))
+ActiveRecord::Base.establish_connection(options)
+ActiveRecord::Base.default_timezone = :local
+
+class Monkey < ActiveRecord::Base; end
+
+class AnotherMonkey
+  attr_accessor :born_at, :id, :name, :price
+
+  def initialize(attrs = {})
+    attrs.each { |k, v| send("#{k}=", v) if respond_to?("#{k}=") }
+  end
+end

data/spec/string_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when string" do
+      
+      it "should write utf-8 string length 0-31 ::= [x00-x1f] <utf8-data>" do
+        (0..31).each do |len|
+          val = '啦' * len
+          bin = Hessian2.write(val)
+
+          expect(bin[0].unpack('C').first).to eq(val.size)
+          expect(bin[1..-1]).to eq(val.b)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write utf-8 string length 0-1023 ::= [x30-x33] b0 <utf8-data>" do
+        [ 33, 256, 512, 1023 ].each do |len|
+          val = '啦' * len
+          bin = Hessian2.write(val)
+
+          b1, b0 = bin[0, 2].unpack('CC')
+          expect(256 * (b1 - 0x30) + b0).to eq(val.size)
+          expect(bin[2..-1]).to eq(val.b)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+      it "should write utf-8 string final chunk ('S') ::= S b1 b0 <utf8-data>" do
+        val = '啦' * 0x400
+        bin = Hessian2.write(val)
+        
+        expect(bin[0]).to eq('S')
+        expect(bin[1, 2].unpack('n').first).to eq(0x400)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+
+      it "should write utf-8 string non-final chunk ('R') ::= x52 b1 b0 <utf8-data>" do
+        val = '啦' * 0x10400
+        bin = Hessian2.write(val)
+
+        chunks = val.size / 0x8000
+        i = 0
+
+        chunks.times do |c|
+          expect(bin[i]).to eq('R')
+          expect(bin[i + 1, 2].unpack('n').first).to eq(0x8000)
+          i += (3 + val[c * 0x8000, 0x8000].bytesize)
+        end
+        
+        expect(bin[i]).to eq('S')
+        expect(bin[i + 1, 2].unpack('n').first).to eq(val.size - 0x8000 * chunks)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/struct_wrapper_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe StructWrapper do
+		hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+		
+		# it "should raise error" do
+		# 	expect(lambda{ Hessian2::StructWrapper.new(MonkeyStruct) }).to raise_error
+		# end
+
+
+		# it "should wrap nil" do
+		# 	bin = Hessian2.write(Hessian2::StructWrapper.new(MonkeyStruct, nil))
+
+		# 	_monkey = Hessian2.parse(bin, MonkeyStruct)
+		# 	expect(_monkey).to eq(nil)
+		# end
+
+
+		# it "should wrap hash, monkey, another monkey" do
+		# 	[ MonkeyStruct, 'MonkeyStruct' ].each do |klass|
+		# 		[ hash, Monkey.new(hash), AnotherMonkey.new(hash) ].each do |val|
+		# 			bin = Hessian2.write(Hessian2::StructWrapper.new(klass, val))
+					
+		# 			_monkey = Hessian2.parse(bin, klass)
+		# 			expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+		# 		end
+		# 	end
+		# end
+
+
+		it "should wrap array" do
+			[ [MonkeyStruct], '[MonkeyStruct' ].each do |klass|
+				arr = [ nil, hash, Monkey.new(hash), AnotherMonkey.new(hash) ]
+				bin = Hessian2.write(Hessian2::StructWrapper.new(klass, arr))
+				
+				_monkey1, _monkey2, _monkey3, _monkey4 = Hessian2.parse(bin, klass, symbolize_keys: true)
+				expect(_monkey1).to eq(nil)
+				expect([ _monkey2[:born_at], _monkey2[:name], _monkey2[:price] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+				[ _monkey3, _monkey4 ].each do |_monkey|
+					expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+				end
+			end
+		end
+		
+	end
+end

data/spec/type_wrapper_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe TypeWrapper do
+  	hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+		it "should raise error" do
+			expect(lambda{ Hessian2::TypeWrapper.new(:unknown) }).to raise_error
+		end
+
+
+		it "should wrap nil" do
+			bin = Hessian2.write(Hessian2::TypeWrapper.new(:unknown, nil))
+
+			expect(bin).to eq('N')
+			expect(Hessian2.parse(bin)).to eq(nil)
+		end
+
+
+		it "should wrap long" do
+			[ 59, '59' ].each do |val|
+				[ 'L', 'l', 'Long', 'long', :long ].each do |type|
+					bin = Hessian2.write(Hessian2::TypeWrapper.new(type, val))
+
+					b1, b0 = bin[0, 2].unpack('CC')
+		      expect(((b1 - 0xf8) << 8) + b0).to eq(Integer(val))
+		      expect(Hessian2.parse(bin)).to eq(Integer(val))
+				end
+			end
+		end
+
+
+		it "should wrap int" do
+			[ 0x7f_fff_fff, '0x7f_fff_fff' ].each do |val|
+				[ 'I', 'i', 'Integer', 'int', :int ].each do |type|
+					bin = Hessian2.write(Hessian2::TypeWrapper.new(type, val))
+
+					expect(bin[0]).to eq('I')
+	        expect(bin[1, 4].unpack('l>').first).to eq(Integer(val))
+	        expect(Hessian2.parse(bin)).to eq(Integer(val))
+				end
+			end
+		end
+
+
+		it "should wrap binary" do
+			val = 'b' * 59
+			[ 'B', 'b', 'Binary', 'bin', :bin ].each do |type|
+				bin = Hessian2.write(Hessian2::TypeWrapper.new(type, val))
+
+				b1, b0 = bin[0, 2].unpack('CC')
+        expect(256 * (b1 - 0x34) + b0).to eq(val.size)
+        expect(bin.size).to eq(2 + val.size)
+        expect(Hessian2.parse(bin)).to eq(val)
+			end
+		end
+
+
+		it "should wrap monkey" do
+			[ Monkey.new(hash), AnotherMonkey.new(hash) ].each do |val|
+				bin = Hessian2.write(Hessian2::TypeWrapper.new('com.sun.java.Monkey', val))
+
+				_hash = Hessian2.parse(bin, nil, symbolize_keys: true)
+				expect([ _hash[:born_at], _hash[:name], _hash[:price] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+			end
+		end
+
+
+		it "should wrap long array" do
+			bin = Hessian2.write(Hessian2::TypeWrapper.new('[long', [ 59, 69, 79, 89, 99 ]))
+
+      expect(Hessian2.parse(bin)).to eq([ 59, 69, 79, 89, 99 ])
+		end
+
+
+		it "should wrap int array" do
+			bin = Hessian2.write(Hessian2::TypeWrapper.new('[int', [ 0x7f_fff_ffb, 0x7f_fff_ffc, 0x7f_fff_ffd, 0x7f_fff_ffe, 0x7f_fff_fff ]))
+
+      expect(Hessian2.parse(bin)).to eq([ 0x7f_fff_ffb, 0x7f_fff_ffc, 0x7f_fff_ffd, 0x7f_fff_ffe, 0x7f_fff_fff ])
+		end
+
+
+		it "should wrap binary array" do
+			bin = Hessian2.write(Hessian2::TypeWrapper.new('[bin', [ 'b' * 59, 'b' * 69, 'b' * 79, 'b' * 89, 'b' * 99 ]))
+
+      expect(Hessian2.parse(bin)).to eq([ 'b' * 59, 'b' * 69, 'b' * 79, 'b' * 89, 'b' * 99 ])
+		end
+
+
+		it "should wrap monkey array" do
+			bin = Hessian2.write(Hessian2::TypeWrapper.new('[com.sun.java.Monkey', [ nil, Monkey.new(hash), AnotherMonkey.new(hash) ]))
+
+			_hash1, _hash2, _hash3 = Hessian2.parse(bin, nil, symbolize_keys: true)
+			expect(_hash1).to eq(nil)
+			[ _hash2, _hash3 ].each do |_hash|
+				expect([ _hash[:born_at], _hash[:name], _hash[:price] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+			end
+		end
+		
+		
+	end
+end

data/test/app.rb

@@ -0,0 +1,15 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+require 'sinatra'
+require File.expand_path('../monkey_service',  __FILE__)
+
+set :logging, false
+
+get '/' do
+  status 405
+  'post me'
+end
+
+post '/' do
+  MonkeyService.handle(request.body.read)
+end

data/test/client.rb

@@ -0,0 +1,9 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+require 'hessian2'
+
+client = Hessian2::Client.new('http://localhost:4567')
+
+puts client.say ARGV.first
+
+puts client.say2

data/test/config.ru

@@ -0,0 +1,2 @@
+require ::File.expand_path('../app',  __FILE__)
+run Sinatra::Application

data/test/monkey_service.rb

@@ -0,0 +1,12 @@
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path)
+require 'hessian2'
+
+class MonkeyService
+  extend Hessian2::Handler
+
+  def self.say(name)
+    "hello #{name}"
+  end
+
+end