mrpin-rocketamf 1.0.4 → 2.0.0

data/lib/rocketamf/types.rb

@@ -0,0 +1 @@
+require 'rocketamf/types/typed_hash'

data/lib/rocketamf/{values → types}/typed_hash.rb

@@ -1,11 +1,21 @@
 module RocketAMF
-  module Values #:nodoc:
+  module Types #:nodoc:
+
     # Hash-like object that can store a type string. Used to preserve type information
     # for unmapped objects after deserialization.
     class TypedHash < Hash
+
+      #
+      # Properties
+      #
+
       attr_reader :type
 
-      def initialize type
+      #
+      # Methods
+      #
+
+      def initialize(type)
         @type = type
       end
     end

data/mrpin-rocketamf.gemspec

@@ -1,22 +1,33 @@
 # -*- encoding: utf-8 -*-
 
-Gem::Specification.new do |s|
-  s.name    = 'mrpin-rocketamf'
-  s.version = '1.0.4'
-  s.platform = Gem::Platform::RUBY
-  s.authors  = ['Jacob Henry', 'Stephen Augenstein', "Joc O'Connor"]
-  s.email    = ['perl.programmer@gmail.com']
-  s.homepage = 'https://github.com/mrpin/mrpin-rocketamf'
-  s.summary = 'Fast AMF serializer/deserializer with remoting request/response wrappers to simplify integration'
+Gem::Specification.new do |spec|
+  spec.name        = 'mrpin-rocketamf'
+  spec.version     = '2.0.0'
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ['Jacob Henry', 'Stephen Augenstein', "Joc O'Connor", 'Gregory Tkach']
+  spec.email       = %w(gregory.tkach@gmail.com)
+  spec.homepage    = 'https://github.com/mrpin/mrpin-rocketamf'
+  spec.license     = 'MIT'
+  spec.summary     = 'Fast AMF3 serializer/deserializer'
+  spec.description = 'Fast AMF3 serializer/deserializer with remoting request/response wrappers to simplify integration'
 
-  s.files         = Dir[*['README.rdoc', 'benchmark.rb', 'mrpin-rocketamf.gemspec', 'Rakefile', 'lib/**/*.rb', 'spec/**/*.{rb,bin,opts}', 'ext/**/*.{c,h,rb}']]
-  s.test_files    = Dir[*['spec/**/*_spec.rb']]
-  s.extensions    = Dir[*["ext/**/extconf.rb"]]
-  s.require_paths = ["lib"]
+  files = []
+  files << 'README.rdoc'
+  files << 'benchmark.rb'
+  files << 'mrpin-rocketamf.gemspec'
+  files << 'Rakefile'
+  files << 'lib/**/*.rb'
+  files << 'spec/**/*.{rb,bin,opts}'
+  files << 'ext/**/*.{c,h,rb}'
 
-  s.add_development_dependency 'rake-compiler'
+  spec.files         = Dir[*files]
+  spec.test_files    = Dir[*['spec/**/*_spec.rb']]
+  spec.extensions    = Dir[*['ext/**/extconf.rb']]
+  spec.require_paths = ['lib']
 
-  s.has_rdoc         = true
-  s.extra_rdoc_files = ['README.rdoc']
-  s.rdoc_options     = ['--line-numbers', '--main', 'README.rdoc']
+  spec.add_development_dependency 'rake-compiler', '~> 0'
+
+  spec.has_rdoc         = true
+  spec.extra_rdoc_files = %w( README.rdoc )
+  spec.rdoc_options     = %w(--line-numbers --main README.rdoc)
 end

data/spec/class_mapping_spec.rb

@@ -1,110 +1,117 @@
-require "spec_helper.rb"
+require 'spec_helper.rb'
 
 describe RocketAMF::ClassMapping do
   before :each do
     RocketAMF::ClassMapping.reset
     RocketAMF::ClassMapping.define do |m|
-      m.map :as => 'ASClass', :ruby => 'ClassMappingTest'
+      m.map as: 'ASClass', ruby: 'ClassMappingTest'
     end
     @mapper = RocketAMF::ClassMapping.new
   end
 
