mrpin-rocketamf 1.0.4 → 2.0.0

data/spec/fast_class_mapping_spec.rb

@@ -1,116 +1,118 @@
-require "spec_helper.rb"
+require 'spec_helper.rb'
 
 describe RocketAMF::Ext::FastClassMapping do
   before :each do
     RocketAMF::Ext::FastClassMapping.reset
     RocketAMF::Ext::FastClassMapping.define do |m|
-      m.map :as => 'ASClass', :ruby => 'ClassMappingTest'
+      m.map :as => 'ASClass', ruby: 'ClassMappingTest'
     end
     @mapper = RocketAMF::Ext::FastClassMapping.new
   end
 
-  describe "class name mapping" do
-    it "should allow resetting of mappings back to defaults" do
+  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
       RocketAMF::Ext::FastClassMapping.reset
       @mapper = RocketAMF::Ext::FastClassMapping.new
       @mapper.get_as_class_name('ClassMappingTest').should be_nil
-      @mapper.get_as_class_name('RocketAMF::Values::AcknowledgeMessage').should_not be_nil
+      @mapper.get_as_class_name('RocketAMF::Types::AcknowledgeMessage').should_not be_nil
     end
 
-    it "should return AS class name for ruby objects" do
+    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(RocketAMF::Types::TypedHash.new('ClassMappingTest')).should == 'ASClass'
       @mapper.get_as_class_name('BadClass').should be_nil
     end
 
-    it "should instantiate a ruby class" do
+    it 'should instantiate a ruby class' do
       @mapper.get_ruby_obj('ASClass').should be_a(ClassMappingTest)
     end
 
-    it "should properly instantiate namespaced classes" do
-      RocketAMF::Ext::FastClassMapping.mappings.map :as => 'ASClass', :ruby => 'ANamespace::TestRubyClass'
+    it 'should properly instantiate namespaced classes' do
+      RocketAMF::Ext::FastClassMapping.mappings.map :as => 'ASClass', ruby: 'ANamespace::TestRubyClass'
       @mapper = RocketAMF::Ext::FastClassMapping.new
       @mapper.get_ruby_obj('ASClass').should 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.should be_a(RocketAMF::Types::TypedHash)
       obj.type.should == '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)
+        @mapper.get_ruby_obj(as_class).should_not 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
       end
     end
 
-    it "should allow config modification" do
-      RocketAMF::Ext::FastClassMapping.mappings.map :as => 'SecondClass', :ruby => 'ClassMappingTest'
+    it 'should allow config modification' do
+      RocketAMF::Ext::FastClassMapping.mappings.map :as => 'SecondClass', ruby: 'ClassMappingTest'
       @mapper = RocketAMF::Ext::FastClassMapping.new
       @mapper.get_as_class_name(ClassMappingTest.new).should == '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'
     end
 
-    it "should populate a typed hash" do
-      obj = @mapper.populate_ruby_obj RocketAMF::Values::TypedHash.new('UnmappedClass'), {'prop_a' => 'Data'}
+    it 'should populate a typed hash' do
+      obj = @mapper.populate_ruby_obj RocketAMF::Types::TypedHash.new('UnmappedClass'), {'prop_a' => 'Data'}
       obj['prop_a'].should == 'Data'
     end
   end
 
-  describe "property extractor" do
+  describe 'property extractor' do
     # Use symbol keys for properties in Ruby >1.9
     def prop_hash hash
       out = {}
       if RUBY_VERSION =~ /^1\.8/
-        hash.each {|k,v| out[k.to_s] = v}
+        hash.each { |k, v| out[k.to_s] = v }
       else
-        hash.each {|k,v| out[k.to_sym] = v}
+        hash.each { |k, v| out[k.to_sym] = v }
       end
       out
     end
 
