rubyamf-ouvrages 2.0.0

data/spec/class_mapping_spec.rb

@@ -0,0 +1,147 @@
+require "spec_helper.rb"
+
+describe RubyAMF::MappingSet do
+  before :each do
+    @set = RubyAMF::MappingSet.new
+  end
+
+  it "should have default mappings" do
+    @set.get_as_class_name('RocketAMF::Values::RemotingMessage').should == 'flex.messaging.messages.RemotingMessage'
+    @set.get_ruby_class_name('flex.messaging.messages.RemotingMessage').should == 'RocketAMF::Values::RemotingMessage'
+  end
+
+  it "should store serialization attributes by scope" do
+    @set.map :as => 'A', :ruby => 'R', :default_scope => :scope_a, :except => ['a']
+    @set.map :as => 'A', :ruby => 'R', :scope => :scope_b, :except => ['b']
+
+    @set.serialization_config('R').should == {:except => ['a']}
+    @set.serialization_config('R', :scope_b).should == {:except => ['b']}
+  end
+
+  it "should assume default scope if configuring attributes" do
+    @set.map :as => 'A', :ruby => 'R', :except => ['a']
+
+    @set.serialization_config('R').should == {:except => ['a']}
+  end
+
+  it "should update scopes on change" do
+    @set.map :as => 'A', :ruby => 'R', :scope => :default, :only => ['a']
+    @set.map :as => 'A', :ruby => 'R', :scope => :default, :except => ['b']
+
+    @set.serialization_config('R').should == {:except => ['b']}
+  end
+end
+
+class UnmappedClass; end
+class MappingTestClass
+  def initialize
+    @initialized = true
+  end
+
+  def initialized?
+    @initialized
+  end
+end
+class MappingModelTestClass < MappingTestClass
+  def rubyamf_init; end
+end
+
+describe RubyAMF::ClassMapping do
+  before :each do
+    RubyAMF::ClassMapping.reset
+    @set = RubyAMF::ClassMapping.mappings
+    @mapper = RubyAMF::ClassMapping.new
+    @conf = RubyAMF.configuration = RubyAMF::Configuration.new
+  end
+
+  it "should auto-map class on deserialization correctly" do
+    @conf.auto_class_mapping = true
+    as_name = "com.test.UnmappedClass"
+    @set.get_ruby_class_name(as_name).should == nil
+    obj = @mapper.get_ruby_obj as_name
+    obj.class.should == UnmappedClass
+    @set.get_ruby_class_name(as_name).should == "UnmappedClass"
+  end
+
+  it "should auto-map class on serialization correctly" do
+    @conf.auto_class_mapping = true
+    name = "UnmappedClass"
+    @set.get_as_class_name(name).should == nil
+    @mapper.get_as_class_name(UnmappedClass.new).should == name
+    @set.get_as_class_name(name).should == name
+  end
+
+  it "should translate property case on deserialization correctly" do
+    @conf.translate_case = true
+    props = {'aProperty' => "asdf", 'aMoreComplexProperty' => "asdf"}
+    dynamic_props = {'aDynamicProperty' => "fdsa"}
+    obj = RocketAMF::Values::TypedHash.new("")
+    @mapper.populate_ruby_obj obj, props, dynamic_props
+    obj.should == {'a_property' => "asdf", 'a_more_complex_property' => "asdf", 'a_dynamic_property' => "fdsa"}
+  end
+
+  it "should translate property case on serialization correctly" do
+    @conf.translate_case = true
+    obj = {"a_dynamic_property" => "asdf"}
+    props = @mapper.props_for_serialization(obj)
+    props.should == {"aDynamicProperty" => "asdf"}
+  end
+
+  it "should allow setting hash key type to symbol" do
+    @conf.hash_key_access = :symbol
+    props = {'asdf' => "asdf", 'fdsa' => "fdsa"}
+    obj = RocketAMF::Values::TypedHash.new("")
+    @mapper.populate_ruby_obj obj, props
+    obj.should == {:asdf => "asdf", :fdsa => "fdsa"}
+  end
+
+  it "should return correct class name for IntermediateObject" do
+    obj = RubyAMF::IntermediateObject.new(MappingTestClass.new, {})
+    @set.map :as => "MappingTestClass", :ruby => "MappingTestClass"
+    @mapper.get_as_class_name(obj).should == "MappingTestClass"
+  end
+
+  it "should extract properties correctly for IntermediateObject" do
+    obj = RubyAMF::IntermediateObject.new(MappingTestClass.new, {:only => "asdf"})
+    obj.object.should_receive(:rubyamf_hash).with(obj.options).and_return({"asdf" => "fdsa"})
+    props = @mapper.props_for_serialization(obj)
+    props.should == {"asdf" => "fdsa"}
+  end
+
+  it "should properly extract properties for mapped class" do
+    obj = MappingTestClass.new
+    @set.map :as => "MappingTestClass", :ruby => "MappingTestClass", :only => "asdf"
+    obj.should_receive(:rubyamf_hash).with({:only => "asdf"}).and_return({"asdf" => "fdsa"})
+    props = @mapper.props_for_serialization(obj)
+    props.should == {"asdf" => "fdsa"}
+  end
+
+  it "should not call initialize on rubyamf_init implementors" do
+    @set.map :as => "MappingTestClass", :ruby => "MappingTestClass"
+    @set.map :as => "MappingModelTestClass", :ruby => "MappingModelTestClass"
+
+    obj = @mapper.get_ruby_obj("MappingTestClass")
+    obj.initialized?.should == true
+
+    obj = @mapper.get_ruby_obj("MappingModelTestClass")
+    obj.initialized?.should_not == true
+  end
+
+  it "should skip properties on deserialize that are globally ignored" do
+    obj = MappingModelTestClass.new
+    @conf.ignore_fields = ["asdf"]
+    @set.map :as => "MappingModelTestClass", :ruby => "MappingModelTestClass"
+
+    obj.should_receive(:rubyamf_init).with({:fdsa => "fdsa"}, nil)
+    @mapper.populate_ruby_obj(obj, {:asdf => "asdf", :fdsa => "fdsa"})
+  end
+
+  it "should skip properties on deserialize that are configured to be ignored" do
+    obj = MappingModelTestClass.new
+    @conf.ignore_fields = ["fdsa"]
+    @set.map :as => "MappingModelTestClass", :ruby => "MappingModelTestClass", :ignore_fields => "asdf"
+
+    obj.should_receive(:rubyamf_init).with({:fdsa => "fdsa"}, nil)
+    @mapper.populate_ruby_obj(obj, {:asdf => "asdf", :fdsa => "fdsa"})
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper.rb"
+
+describe RubyAMF::Configuration do
+  before :each do
+    RubyAMF::ClassMapping.reset
+    @conf = RubyAMF::Configuration.new
+    @legacy_path = File.dirname(__FILE__) + '/fixtures/rubyamf_config.rb'
+  end
+
+  it "should read legacy files without errors" do
+    @conf.load_legacy(@legacy_path)
+  end
+
+  it "should properly map blank class mapping" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.get_ruby_class_name('Blank').should == 'Blank'
+    mapset.serialization_config('Blank').should == nil
+  end
+
+  it "should properly map attribute setting" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Attribute').should == {:only => ["prop_a", "prop_b"]}
+  end
+
+  it "should properly map association setting" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Association').should == {:include => ["assoc_a", "assoc_b"]}
+  end
+
+  it "should properly map attribute and association setting" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Both').should == {
+      :only => ["prop_a", "prop_b"],
+      :include => ["assoc_a", "assoc_b"]
+    }
+  end
+
+  it "should properly map methods setting" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Method').should == {:methods => ["meth_a"]}
+  end
+
+  it "should properly map scoped attributes" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Scoped1', :scope_1).should == {:only => ["prop_a", "prop_b"]}
+    mapset.serialization_config('Scoped1', "scope_2").should == {:only => ["prop_a"]}
+  end
+
+  it "should properly map scoped associations" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Scoped2', :scope_1).should == {:include => ["assoc_a", "assoc_b"]}
+    mapset.serialization_config('Scoped2', :scope_2).should == {:include => ["assoc_a"]}
+  end
+
+  it "should properly map partially scoped settings" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Scoped3', :scope_1).should == {
+      :only => ["prop_a", "prop_b"],
+      :include => ["assoc_a", "assoc_b"]
+    }
+    mapset.serialization_config('Scoped3', :scope_2).should == {
+      :only => ["prop_a"],
+      :include => ["assoc_a", "assoc_b"]
+    }
+  end
+
+  it "should properly map both scoped settings" do
+    @conf.load_legacy(@legacy_path)
+    mapset = RubyAMF::ClassMapping.mappings
+    mapset.serialization_config('Scoped4', :scope_1).should == {
+      :only => ["prop_a", "prop_b"],
+      :include => ["assoc_a", "assoc_b"]
+    }
+    mapset.serialization_config('Scoped4', :scope_2).should == {:only => ["prop_a"]}
+    mapset.serialization_config('Scoped4', :scope_3).should == {:include => ["assoc_a"]}
+  end
+
+  it "should properly store parameter mappings" do
+    @conf.load_legacy(@legacy_path)
+    @conf.param_mappings["Controller#action"].should == [:param_1, :param_2, nil, :param_4]
+  end
+end