-  describe "class name mapping" do
-    it "should allow resetting of mappings back to defaults" do
-      @mapper.get_as_class_name('ClassMappingTest').should_not be_nil
+  describe 'class name mapping' do
+    it 'should allow resetting of mappings back to defaults' do
+      expect(@mapper.get_as_class_name('ClassMappingTest')).not_to be_nil
+
       RocketAMF::ClassMapping.reset
+
       @mapper = RocketAMF::ClassMapping.new
-      @mapper.get_as_class_name('ClassMappingTest').should be_nil
-      @mapper.get_as_class_name('RocketAMF::Values::AcknowledgeMessage').should_not be_nil
+      expect(@mapper.get_as_class_name('ClassMappingTest')).to be_nil
+      expect(@mapper.get_as_class_name('RocketAMF::Types::AcknowledgeMessage')).not_to be_nil
     end
 
-    it "should return AS class name for ruby objects" do
-      @mapper.get_as_class_name(ClassMappingTest.new).should == 'ASClass'
-      @mapper.get_as_class_name('ClassMappingTest').should == 'ASClass'
-      @mapper.get_as_class_name(RocketAMF::Values::TypedHash.new('ClassMappingTest')).should == 'ASClass'
-      @mapper.get_as_class_name('BadClass').should be_nil
+    it 'should return AS class name for ruby objects' do
+      expect(@mapper.get_as_class_name(ClassMappingTest.new)).to eq('ASClass')
+      expect(@mapper.get_as_class_name('ClassMappingTest')).to eq('ASClass')
+      expect(@mapper.get_as_class_name(RocketAMF::Types::TypedHash.new('ClassMappingTest'))).to eq('ASClass')
+      expect(@mapper.get_as_class_name('BadClass')).to be_nil
     end
 
-    it "should instantiate a ruby class" do
-      @mapper.get_ruby_obj('ASClass').should be_a(ClassMappingTest)
+    it 'should instantiate a ruby class' do
+      expect(@mapper.get_ruby_obj('ASClass')).to be_a(ClassMappingTest)
     end
 
-    it "should properly instantiate namespaced classes" do
-      RocketAMF::ClassMapping.mappings.map :as => 'ASClass', :ruby => 'ANamespace::TestRubyClass'
+    it 'should properly instantiate namespaced classes' do
+      RocketAMF::ClassMapping.mappings.map as: 'ASClass', ruby: 'ANamespace::TestRubyClass'
       @mapper = RocketAMF::ClassMapping.new
-      @mapper.get_ruby_obj('ASClass').should be_a(ANamespace::TestRubyClass)
+
+      expect(@mapper.get_ruby_obj('ASClass')).to be_a(ANamespace::TestRubyClass)
     end
 
-    it "should return a hash with original type if not mapped" do
+    it 'should return a hash with original type if not mapped' do
       obj = @mapper.get_ruby_obj('UnmappedClass')
-      obj.should be_a(RocketAMF::Values::TypedHash)
-      obj.type.should == 'UnmappedClass'
+
+      expect(obj).to be_a(RocketAMF::Types::TypedHash)
+      expect(obj.type).to eq('UnmappedClass')
     end
 
-    it "should map special classes from AS by default" do
-      as_classes = [
-        'flex.messaging.messages.AcknowledgeMessage',
-        'flex.messaging.messages.CommandMessage',
-        'flex.messaging.messages.RemotingMessage'
-      ]
+    it 'should map special classes from AS by default' do
+      as_classes =
+          %w(
+              flex.messaging.messages.AcknowledgeMessage
+              flex.messaging.messages.CommandMessage
+              flex.messaging.messages.RemotingMessage
+            )
 
       as_classes.each do |as_class|
-        @mapper.get_ruby_obj(as_class).should_not be_a(RocketAMF::Values::TypedHash)
+        expect(@mapper.get_ruby_obj(as_class)).not_to be_a(RocketAMF::Types::TypedHash)
       end
     end
 
-    it "should map special classes from ruby by default" do
-      ruby_classes = [
-        'RocketAMF::Values::AcknowledgeMessage',
-        'RocketAMF::Values::ErrorMessage'
-      ]
+    it 'should map special classes from ruby by default' do
+      ruby_classes =
+          %w(
+              RocketAMF::Types::AcknowledgeMessage
+              RocketAMF::Types::ErrorMessage
+            )
 
       ruby_classes.each do |obj|
