rack-amf 0.0.1

data/spec/amf/class_mapping_spec.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe AMF::ClassMapping do
+  before(:all) do
+    class RubyClass
+      attr_accessor :prop_a
+      attr_accessor :prop_b
+      attr_accessor :prop_c
+    end
+  end
+
+  before :each do
+    @mapper = AMF::ClassMapping.new
+    @mapper.define do |m|
+      m.map :as => 'ASClass', :ruby => 'RubyClass'
+    end
+  end
+
+  it "should return AS class name for ruby objects" do
+    @mapper.get_as_class_name(RubyClass.new).should == 'ASClass'
+    @mapper.get_as_class_name('RubyClass').should == 'ASClass'
+  end
+
+  it "should allow config modification" do
+    @mapper.define do |m|
+      m.map :as => 'SecondClass', :ruby => 'RubyClass'
+    end
+    @mapper.get_as_class_name(RubyClass.new).should == 'SecondClass'
+  end
+
+  describe "ruby object generator" do
+    it "should instantiate a ruby class" do
+      @mapper.get_ruby_obj('ASClass').should be_a(RubyClass)
+    end
+
+    it "should properly instantiate namespaced classes" do
+      module ANamespace; class TestRubyClass; end; end
+      @mapper.define {|m| m.map :as => 'ASClass', :ruby => 'ANamespace::TestRubyClass'}
+      @mapper.get_ruby_obj('ASClass').should be_a(ANamespace::TestRubyClass)
+    end
+
+    it "should return a hash with original type if not mapped" do
+      obj = @mapper.get_ruby_obj('UnmappedClass')
+      obj.should be_a(AMF::Values::TypedHash)
+      obj.type.should == 'UnmappedClass'
+    end
+  end
+
+  describe "ruby object populator" do
+    it "should populate a ruby class" do
+      obj = @mapper.populate_ruby_obj RubyClass.new, {:prop_a => 'Data'}
+      obj.prop_a.should == 'Data'
+    end
+
+    it "should populate a typed hash" do
+      obj = @mapper.populate_ruby_obj AMF::Values::TypedHash.new('UnmappedClass'), {:prop_a => 'Data'}
+      obj[:prop_a].should == 'Data'
+    end
+
+    it "should allow custom populators" do
+      class CustomPopulator
+        def can_handle? obj
+          true
+        end
+        def populate obj, props, dynamic_props
+          obj[:populated] = true
+          obj.merge! props
+          obj.merge! dynamic_props if dynamic_props
+        end
+      end
+
+      @mapper.object_populators << CustomPopulator.new
+      obj = @mapper.populate_ruby_obj({}, {:prop_a => 'Data'})
+      obj[:populated].should == true
+      obj[:prop_a].should == 'Data'
+    end
+  end
+
+  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'}
+    end
+
+    it "should extract object properties" do
+      obj = RubyClass.new
+      obj.prop_a = 'Test A'
+      obj.prop_b = 'Test B'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => 'Test B', 'prop_c' => nil}
+    end
+
+    it "should allow custom serializers" do
+      class CustomSerializer
+        def can_handle? obj
+          true
+        end
+        def serialize obj
+          {:success => true}
+        end
+      end
+
+      @mapper.object_serializers << CustomSerializer.new
+      @mapper.props_for_serialization(nil).should == {:success => true}
+    end
+  end
+end

data/spec/amf/deserializer_spec.rb