-    it "should return hash without modification" do
-      hash = {:a => 'test1', 'b' => 'test2'}
+    it 'should return hash without modification' do
+      hash  = {:a => 'test1', 'b' => 'test2'}
       props = @mapper.props_for_serialization(hash)
       props.should === hash
     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_hash({'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'
 
@@ -118,26 +120,30 @@ describe RocketAMF::Ext::FastClassMapping do
       hash.should == prop_hash({'prop_a' => 'Test A', 'prop_b' => nil, 'prop_c' => 'Test C'})
     end
 
-    it "should cache property lookups by instance" do
-      class ClassMappingTest3; attr_accessor :prop_a; end;
+    it 'should cache property lookups by instance' do
+      class ClassMappingTest3;
+        attr_accessor :prop_a;
+      end;
 
       # Cache properties
-      obj = ClassMappingTest3.new
+      obj  = ClassMappingTest3.new
       hash = @mapper.props_for_serialization obj
 
       # Add a method to ClassMappingTest3
-      class ClassMappingTest3; attr_accessor :prop_b; end;
+      class ClassMappingTest3;
+        attr_accessor :prop_b;
+      end;
 
       # Test property list does not have new property
-      obj = ClassMappingTest3.new
+      obj        = ClassMappingTest3.new
       obj.prop_a = 'Test A'
       obj.prop_b = 'Test B'
-      hash = @mapper.props_for_serialization obj
+      hash       = @mapper.props_for_serialization obj
       hash.should == prop_hash({'prop_a' => 'Test A'})
 
       # Test that new class mapper *does* have new property (cache per instance)
       @mapper = RocketAMF::Ext::FastClassMapping.new
-      hash = @mapper.props_for_serialization obj
+      hash    = @mapper.props_for_serialization obj
       hash.should == prop_hash({'prop_a' => 'Test A', 'prop_b' => 'Test B'})
     end
   end

data/spec/helpers/class_mapping_test.rb

@@ -0,0 +1,4 @@
+class ClassMappingTest
+  attr_accessor :prop_a
+  attr_accessor :prop_b
+end

data/spec/helpers/class_mapping_test2.rb

@@ -0,0 +1,3 @@
+class ClassMappingTest2 < ClassMappingTest
+  attr_accessor :prop_c
+end

data/spec/helpers/externalizable_test.rb

@@ -0,0 +1,24 @@
+class ExternalizableTest
+  include RocketAMF::Pure::IOHelperRead
+  include RocketAMF::Pure::IOHelperWrite
+
+  attr_accessor :one, :two
+
+  #
+  # Methods
+  #
+
+  def encode_amf(serializer)
+    serializer.write_object(self, nil, {class_name: 'ExternalizableTest', dynamic: false, externalizable: true, members: []})
+  end
+
+  def read_external(deserializer)
+    @one = read_double(deserializer.source)
+    @two = read_double(deserializer.source)
+  end
+
+  def write_external(serializer)
+    serializer.stream << pack_double(@one)
+    serializer.stream << pack_double(@two)
+  end
+end

data/spec/helpers/fixtures.rb

@@ -0,0 +1,28 @@
+def request_fixture(binary_path)
+  data = File.open(File.dirname(__FILE__) + '/../fixtures/request/' + binary_path, 'rb').read
+  data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding)
+  data
+end
+
+def object_fixture(binary_path)
+  data = File.open(File.dirname(__FILE__) + '/../fixtures/objects/' + binary_path, 'rb').read
+  data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding)
+  data
+end
+
+def first_request_eq(object_fixture, value)
+  input  = object_fixture(object_fixture)
+  output = RocketAMF.deserialize(input)
+
+  request = output[:requests][0]
+
+  expect(request).to eq(value)
+end
+
+def get_first_request(object_fixture)
+  input  = object_fixture(object_fixture)
+  output = RocketAMF.deserialize(input)
+
+  requests = output[:requests]
+  requests[0]
+end

data/spec/helpers/other_class.rb

@@ -0,0 +1,4 @@
+class OtherClass;
+  attr_accessor :bar
+  attr_accessor :foo
+end

