scotttam-RocketAMF 0.2.2

data/spec/amf/deserializer_spec.rb

@@ -0,0 +1,367 @@
+# encoding: UTF-8
+
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe "when deserializing" do
+  before :each do
+    RocketAMF::ClassMapper.reset
+  end
+
+  describe "AMF0" do
+    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 anonymous objects" do
+      input = object_fixture('amf0-object.bin')
+      output = RocketAMF.deserialize(input, 0)
+      output.should == {:foo => 'baz', :bar => 3.14}
+    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 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
+
+    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 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 = RocketAMF.deserialize(input, 0)
+      output.should == ['a', 'b', 'c', 'd']
+    end
+
+    it "should serialize 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-date.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-xmlDoc.bin')
+      output = RocketAMF.deserialize(input, 0)
+      output.should == '<parent><child prop="test" /></parent>'
+    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.rocketAMF.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.rocketAMF.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
+  end
+
+  describe "AMF3" do
+    describe "simple messages" do
+      it "should deserialize a null" do
+        input = object_fixture("amf3-null.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == nil
+      end
+
+      it "should deserialize a false" do
+        input = object_fixture("amf3-false.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == false
+      end
+
+      it "should deserialize a true" do
+        input = object_fixture("amf3-true.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == 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
+      end
+
+      it "should deserialize large integers" do
+        input = object_fixture("amf3-largeMax.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == RocketAMF::MAX_INTEGER + 1
+
+        input = object_fixture("amf3-largeMin.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == RocketAMF::MIN_INTEGER - 1
+      end
+
+      it "should deserialize BigNums" do
+        input = object_fixture("amf3-bigNum.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == 2**1000
+      end
+
+      it "should deserialize a simple string" do
+        input = object_fixture("amf3-string.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == "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"
+      end
+
+      it "should deserialize dates" do
+        input = object_fixture("amf3-date.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == Time.at(0)
+      end
+
+      it "should deserialize XML" do
+        # XMLDocument tag
+        input = object_fixture("amf3-xmlDoc.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == '<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>'
+      end
+    end
+
+    describe "objects" do
+      it "should deserialize an unmapped object as a dynamic anonymous object" do
+        input = object_fixture("amf3-dynObject.bin")
+        output = RocketAMF.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
+        RocketAMF::ClassMapper.define {|m| m.map :as => 'org.rocketAMF.ASClass', :ruby => 'RubyClass'}
+
+        input = object_fixture("amf3-typedObject.bin")
+        output = RocketAMF.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 = RocketAMF.deserialize(input, 3)
+        output.should == {:foo => "bar", :answer => 42}
+      end
+
+      it "should deserialize an empty array" do
+        input = object_fixture("amf3-emptyArray.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == []
+      end
+
+      it "should deserialize an array of primitives" do
+        input = object_fixture("amf3-primArray.bin")
+        output = RocketAMF.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 = RocketAMF.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" do
+        input = object_fixture("amf3-byteArray.bin")
+        output = RocketAMF.deserialize(input, 3)
+
+        output.should be_a(StringIO)
+        expected = "\000\003これtest\100"
+        expected.force_encoding("ASCII-8BIT") if expected.respond_to?(:force_encoding)
+        output.string.should == expected
+      end
+
+      it "should deserialize an empty dictionary" do
+        input = object_fixture("amf3-emptyDictionary.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == {}
+      end
+
+      it "should deserialize a dictionary" do
+        input = object_fixture("amf3-dictionary.bin")
+        output = RocketAMF.deserialize(input, 3)
+
+        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.rocketAMF.ASClass'
+        output[obj_key].should == "asdf2"
+        str_key.should == "bar"
+        output[str_key].should == "asdf1"
+      end
+    end
+
+    describe "and implementing the AMF Spec" do
+      it "should keep references of duplicate strings" do
+        input = object_fixture("amf3-stringRef.bin")
+        output = RocketAMF.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 = RocketAMF.deserialize(input, 3)
+        output.should == ["",""]
+      end
+
+      it "should keep references of duplicate dates" do
+        input = object_fixture("amf3-datesRef.bin")
+        output = RocketAMF.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 = RocketAMF.deserialize(input, 3)
+
+        obj1 = {:foo => "bar"}
+        obj2 = {:foo => obj1[:foo]}
+        output.should == [[obj1, obj2], "bar", [obj1, obj2]]
+      end
+
+      it "should keep reference of duplicate object traits" do
+        RocketAMF::ClassMapper.define {|m| m.map :as => 'org.rocketAMF.ASClass', :ruby => 'RubyClass'}
+
+        input = object_fixture("amf3-traitRef.bin")
+        output = RocketAMF.deserialize(input, 3)
+
+        output[0].foo.should == "foo"
+        output[1].foo.should == "bar"
+      end
+
+      it "should keep references of duplicate arrays" do
+        input = object_fixture("amf3-arrayRef.bin")
+        output = RocketAMF.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 = RocketAMF.deserialize(input, 3)
+
+        a = []
+        b = []
+        output.should == [a,b,a,b]
+      end
+
+      it "should keep references of duplicate XML and XMLDocuments" do
+        input = object_fixture("amf3-xmlRef.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output.should == ['<parent><child prop="test"/></parent>', '<parent><child prop="test"/></parent>']
+      end
+
+      it "should keep references of duplicate byte arrays" do
+        input = object_fixture("amf3-byteArrayRef.bin")
+        output = RocketAMF.deserialize(input, 3)
+        output[0].object_id.should == output[1].object_id
+        output[0].string.should == "ASDF"
+      end
+
+      it "should deserialize a deep object graph with circular references" do
+        input = object_fixture("amf3-graphMember.bin")
+        output = RocketAMF.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,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe RocketAMF::Envelope do
+  describe 'deserializer' do
+    it "should handle remoting message from remote object" do
+      req = create_envelope("remotingMessage.bin")
+
+      req.headers.length.should == 0
+      req.messages.length.should == 1
+      message = req.messages[0].data
+      message.should be_a(RocketAMF::Values::RemotingMessage)
+      message.messageId.should == "FE4AF2BC-DD3C-5470-05D8-9971D51FF89D"
+      message.body.should == [true]
+    end
+
+    it "should handle command message from remote object" do
+      req = create_envelope("commandMessage.bin")
+
+      req.headers.length.should == 0
+      req.messages.length.should == 1
+      message = req.messages[0].data
+      message.should be_a(RocketAMF::Values::CommandMessage)
+      message.messageId.should == "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
+      message.body.should == {}
+    end
+  end
+
+  describe "#deserialize" do
+    it "should parse the message envelope into a hash" do
+      parsed_amf = RocketAMF::Envelope.new.deserialize(create_envelope('commandMessage.bin').serialize)
+      parsed_amf[:amf_version].should == 3
+      parsed_amf[:headers].should == []
+      parsed_amf[:bodies].first[:target_uri].should == "null"
+      parsed_amf[:bodies].first[:response_uri].should == "/1"
+      puts parsed_amf[:bodies].first[:content].class.should == RocketAMF::Values::CommandMessage
+    end
+
+    it "should return nil if nil is passed in" do
+      RocketAMF::Envelope.new.deserialize(nil).should be_nil
+    end
+  end  
+
+  describe 'serializer' do
+    it "should serialize response when converted to string" do
+      res = RocketAMF::Envelope.new
+      res.should_receive(:serialize).and_return('serialized')
+      res.to_s.should == 'serialized'
+    end
+
+    it "should serialize a simple call" do
+      res = RocketAMF::Envelope.new :amf_version => 3
+      res.messages << RocketAMF::Message.new('/1/onResult', '', 'hello')
+
+      expected = request_fixture('simple-response.bin')
+      res.serialize.should == expected
+    end
+
+    it "should serialize a AcknowledgeMessage response" do
+      ak = RocketAMF::Values::AcknowledgeMessage.new
+      ak.clientId = "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
+      ak.messageId = "7B0ACE15-8D57-6AE5-B9D4-99C2D32C8246"
+      ak.timestamp = 0
+      res = RocketAMF::Envelope.new :amf_version => 3
+      res.messages << RocketAMF::Message.new('/1/onResult', '', ak)
+
+      expected = request_fixture('acknowledge-response.bin')
+      res.serialize.should == expected
+    end
+  end
+
+  describe 'message handler' do
+    it "should respond to ping command" do
+      res = RocketAMF::Envelope.new
+      req = create_envelope('commandMessage.bin')
+      res.each_method_call req do |method, args|
+        nil
+      end
+
+      res.messages.length.should == 1
+      res.messages[0].data.should be_a(RocketAMF::Values::AcknowledgeMessage)
+    end
+
+    it "should fail on unsupported command" do
+      res = RocketAMF::Envelope.new
+      req = create_envelope('unsupportedCommandMessage.bin')
+      res.each_method_call req do |method, args|
+        nil
+      end
+
+      res.messages.length.should == 1
+      res.messages[0].data.should be_a(RocketAMF::Values::ErrorMessage)
+      res.messages[0].data.faultString.should == "CommandMessage 10000 not implemented"
+    end
+
+    it "should handle RemotingMessages properly" do
+      res = RocketAMF::Envelope.new
+      req = create_envelope('remotingMessage.bin')
+      res.each_method_call req do |method, args|
+        method.should == 'WritesController.save'
+        args.should == [true]
+        true
+      end
+
+      res.messages.length.should == 1
+      res.messages[0].data.should be_a(RocketAMF::Values::AcknowledgeMessage)
+      res.messages[0].data.body.should == true
+    end
+
+    it "should catch exceptions properly" do
+      res = RocketAMF::Envelope.new
+      req = create_envelope('remotingMessage.bin')
+      res.each_method_call req do |method, args|
+        raise 'Error in call'
+      end
+
+      res.messages.length.should == 1
+      res.messages[0].data.should be_a(RocketAMF::Values::ErrorMessage)
+      res.messages[0].target_uri.should =~ /onStatus$/
+    end
+
+    it "should not crash if source missing on RemotingMessage" do
+      res = RocketAMF::Envelope.new
+      req = create_envelope('remotingMessage.bin')
+      req.messages[0].data.instance_variable_set("@source", nil)
+      lambda {
+        res.each_method_call req do |method,args|
+          true
+        end
+      }.should_not raise_error
+    end
+  end
+end