mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/test/unit/associations/test_base.rb

@@ -5,203 +5,208 @@ class FooMonster; end
 
 class AssociationBaseTest < Test::Unit::TestCase
   include MongoMapper::Plugins::Associations
-  
+
   should "initialize with type and name" do
     base = Base.new(:many, :foos)
     base.type.should == :many
     base.name.should == :foos
   end
-  
+
   should "also allow options when initializing" do
     base = Base.new(:many, :foos, :polymorphic => true)
     base.options[:polymorphic].should be_true
   end
-  
+
   context "class_name" do
     should "work for belongs_to" do
       Base.new(:belongs_to, :user).class_name.should == 'User'
     end
-    
+
     should "work for many" do
       Base.new(:many, :smart_people).class_name.should == 'SmartPerson'
     end
-    
+
     should "be changeable using class_name option" do
       base = Base.new(:many, :smart_people, :class_name => 'IntelligentPerson')
       base.class_name.should == 'IntelligentPerson'
     end
   end
-  
+
   context "klass" do
     should "default to class_name constantized" do
       Base.new(:belongs_to, :foo_monster).klass.should == FooMonster
     end
-    
+
     should "be the specified class" do
       anonnymous_class = Class.new
       Base.new(:belongs_to, :foo_monster, :class => anonnymous_class).klass.should == anonnymous_class
     end
   end
-  
+
   context "many?" do
     should "be true if many" do
       Base.new(:many, :foos).many?.should be_true
     end
-    
+
     should "be false if not many" do
       Base.new(:belongs_to, :foo).many?.should be_false
       Base.new(:one, :foo).many?.should be_false
     end
   end
-  
+
   context "one?" do
     should "be true if one" do
       Base.new(:one, :foo).one?.should be_true
     end
-    
+
     should "be false if not one" do
       Base.new(:many, :foo).one?.should be_false
     end
   end
-  
+
   context "belongs_to?" do
     should "be true if belongs_to" do
       Base.new(:belongs_to, :foo).belongs_to?.should be_true
     end
-    
+
     should "be false if not belongs_to" do
       Base.new(:many, :foos).belongs_to?.should be_false
     end
   end
-  
+
   context "polymorphic?" do
     should "be true if polymorphic" do
       Base.new(:many, :foos, :polymorphic => true).polymorphic?.should be_true
     end
-    
+
     should "be false if not polymorphic" do
       Base.new(:many, :bars).polymorphic?.should be_false
     end
   end
-  
+
   context "as?" do
     should "be true if one" do
       Base.new(:one, :foo, :as => :commentable).as?.should be_true
     end
-    
+
     should "be false if not one" do
       Base.new(:many, :foo).as?.should be_false
     end
   end
-  
+
   context "in_array?" do
     should "be true if one" do
       Base.new(:one, :foo, :in => :list_ids).in_array?.should be_true
     end
-    
+
     should "be false if not one" do
       Base.new(:many, :foo).in_array?.should be_false
     end
   end
-  
+
   context "query_options" do
     should "default to empty hash" do
       base = Base.new(:many, :foos)
       base.query_options.should == {}
     end
-    
+
     should "work with order" do
       base = Base.new(:many, :foos, :order => 'position')
       base.query_options.should == {:order => 'position'}
     end
-    
+
     should "correctly parse from options" do
       base = Base.new(:many, :foos, :order => 'position', :somekey => 'somevalue')
       base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
     end
   end
-  
+
   context "type_key_name" do
     should "be _type for many" do
       Base.new(:many, :foos).type_key_name.should == '_type'
     end
-    
+
     should "be association name _ type for belongs_to" do
       Base.new(:belongs_to, :foo).type_key_name.should == 'foo_type'
     end
   end
-  
+
   context "foreign_key" do
     should "default to assocation name _id for belongs to" do
       base = Base.new(:belongs_to, :foo)
       base.foreign_key.should == 'foo_id'
     end
-    
+
     should "be overridable with :foreign_key option" do
       base = Base.new(:belongs_to, :foo, :foreign_key => 'foobar_id')
       base.foreign_key.should == 'foobar_id'
     end
   end
-  
+
   should "have ivar that is association name" do
     Base.new(:belongs_to, :foo).ivar.should == '@_foo'
   end
-  
+
   context "embeddable?" do
     should "be true if class is embeddable" do
       base = Base.new(:many, :medias)
       base.embeddable?.should be_true
     end