-        @mapper.get_as_class_name(obj).should_not be_nil
+        expect(@mapper.get_as_class_name(obj)).not_to be_nil
       end
     end
 
-    it "should allow config modification" do
-      RocketAMF::ClassMapping.mappings.map :as => 'SecondClass', :ruby => 'ClassMappingTest'
+    it 'should allow config modification' do
+      RocketAMF::ClassMapping.mappings.map as: 'SecondClass', ruby: 'ClassMappingTest'
       @mapper = RocketAMF::ClassMapping.new
-      @mapper.get_as_class_name(ClassMappingTest.new).should == 'SecondClass'
+
+      expect(@mapper.get_as_class_name(ClassMappingTest.new)).to eq('SecondClass')
     end
   end
 
-  describe "ruby object populator" do
-    it "should populate a ruby class" do
+  describe 'ruby object populator' do
+    it 'should populate a ruby class' do
       obj = @mapper.populate_ruby_obj ClassMappingTest.new, {:prop_a => 'Data'}
-      obj.prop_a.should == 'Data'
+      expect(obj.prop_a).to eq('Data')
     end
 
-    it "should populate a typed hash" do
-      obj = @mapper.populate_ruby_obj RocketAMF::Values::TypedHash.new('UnmappedClass'), {:prop_a => 'Data'}
-      obj[:prop_a].should == 'Data'
+    it 'should populate a typed hash' do
+      obj = @mapper.populate_ruby_obj RocketAMF::Types::TypedHash.new('UnmappedClass'), {prop_a: 'Data'}
+      expect(obj[:prop_a]).to eq('Data')
     end
   end
 
-  describe "property extractor" do
-    it "should extract hash properties" do
-      hash = {:a => 'test1', 'b' => 'test2'}
+  describe 'property extractor' do
+    it 'should extract hash properties' do
+      hash  = {a: 'test1', 'b' => 'test2'}
       props = @mapper.props_for_serialization(hash)
-      props.should == {'a' => 'test1', 'b' => 'test2'}
+      expect(props).to eq({'a' => 'test1', 'b' => 'test2'})
     end
 
-    it "should extract object properties" do
-      obj = ClassMappingTest.new
+    it 'should extract object properties' do
+      obj        = ClassMappingTest.new
       obj.prop_a = 'Test A'
 
       hash = @mapper.props_for_serialization obj
-      hash.should == {'prop_a' => 'Test A', 'prop_b' => nil}
+      expect(hash).to eq({'prop_a' => 'Test A', 'prop_b' => nil})
     end
 
-    it "should extract inherited object properties" do
-      obj = ClassMappingTest2.new
+    it 'should extract inherited object properties' do
+      obj        = ClassMappingTest2.new
       obj.prop_a = 'Test A'
       obj.prop_c = 'Test C'
 
       hash = @mapper.props_for_serialization obj
-      hash.should == {'prop_a' => 'Test A', 'prop_b' => nil, 'prop_c' => 'Test C'}
+      expect(hash).to eq({'prop_a' => 'Test A', 'prop_b' => nil, 'prop_c' => 'Test C'})
     end
   end
 end

data/spec/deserializer_spec.rb

@@ -1,444 +1,280 @@
 # encoding: UTF-8
 
-require "spec_helper.rb"
+require 'spec_helper.rb'
 
-describe "when deserializing" do
+describe 'when deserializing' do
   before :each do
-    RocketAMF::ClassMapper.reset
+    RocketAMF::CLASS_MAPPER.reset
   end
 