data/spec/helpers/ruby_class.rb

@@ -0,0 +1,4 @@
+class RubyClass;
+  attr_accessor :baz
+  attr_accessor :foo
+end

data/spec/helpers/test_ruby_class.rb

@@ -0,0 +1,4 @@
+module ANamespace
+  class TestRubyClass
+  end
+end

data/spec/serializer_spec.rb

@@ -1,229 +1,128 @@
 # encoding: UTF-8
 
-require "spec_helper.rb"
+require 'spec_helper.rb'
 require 'rexml/document'
 require 'bigdecimal'
 require 'rational'
 
-describe "when serializing" do
+describe 'when serializing' do
   before :each do
-    RocketAMF::ClassMapper.reset
+    RocketAMF::CLASS_MAPPER.reset
   end
 
-  it "should raise exception with invalid version number" do
-    lambda {
-      RocketAMF.serialize("", 5)
-    }.should raise_error("unsupported version 5")
-  end
-
-  describe "AMF0" do
-    it "should serialize nils" do
-      output = RocketAMF.serialize(nil, 0)
-      output.should == object_fixture('amf0-null.bin')
-    end
-
-    it "should serialize booleans" do
-      output = RocketAMF.serialize(true, 0)
-      output.should === object_fixture('amf0-boolean.bin')
-    end
-
-    it "should serialize numbers" do
-      output = RocketAMF.serialize(3.5, 0)
-      output.should == object_fixture('amf0-number.bin')
-    end
-
-    it "should serialize Numeric conformers" do
-      output = RocketAMF.serialize(BigDecimal.new("3.5"), 0)
-      output.should == object_fixture('amf0-number.bin')
-    end
-
-    it "should serialize strings" do
-      output = RocketAMF.serialize("this is a テスト", 0)
-      output.should == object_fixture('amf0-string.bin')
-    end
-
-    it "should serialize frozen strings" do
-      output = RocketAMF.serialize("this is a テスト".freeze, 0)
-      output.should == object_fixture('amf0-string.bin')
-    end
-
-    it "should serialize arrays" do
-      output = RocketAMF.serialize(['a', 'b', 'c', 'd'], 0)
-      output.should == object_fixture('amf0-strict-array.bin')
-    end
-
-    it "should serialize references" do
-      obj = OtherClass.new
-      obj.foo = "baz"
-      obj.bar = 3.14
-
-      output = RocketAMF.serialize({'0' => obj, '1' => obj}, 0)
-      output.should == object_fixture('amf0-ref-test.bin')
-    end
-
-    it "should serialize Time objects" do
-      output = RocketAMF.serialize(Time.utc(2003, 2, 13, 5), 0)
-      output.bytesize.should == 11
-      output[0,9].should == object_fixture('amf0-time.bin')[0,9] # Ignore TZ
-    end
-
-    it "should serialize Date objects" do
-      output = RocketAMF.serialize(Date.civil(2020, 5, 30), 0)
-      output.bytesize.should == 11
-      output[0,9].should == object_fixture('amf0-date.bin')[0,9] # Ignore TZ
-    end
-
-    it "should serialize DateTime objects" do
-      output = RocketAMF.serialize(DateTime.civil(2003, 2, 13, 5), 0)
-      output.bytesize.should == 11
-      output[0,9].should == object_fixture('amf0-time.bin')[0,9] # Ignore TZ
-    end
-
-    it "should serialize hashes as objects" do
-      output = RocketAMF.serialize({:baz => nil, "foo" => "bar"}, 0)
-      output.should == object_fixture('amf0-untyped-object.bin')
-    end
-
-    it "should serialize unmapped objects" do
-      obj = RubyClass.new
-      obj.foo = "bar"
-
-      output = RocketAMF.serialize(obj, 0)
-      output.should == object_fixture('amf0-untyped-object.bin')
-    end
-
-    it "should serialize mapped objects" do
-      obj = RubyClass.new
-      obj.foo = "bar"
-      RocketAMF::ClassMapper.define {|m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass'}
-
-      output = RocketAMF.serialize(obj, 0)
-      output.should == object_fixture('amf0-typed-object.bin')
-    end
-
-    describe "and handling encodings", :if => "".respond_to?(:force_encoding) do
-      it "should support multiple encodings" do
-        shift_str = "\x53\x68\x69\x66\x74\x20\x83\x65\x83\x58\x83\x67".force_encoding("Shift_JIS") # "Shift テスト"
-        utf_str = "\x55\x54\x46\x20\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88".force_encoding("UTF-8") # "UTF テスト"
-        output = RocketAMF.serialize({:shift => shift_str, :utf => utf_str, :zed => 5}, 0)
-        output.should == object_fixture("amf0-complex-encoded-string.bin")
-      end
-    end
-  end
-
-  describe "AMF3" do
-    describe "simple messages" do
-      it "should serialize a null" do
-        expected = object_fixture("amf3-null.bin")
-        output = RocketAMF.serialize(nil, 3)
-        output.should == expected
+  describe 'AMF3' do
+    describe 'simple messages' do
+      it 'should serialize a null' do
+        expected = object_fixture('amf3-null.bin')
+        output   = RocketAMF.serialize(nil)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a false" do
-        expected = object_fixture("amf3-false.bin")
-        output = RocketAMF.serialize(false, 3)
-        output.should == expected
+      it 'should serialize a false' do
+        expected = object_fixture('amf3-false.bin')
+        output   = RocketAMF.serialize(false)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a true" do
-        expected = object_fixture("amf3-true.bin")
-        output = RocketAMF.serialize(true, 3)
-        output.should == expected
+      it 'should serialize a true' do
+        expected = object_fixture('amf3-true.bin')
+        output   = RocketAMF.serialize(true)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize integers" do
-        expected = object_fixture("amf3-max.bin")
-        input = RocketAMF::MAX_INTEGER
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize integers' do
+        expected = object_fixture('amf3-max.bin')
+        input    = RocketAMF::MAX_INTEGER
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
 
-        expected = object_fixture("amf3-0.bin")
-        output = RocketAMF.serialize(0, 3)
-        output.should == expected
+        expected = object_fixture('amf3-0.bin')
+        output   = RocketAMF.serialize(0)
+        expect(output).to eq(expected)
 
-        expected = object_fixture("amf3-min.bin")
-        input = RocketAMF::MIN_INTEGER
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-min.bin')
+        input    = RocketAMF::MIN_INTEGER
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize large integers" do
-        expected = object_fixture("amf3-large-max.bin")
-        input = RocketAMF::MAX_INTEGER + 1
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize large integers' do
+        expected = object_fixture('amf3-large-max.bin')
+        input    = RocketAMF::MAX_INTEGER + 1
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
 
-        expected = object_fixture("amf3-large-min.bin")
-        input = RocketAMF::MIN_INTEGER - 1
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-large-min.bin')
+        input    = RocketAMF::MIN_INTEGER - 1
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize floats" do
-        expected = object_fixture("amf3-float.bin")
-        input = 3.5
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize floats' do
+        expected = object_fixture('amf3-float.bin')
+        input    = 3.5
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize BigNums" do
-        expected = object_fixture("amf3-bigNum.bin")
-        input = 2**1000
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize BigNums' do
+        expected = object_fixture('amf3-bigNum.bin')
+        input    = 2**1000
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize float Numeric conformers" do
-        expected = object_fixture("amf3-float.bin")
-        input = Rational(7, 2) # 3.5
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize float Numeric conformers' do
+        expected = object_fixture('amf3-float.bin')
+        input    = Rational(7, 2) # 3.5
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a simple string" do
-        expected = object_fixture("amf3-string.bin")
-        input = "String . String"
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize a simple string' do
+        expected = object_fixture('amf3-string.bin')
+        input    = 'String . String'
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a frozen string" do
-        expected = object_fixture("amf3-string.bin")
-        input = "String . String".freeze
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize a frozen string' do
+        expected = object_fixture('amf3-string.bin')
+        input    = 'String . String'.freeze
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a symbol as a string" do
-        expected = object_fixture("amf3-symbol.bin")
-        output = RocketAMF.serialize(:foo, 3)
-        output.should == expected
+      it 'should serialize a symbol as a string' do
+        expected = object_fixture('amf3-symbol.bin')
+        output   = RocketAMF.serialize(:foo)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize Time objects" do
-        expected = object_fixture("amf3-date.bin")
-        input = Time.utc 1970, 1, 1, 0
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize Time objects' do
+        expected = object_fixture('amf3-date.bin')
+        input    = Time.utc 1970, 1, 1, 0
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize Date objects" do
-        expected = object_fixture("amf3-date.bin")
-        input = Date.civil 1970, 1, 1, 0
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize Date objects' do
+        expected = object_fixture('amf3-date.bin')
+        input    = Date.civil 1970, 1, 1, 0
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize DateTime objects" do
-        expected = object_fixture("amf3-date.bin")
-        input = DateTime.civil 1970, 1, 1, 0
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize DateTime objects' do
+        expected = object_fixture('amf3-date.bin')
+        input    = DateTime.civil 1970, 1, 1, 0
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
     end
 
-    describe "objects" do
-      it "should serialize an unmapped object as a dynamic anonymous object" do
+    describe 'objects' do
+      it 'should serialize an unmapped object as a dynamic anonymous object' do
         class NonMappedObject
           def another_public_property
             'a_public_value'
@@ -233,221 +132,229 @@ describe "when serializing" do
           attr_accessor :property_one
           attr_writer :read_only_prop
 
-          def method_with_arg arg='foo'
+          def method_with_arg(arg = 'foo')
             arg
           end
         end
-        obj = NonMappedObject.new
+        obj              = NonMappedObject.new
         obj.property_one = 'foo'
         obj.nil_property = nil
 
-        expected = object_fixture("amf3-dynamic-object.bin")
-        input = obj
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-dynamic-object.bin')
+        input    = obj
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize externalizable objects" do
-        a = ExternalizableTest.new
+      it 'should serialize externalizable objects' do
+        a     = ExternalizableTest.new
         a.one = 5
         a.two = 7
-        b = ExternalizableTest.new
+        b     = ExternalizableTest.new
         b.one = 13
         b.two = 5
-        obj = [a, b]
+        obj   = [a, b]
 
-        expected = object_fixture("amf3-externalizable.bin")
-        input = obj
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-externalizable.bin')
+        input    = obj
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a hash as a dynamic anonymous object" do
-        hash = {}
+      it 'should serialize a hash as a dynamic anonymous object' do
+        hash          = {}
         hash[:answer] = 42
-        hash['foo'] = "bar"
+        hash['foo']   = 'bar'
 
-        expected = object_fixture("amf3-hash.bin")
-        input = hash
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-hash.bin')
+        input    = hash
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize an empty array" do
-        expected = object_fixture("amf3-empty-array.bin")
-        input = []
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize an empty array' do
+        expected = object_fixture('amf3-empty-array.bin')
+        input    = []
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize an array of primatives" do
-        expected = object_fixture("amf3-primitive-array.bin")
-        input = [1, 2, 3, 4, 5]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize an array of primatives' do
+        expected = object_fixture('amf3-primitive-array.bin')
+        input    = [1, 2, 3, 4, 5]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize an array of mixed objects" do
-        h1 = {:foo_one => "bar_one"}
-        h2 = {:foo_two => ""}
+      it 'should serialize an array of mixed objects' do
+        h1 = {:foo_one => 'bar_one'}
+        h2 = {:foo_two => ''}
         class SimpleObj
           attr_accessor :foo_three
         end
-        so1 = SimpleObj.new
+        so1           = SimpleObj.new
         so1.foo_three = 42
 
-        expected = object_fixture("amf3-mixed-array.bin")
-        input = [h1, h2, so1, {}, [h1, h2, so1], [], 42, "", [], "", {}, "bar_one", so1]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-mixed-array.bin')
+        input    = [h1, h2, so1, {}, [h1, h2, so1], [], 42, '', [], '', {}, 'bar_one', so1]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize an array as an array collection" do
-        expected = object_fixture('amf3-array-collection.bin')
+      it 'should serialize an array as an array collection' do
+        expected                                     = object_fixture('amf3-array-collection.bin')
 
         # Test global
-        RocketAMF::ClassMapper.use_array_collection = true
-        input = ["foo", "bar"]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
-        RocketAMF::ClassMapper.use_array_collection = false
+        RocketAMF::CLASS_MAPPER.use_array_collection = true
+        input                                        = %w( foo bar )
+        output                                       = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
+        RocketAMF::CLASS_MAPPER.use_array_collection = false
 
         # Test override
-        input = ["foo", "bar"]
-        input.is_array_collection = true
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        input                                        = %w( foo bar )
+        input.is_array_collection                    = true
+        output                                       = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a complex set of array collections" do
-        RocketAMF::ClassMapper.define {|m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass'}
+      it 'should serialize a complex set of array collections' do
+        RocketAMF::CLASS_MAPPER.define { |m| m.map :as => 'org.amf.ASClass', :ruby => 'RubyClass' }
         expected = object_fixture('amf3-complex-array-collection.bin')
 
-        a = ["foo", "bar"]
+        a                     = %w(foo bar)
         a.is_array_collection = true
-        obj1 = RubyClass.new
-        obj1.foo = "bar"
-        def obj1.encode_amf serializer
-          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, :members => ["baz", "foo"]})
+        obj1                  = RubyClass.new
+        obj1.foo              = 'bar'
+
+        def obj1.encode_amf(serializer)
+          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, members: %w( baz foo )})
         end