@@ -0,0 +1,301 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe "when deserializing" do
+  describe "AMF0" do
+    it "should deserialize numbers" do
+      input = object_fixture('amf0-number.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == 3.5
+    end
+
+    it "should deserialize booleans" do
+      input = object_fixture('amf0-boolean.bin')
+      output = AMF.deserialize(input, 0)
+      output.should === true
+    end
+
+    it "should deserialize strings" do
+      input = object_fixture('amf0-string.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == "this is a テスト"
+    end
+
+    it "should deserialize anonymous objects" do
+      input = object_fixture('amf0-object.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == {:foo => 'baz', :bar => 3.14}
+    end
+
+    it "should deserialize nulls" do
+      input = object_fixture('amf0-null.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == nil
+    end
+
+    it "should deserialize undefineds" do
+      input = object_fixture('amf0-undefined.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == nil
+    end
+
+    it "should deserialize references properly" do
+      input = object_fixture('amf0-ref-test.bin')
+      output = AMF.deserialize(input, 0)
+      output.length.should == 2
+      output[0].should === output[1]
+    end
+
+    it "should deserialize hashes" do
+      input = object_fixture('amf0-hash.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == {:a => 'b', :c => 'd'}
+    end
+
+    it "should deserialize arrays from flash player" do
+      # Even Array is serialized as a "hash", so check that deserializer converts to array
+      input = object_fixture('amf0-ecma-ordinal-array.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == ['a', 'b', 'c', 'd']
+    end
+
+    it "should deserialize dates" do
+      input = object_fixture('amf0-date.bin')
+      output = AMF.deserialize(input, 0)
+      output.should == Time.utc(2003, 2, 13, 5)
+    end
+
+    it "should deserialize an unmapped object as a dynamic anonymous object" do
+      input = object_fixture("amf0-typed-object.bin")
+      output = AMF.deserialize(input, 0)
+
+      output.type.should == 'org.rackAMF.ASClass'
+      output.should == {:foo => 'bar', :baz => nil}
+    end
+
+    it "should deserialize a mapped object as a mapped ruby class instance" do
+      class RubyClass
+        attr_accessor :foo, :baz
+      end
+      AMF::ClassMapper.define {|m| m.map :as => 'org.rackAMF.ASClass', :ruby => 'RubyClass'}
+
+      input = object_fixture("amf0-typed-object.bin")
+      output = AMF.deserialize(input, 0)
+
+      output.should be_a(RubyClass)
+      output.foo.should == 'bar'
+      output.baz.should == nil
+    end
+  end
+
+  describe "AMF3" do
+    describe "simple messages" do
+      it "should deserialize a null" do
+        input = object_fixture("amf3-null.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == nil
+      end
+
+      it "should deserialize a false" do
+        input = object_fixture("amf3-false.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == false
+      end
+
+      it "should deserialize a true" do
+        input = object_fixture("amf3-true.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == true
+      end
+
+      it "should deserialize integers" do
+        input = object_fixture("amf3-max.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == AMF::MAX_INTEGER
+
+        input = object_fixture("amf3-0.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == 0
+
+        input = object_fixture("amf3-min.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == AMF::MIN_INTEGER
+      end
+
+      it "should deserialize large integers" do
+        input = object_fixture("amf3-largeMax.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == AMF::MAX_INTEGER + 1
+
+        input = object_fixture("amf3-largeMin.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == AMF::MIN_INTEGER - 1
+      end
+
+      it "should deserialize BigNums" do
+        input = object_fixture("amf3-bigNum.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == 2**1000
+      end
+
+      it "should deserialize a simple string" do
+        input = object_fixture("amf3-string.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == "String . String"
+      end
+
+      it "should deserialize a symbol as a string" do
+        input = object_fixture("amf3-symbol.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == "foo"
+      end
+
+      it "should deserialize dates" do
+        input = object_fixture("amf3-date.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == Time.at(0)
+      end
+
+      #BAH! Who sends XML over AMF?
+      it "should deserialize a REXML document"
+    end
+
+    describe "objects" do
+      it "should deserialize an unmapped object as a dynamic anonymous object" do
+        input = object_fixture("amf3-dynObject.bin")
+        output = AMF.deserialize(input, 3)
+
+        expected = {
+          :property_one => 'foo',
+          :property_two => 1,
+          :nil_property => nil,
+          :another_public_property => 'a_public_value'
+        }
+        output.should == expected
+      end
+
+      it "should deserialize a mapped object as a mapped ruby class instance" do
+        class RubyClass
+          attr_accessor :foo, :baz
+        end
+        AMF::ClassMapper.define {|m| m.map :as => 'org.rackAMF.ASClass', :ruby => 'RubyClass'}
+
+        input = object_fixture("amf3-typedObject.bin")
+        output = AMF.deserialize(input, 3)
+
+        output.should be_a(RubyClass)
+        output.foo.should == 'bar'
+        output.baz.should == nil
+      end
+
+      it "should deserialize a hash as a dynamic anonymous object" do
+        input = object_fixture("amf3-hash.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == {:foo => "bar", :answer => 42}
+      end
+
+      it "should deserialize an open struct as a dynamic anonymous object"
+
+      it "should deserialize an empty array" do
+        input = object_fixture("amf3-emptyArray.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == []
+      end
+
+      it "should deserialize an array of primatives" do
+        input = object_fixture("amf3-primArray.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == [1,2,3,4,5]
+      end
+
+      it "should deserialize an array of mixed objects" do
+        input = object_fixture("amf3-mixedArray.bin")
+        output = AMF.deserialize(input, 3)
+
+        h1 = {:foo_one => "bar_one"}
+        h2 = {:foo_two => ""}
+        so1 = {:foo_three => 42}
+        output.should == [h1, h2, so1, {:foo_three => nil}, {}, [h1, h2, so1], [], 42, "", [], "", {}, "bar_one", so1]
+      end
+
+      it "should deserialize a byte array"
+    end
+
+    describe "and implementing the AMF Spec" do
+      it "should keep references of duplicate strings" do
+        input = object_fixture("amf3-stringRef.bin")
+        output = AMF.deserialize(input, 3)
+
+        class StringCarrier; attr_accessor :str; end
+        foo = "foo"
+        bar = "str"
+        sc = StringCarrier.new
+        sc = {:str => foo}
+        output.should == [foo, bar, foo, bar, foo, sc]
+      end
+
+      it "should not reference the empty string" do
+        input = object_fixture("amf3-emptyStringRef.bin")
+        output = AMF.deserialize(input, 3)
+        output.should == ["",""]
+      end
+
+      it "should keep references of duplicate dates" do
+        input = object_fixture("amf3-datesRef.bin")
+        output = AMF.deserialize(input, 3)
+
+        output[0].should equal(output[1])
+        # Expected object:
+        # [DateTime.parse "1/1/1970", DateTime.parse "1/1/1970"]
+      end
+
+      it "should keep reference of duplicate objects" do
+        input = object_fixture("amf3-objRef.bin")
+        output = AMF.deserialize(input, 3)
+
+        obj1 = {:foo => "bar"}
+        obj2 = {:foo => obj1[:foo]}
+        output.should == [[obj1, obj2], "bar", [obj1, obj2]]
+      end
+
+      it "should keep references of duplicate arrays" do
+        input = object_fixture("amf3-arrayRef.bin")
+        output = AMF.deserialize(input, 3)
+
+        a = [1,2,3]
+        b = %w{ a b c }
+        output.should == [a, b, a, b]
+      end
+
+      it "should not keep references of duplicate empty arrays unless the object_id matches" do
+        input = object_fixture("amf3-emptyArrayRef.bin")
+        output = AMF.deserialize(input, 3)
+
+        a = []
+        b = []
+        output.should == [a,b,a,b]
+      end
+
+      it "should keep references of duplicate XML and XMLDocuments"
+      it "should keep references of duplicate byte arrays"
+
+      it "should deserialize a deep object graph with circular references" do
+        input = object_fixture("amf3-graphMember.bin")
+        output = AMF.deserialize(input, 3)
+
+        output[:children][0][:parent].should === output
+        output[:parent].should === nil
+        output[:children].length.should == 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/amf/remoting_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe "when handling requests" do
+  it "should handle remoting message from remote object" do
+    input = request_fixture("remotingMessage.bin")
+    req = AMF::Request.new.populate_from_stream(input)
+
+    req.headers.length.should == 0
+    req.messages.length.should == 1
+    message = req.messages[0].data
+    message.should be_a(AMF::Values::RemotingMessage)
+    message.messageId.should == "FE4AF2BC-DD3C-5470-05D8-9971D51FF89D"
+    message.body.should == [true]
+  end
+
+  it "should handle command message from remote object" do
+    input = request_fixture("commandMessage.bin")
+    req = AMF::Request.new.populate_from_stream(input)
+
+    req.headers.length.should == 0
+    req.messages.length.should == 1
+    message = req.messages[0].data
+    message.should be_a(AMF::Values::CommandMessage)
+    message.messageId.should == "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
+    message.body.should == {}
+  end
+end
+
+describe "when handling responses" do
+  it "should serialize a simple call" do
+    resp = AMF::Response.new
+    resp.messages << AMF::Message.new('/1/onResult', '', 'hello')
+
+    expected = request_fixture('simple-response.bin')
+    resp.serialize.should == expected
+  end
+end

data/spec/amf/serializer_spec.rb

@@ -0,0 +1,254 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'rexml/document'
+
+describe "when serializing" do
+  describe "AMF3" do
+    describe "simple messages" do
+      it "should serialize a null" do
+        expected = object_fixture("amf3-null.bin")
+        output = AMF.serialize(nil, 3)
+        output.should == expected
+      end
+
+      it "should serialize a false" do
+        expected = object_fixture("amf3-false.bin")
+        output = AMF.serialize(false, 3)
+        output.should == expected
+      end
+
+      it "should serialize a true" do
+        expected = object_fixture("amf3-true.bin")
+        output = AMF.serialize(true, 3)
+        output.should == expected
+      end
+
+      it "should serialize integers" do
+        expected = object_fixture("amf3-max.bin")
+        input = AMF::MAX_INTEGER
+        output = AMF.serialize(input, 3)
+        output.should == expected
+
+        expected = object_fixture("amf3-0.bin")
+        output = AMF.serialize(0, 3)
+        output.should == expected
+
+        expected = object_fixture("amf3-min.bin")
+        input = AMF::MIN_INTEGER
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize large integers" do
+        expected = object_fixture("amf3-largeMax.bin")
+        input = AMF::MAX_INTEGER + 1
+        output = AMF.serialize(input, 3)
+        output.should == expected
+
+        expected = object_fixture("amf3-largeMin.bin")
+        input = AMF::MIN_INTEGER - 1
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize BigNums" do
+        expected = object_fixture("amf3-bigNum.bin")
+        input = 2**1000
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize a simple string" do
+        expected = object_fixture("amf3-string.bin")
+        input = "String . String"
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize a symbol as a string" do
+        expected = object_fixture("amf3-symbol.bin")
+        output = AMF.serialize(:foo, 3)
+        output.should == expected
+      end
+
+      it "should serialize Times" do
+        expected = object_fixture("amf3-date.bin")
+        input = Time.utc 1970, 1, 1, 0
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      #BAH! Who sends XML over AMF?
+      it "should serialize a REXML document"
+    end
+
+    describe "objects" do
+      it "should serialize an unmapped object as a dynamic anonymous object" do
+        class NonMappedObject
+          attr_accessor :property_one
+          attr_accessor :property_two
+          attr_accessor :nil_property
+          attr_writer :read_only_prop
+
+          def another_public_property
+            'a_public_value'
+          end
+
+          def method_with_arg arg='foo'
+            arg
+          end
+        end
+        obj = NonMappedObject.new
+        obj.property_one = 'foo'
+        obj.property_two = 1
+        obj.nil_property = nil
+
+        expected = object_fixture("amf3-dynObject.bin")
+        input = obj
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize a hash as a dynamic anonymous object" do
+        hash = {}
+        hash[:answer] = 42
+        hash[:foo] = "bar"
+
+        expected = object_fixture("amf3-hash.bin")
+        input = hash
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize an open struct as a dynamic anonymous object"
+
+      it "should serialize an empty array" do
+        expected = object_fixture("amf3-emptyArray.bin")
+        input = []
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize an array of primatives" do
+        expected = object_fixture("amf3-primArray.bin")
+        input = [1, 2, 3, 4, 5]
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      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.foo_three = 42
+
+        expected = object_fixture("amf3-mixedArray.bin")
+        input = [h1, h2, so1, SimpleObj.new, {}, [h1, h2, so1], [], 42, "", [], "", {}, "bar_one", so1]
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should serialize a byte array"
+    end
+
+    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
+        sc.str = foo
+
+        expected = object_fixture("amf3-stringRef.bin")
+        input = [foo, bar, foo, bar, foo, sc]
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should not reference the empty string" do
+        expected = object_fixture("amf3-emptyStringRef.bin")
+        input = ""
+        output = AMF.serialize([input,input], 3)
+        output.should == expected
+      end
+
+      it "should keep references of duplicate dates" do
+        expected = object_fixture("amf3-datesRef.bin")
+        input = Time.utc 1970, 1, 1, 0
+        output = AMF.serialize([input,input], 3)
+        output.should == expected
+      end
+
+      it "should keep reference of duplicate objects" do
+        class SimpleReferenceableObj
+          attr_accessor :foo
+        end
+        obj1 = SimpleReferenceableObj.new
+        obj1.foo = :bar
+        obj2 = SimpleReferenceableObj.new
+        obj2.foo = obj1.foo
+
+        expected = object_fixture("amf3-objRef.bin")
+        input = [[obj1, obj2], "bar", [obj1, obj2]]
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should keep references of duplicate arrays" do
+        a = [1,2,3]
+        b = %w{ a b c }
+
+        expected = object_fixture("amf3-arrayRef.bin")
+        input = [a, b, a, b]
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      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
+
+        expected = object_fixture("amf3-emptyArrayRef.bin")
+        input = [a,b,a,b]
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+
+      it "should keep references of duplicate XML and XMLDocuments"
+      it "should keep references of duplicate byte arrays"
+
+      it "should serialize a deep object graph with circular references" do
+        class GraphMember
+          attr_accessor :parent
+          attr_accessor :children
+
+          def initialize
+            self.children = []
+          end
+
+          def add_child child
+            children << child
+            child.parent = self
+            child
+          end
+        end
+
+        parent = GraphMember.new
+        level_1_child_1 = parent.add_child GraphMember.new
+        level_1_child_2 = parent.add_child GraphMember.new
+
+        expected = object_fixture("amf3-graphMember.bin")
+        input = parent
+        output = AMF.serialize(input, 3)
+        output.should == expected
+      end
+    end
+  end
+end

data/spec/amf/values/array_collection_spec.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe AMF::Values::ArrayCollection do
+  it "should deserialize properly"
+  it "should serialize properly"
+end