-    
+
     should "be false if class is not embeddable" do
       base = Base.new(:many, :statuses)
       base.embeddable?.should be_false
-      
+
       base = Base.new(:belongs_to, :project)
       base.embeddable?.should be_false
     end
   end
-  
+
   context "proxy_class" do
-    should "be ManyDocumentsProxy for many" do      
+    should "be ManyDocumentsProxy for many" do
       base = Base.new(:many, :statuses)
       base.proxy_class.should == ManyDocumentsProxy
     end
-    
+
     should "be ManyPolymorphicProxy for polymorphic many" do
       base = Base.new(:many, :messages, :polymorphic => true)
       base.proxy_class.should == ManyPolymorphicProxy
     end
-    
+
     should "be ManyEmbeddedProxy for many embedded" do
       base = Base.new(:many, :medias)
       base.proxy_class.should == ManyEmbeddedProxy
     end
-    
+
     should "be ManyEmbeddedPolymorphicProxy for polymorphic many embedded" do
       base = Base.new(:many, :medias, :polymorphic => true)
       base.proxy_class.should == ManyEmbeddedPolymorphicProxy
     end
-    
+
     should "be BelongsToProxy for belongs_to" do
       base = Base.new(:belongs_to, :project)
       base.proxy_class.should == BelongsToProxy
     end
-    
+
     should "be BelongsToPolymorphicProxy for polymorphic belongs_to" do
       base = Base.new(:belongs_to, :target, :polymorphic => true)
       base.proxy_class.should == BelongsToPolymorphicProxy
     end
-    
+
     should "be OneProxy for one" do
-      base = Base.new(:one, :target, :polymorphic => true)
+      base = Base.new(:one, :status, :polymorphic => true)
       base.proxy_class.should == OneProxy
     end
-    
+
+    should "be OneEmbeddedProxy for one embedded" do
+      base = Base.new(:one, :media)
+      base.proxy_class.should == OneEmbeddedProxy
+    end
+
     should "be InArrayProxy for many with :in option" do
       base = Base.new(:many, :messages, :in => :message_ids)
       base.proxy_class.should == InArrayProxy
     end
   end
-  
-end
+
+end

data/test/unit/associations/test_proxy.rb

@@ -27,77 +27,77 @@ class ProxyTest < Test::Unit::TestCase
     @nil_proxy   = FakeNilProxy.new(@owner, @association)
     @blank_proxy = FakeBlankProxy.new(@owner, @association)
   end
-  
+
   should 'return true for === target' do
     @proxy = FakeProxy.new(@owner, @association)
     @proxy.should === Array
   end
-  
+
   should "set target to nil when reset is called" do
     @proxy.reset
     @proxy.target.should be_nil
   end
-  
+
   should "be able to inspect the proxy" do
     @proxy.inspect.should == '[1, 2]'
   end
-  
+
   context "nil?" do
     should "be true if nil" do
       @nil_proxy.nil?.should be_true
     end
-    
+
     should "be false if not nil" do
       @proxy.nil?.should be_false
     end
   end
-  
+
   context "blank?" do
     should "be true if blank" do
       @blank_proxy.blank?.should be_true
       @nil_proxy.blank?.should be_true
     end
-    
+
     should "be false if not blank" do
       @proxy.blank?.should be_false
     end
   end
-  
+
   context "present?" do
     should "be true if present" do
       @proxy.present?.should be_true
     end
-    
+
     should "be false if not present" do
       @blank_proxy.present?.should be_false
       @nil_proxy.present?.should be_false
     end
   end
-  
+
   should "delegate respond_to? to target" do
     @proxy.respond_to?(:each).should be_true
     @proxy.respond_to?(:size).should be_true
     @proxy.respond_to?(:gsub).should be_false
   end
-  
+
   should "alias proxy owner to owner" do
     @proxy.proxy_owner.should == @owner
   end
-  
+
   should "alias proxy target to target" do
     @proxy.proxy_target.should == @target
   end
-  
+
   context "send" do
     should "work if proxy responds to method" do
       @proxy.send(:reset)
       @proxy.target.should be_nil
     end
-    
+
     should "work if the target responds to the method" do
       @proxy.send(:size).should == 2
     end
-    
+
     should "not work if neither the proxy or target respond to method" do
       lambda { @proxy.send(:gsub) }.should raise_error
     end