-        obj2 = RubyClass.new
-        obj2.foo = "asdf"
-        def obj2.encode_amf serializer
-          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, :members => ["baz", "foo"]})
+
+        obj2     = RubyClass.new
+        obj2.foo = 'asdf'
+
+        def obj2.encode_amf(serializer)
+          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, members: %w( baz foo )})
         end
-        b = [obj1, obj2]
+
+        b                     = [obj1, obj2]
         b.is_array_collection = true
-        input = [a, b, b]
+        input                 = [a, b, b]
 
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        output = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a byte array" do
-        expected = object_fixture("amf3-byte-array.bin")
-        str = "\000\003これtest\100"
-        str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
-        input = StringIO.new(str)
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+      it 'should serialize a byte array' do
+        expected = object_fixture('amf3-byte-array.bin')
+        str      = "\000\003これtest\100"
+        str.force_encoding('ASCII-8BIT') if str.respond_to?(:force_encoding)
+        input  = StringIO.new(str)
+        output = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
     end
 
-    describe "and implementing the AMF Spec" do
-      it "should keep references of duplicate strings" do
+    describe 'and implementing the AMF Spec' do
+      it 'should keep references of duplicate strings' do
         class StringCarrier
           attr_accessor :str
         end
-        foo = "foo"
-        bar = "str"
-        sc = StringCarrier.new
+        foo    = 'foo'
+        bar    = 'str'
+        sc     = StringCarrier.new
         sc.str = foo
 
