mrpin-amf 2.1.8

data/spec/fixtures/objects/complex/amf3-dynamic-object.bin

@@ -0,0 +1,2 @@
+
+
/another_public_propertya_public_valuenil_property
property_onefoo

data/spec/fixtures/objects/complex/amf3-empty-array.bin

@@ -0,0 +1 @@
+	

data/spec/fixtures/objects/complex/amf3-hash.bin

@@ -0,0 +1,2 @@
+
+

data/spec/fixtures/objects/complex/amf3-mixed-array.bin

@@ -0,0 +1,10 @@
+	

+
foo_onebar_one

+
foo_two


+
foo_three*

+

	

+
+
+	

*
	



+


+

data/spec/fixtures/objects/complex/amf3-primitive-array.bin

@@ -0,0 +1 @@
+	



data/spec/fixtures/objects/complex/amf3-typed-object.bin

@@ -0,0 +1,2 @@
+
+#org.amf.ASClassbazfoo
bar

data/spec/fixtures/objects/encoding/amf3-complex-encoded-string-array.bin

@@ -0,0 +1 @@
+		
Shift テストUTF テスト

data/spec/fixtures/objects/references/amf3-array-ref.bin

@@ -0,0 +1 @@
+		
	

	
abc		

data/spec/fixtures/objects/references/amf3-byte-array-ref.bin

@@ -0,0 +1 @@
+	
	ASDF

data/spec/fixtures/objects/references/amf3-empty-array-ref.bin

@@ -0,0 +1 @@
+		
	

	

		

data/spec/fixtures/objects/references/amf3-empty-string-ref.bin

@@ -0,0 +1 @@
+	



data/spec/fixtures/objects/references/amf3-trait-ref.bin

@@ -0,0 +1,3 @@
+	

+#org.amf.ASClassbazfoo

+

bar

data/spec/fixtures/objects/simple/amf3-false.bin

@@ -0,0 +1 @@
+

data/spec/fixtures/objects/simple/amf3-max.bin

@@ -0,0 +1 @@
+����

data/spec/fixtures/objects/simple/amf3-null.bin

@@ -0,0 +1 @@
+

data/spec/fixtures/objects/simple/amf3-string.bin

@@ -0,0 +1 @@
+String . String

data/spec/fixtures/objects/simple/amf3-symbol.bin

@@ -0,0 +1 @@
+foo

data/spec/fixtures/objects/simple/amf3-true.bin

@@ -0,0 +1 @@
+

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/fixtures.rb

@@ -0,0 +1,34 @@
+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_object_eq(object_fixture, value)
+  input  = object_fixture(object_fixture)
+  output = AMF::Root.deserialize(input)
+
+  first_object = output[:objects][0]
+
+  expect(first_object).to eq(value)
+end
+
+def get_first_object(object_fixture)
+  input  = object_fixture(object_fixture)
+  output = AMF::Root.deserialize(input)
+
+  requests = output[:objects]
+  requests[0]
+end
+
+def compare_with_fixture(input, fixture_name)
+  expected = object_fixture(fixture_name)
+  output   = AMF::Root.serialize(input)
+  expect(output).to eq(expected)
+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/spec-class_mapping.rb