data/spec/envelope_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper.rb"
+
+describe RubyAMF::Envelope do
+  before :each do
+    @envelope = RubyAMF::Envelope.new
+    @logger = mock(RubyAMF::Logger)
+    @logger.stub!("log_error")
+    RubyAMF.configuration = RubyAMF::Configuration.new # Reset configuration
+  end
+
+  def create_envelope fixture
+    data = File.open(File.dirname(__FILE__) + '/fixtures/' + fixture).read
+    data.force_encoding("ASCII-8BIT") if data.respond_to?(:force_encoding)
+    RubyAMF::Envelope.new.populate_from_stream(StringIO.new(data))
+  end
+
+  it "should raise and handle returned exception objects like RubyAMF::Fault" do
+    RubyAMF.should_receive("logger").and_return(@logger)
+
+    res = RubyAMF::Envelope.new
+    req = create_envelope('remotingMessage.bin')
+    res.each_method_call req do |method, args|
+      FaultObject.new('Error in call')
+    end
+
+    res.messages.length.should == 1
+    res.messages[0].data.should be_a(RocketAMF::Values::ErrorMessage)
+    res.messages[0].data.faultString.should == "Error in call"
+  end
+
+  it "should clear backtrace from raised exceptions before serialization" do
+    RubyAMF.should_receive("logger").and_return(@logger)
+
+    res = RubyAMF::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].data.faultDetail.should == ""
+  end
+
+  it "should log exceptions in each_method_call handler" do
+    e = Exception.new('Error in call')
+    @logger.should_receive("log_error").with(e).and_return(nil)
+    RubyAMF.should_receive("logger").and_return(@logger)
+
+    res = RubyAMF::Envelope.new
+    req = create_envelope('remotingMessage.bin')
+    res.each_method_call req do |method, args|
+      raise e
+    end
+  end
+
+  it "should calculate params hash from configuration" do
+    RubyAMF.configuration.map_params "c", "a", ["param1", :param2]
+    params = @envelope.params_hash "c", "a", ["asdf", "fdsa"]
+    params.should == {"param1" => "asdf", "param2" => "fdsa", 0 => "asdf", 1 => "fdsa"}
+  end
+
+  it "should respect hash_key_access for params hash" do
+    RubyAMF.configuration.hash_key_access = :symbol
+    RubyAMF.configuration.map_params "c", "a", ["param1", :param2]
+    params = @envelope.params_hash "c", "a", ["asdf", "fdsa"]
+    params.should == {:param1 => "asdf", :param2 => "fdsa", 0 => "asdf", 1 => "fdsa"}
+  end
+
+  it "should expose credentials set through NetConnection credentials header" do
+    req = create_envelope('requestWithOldCredentials.bin')
+    req.credentials.should == {'username' => "username", 'password' => "password"}
+  end
+
+  it "should expose credentials set through setRemoteCredentials" do
+    req = create_envelope('requestWithNewCredentials.bin')
+    req.credentials.should == {'username' => "username", 'password' => "password"}
+  end
+
+  it "should return empty credentials if unset" do
+    req = create_envelope('remotingMessage.bin')
+    req.credentials.should == {'username' => nil, 'password' => nil}
+  end
+
+  it "should respect hash_key_access config for credentials" do
+    RubyAMF.configuration.hash_key_access = :symbol
+    req = create_envelope('requestWithOldCredentials.bin')
+    req.credentials.should == {:username => "username", :password => "password"}
+    req = create_envelope('requestWithNewCredentials.bin')
+    req.credentials.should == {:username => "username", :password => "password"}
+    req = create_envelope('remotingMessage.bin')
+    req.credentials.should == {:username => nil, :password => nil}
+  end
+
+  it "should respect translate_case config for credentials" do
+    RubyAMF.configuration.translate_case = true
+    req = create_envelope('requestWithOldCredentials.bin')
+    req.credentials.should == {'username' => "username", 'password' => "password"}
+    req = create_envelope('requestWithNewCredentials.bin')
+    req.messages[0].data.messageId.should == "CA4F7056-317E-FC0C-BEDA-DFFC8B3AA791"
+    req.credentials.should == {'username' => "username", 'password' => "password"}
+    req = create_envelope('remotingMessage.bin')
+    req.messages[0].data.messageId.should == "FE4AF2BC-DD3C-5470-05D8-9971D51FF89D"
+    req.credentials.should == {'username' => nil, 'password' => nil}
+  end
+end