-        expected = object_fixture("amf3-string-ref.bin")
-        input = [foo, bar, foo, bar, foo, sc]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-string-ref.bin')
+        input    = [foo, bar, foo, bar, foo, sc]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should not reference the empty string" do
-        expected = object_fixture("amf3-empty-string-ref.bin")
-        input = ""
-        output = RocketAMF.serialize([input,input], 3)
-        output.should == expected
+      it 'should not reference the empty string' do
+        expected = object_fixture('amf3-empty-string-ref.bin')
+        input    = ''
+        output   = RocketAMF.serialize([input, input])
+        expect(output).to eq(expected)
       end
 
-      it "should keep references of duplicate dates" do
-        expected = object_fixture("amf3-date-ref.bin")
-        input = Time.utc 1970, 1, 1, 0
-        output = RocketAMF.serialize([input,input], 3)
-        output.should == expected
+      it 'should keep references of duplicate dates' do
+        expected = object_fixture('amf3-date-ref.bin')
+        input    = Time.utc 1970, 1, 1, 0
+        output   = RocketAMF.serialize([input, input])
+        expect(output).to eq(expected)
       end
 
-      it "should keep reference of duplicate objects" do
+      it 'should keep reference of duplicate objects' do
         class SimpleReferenceableObj
           attr_accessor :foo
         end