@@ -0,0 +1,98 @@
+require 'spec_helper.rb'
+
+describe AMF::ClassMapper do
+  before :each do
+    AMF::ClassMapper.reset
+    AMF::ClassMapper.register_class_alias('ClassMappingTest', 'ASClass')
+
+    @mapper = AMF::ClassMapper.new
+  end
+
+  describe 'class name mapping' do
+    it 'should allow resetting of mappings back to defaults' do
+      expect(@mapper.get_class_name_remote(ClassMappingTest.new)).not_to be_nil
+
+      AMF::ClassMapper.reset
+
+      @mapper = AMF::ClassMapper.new
+      expect(@mapper.get_class_name_remote(ClassMappingTest.new)).to be_nil
+    end
+
+    it 'should return AS class name for ruby objects' do
+      expect(@mapper.get_class_name_remote(ClassMappingTest.new)).to eq('ASClass')
+      expect(@mapper.get_class_name_remote(AMF::HashWithType.new('ClassMappingTest'))).to eq('ASClass')
+      expect(@mapper.get_class_name_remote('BadClass')).to be_nil
+    end
+
+    it 'should instantiate a ruby class' do
+      expect(@mapper.create_object('ASClass')).to be_a(ClassMappingTest)
+    end
+
+    it 'should properly instantiate namespaced classes' do
+      AMF::ClassMapper.register_class_alias('ANamespace::TestRubyClass', 'ASClass')
+      @mapper = AMF::ClassMapper.new
+
+      expect(@mapper.create_object('ASClass')).to be_a(ANamespace::TestRubyClass)
+    end
+
+    it 'should return a hash with original type if not mapped' do
+      obj = @mapper.create_object('UnmappedClass')
+
+      expect(obj).to be_a(AMF::HashWithType)
+      expect(obj.class_type).to eq('UnmappedClass')
+    end
+
+    it 'should map special classes from AS by default' do
+      as_classes =
+          %w( )
+
+      as_classes.each do |as_class|
+        expect(@mapper.create_object(as_class)).not_to be_a(AMF::Types::HashWithType)
+      end
+    end
+
+    it 'should allow config modification' do
+      AMF::ClassMapper.register_class_alias('ClassMappingTest', 'SecondClass')
+      @mapper = AMF::ClassMapper.new
+
+      expect(@mapper.get_class_name_remote(ClassMappingTest.new)).to eq('SecondClass')
+    end
+  end
+
+  describe 'ruby object populator' do
+    it 'should populate a ruby class' do
+      obj = @mapper.object_deserialize ClassMappingTest.new, {:prop_a => 'Data'}
+      expect(obj.prop_a).to eq('Data')
+    end
+
+    it 'should populate a typed hash' do
+      obj = @mapper.object_deserialize AMF::HashWithType.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'}
+      props = @mapper.object_serialize(hash)
+      expect(props).to eq({'a' => 'test1', 'b' => 'test2'})
+    end
+
+    it 'should extract object properties' do
+      obj        = ClassMappingTest.new
+      obj.prop_a = 'Test A'
+
+      hash = @mapper.object_serialize obj
+      expect(hash).to eq({'prop_a' => 'Test A', 'prop_b' => nil})
+    end
+
+    it 'should extract inherited object properties' do
+      obj        = ClassMappingTest2.new
+      obj.prop_a = 'Test A'
+      obj.prop_c = 'Test C'
+
+      hash = @mapper.object_serialize obj
+      expect(hash).to eq({'prop_a' => 'Test A', 'prop_b' => nil, 'prop_c' => 'Test C'})
+    end
+  end
+end

data/spec/spec_deserializer.rb