data/test/unit/serializers/test_json_serializer.rb

@@ -2,18 +2,18 @@ require 'test_helper'
 require 'active_support/version'
 
 class JsonSerializationTest < Test::Unit::TestCase
-  
-  # Helper function in case things change in the future 
+
+  # Helper function in case things change in the future
   # - replacing all those to_json calls was a nightmare
-  def convert_to_json object, options = {}
+  def convert_to_json(object, options={})
     ActiveSupport::JSON.encode(object, options)
   end
-  
+
   class Tag
     include MongoMapper::EmbeddedDocument
     key :name, String
   end
-  
+
   class Contact
     include MongoMapper::Document
     key :name, String
@@ -21,10 +21,10 @@ class JsonSerializationTest < Test::Unit::TestCase
     key :created_at, Time
     key :awesome, Boolean
     key :preferences, Hash
-    
+
     many :tags, :class_name => 'JsonSerializationTest::Tag'
   end
-  
+
   def setup
     Contact.include_root_in_json = false
     @contact = Contact.new(
@@ -35,12 +35,12 @@ class JsonSerializationTest < Test::Unit::TestCase
       :preferences => { :shows => 'anime' }
     )
   end
-  
+
   should "include demodulized root" do
     Contact.include_root_in_json = true
     assert_match %r{^\{"contact":\s?\{}, convert_to_json(@contact)
   end
-  
+
   should "encode all encodable attributes" do
     json = convert_to_json(@contact)
 
@@ -51,7 +51,7 @@ class JsonSerializationTest < Test::Unit::TestCase
     assert_match %r{"awesome":true}, json
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
-  
+
   should "allow attribute filtering with only" do
     json = convert_to_json(@contact, :only => [:name, :age])
 
@@ -62,7 +62,7 @@ class JsonSerializationTest < Test::Unit::TestCase
     assert_no_match %r{"created_at"}, json
     assert_no_match %r{"preferences"}, json
   end
-  
+
   should "allow attribute filtering with except" do
     json = convert_to_json(@contact, :except => [:name, :age])
 
@@ -73,30 +73,30 @@ class JsonSerializationTest < Test::Unit::TestCase
     assert_match %r{"created_at"}, json
     assert_match %r{"preferences"}, json
   end
-  
+
   context "_id key" do
     should "not be included by default" do
       json = convert_to_json(@contact)
       assert_no_match %r{"_id":}, json
     end
-    
+
     should "not be included even if :except is used" do
       json = convert_to_json(@contact, :except => :name)
       assert_no_match %r{"_id":}, json
     end
   end
-  
+
   context "id method" do
     setup do
       def @contact.label; "Has cheezburger"; end
       def @contact.favorite_quote; "Constraints are liberating"; end
     end
-    
+
     should "be included by default" do
       json = convert_to_json(@contact)
       assert_match %r{"id"}, json
     end
-    
+
     should "be included when single method included" do
       json = convert_to_json(@contact, :methods => :label)
       assert_match %r{"id"}, json
@@ -104,7 +104,7 @@ class JsonSerializationTest < Test::Unit::TestCase
       assert_match %r{"name":"Konata Izumi"}, json
       assert_no_match %r{"favorite_quote":"Constraints are liberating"}, json
     end
-    
+
     should "be included when multiple methods included" do
       json = convert_to_json(@contact, :methods => [:label, :favorite_quote])
       assert_match %r{"id"}, json
@@ -112,29 +112,29 @@ class JsonSerializationTest < Test::Unit::TestCase
       assert_match %r{"favorite_quote":"Constraints are liberating"}, json
       assert_match %r{"name":"Konata Izumi"}, json
     end
-    
+
     should "not be included if :only is present" do
       json = convert_to_json(@contact, :only => :name)
       assert_no_match %r{"id":}, json
     end
-    
+
     should "be represented by a string" do
       json = convert_to_json(@contact)
       assert_match %r{"id":"}, json
-    end      
-  end  
-  
+    end
+  end
+
   context "including methods" do
     setup do
       def @contact.label; "Has cheezburger"; end
       def @contact.favorite_quote; "Constraints are liberating"; end
     end
-    
+
     should "include single method" do
       json = convert_to_json(@contact, :methods => :label)
       assert_match %r{"label":"Has cheezburger"}, json
     end
-    
+
     should "include multiple methods" do
       json = convert_to_json(@contact, :only => :name, :methods => [:label, :favorite_quote])
       assert_match %r{"label":"Has cheezburger"}, json
@@ -146,7 +146,7 @@ class JsonSerializationTest < Test::Unit::TestCase
       assert_no_match %r{"preferences"}, json
     end
   end
-  
+
   context "array of records" do
     setup do
       @contacts = [
@@ -160,7 +160,7 @@ class JsonSerializationTest < Test::Unit::TestCase
       assert_match %r{\{"name":"David"\}}, json
       assert_match %r{\{"name":"Mary"\}}, json
     end
-    
+
     should "allow attribute filtering with except" do
       json = convert_to_json(@contacts, :except => [:name, :preferences, :awesome, :created_at, :updated_at])
       assert_match %r{"age":39},          json
@@ -172,7 +172,7 @@ class JsonSerializationTest < Test::Unit::TestCase
       assert_no_match %r{"updated_at":},  json
     end
   end
-  
+
   should "allow options for hash of records" do
     contacts = {
       1 => Contact.new(:name => 'David', :age => 39),
@@ -183,7 +183,7 @@ class JsonSerializationTest < Test::Unit::TestCase
     assert_match %r{\{"name":"David"\}}, json
     assert_no_match %r{"2":},            json
   end
-  
+
   should "include embedded attributes" do
     contact = Contact.new(:name => 'John', :age => 27)
     contact.tags = [Tag.new(:name => 'awesome'), Tag.new(:name => 'ruby')]
@@ -192,7 +192,7 @@ class JsonSerializationTest < Test::Unit::TestCase
     assert_match %r{"name":"awesome"}, json
     assert_match %r{"name":"ruby"}, json
   end
-  
+
   should "include dynamic attributes" do
     contact = Contact.new(:name => 'John', :age => 27, :foo => 'bar')
     contact['smell'] = 'stinky'

data/test/unit/test_clone.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class CloneTest < Test::Unit::TestCase
+  context "Document" do
+    setup do
+      @document = Doc()
+      @embedded = EDoc()
+      @document.many :widgets, :class => @embedded
+      @tags = ['red', 'green', 'blue']
+      @doc = @document.create({
+        :name    => "foo",
+        :age     => 27,
+        :tags    => @tags,
+        :widgets => [@embedded.new, @embedded.new],
+      })
+    end
+
+    context "#clone" do
+      should "be new" do
+        @doc.clone.should be_new
+      end
+
+      should "copy the attributes" do
+        clone = @doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+
+      should "clone duplicable attributes" do
+        @doc.clone.tags.should_not equal(@tags)
+      end
+
+      should "clone many embedded documents" do
+        @doc.clone.widgets.should_not equal(@doc.widgets)
+      end
+
+      should "not be destroyed" do
+        @doc.destroy
+        @doc.clone.should_not be_destroyed
+      end
+    end
+  end
+
+  context "EmbeddedDocument" do
+    setup do
+      @document = EDoc do
+        key :name, String
+        key :age, Integer
+      end
+    end
+
+    context "#clone" do
+      should "regenerate the id" do
+        doc = @document.new(:name => "foo", :age => 27)
+        doc_id = doc.id
+        clone = doc.clone
+        clone_id = clone.id
+        clone_id.should_not == doc_id
+      end
+
+      should "copy the attributes" do
+        doc = @document.new(:name => "foo", :age => 27)
+        clone = doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+    end
+  end
+end

data/test/unit/test_descendant_appends.rb

@@ -5,7 +5,7 @@ class DescendantAppendsTest < Test::Unit::TestCase
     should "default descendants to a new set" do
       MongoMapper::Document.descendants.should be_instance_of(Set)
     end
-    
+
     should 'allow extensions to Document to be appended' do
       module Extension; def test_this_extension; end end
       MongoMapper::Document.append_extensions(Extension)
@@ -34,12 +34,12 @@ class DescendantAppendsTest < Test::Unit::TestCase
       article.new.should respond_to(:test_this_inclusion)
     end
   end
-  
+
   context "EmbeddedDocument" do
     should "default descendants to a new set" do
       MongoMapper::EmbeddedDocument.descendants.should be_instance_of(Set)
     end
-    
+
     should 'allow extensions to Document to be appended' do
       module Extension; def test_this_extension; end end
       MongoMapper::EmbeddedDocument.append_extensions(Extension)