-  it "should raise exception with invalid version number" do
-    lambda {
-      RocketAMF.deserialize("", 5)
-    }.should raise_error("unsupported version 5")
-  end
-
-  describe "AMF0" do
-    it "should update source pos if source is a StringIO object" do
-      input = StringIO.new(object_fixture('amf0-number.bin'))
-      input.pos.should == 0
-      output = RocketAMF.deserialize(input, 0)
-      input.pos.should == 9
-    end
-
-    it "should deserialize numbers" do
-      input = object_fixture('amf0-number.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == 3.5
-    end
-
-    it "should deserialize booleans" do
-      input = object_fixture('amf0-boolean.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should === true
-    end
-
-    it "should deserialize UTF8 strings" do
-      input = object_fixture('amf0-string.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == "this is a テスト"
-    end
-
-    it "should deserialize nulls" do
-      input = object_fixture('amf0-null.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == nil
-    end
-
-    it "should deserialize undefineds" do
-      input = object_fixture('amf0-undefined.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == nil
-    end
-
-    it "should deserialize hashes" do
-      input = object_fixture('amf0-hash.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == {'a' => 'b', 'c' => 'd'}
-    end
-
-    it "should deserialize hashes with empty string keys" do
-      input = object_fixture('amf0-empty-string-key-hash.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == {'a' => 'b', 'c' => 'd', '' => 'last'}
-    end
-
-    it "should deserialize arrays from flash player" do
-      # Even Array is serialized as a "hash"
-      input = object_fixture('amf0-ecma-ordinal-array.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == {'0' => 'a', '1' => 'b', '2' => 'c', '3' => 'd'}
-    end
-
-    it "should deserialize strict arrays" do
-      input = object_fixture('amf0-strict-array.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == ['a', 'b', 'c', 'd']
-    end
-
-    it "should deserialize dates" do
-      input = object_fixture('amf0-time.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == Time.utc(2003, 2, 13, 5)
-    end
-
-    it "should deserialize an XML document" do
-      input = object_fixture('amf0-xml-doc.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == '<parent><child prop="test" /></parent>'
-    end
-
-    it "should deserialize anonymous objects" do
-      input = object_fixture('amf0-object.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.should == {'foo' => 'baz', 'bar' => 3.14}
-      output.type.should == ""
-    end
-
-    it "should deserialize an unmapped object as a dynamic anonymous object" do
-      input = object_fixture("amf0-typed-object.bin")
-      output = RocketAMF.deserialize(input, 0)
-
-      output.type.should == 'org.amf.ASClass'
-      output.should == {'foo' => 'bar', 'baz' => nil}
-    end
-
-    it "should deserialize a mapped object as a mapped ruby class instance" do
-      RocketAMF::ClassMapper.define {|m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass'}
-
-      input = object_fixture("amf0-typed-object.bin")
-      output = RocketAMF.deserialize(input, 0)
-
-      output.should be_a(RubyClass)
-      output.foo.should == 'bar'
-      output.baz.should == nil
-    end
+  describe 'AMF3' do
+    it 'should update source pos if source is a StringIO object' do
+      input = StringIO.new(object_fixture('amf3-null.bin'))
+      expect(input.pos).to eq(0)
 
-    it "should deserialize references properly" do
-      input = object_fixture('amf0-ref-test.bin')
-      output = RocketAMF.deserialize(input, 0)
-      output.length.should == 2
-      output["0"].should === output["1"]
-    end
-  end
+      RocketAMF.deserialize(input)
 
-  describe "AMF3" do
-    it "should update source pos if source is a StringIO object" do
-      input = StringIO.new(object_fixture('amf3-null.bin'))
-      input.pos.should == 0
-      output = RocketAMF.deserialize(input, 3)
-      input.pos.should == 1
+      expect(input.pos).to eq(1)
     end
 
-    describe "simple messages" do
-      it "should deserialize a null" do
-        input = object_fixture("amf3-null.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == nil
+    describe 'simple messages' do
+      it 'should deserialize a null' do
+        first_request_eq('amf3-null.bin', nil)
       end
 
-      it "should deserialize a false" do
-        input = object_fixture("amf3-false.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == false
+      it 'should deserialize a false' do
+        first_request_eq('amf3-false.bin', false)
       end
 
-      it "should deserialize a true" do
-        input = object_fixture("amf3-true.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == true
+      it 'should deserialize a true' do
+        first_request_eq('amf3-true.bin', true)
       end
 
-      it "should deserialize integers" do
-        input = object_fixture("amf3-max.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == RocketAMF::MAX_INTEGER
-
-        input = object_fixture("amf3-0.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == 0
-
-        input = object_fixture("amf3-min.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == RocketAMF::MIN_INTEGER
+      it 'should deserialize integers' do
+        first_request_eq('amf3-max.bin', RocketAMF::MAX_INTEGER)
+        first_request_eq('amf3-0.bin', 0)
+        first_request_eq('amf3-min.bin', RocketAMF::MIN_INTEGER)
       end
 
-      it "should deserialize large integers" do
-        input = object_fixture("amf3-large-max.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == RocketAMF::MAX_INTEGER + 1
-
-        input = object_fixture("amf3-large-min.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == RocketAMF::MIN_INTEGER - 1
+      it 'should deserialize large integers' do
+        first_request_eq('amf3-large-max.bin', RocketAMF::MAX_INTEGER + 1.0)
+        first_request_eq('amf3-large-min.bin', RocketAMF::MIN_INTEGER - 1.0)
       end
 
-      it "should deserialize BigNums" do
-        input = object_fixture("amf3-bignum.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == 2**1000
+      it 'should deserialize BigNums' do
+        first_request_eq('amf3-bignum.bin', 2.0**1000)
       end
 
-      it "should deserialize a simple string" do
-        input = object_fixture("amf3-string.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == "String . String"
+      it 'should deserialize a simple string' do
+        first_request_eq('amf3-string.bin', 'String . String')
       end
 
-      it "should deserialize a symbol as a string" do
-        input = object_fixture("amf3-symbol.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == "foo"
+      it 'should deserialize a symbol as a string' do
+        first_request_eq('amf3-symbol.bin', 'foo')
       end
 
-      it "should deserialize dates" do
-        input = object_fixture("amf3-date.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == Time.at(0)
+      it 'should deserialize dates' do
+        first_request_eq('amf3-date.bin', Time.at(0))
       end
 
-      it "should deserialize XML" do
+      it 'should deserialize XML' do
         # XMLDocument tag
-        input = object_fixture("amf3-xml-doc.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == '<parent><child prop="test" /></parent>'
+        first_request_eq('amf3-xml-doc.bin', '<parent><child prop="test" /></parent>')
 
         # XML tag
-        input = object_fixture("amf3-xml.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == '<parent><child prop="test"/></parent>'
+        first_request_eq('amf3-xml.bin', '<parent><child prop="test"/></parent>')
       end
     end
 
-    describe "objects" do
-      it "should deserialize an unmapped object as a dynamic anonymous object" do
-        input = object_fixture("amf3-dynamic-object.bin")
-        output = RocketAMF.deserialize(input, 3)
+    describe 'objects' do
+      it 'should deserialize an unmapped object as a dynamic anonymous object' do
+
+        value =
+            {
+                'property_one'            => 'foo',
+                'nil_property'            => nil,
+                'another_public_property' => 'a_public_value'
+            }
 
-        expected = {
-          'property_one' => 'foo',
-          'nil_property' => nil,
-          'another_public_property' => 'a_public_value'
-        }
-        output.should == expected
-        output.type.should == ""
+        request = get_first_request('amf3-dynamic-object.bin')
+
+        expect(request).to match(value)
+        expect(request.type).to eq('')
       end
 
-      it "should deserialize a mapped object as a mapped ruby class instance" do
-        RocketAMF::ClassMapper.define {|m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass'}
+      it 'should deserialize a mapped object as a mapped ruby class instance' do
+        RocketAMF::CLASS_MAPPER.define { |m| m.map :as => 'org.amf.ASClass', ruby: 'RubyClass' }
 
-        input = object_fixture("amf3-typed-object.bin")
-        output = RocketAMF.deserialize(input, 3)
+        request = get_first_request('amf3-typed-object.bin')
 
-        output.should be_a(RubyClass)
-        output.foo.should == 'bar'
-        output.baz.should == nil
+        expect(request).to be_a(RubyClass)
+        expect(request.foo).to eq('bar')
+        expect(request.baz).to eq(nil)
       end
 
-      it "should deserialize externalizable objects" do
-        RocketAMF::ClassMapper.define {|m| m.map :as => 'ExternalizableTest', :ruby => 'ExternalizableTest'}
+      it 'should deserialize externalizable objects' do
+        RocketAMF::CLASS_MAPPER.define { |m| m.map :as => 'ExternalizableTest', ruby: 'ExternalizableTest' }
 
-        input = object_fixture("amf3-externalizable.bin")
-        output = RocketAMF.deserialize(input, 3)
+        request = get_first_request('amf3-externalizable.bin')
 
-        output.length.should == 2
-        output[0].one.should == 5
-        output[1].two.should == 5
+        expect(request.length).to eq(2)
+        expect(request[0].one).to eq(5)
+        expect(request[1].two).to eq(5)
       end
 
-      it "should deserialize a hash as a dynamic anonymous object" do
-        input = object_fixture("amf3-hash.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == {'foo' => "bar", 'answer' => 42}
+      it 'should deserialize a hash as a dynamic anonymous object' do
+        first_request_eq('amf3-hash.bin', {'foo' => 'bar', 'answer' => 42})
       end
 
-      it "should deserialize an empty array" do
-        input = object_fixture("amf3-empty-array.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == []
+      it 'should deserialize an empty array' do
+        request = get_first_request('amf3-empty-array.bin')
+        expect(request).to match_array([])
       end
 
-      it "should deserialize an array of primitives" do
-        input = object_fixture("amf3-primitive-array.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == [1,2,3,4,5]
+      it 'should deserialize an array of primitives' do
+        request = get_first_request('amf3-primitive-array.bin')
+        expect(request).to match_array([1, 2, 3, 4, 5])
       end
 
-      it "should deserialize an associative array" do
-        input = object_fixture("amf3-associative-array.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == {0=>"bar1", 1=>"bar2", 2=>"bar3", "asdf"=>"fdsa", "foo"=>"bar", "42"=>"bar"}
+      it 'should deserialize an associative array' do
+        request = get_first_request('amf3-associative-array.bin')
+        expect(request).to match({0 => 'bar1', 1 => 'bar2', 2 => 'bar3', 'asdf' => 'fdsa', 'foo' => 'bar', '42' => 'bar'})
       end
 
-      it "should deserialize an array of mixed objects" do
-        input = object_fixture("amf3-mixed-array.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should deserialize an array of mixed objects' do
+        request = get_first_request('amf3-mixed-array.bin')
 
-        h1 = {'foo_one' => "bar_one"}
-        h2 = {'foo_two' => ""}
+        h1  = {'foo_one' => 'bar_one'}
+        h2  = {'foo_two' => ''}
         so1 = {'foo_three' => 42}
-        output.should == [h1, h2, so1, {}, [h1, h2, so1], [], 42, "", [], "", {}, "bar_one", so1]
+        expect(request).to match_array([h1, h2, so1, {}, [h1, h2, so1], [], 42, '', [], '', {}, 'bar_one', so1])
       end
 
-      it "should deserialize an array collection as an array" do
-        input = object_fixture("amf3-array-collection.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should deserialize an array collection as an array' do
+        request = get_first_request('amf3-array-collection.bin')
 
-        output.class.should == Array
-        output.should == ["foo", "bar"]
+        expect(request.class).to eq(Array)
+        expect(request).to match_array(%w( foo bar ))
       end
 
-      it "should deserialize a complex set of array collections" do
-        RocketAMF::ClassMapper.define {|m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass'}
-        input = object_fixture('amf3-complex-array-collection.bin')
+      it 'should deserialize a complex set of array collections' do
+        RocketAMF::CLASS_MAPPER.define { |m| m.map :as => 'org.amf.ASClass', ruby: 'RubyClass' }
 
-        output = RocketAMF.deserialize(input, 3)
+        request = get_first_request('amf3-complex-array-collection.bin')
 
-        output[0].should == ["foo", "bar"]
-        output[1][0].should be_a(RubyClass)
-        output[1][1].should be_a(RubyClass)
-        output[2].should === output[1]
+        expect(request[0]).to match_array(%w( foo bar ))
+        expect(request[1][0]).to be_a(RubyClass)
+        expect(request[1][1]).to be_a(RubyClass)
+        expect(request[2]).to eq(request[1])
       end
 
-      it "should deserialize a byte array" do
-        input = object_fixture("amf3-byte-array.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should deserialize a byte array' do
+        request = get_first_request('amf3-byte-array.bin')
 
-        output.should be_a(StringIO)
+        expect(request).to be_a(StringIO)
         expected = "\000\003これtest\100"
-        expected.force_encoding("ASCII-8BIT") if expected.respond_to?(:force_encoding)
-        output.string.should == expected
+        expected.force_encoding('ASCII-8BIT') if expected.respond_to?(:force_encoding)
+        expect(request.string).to eq(expected)
       end
 
-      it "should deserialize an empty dictionary" do
-        input = object_fixture("amf3-empty-dictionary.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == {}
+      it 'should deserialize an empty dictionary' do
+        request = get_first_request('amf3-empty-dictionary.bin')
+        expect(request).to match({})
       end
 
-      it "should deserialize a dictionary" do
-        input = object_fixture("amf3-dictionary.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should deserialize a dictionary' do
+        request = get_first_request('amf3-dictionary.bin')
+
+        keys = request.keys
+        expect(keys.length).to eq(2)
+        obj_key, str_key = keys[0].is_a?(RocketAMF::Types::TypedHash) ? [keys[0], keys[1]] : [keys[1], keys[0]]
 
-        keys = output.keys
-        keys.length.should == 2
-        obj_key, str_key = keys[0].is_a?(RocketAMF::Values::TypedHash) ? [keys[0], keys[1]] : [keys[1], keys[0]]
-        obj_key.type.should == 'org.amf.ASClass'
-        output[obj_key].should == "asdf2"
-        str_key.should == "bar"
-        output[str_key].should == "asdf1"
+        expect(obj_key.type).to eq('org.amf.ASClass')
+        expect(request[obj_key]).to eq('asdf2')
+        expect(str_key).to eq('bar')
+        expect(request[str_key]).to eq('asdf1')
       end
 
-      it "should deserialize Vector.<int>" do
-        input = object_fixture('amf3-vector-int.bin')
-        output = RocketAMF.deserialize(input, 3)
-        output.should == [4, -20, 12]
+      it 'should deserialize Vector.<int>' do
+        request = get_first_request('amf3-vector-int.bin')
+        expect(request).to match_array([4, -20, 12])
       end
 
-      it "should deserialize Vector.<uint>" do
-        input = object_fixture('amf3-vector-uint.bin')
-        output = RocketAMF.deserialize(input, 3)
-        output.should == [4, 20, 12]
+      it 'should deserialize Vector.<uint>' do
+        request = get_first_request('amf3-vector-uint.bin')
+        expect(request).to match_array([4, 20, 12])
       end
 
-      it "should deserialize Vector.<Number>" do
-        input = object_fixture('amf3-vector-double.bin')
-        output = RocketAMF.deserialize(input, 3)
-        output.should == [4.3, -20.6]
+      it 'should deserialize Vector.<Number>' do
+        output = get_first_request('amf3-vector-double.bin')
+        expect(output).to match_array([4.3, -20.6])
       end
 
-      it "should deserialize Vector.<Object>" do
-        input = object_fixture('amf3-vector-object.bin')
-        output = RocketAMF.deserialize(input, 3)
-        output[0]['foo'].should == 'foo'
-        output[1].type.should == 'org.amf.ASClass'
-        output[2]['foo'].should == 'baz'
+      it 'should deserialize Vector.<Object>' do
+        output = get_first_request('amf3-vector-object.bin')
+
+        expect(output[0]['foo']).to eq('foo')
+        expect(output[1].type).to eq('org.amf.ASClass')
+        expect(output[2]['foo']).to eq('baz')
       end
     end
 
-    describe "and implementing the AMF Spec" do
-      it "should keep references of duplicate strings" do
-        input = object_fixture("amf3-string-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
+    describe 'and implementing the AMF Spec' do
+      it 'should keep references of duplicate strings' do
+        output = get_first_request('amf3-string-ref.bin')
 
-        foo = "foo"
-        bar = "str"
-        output.should == [foo, bar, foo, bar, foo, {'str' => "foo"}]
+        foo = 'foo'
+        bar = 'str'
+        expect(output).to match_array([foo, bar, foo, bar, foo, {'str' => 'foo'}])
       end
 
-      it "should not reference the empty string" do
-        input = object_fixture("amf3-empty-string-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == ["",""]
+      it 'should not reference the empty string' do
+        output = get_first_request('amf3-empty-string-ref.bin')
+        expect(output).to match_array(['', ''])
       end
 
-      it "should keep references of duplicate dates" do
-        input = object_fixture("amf3-date-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should keep references of duplicate dates' do
+        output = get_first_request('amf3-date-ref.bin')
 
-        output[0].should == Time.at(0)
-        output[0].should equal(output[1])
+        expect(output[0]).to eq(Time.at(0))
+        expect(output[0]).to eq(output[1])
         # Expected object:
-        # [DateTime.parse "1/1/1970", DateTime.parse "1/1/1970"]
+        # [DateTime.parse '1/1/1970', DateTime.parse '1/1/1970']
       end
 
-      it "should keep reference of duplicate objects" do
-        input = object_fixture("amf3-object-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should keep reference of duplicate objects' do
+        output = get_first_request('amf3-object-ref.bin')
 
-        obj1 = {'foo' => "bar"}
+        obj1 = {'foo' => 'bar'}
         obj2 = {'foo' => obj1['foo']}
-        output.should == [[obj1, obj2], "bar", [obj1, obj2]]
+
+        expect(output).to match_array([[obj1, obj2], 'bar', [obj1, obj2]])
       end
 
-      it "should keep reference of duplicate object traits" do
-        RocketAMF::ClassMapper.define {|m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass'}
+      it 'should keep reference of duplicate object traits' do
+        RocketAMF::CLASS_MAPPER.define { |m| m.map :as => 'org.amf.ASClass', ruby: 'RubyClass' }
 
-        input = object_fixture("amf3-trait-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
+        output = get_first_request('amf3-trait-ref.bin')
 
-        output[0].foo.should == "foo"
-        output[1].foo.should == "bar"
+        expect(output[0].foo).to eq('foo')
+        expect(output[1].foo).to eq('bar')
       end
 
-      it "should keep references of duplicate arrays" do
-        input = object_fixture("amf3-array-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should keep references of duplicate arrays' do
+        output = get_first_request('amf3-array-ref.bin')
 
-        a = [1,2,3]
+        a = [1, 2, 3]
         b = %w{ a b c }
-        output.should == [a, b, a, b]
+        expect(output).to match_array([a, b, a, b])
       end
 
-      it "should not keep references of duplicate empty arrays unless the object_id matches" do
-        input = object_fixture("amf3-empty-array-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should not keep references of duplicate empty arrays unless the object_id matches' do
+        output = get_first_request('amf3-empty-array-ref.bin')
 
         a = []
         b = []
-        output.should == [a,b,a,b]
+        expect(output).to match_array([a, b, a, b])
       end
 
-      it "should keep references of duplicate XML and XMLDocuments" do
-        input = object_fixture("amf3-xml-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output.should == ['<parent><child prop="test"/></parent>', '<parent><child prop="test"/></parent>']
+      it 'should keep references of duplicate XML and XMLDocuments' do
+        request = get_first_request('amf3-xml-ref.bin')
+        expect(request).to match_array(['<parent><child prop="test"/></parent>', '<parent><child prop="test"/></parent>'])
       end
 
-      it "should keep references of duplicate byte arrays" do
-        input = object_fixture("amf3-byte-array-ref.bin")
-        output = RocketAMF.deserialize(input, 3)
-        output[0].object_id.should == output[1].object_id
-        output[0].string.should == "ASDF"
+      it 'should keep references of duplicate byte arrays' do
+        output = get_first_request('amf3-byte-array-ref.bin')
+
+        expect(output[0].object_id).to eq(output[1].object_id)
+        expect(output[0].string).to eq('ASDF')
       end
 
-      it "should deserialize a deep object graph with circular references" do
-        input = object_fixture("amf3-graph-member.bin")
-        output = RocketAMF.deserialize(input, 3)
+      it 'should deserialize a deep object graph with circular references' do
+
+        output = get_first_request('amf3-graph-member.bin')
 
-        output['children'][0]['parent'].should === output
-        output['parent'].should === nil
-        output['children'].length.should == 2
+        expect(output['children'][0]['parent']).to eq(output)
+        expect(output['parent']).to eq(nil)
+        expect(output['children'].length).to eq(2)
         # Expected object:
         # parent = Hash.new
         # child1 = Hash.new