data/spec/fixtures/rubyamf_config.rb

@@ -0,0 +1,24 @@
+require 'app/configuration'
+module RubyAMF
+  module Configuration
+    ClassMappings.ignore_fields = ['changed']
+    ClassMappings.translate_case = true
+    ClassMappings.hash_key_access = :string
+    ClassMappings.assume_types = true
+    ClassMappings.use_array_collection = true
+    ClassMappings.check_for_associations = false
+    ParameterMappings.always_add_to_params = false
+
+    ClassMappings.register(:actionscript => 'Blank', :ruby => 'Blank', :type => 'active_record')
+    ClassMappings.register(:actionscript => 'Attribute', :ruby => 'Attribute', :type => 'active_record', :attributes => ["prop_a", "prop_b"])
+    ClassMappings.register(:actionscript => 'Association', :ruby => 'Association', :type => 'active_record', :associations=> ["assoc_a", "assoc_b"])
+    ClassMappings.register(:actionscript => 'Both', :ruby => 'Both', :type => 'active_record', :attributes => ["prop_a", "prop_b"], :associations=> ["assoc_a", "assoc_b"])
+    ClassMappings.register(:actionscript => 'Method', :ruby => 'Method', :methods => ["meth_a"])
+    ClassMappings.register(:actionscript => 'Scoped1', :ruby => 'Scoped1', :attributes => {"scope_1" => ["prop_a", "prop_b"], "scope_2" => ["prop_a"]})
+    ClassMappings.register(:actionscript => 'Scoped2', :ruby => 'Scoped2', :associations => {:scope_1 => ["assoc_a", "assoc_b"], :scope_2 => ["assoc_a"]})
+    ClassMappings.register(:actionscript => 'Scoped3', :ruby => 'Scoped3', :attributes => {"scope_1" => ["prop_a", "prop_b"], "scope_2" => ["prop_a"]}, :associations => ["assoc_a", "assoc_b"])
+    ClassMappings.register(:actionscript => 'Scoped4', :ruby => 'Scoped4', :attributes => {"scope_1" => ["prop_a", "prop_b"], "scope_2" => ["prop_a"]}, :associations => {"scope_1" => ["assoc_a", "assoc_b"], "scope_3" => ["assoc_a"]})
+
+    ParameterMappings.register(:controller => :Controller, :action => :action, :params => {:param_1 => "[0]", :param_2 => "[1]", :param_4 => "[3]"})
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,281 @@
+require "spec_helper.rb"
+
+# Include in ActiveRecord because rails bootstrap not triggered in specs
+require "rubyamf/rails/model"
+ActiveRecord::Base.send(:include, RubyAMF::Rails::Model)
+
+describe RubyAMF::Model do
+  before :all do
+    class SimpleModelTestObject
+      include RubyAMF::Model
+      attr_accessor :prop_a, :prop_b
+      def initialize
+        @prop_a = "asdf"
+        @prop_b = "fdsa"
+      end
+    end
+
+    class ModelTestObject
+      include RubyAMF::Model
+      attr_accessor :attributes, :settable_method
+      def initialize
+        @attributes = {"prop_a" => "asdf", "prop_b" => "fdsa"}
+      end
+      def a_method
+        "result"
+      end
+    end
+
+    p = Parent.create :name => "parent"
+    p.children.create :name => "child 1"
+    p.children.create :name => "child 2"
+    p.home = Home.create :address => "1234 Main St."
+  end
+
+  before :each do
+    RubyAMF::ClassMapper.reset
+    RubyAMF.configuration = RubyAMF::Configuration.new
+  end
+
+  describe 'configuration' do
+    it "should map ruby class to flash class" do
+      ModelTestObject.module_eval do
+        as_class "as"
+        actionscript_class "actionscript"
+        flash_class "flash"
+      end
+      m = RubyAMF::ClassMapper.mappings
+      m.get_as_class_name("ModelTestObject").should == "flash"
+      m.get_ruby_class_name("flash").should == "ModelTestObject"
+    end
+
+    it "should save serialization configs to class mapper" do
+      ModelTestObject.module_eval do
+        as_class "com.test.ASClass"
+        map_amf :only => "prop_a"
+        map_amf :testing, :only => "prop_b"
+        map_amf :default_scope => :asdf, :only => "prop_c"
+      end
+      m = RubyAMF::ClassMapper.mappings
+      m.get_as_class_name("ModelTestObject").should == "com.test.ASClass"
+      m.get_ruby_class_name("com.test.ASClass").should == "ModelTestObject"
+      m.serialization_config("ModelTestObject", :default).should == {:only => "prop_a"}
+      m.serialization_config("ModelTestObject", :testing).should == {:only => "prop_b"}
+      m.serialization_config("ModelTestObject", :asdf).should == {:only => "prop_c"}
+    end
+
+    it "should work with RocketAMF class mapper" do
+      # Swap out class mapper
+      old_mapper = RubyAMF.send(:remove_const, :ClassMapper)
+      RubyAMF.const_set(:ClassMapper, RocketAMF::ClassMapping)
+
+      # Test it
+      ModelTestObject.module_eval do
+        as_class "com.test.ASClass"
+        map_amf :only => "prop_a"
+        map_amf :testing, :only => "prop_b"
+        map_amf :default_scope => :asdf, :only => "prop_c"
+      end
+      m = RubyAMF::ClassMapper.mappings
+      m.get_as_class_name("ModelTestObject").should == "com.test.ASClass"
+      m.get_ruby_class_name("com.test.ASClass").should == "ModelTestObject"
+
+      # Swap old class mapper back in
+      RubyAMF.send(:remove_const, :ClassMapper)
+      RubyAMF.const_set(:ClassMapper, old_mapper)
+    end
+  end
+
+  describe 'deserialization' do
+    it "should populate simple object properly from deserialization" do
+      t = SimpleModelTestObject.allocate
+      t.rubyamf_init({:prop_a => "seta", :prop_b => "setb"})
+      t.prop_a.should == "seta"
+      t.prop_b.should == "setb"
+    end
+
+    it "should populate fully-conforming object properly from deserialization" do
+      t = ModelTestObject.allocate
+      t.rubyamf_init({"prop_a" => "seta"}, {"prop_b" => "setb"}) # classmapper would pass symbolic keys - oh well?
+      t.attributes.should == {"prop_a" => "seta", "prop_b" => "setb"}
+    end
+
+    it "should call setters for non-attributes" do
+      t = ModelTestObject.allocate
+      t.rubyamf_init({"prop_a" => "seta", "settable_method" => "meth"})
+      t.attributes.should == {"prop_a" => "seta"}
+      t.settable_method.should == "meth"
+    end
+  end
+
+  describe 'serialization' do
+    it "should return an IntermediateObject when to_amf is called" do
+      t = ModelTestObject.new
+      obj = t.to_amf({:only => "prop_a"})
+      obj.should be_a(RubyAMF::IntermediateObject)
+      obj.object.should == t
+      obj.options.should == {:only => "prop_a"}
+    end
+
+    it "should convert simple object to serializable hash" do
+      t = SimpleModelTestObject.new
+      t.rubyamf_hash.should == {"prop_a" => "asdf", "prop_b" => "fdsa"}
+      t.rubyamf_hash(:only => "prop_a").should == {"prop_a" => "asdf"}
+      t.rubyamf_hash(:except => ["prop_a"]).should == {"prop_b" => "fdsa"}
+    end
+
+    it "should convert fully-conforming object to serializable hash" do
+      t = ModelTestObject.new
+      t.rubyamf_hash.should == t.attributes
+      t.rubyamf_hash(:only => "prop_a").should == {"prop_a" => "asdf"}
+      t.rubyamf_hash(:except => ["prop_a"]).should == {"prop_b" => "fdsa"}
+      t.rubyamf_hash(:methods => :a_method).should == {"prop_a" => "asdf", "prop_b" => "fdsa", "a_method" => "result"}
+    end
+
+    it "should properly process generic includes" do
+      t = ModelTestObject.new
+      t.should_receive(:courses).and_return([ModelTestObject.new])
+      h = t.rubyamf_hash(:except => "prop_a", :include => :courses)
+      h.keys.sort.should == ["courses", "prop_b"]
+      h["prop_b"].should == "fdsa"
+      h["courses"].length.should == 1
+      h["courses"][0].class.should == ModelTestObject
+    end
+
+    it "should convert configured includes to IntermediateObjects" do
+      t = ModelTestObject.new
+      t.should_receive(:courses).and_return([ModelTestObject.new])
+      h = t.rubyamf_hash(:except => "prop_a", :include => {:courses => {:except => "prop_b"}})
+      h.keys.sort.should == ["courses", "prop_b"]
+      h["prop_b"].should == "fdsa"
+      h["courses"].length.should == 1
+      h["courses"][0].options.should == {:except => "prop_b"}
+    end
+  end
+
+  # Need to run these tests against rails 2.3, 3.0, and 3.1
+  describe 'ActiveRecord' do
+    describe 'deserialization' do
+
+      it "should create new records if no id given" do
+        c = Child.allocate
+        c.rubyamf_init({:name => "Foo Bar"})
+        c.name.should == "Foo Bar"
+        c.new_record?.should == true
+        c.changed.should == ["name"]
+      end
+
+      it "should create new records if id is 'empty'" do
+        c = Child.allocate
+        c.rubyamf_init({:id => 0, :name => "Foo Bar"})
+        c.name.should == "Foo Bar"
+        c.new_record?.should == true
+        c.changed.should == ["name"]
+
+        c = Child.allocate
+        c.rubyamf_init({:id => nil, :name => "Foo Bar"})
+        c.name.should == "Foo Bar"
+        c.new_record?.should == true
+        c.changed.should == ["name"]
+      end
+
+      it "should determine whether a record is new if composite PK" do
+        # Create composite child in DB
+        c = CompositeChild.new
+        c.id = [10, "blah"]
+        c.save
+
+        # Check it
+        c = CompositeChild.allocate
+        c.rubyamf_init({:id => 10, :name => "blah"})
+        c.id.should == [10, "blah"]
+        c.new_record?.should == false
+        c.changed.should == []
+      end
+
+      it "should properly initialize 'existing' objects" do
+        c = Child.allocate
+        c.rubyamf_init({:id => 5, :name => "Bar Foo"})
+        c.id.should == 5
+        c.name.should == "Bar Foo"
+        c.new_record?.should == false
+        c.changed.should == ["name"]
+      end
+
+      it "should properly initialize STI objects"
+
+      context "associations" do
+        let(:p) { Parent.allocate }
+        let(:c) { Child.allocate }
+        let(:p_with_associations) { Parent.allocate }
+
+        def create_deserialized_parent_with_associations children=nil, home=nil, save_parent=true
+          p_with_associations.rubyamf_init({:id => p.id, :name => "parent", :children => children, :home => home})
+          p_with_associations.save if save_parent
+        end
+
+        before :each do
+          c.rubyamf_init({:name => "Foo Bar"})
+          p.rubyamf_init({:name => "parent", :children => [c]})
+          p.children.length.should == 1
+          p.save
+        end
+
+        it "should deserialize associations" do
+          p.children[0].parent_id.should == p.id
+        end
+
+        it "should deserialize and not clear empty associations" do
+          create_deserialized_parent_with_associations []
+          p_with_associations.children(true).length.should == 1
+        end
+
+        it "should ignore nil associations" do
+          create_deserialized_parent_with_associations nil
+          p_with_associations.children(true).length.should == 1
+        end
+
+        it "should deserialize and not automatically save associations" do
+          c2 = Child.allocate
+          c2.rubyamf_init({:name => "Foo Bars"})
+          h = Home.allocate
+          h.rubyamf_init(:address => "1234 Here")
+          create_deserialized_parent_with_associations [c2], h, false
+          c2.should be_new_record
+          h.should be_new_record
+          p_with_associations.save
+          c2.should_not be_new_record
+          h.should_not be_new_record
+        end
+      end
+    end
+
+    describe 'serialization' do
+      it "should support serializing associations" do
+        h = Parent.first.rubyamf_hash(:include => [:children])
+        h["children"].length.should == 2
+      end
+
+      it "should support serializing associations with configurations" do
+        h = Parent.first.rubyamf_hash(:include => {:children => {:only => "name"}})
+        h["children"].length.should == 2
+      end
+
+      it "should support automatically including loaded relations without belongs_to" do
+        # No associations pre-loaded
+        p = Parent.first
+        p.rubyamf_hash.should == {"id" => 1, "name" => "parent"}
+
+        # Force associations to load
+        p.children.to_a
+        p.home
+
+        # Associations should be in hash
+        h = p.rubyamf_hash
+        h["children"].length.should == 2
+        h["children"][0].rubyamf_hash.should == {"id" => 1, "name" => "child 1", "parent_id" => 1}
+        h["home"].should == p.home
+      end
+    end
+  end
+end