-        obj1 = SimpleReferenceableObj.new
+        obj1     = SimpleReferenceableObj.new
         obj1.foo = :bar
-        obj2 = SimpleReferenceableObj.new
+        obj2     = SimpleReferenceableObj.new
         obj2.foo = obj1.foo
 
-        expected = object_fixture("amf3-object-ref.bin")
-        input = [[obj1, obj2], "bar", [obj1, obj2]]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-object-ref.bin')
+        input    = [[obj1, obj2], 'bar', [obj1, obj2]]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should keep reference of duplicate object traits" do
-        obj1 = RubyClass.new
-        obj1.foo = "foo"
-        def obj1.encode_amf serializer
-          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, :members => ["baz", "foo"]})
+      it 'should keep reference of duplicate object traits' do
+        obj1     = RubyClass.new
+        obj1.foo = 'foo'
+
+        def obj1.encode_amf(serializer)
+          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, :members => %w( baz foo )})
         end
-        obj2 = RubyClass.new
-        obj2.foo = "bar"
-        def obj2.encode_amf serializer
-          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, :members => ["baz", "foo"]})
+
+        obj2     = RubyClass.new
+        obj2.foo = 'bar'
+
+        def obj2.encode_amf(serializer)
+          serializer.write_object(self, nil, {:class_name => 'org.amf.ASClass', :dynamic => false, :externalizable => false, :members => %w( baz foo )})
         end