@@ -0,0 +1,239 @@
+# encoding: UTF-8
+
+require 'spec_helper.rb'
+
+describe 'when deserializing' do
+  before :each do
+    AMF::Root.clear_class_aliases
+  end
+
+  describe 'AMF3' do
+    it 'should update source pos if source is a StringIO object' do
+      input = StringIO.new(object_fixture('simple/amf3-null.bin'))
+      expect(input.pos).to eq(0)
+
+      AMF::Root.deserialize(input)
+
+      expect(input.pos).to eq(1)
+    end
+
+    describe 'simple messages' do
+      it 'should deserialize a null' do
+        first_object_eq('simple/amf3-null.bin', nil)
+      end
+
+      it 'should deserialize a false' do
+        first_object_eq('simple/amf3-false.bin', false)
+      end
+
+      it 'should deserialize a true' do
+        first_object_eq('simple/amf3-true.bin', true)
+      end
+
+      it 'should deserialize integers' do
+        first_object_eq('simple/amf3-max.bin', AMF::AMFConstants::INTEGER_MAX)
+        first_object_eq('simple/amf3-0.bin', 0)
+        first_object_eq('simple/amf3-min.bin', AMF::AMFConstants::INTEGER_MIN)
+      end
+
+      it 'should deserialize large integers' do
+        first_object_eq('simple/amf3-large-max.bin', AMF::AMFConstants::INTEGER_MAX + 1.0)
+        first_object_eq('simple/amf3-large-min.bin', AMF::AMFConstants::INTEGER_MIN - 1.0)
+      end
+
+      it 'should deserialize BigNums' do
+        first_object_eq('simple/amf3-bignum.bin', 2.0**1000)
+      end
+
+      it 'should deserialize a simple string' do
+        first_object_eq('simple/amf3-string.bin', 'String . String')
+      end
+
+      it 'should deserialize a symbol as a string' do
+        first_object_eq('simple/amf3-symbol.bin', 'foo')
+      end
+
+    end
+
+    describe 'objects' do
+
+      it 'should deserialize dates' do
+        first_object_eq('complex/amf3-date.bin', Time.at(0))
+      end
+
+      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'
+            }
+
+        request = get_first_object('complex/amf3-dynamic-object.bin')
+
+        expect(request).to match(value)
+      end
+
+      it 'should deserialize a mapped object as a mapped ruby class instance' do
+        AMF::Root.register_class_alias('RubyClass', 'org.amf.ASClass')
+
+        request = get_first_object('complex/amf3-typed-object.bin')
+
+        expect(request).to be_a(RubyClass)
+        expect(request.foo).to eq('bar')
+        expect(request.baz).to eq(nil)
+      end
+
+      it 'should deserialize a hash as a dynamic anonymous object' do
+        first_object_eq('complex/amf3-hash.bin', {'foo' => 'bar', 'answer' => 42})
+      end
+
+      it 'should deserialize an empty array' do
+        request = get_first_object('complex/amf3-empty-array.bin')
+        expect(request).to match_array([])
+      end
+
+      it 'should deserialize an array of primitives' do
+        request = get_first_object('complex/amf3-primitive-array.bin')
+        expect(request).to match_array([1, 2, 3, 4, 5])
+      end
+
+      it 'should deserialize an associative array' do
+        request = get_first_object('complex/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
+        request = get_first_object('complex/amf3-mixed-array.bin')
+
+        value0 = {'foo_one' => 'bar_one'}
+        value1 = {'foo_two' => ''}
+        value2 = {'foo_three' => 42}
+        expect(request).to match_array([value0, value1, value2, {}, [value0, value1, value2], [], 42, '', [], '', {}, 'bar_one', value2])
+      end
+
+      it 'should deserialize a byte array' do
+        request = get_first_object('complex/amf3-byte-array.bin')
+
+        expect(request).to be_a(StringIO)
+        expected = "\000\003これtest\100"
+        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
+        request = get_first_object('complex/amf3-empty-dictionary.bin')
+        expect(request).to match({})
+      end
+
+      it 'should deserialize a dictionary' do
+        request = get_first_object('complex/amf3-dictionary.bin')
+
+        keys = request.keys
+        expect(keys.length).to eq(2)
+        obj_key, str_key = keys[0].is_a?(AMF::HashWithType) ? [keys[0], keys[1]] : [keys[1], keys[0]]
+
+        expect(obj_key.class_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
+    end
+
+    describe 'and implementing the AMF references' do
+      it 'should keep references of duplicate strings' do
+        output = get_first_object('references/amf3-string-ref.bin')
+
+        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
+        output = get_first_object('references/amf3-empty-string-ref.bin')
+        expect(output).to match_array(['', ''])
+      end
+
+      it 'should keep references of duplicate dates' do
+        output = get_first_object('references/amf3-date-ref.bin')
+
+        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']
+      end
+
+      it 'should keep reference of duplicate objects' do
+        output = get_first_object('references/amf3-object-ref.bin')
+
+        obj1 = {'foo' => 'bar'}
+        obj2 = {'foo' => obj1['foo']}
+
+        expect(output).to match_array([[obj1, obj2], 'bar', [obj1, obj2]])
+      end
+
+      it 'should keep reference of duplicate object traits' do
+        AMF::Root.register_class_alias('RubyClass', 'org.amf.ASClass')
+
+        output = get_first_object('references/amf3-trait-ref.bin')
+
+        expect(output[0].foo).to eq('foo')
+        expect(output[0].class).to eq(RubyClass)
+
+        expect(output[1].foo).to eq('bar')
+        expect(output[1].class).to eq(RubyClass)
+      end
+
+      it 'should keep references of duplicate arrays' do
+        output = get_first_object('references/amf3-array-ref.bin')
+
+        a = [1, 2, 3]
+        b = %w{ a b c }
+        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
+        output = get_first_object('references/amf3-empty-array-ref.bin')
+
+        a = []
+        b = []
+
+        expect(output).to match_array([a, b, a, b])
+
+        expect(output[0].object_id).to eq(output[2].object_id)
+        expect(output[1].object_id).to eq(output[3].object_id)
+
+        expect(output[0].object_id).not_to eq(output[1].object_id)
+
+
+      end
+
+      it 'should keep references of duplicate byte arrays' do
+        output = get_first_object('references/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
+
+        output = get_first_object('references/amf3-graph-member.bin')
+
+        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
+        # child1[:parent] = parent
+        # child1[:children] = []
+        # child2 = Hash.new
+        # child2[:parent] = parent
+        # child2[:children] = []
+        # parent[:parent] = nil
+        # parent[:children] = [child1, child2]
+      end
+    end
+  end
+end

data/spec/spec_fast_class_mapping.rb

@@ -0,0 +1,147 @@
+require 'spec_helper.rb'
+
+describe AMF::Ext::FastClassMapping do
+  before :each do
+    AMF::Ext::FastClassMapping.reset
+    AMF::Ext::FastClassMapping.define do |m|
+      m.map :as => 'ASClass', ruby: 'ClassMappingTest'
+    end
+    @mapper = AMF::Ext::FastClassMapping.new
+  end
+
+  describe 'class name mapping' do
+    it 'should allow resetting of mappings back to defaults' do
+      @mapper.get_class_name_remote('ClassMappingTest').should_not be_nil
+      AMF::Ext::FastClassMapping.reset
+      @mapper = AMF::Ext::FastClassMapping.new
+      @mapper.get_class_name_remote('ClassMappingTest').should be_nil
+    end
+
+    it 'should return AS class name for ruby objects' do
+      @mapper.get_class_name_remote(ClassMappingTest.new).should == 'ASClass'
+      @mapper.get_class_name_remote('ClassMappingTest').should == 'ASClass'
+      @mapper.get_class_name_remote(AMF::Types::HashWithType.new('ClassMappingTest')).should == 'ASClass'
+      @mapper.get_class_name_remote('BadClass').should be_nil
+    end
+
+    it 'should instantiate a ruby class' do
+      @mapper.create_object('ASClass').should be_a(ClassMappingTest)
+    end
+
+    it 'should properly instantiate namespaced classes' do
+      AMF::Ext::FastClassMapping.map.map :as => 'ASClass', ruby: 'ANamespace::TestRubyClass'
+      @mapper = AMF::Ext::FastClassMapping.new
+      @mapper.create_object('ASClass').should be_a(ANamespace::TestRubyClass)
+    end
+
+    it 'should return a hash with original type if not mapped' do
+      obj = @mapper.create_object('UnmappedClass')
+      obj.should be_a(AMF::Types::HashWithType)
+      obj.class_type.should == 'UnmappedClass'
+    end
+
+    it 'should map special classes from AS by default' do
+      as_classes =
+          %w(
+              flex.messaging.messages.CommandMessage
+              flex.messaging.messages.RemotingMessage
+            )
+
+      as_classes.each do |as_class|
+        @mapper.create_object(as_class).should_not be_a(AMF::Types::HashWithType)
+      end
+    end
+
+    it 'should map special classes from ruby by default' do
+      ruby_classes =
+          %w(
+              AMF::Types::ErrorMessage
+            )
+
+      ruby_classes.each do |obj|
+        @mapper.get_class_name_remote(obj).should_not be_nil
+      end
+    end
+
+    it 'should allow config modification' do
+      AMF::Ext::FastClassMapping.map.map :as => 'SecondClass', ruby: 'ClassMappingTest'
+      @mapper = AMF::Ext::FastClassMapping.new
+      @mapper.get_class_name_remote(ClassMappingTest.new).should == 'SecondClass'
+    end
+  end
+
+  describe 'ruby object populator' do
+    it 'should populate a ruby class' do
+      obj = @mapper.object_deserialize ClassMappingTest.new, {:prop_a => 'Data'}
+      obj.prop_a.should == 'Data'
+    end
+
+    it 'should populate a typed hash' do
+      obj = @mapper.object_deserialize AMF::Types::HashWithType.new('UnmappedClass'), {'prop_a' => 'Data'}
+      obj['prop_a'].should == 'Data'
+    end
+  end
+
+  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 }
+      else
+        hash.each { |k, v| out[k.to_sym] = v }
+      end
+      out
+    end
+
+    it 'should return hash without modification' do
+      hash  = {:a => 'test1', 'b' => 'test2'}
+      props = @mapper.object_serialize(hash)
+      props.should === hash
+    end
+
+    it 'should extract object properties' do
+      obj        = ClassMappingTest.new
+      obj.prop_a = 'Test A'
+
+      hash = @mapper.object_serialize obj
+      hash.should == prop_hash({'prop_a' => 'Test A', 'prop_b' => nil})
+    end
+
+    it 'should extract inherited object properties' do
+      obj        = ClassMappingTest2.new
+      obj.prop_a = 'Test A'
+      obj.prop_c = 'Test C'
+
+      hash = @mapper.object_serialize obj
+      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;
+
+      # Cache properties
+      obj  = ClassMappingTest3.new
+      hash = @mapper.object_serialize obj
+
+      # Add a method to ClassMappingTest3
+      class ClassMappingTest3;
+        attr_accessor :prop_b;
+      end
+
+      # Test property list does not have new property
+      obj        = ClassMappingTest3.new
+      obj.prop_a = 'Test A'
+      obj.prop_b = 'Test B'
+      hash       = @mapper.object_serialize obj
+      hash.should == prop_hash({'prop_a' => 'Test A'})
+
+      # Test that new class mapper *does* have new property (cache per instance)
+      @mapper = AMF::Ext::FastClassMapping.new
+      hash    = @mapper.object_serialize obj
+      hash.should == prop_hash({'prop_a' => 'Test A', 'prop_b' => 'Test B'})
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'rspec'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'amf'
+
+Dir[File.dirname(__FILE__) + '/helpers/*.rb'].each { |file| require file }