+
         input = [obj1, obj2]
 
-        expected = object_fixture("amf3-trait-ref.bin")
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-trait-ref.bin')
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should keep references of duplicate arrays" do
-        a = [1,2,3]
+      it 'should keep references of duplicate arrays' do
+        a = [1, 2, 3]
         b = %w{ a b c }
 
-        expected = object_fixture("amf3-array-ref.bin")
-        input = [a, b, a, b]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-array-ref.bin')
+        input    = [a, b, a, b]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should not keep references of duplicate empty arrays unless the object_id matches" do
+      it 'should not keep references of duplicate empty arrays unless the object_id matches' do
         a = []
         b = []
-        a.should == b
-        a.object_id.should_not == b.object_id
+        expect(a).to eq(b)
+        expect(a.object_id).not_to eq(b.object_id)
 
-        expected = object_fixture("amf3-empty-array-ref.bin")
-        input = [a,b,a,b]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-empty-array-ref.bin')
+        input    = [a, b, a, b]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should keep references of duplicate byte arrays" do
-        b = StringIO.new "ASDF"
+      it 'should keep references of duplicate byte arrays' do
+        b = StringIO.new 'ASDF'
 
-        expected = object_fixture("amf3-byte-array-ref.bin")
-        input = [b, b]
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-byte-array-ref.bin')
+        input    = [b, b]
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
 
-      it "should serialize a deep object graph with circular references" do
+      it 'should serialize a deep object graph with circular references' do
         class GraphMember
           attr_accessor :children
           attr_accessor :parent
@@ -456,7 +363,7 @@ describe "when serializing" do
             self.children = []
           end
 
-          def add_child child
+          def add_child(child)
             children << child
             child.parent = self
             child
@@ -464,39 +371,41 @@ describe "when serializing" do
         end
 
         parent = GraphMember.new
-        level_1_child_1 = parent.add_child GraphMember.new
-        level_1_child_2 = parent.add_child GraphMember.new
+        #level_1_child_1
+        parent.add_child(GraphMember.new)
+        #level_1_child_2
+        parent.add_child(GraphMember.new)
 
-        expected = object_fixture("amf3-graph-member.bin")
-        input = parent
-        output = RocketAMF.serialize(input, 3)
-        output.should == expected
+        expected = object_fixture('amf3-graph-member.bin')
+        input    = parent
+        output   = RocketAMF.serialize(input)
+        expect(output).to eq(expected)
       end
     end
 
-    describe "and handling encodings", :if => "".respond_to?(:force_encoding) do
-      it "should support multiple encodings" do
-        shift_str = "\x53\x68\x69\x66\x74\x20\x83\x65\x83\x58\x83\x67".force_encoding("Shift_JIS") # "Shift テスト"
-        utf_str = "\x55\x54\x46\x20\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88".force_encoding("UTF-8") # "UTF テスト"
-        output = RocketAMF.serialize([5, shift_str, utf_str, 5], 3)
-        output.should == object_fixture("amf3-complex-encoded-string-array.bin")
+    describe 'and handling encodings', if: ''.respond_to?(:force_encoding) do
+      it 'should support multiple encodings' do
+        shift_str = "\x53\x68\x69\x66\x74\x20\x83\x65\x83\x58\x83\x67".force_encoding('Shift_JIS') # 'Shift テスト'
+        utf_str   = "\x55\x54\x46\x20\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88".force_encoding('UTF-8') # 'UTF テスト'
+        output    = RocketAMF.serialize([5, shift_str, utf_str, 5])
+        expect(output).to eq(object_fixture('amf3-complex-encoded-string-array.bin'))
       end
 
-      it "should keep references of duplicate strings with different encodings" do
-        # String is "this is a テスト"
-        shift_str = "\x74\x68\x69\x73\x20\x69\x73\x20\x61\x20\x83\x65\x83\x58\x83\x67".force_encoding("Shift_JIS")
-        utf_str   = "\x74\x68\x69\x73\x20\x69\x73\x20\x61\x20\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88".force_encoding("UTF-8")
+      it 'should keep references of duplicate strings with different encodings' do
+        # String is 'this is a テスト'
+        shift_str = "\x74\x68\x69\x73\x20\x69\x73\x20\x61\x20\x83\x65\x83\x58\x83\x67".force_encoding('Shift_JIS')
+        utf_str   = "\x74\x68\x69\x73\x20\x69\x73\x20\x61\x20\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88".force_encoding('UTF-8')
 
-        expected = object_fixture("amf3-encoded-string-ref.bin")
-        output = RocketAMF.serialize([shift_str, utf_str], 3)
-        output.should == expected
+        expected = object_fixture('amf3-encoded-string-ref.bin')
+        output   = RocketAMF.serialize([shift_str, utf_str])
+        expect(output).to eq(expected)
       end
 
-      it "should handle inappropriate UTF-8 characters in byte arrays" do
-        str = "\xff\xff\xff".force_encoding("ASCII-8BIT")
+      it 'should handle inappropriate UTF-8 characters in byte arrays' do
+        str = "\xff\xff\xff".force_encoding('ASCII-8BIT')
         str.freeze # For added amusement
-        output = RocketAMF.serialize(StringIO.new(str), 3)
-        output.should == "\x0c\x07\xff\xff\xff".force_encoding("ASCII-8BIT")
+        output = RocketAMF.serialize(StringIO.new(str))
+        expect(output).to eq("\x0c\x07\xff\xff\xff".force_encoding('ASCII-8BIT'))
       end
     end
   end