djsun-mongomapper 0.3.1.1 → 0.3.3

data/test/functional/test_document.rb

@@ -15,6 +15,38 @@ class DocumentTest < Test::Unit::TestCase
     @document.collection.clear
   end
 
+  context "Saving a document with a custom id" do
+    should "clear custom id flag when saved" do
+      doc = @document.new(:id => '1234')
+      doc.using_custom_id?.should be_true
+      doc.save.should be_true
+      doc.using_custom_id?.should be_false
+    end
+  end
+  
+  context "Loading a document from the database with keys that are not defined" do
+    setup do
+      @id = XGen::Mongo::Driver::ObjectID.new.to_s
+      @document.collection.insert({
+        :_id            => @id,
+        :first_name     => 'John', 
+        :last_name      => 'Nunemaker', 
+        :age            => 27, 
+        :favorite_color => 'red',
+        :skills         => ['ruby', 'rails', 'javascript', 'xhtml', 'css']
+      })
+    end
+
+    should "assign all keys from database" do
+      doc = @document.find(@id)
+      doc.first_name.should == 'John'
+      doc.last_name.should == 'Nunemaker'
+      doc.age.should == 27
+      doc.favorite_color.should == 'red'
+      doc.skills.should == ['ruby', 'rails', 'javascript', 'xhtml', 'css']
+    end
+  end
+  
   context "Document Class Methods" do
     context "Using key with type Array" do
       setup do
@@ -53,7 +85,7 @@ class DocumentTest < Test::Unit::TestCase
         doc.tags.should == ["foo"]
       end
 
-      should_eventually "work with << then save" do
+      should "work with << then save" do
         doc = @document.new
         doc.tags << "foo"
         doc.tags << "bar"
@@ -61,7 +93,6 @@ class DocumentTest < Test::Unit::TestCase
         doc.tags.should == %w(foo bar)
         @document.find(doc.id).tags.should == %w(foo bar)
       end
-
     end
 
     context "Using key with type Hash" do
@@ -73,14 +104,14 @@ class DocumentTest < Test::Unit::TestCase
         doc = @document.new
         doc.foo.should == {}
       end
-      
+
       should "work with []=" do
         doc = @document.new
         doc.foo["quux"] = "bar"
         doc.foo["quux"].should == "bar"
         doc.foo.should == { "quux" => "bar" }
       end
-      
+
       should "work with indifferent access" do
         doc = @document.new
         doc.foo = {:baz => 'bar'}
@@ -92,6 +123,7 @@ class DocumentTest < Test::Unit::TestCase
         doc = @document.new
         doc.foo = {:baz => 'bar'}
         doc.save
+
         doc = @document.find(doc.id)
         doc.foo[:baz].should == 'bar'
         doc.foo['baz'].should == 'bar'
@@ -132,6 +164,10 @@ class DocumentTest < Test::Unit::TestCase
         @doc_instance.id.size.should == 24
       end
 
+      should "no longer be new?" do
+        @doc_instance.new?.should be_false
+      end
+
       should "return instance of document" do
         @doc_instance.should be_instance_of(@document)
         @doc_instance.first_name.should == 'John'
@@ -249,11 +285,7 @@ class DocumentTest < Test::Unit::TestCase
         end
 
         should "raise error if document not found" do
-          lambda { @document.find(MongoID.new) }.should raise_error(MongoMapper::DocumentNotFound)
-        end
-
-        should_eventually "raise error if id is illegal" do
-          lambda { @document.find(1) }.should raise_error(MongoMapper::IllegalID)
+          lambda { @document.find(123) }.should raise_error(MongoMapper::DocumentNotFound)
         end
       end
 
@@ -280,7 +312,7 @@ class DocumentTest < Test::Unit::TestCase
       context "with #all" do
         should "find all documents based on criteria" do
           @document.all(:order => 'first_name').should == [@doc1, @doc3, @doc2]
-          @document.all(:conditions => {:last_name => 'Nunemaker'}).should == [@doc1, @doc3]
+          @document.all(:conditions => {:last_name => 'Nunemaker'}, :order => 'age desc').should == [@doc1, @doc3]
         end
       end
 
@@ -299,17 +331,75 @@ class DocumentTest < Test::Unit::TestCase
 
       context "with :last" do
         should "find last document" do
-          @document.find(:last).should == @doc3
+          @document.find(:last, :order => 'age').should == @doc2
         end
       end
 
       context "with #last" do
         should "find last document based on criteria" do
-          @document.last.should == @doc3
+          @document.last(:order => 'age').should == @doc2
           @document.last(:conditions => {:age => 28}).should == @doc2
         end
       end
 
+      context "with :find_by" do
+        should "find document based on argument" do
+          @document.find_by_first_name('John').should == @doc1
+          @document.find_by_last_name('Nunemaker', :order => 'age desc').should == @doc1
+          @document.find_by_age(27).should == @doc1
+        end
+
+        should "not raise error" do
+          @document.find_by_first_name('Mongo').should be_nil
+        end
+
+        should "define a method for each key" do
+          @document.methods(false).select { |e| e =~ /^find_by_/ }.size == @document.keys.size
+        end
+      end
+
+      context "with dynamic finders" do
+        should "find document based on all arguments" do
+          @document.find_by_first_name_and_last_name_and_age('John', 'Nunemaker', 27).should == @doc1
+        end
+
+        should "not find the document if an argument is wrong" do
+          @document.find_by_first_name_and_last_name_and_age('John', 'Nunemaker', 28).should be_nil
+        end
+
+        should "find all documents based on arguments" do
+          docs = @document.find_all_by_last_name('Nunemaker')
+          docs.should be_kind_of(Array)
+          docs.should include(@doc1)
+          docs.should include(@doc3)
+        end
+
+        should "find last document based on arguments" do
+          doc = @document.find_last_by_last_name('Nunemaker', :order => 'age')
+          doc.should == @doc1
+        end
+
+        should "initialize document with given arguments" do
+          doc = @document.find_or_initialize_by_first_name_and_last_name('David', 'Cuadrado')
+          doc.should be_new
+          doc.first_name.should == 'David'
+        end
+
+        should "not initialize document if document is found" do
+          doc = @document.find_or_initialize_by_first_name('John')
+          doc.should_not be_new
+        end
+
+        should "create document with given arguments" do
+          doc = @document.find_or_create_by_first_name_and_last_name('David', 'Cuadrado')
+          doc.should_not be_new
+          doc.first_name.should == 'David'
+        end
+
+        should "raise error if document is not found" do
+          lambda {@document.find_by_first_name_and_last_name!(1,2)}.should raise_error(MongoMapper::DocumentNotFound)
+        end
+      end
     end # finding documents
 
     context "Finding document by id" do
@@ -324,7 +414,7 @@ class DocumentTest < Test::Unit::TestCase
       end
 
       should "return nil if document not found" do
-        @document.find_by_id(MongoID.new).should be(nil)
+        @document.find_by_id(1234).should be(nil)
       end
     end
 
@@ -448,6 +538,123 @@ class DocumentTest < Test::Unit::TestCase
       end
     end
 
+    context ":dependent" do
+      setup do
+        # FIXME: make use of already defined models
+        class ::Property
+          include MongoMapper::Document
+        end
+        Property.delete_all
+
+        class ::Thing
+          include MongoMapper::Document
+          key :name, String
+        end
+        Thing.delete_all
+      end
+
+      teardown do
+        Object.send :remove_const, 'Property' if defined?(::Property)
+        Object.send :remove_const, 'Thing' if defined?(::Thing)
+      end
+
+      context "many" do
+        context "=> destroy" do
+          setup do
+            Property.key :thing_id, String
+            Property.belongs_to :thing, :dependent => :destroy
+            Thing.many :properties, :dependent => :destroy
+
+            @thing = Thing.create(:name => "Tree")
+            @property1 = Property.create
+            @property2 = Property.create
+            @property3 = Property.create
+            @thing.properties << @property1
+            @thing.properties << @property2
+            @thing.properties << @property3
+          end
+
+          should "should destroy the associated documents" do
+            @thing.properties.count.should == 3
+            @thing.destroy
+            @thing.properties.count.should == 0
+            Property.count.should == 0
+          end
+        end
+
+        context "=> delete_all" do
+          setup do
+            Property.key :thing_id, String
+            Property.belongs_to :thing
+            Thing.has_many :properties, :dependent => :delete_all
+
+            @thing = Thing.create(:name => "Tree")
+            @property1 = Property.create
+            @property2 = Property.create
+            @property3 = Property.create
+            @thing.properties << @property1
+            @thing.properties << @property2
+            @thing.properties << @property3
+          end
+
+          should "should delete associated documents" do
+            @thing.properties.count.should == 3
+            @thing.destroy
+            @thing.properties.count.should == 0
+            Property.count.should == 0
+          end
+        end
+
+        context "=> nullify" do
+          setup do
+            Property.key :thing_id, String
+            Property.belongs_to :thing
+            Thing.has_many :properties, :dependent => :nullify
+
+            @thing = Thing.create(:name => "Tree")
+            @property1 = Property.create
+            @property2 = Property.create
+            @property3 = Property.create
+            @thing.properties << @property1
+            @thing.properties << @property2
+            @thing.properties << @property3
+          end
+
+          should "should nullify relationship but not destroy associated documents" do
+            @thing.properties.count.should == 3
+            @thing.destroy
+            @thing.properties.count.should == 0
+            Property.count.should == 3
+          end
+        end
+      end
+
+      context "belongs_to" do
+        context "=> destroy" do
+          setup do
+            Property.key :thing_id, String
+            Property.belongs_to :thing, :dependent => :destroy
+            Thing.has_many :properties
+
+            @thing = Thing.create(:name => "Tree")
+            @property1 = Property.create
+            @property2 = Property.create
+            @property3 = Property.create
+            @thing.properties << @property1
+            @thing.properties << @property2
+            @thing.properties << @property3
+          end
+
+          should "destroy the thing" do
+            Thing.count.should == 1
+            @property1.destroy
+            Thing.count.should == 0
+            @property1.thing.should be_frozen
+          end
+        end
+      end
+    end
+
     context "Counting documents in collection" do
       setup do
         @doc1 = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
@@ -504,13 +711,13 @@ class DocumentTest < Test::Unit::TestCase
         @document.ensure_index :first_name, :unique => true
       end
 
-      should_eventually "allow creating index on multiple keys" do
+      should "allow creating index on multiple keys" do
         index_name = nil
         lambda {
           index_name = @document.ensure_index [[:first_name, 1], [:last_name, -1]]
         }.should change { @document.collection.index_information.size }.by(1)
 
-        index_name.should == 'first_name_1_last_name_-1'
+        [ 'first_name_1_last_name_-1', 'last_name_-1_first_name_1' ].should include(index_name)
 
         index = @document.collection.index_information[index_name]
         index.should_not be_nil
@@ -551,6 +758,21 @@ class DocumentTest < Test::Unit::TestCase
       from_db.first_name.should == 'John'
       from_db.age.should == 27
     end
+
+    should "allow to add custom attributes to the document" do
+      @doc = @document.new(:first_name => 'David', :age => '26', :gender => 'male', :tags => [1, "2"])
+      @doc.save
+      from_db = @document.find(@doc.id)
+      from_db.gender.should == 'male'
+      from_db.tags.should == [1, "2"]
+    end
+
+    should "allow to use custom methods to assign properties" do
+      person = RealPerson.new(:realname => "David")
+      person.save
+      from_db = RealPerson.find(person.id)
+      from_db.name.should == "David"
+    end
   end
 
   context "Saving an existing document" do
@@ -575,6 +797,14 @@ class DocumentTest < Test::Unit::TestCase
       from_db.first_name.should == 'Johnny'
       from_db.age.should == 30
     end
+
+    should "allow to update custom attributes" do
+      @doc = @document.new(:first_name => 'David', :age => '26', :gender => 'male')
+      @doc.gender = 'Male'
+      @doc.save
+      from_db = @document.find(@doc.id)
+      from_db.gender.should == 'Male'
+    end
   end
 
   context "Calling update attributes on a new document" do
@@ -603,6 +833,12 @@ class DocumentTest < Test::Unit::TestCase
       from_db.first_name.should == 'Johnny'
       from_db.age.should == 30
     end
+
+    should "allow to update custom attributes" do
+      @doc.update_attributes(:gender => 'mALe')
+      from_db = @document.find(@doc.id)
+      from_db.gender.should == 'mALe'
+    end
   end
 
   context "Updating an existing document using update attributes" do
@@ -626,6 +862,20 @@ class DocumentTest < Test::Unit::TestCase
       from_db.age.should == 30
     end
   end
+  
+  context "update_attributes" do
+    setup do
+      @document.key :foo, String, :required => true
+    end
+    
+    should "return true if document valid" do
+      @document.new.update_attributes(:foo => 'bar').should be_true
+    end
+    
+    should "return false if document not valid" do
+      @document.new.update_attributes({}).should be_false
+    end
+  end
 
   context "Destroying a document that exists" do
     setup do
@@ -640,6 +890,10 @@ class DocumentTest < Test::Unit::TestCase
     should "raise error if assignment is attempted" do
       lambda { @doc.first_name = 'Foo' }.should raise_error(TypeError)
     end
+
+    should "do nothing if destroy is called again" do
+      @doc.destroy.should be_false
+    end
   end
 
   context "Destroying a document that is a new" do
@@ -660,6 +914,10 @@ class DocumentTest < Test::Unit::TestCase
   end
 
   context "timestamping" do
+    setup do
+      @document.timestamps!
+    end
+    
     should "set created_at and updated_at on create" do
       doc = @document.new(:first_name => 'John', :age => 27)
       doc.created_at.should be(nil)
@@ -679,13 +937,16 @@ class DocumentTest < Test::Unit::TestCase
       doc.updated_at.should_not == old_updated_at
     end
 
-    should_eventually "set updated_at on document update but leave created_at alone" do
+    should "set updated_at on document update but leave created_at alone" do
       doc = @document.create(:first_name => 'John', :age => 27)
       old_created_at = doc.created_at
       old_updated_at = doc.updated_at
-      doc = @document.update(old._id, { :first_name => 'Johnny' })
-      doc.created_at.should == old_created_at
-      doc.updated_at.should_not == old_updated_at
+      sleep 1 # this annoys me
+      @document.update(doc._id, { :first_name => 'Johnny' })
+
+      from_db = @document.find(doc.id)
+      from_db.created_at.to_i.should == old_created_at.to_i
+      from_db.updated_at.to_i.should_not == old_updated_at.to_i
     end
   end
-end
+end

data/test/functional/test_rails_compatibility.rb

@@ -18,9 +18,8 @@ class TestRailsCompatibility < Test::Unit::TestCase
     end
   
     should "have to_param that returns id" do
-      id = MongoID.new
-      instance = Order.create('_id' => id.to_s)
-      instance.to_param.should == id.to_s
+      instance = Order.create('_id' => 1234)
+      instance.to_param.should == '1234'
     end
 
     should "alias new to new_record?" do

data/test/models.rb

@@ -1,5 +1,6 @@
 class Address
   include MongoMapper::EmbeddedDocument
+  
   key :address, String
   key :city,    String
   key :state,   String
@@ -8,7 +9,12 @@ end
 
 class Message
   include MongoMapper::Document
+  
   key :body, String
+  key :position, Integer
+  key :_type, String
+  key :room_id, String
+  
   belongs_to :room
 end
 
@@ -18,12 +24,14 @@ class Chat < Message;  end
 
 class Room
   include MongoMapper::Document
+  
   key :name, String
   many :messages, :polymorphic => true
 end
 
 class Project
   include MongoMapper::Document
+  
   key :name, String
   many :statuses
   many :addresses
@@ -31,32 +39,48 @@ end
 
 class Status
   include MongoMapper::Document
+  
+  key :project_id, String
+  key :target_id, String
+  key :target_type, String
+  key :name, String
+  key :position, Integer
+  
   belongs_to :project
   belongs_to :target, :polymorphic => true
-  key :name, String
 end
 
 class RealPerson
   include MongoMapper::Document
-  many :pets  
+  
+  many :pets
   key :name, String
+
+  def realname=(n)
+    self.name = n
+  end
 end
 
 class Person
   include MongoMapper::EmbeddedDocument
+  
   key :name, String
   key :child, Person
+  
   many :pets
 end
 
 class Pet
   include MongoMapper::EmbeddedDocument
+  
   key :name, String
   key :species, String
 end
 
 class Media
   include MongoMapper::EmbeddedDocument
+  
+  key :_type, String
   key :file, String
 end
 
@@ -75,34 +99,41 @@ end
 
 class Catalog
   include MongoMapper::Document
+  
   many :medias, :polymorphic => true
 end
 
 module TrModels
   class Transport
     include MongoMapper::EmbeddedDocument
+    
+    key :_type, String
     key :license_plate, String
   end
-  
+
   class Car < TrModels::Transport
     include MongoMapper::EmbeddedDocument
+    
     key :model, String
     key :year, Integer
   end
-  
+
   class Bus < TrModels::Transport
     include MongoMapper::EmbeddedDocument
+    
     key :max_passengers, Integer
   end
-  
+
   class Ambulance < TrModels::Transport
     include MongoMapper::EmbeddedDocument
+    
     key :icu, Boolean
   end
-  
+
   class Fleet
     include MongoMapper::Document
+    
     many :transports, :polymorphic => true, :class_name => "TrModels::Transport"
-    key :name, String    
+    key :name, String
   end
-end
+end

data/test/unit/serializers/test_json_serializer.rb

@@ -51,7 +51,7 @@ class JsonSerializationTest < Test::Unit::TestCase
   should "allow attribute filtering with except" do
     json = @contact.to_json(:except => [:name, :age])
 
-    assert_match %r{"_id"}, json
+    assert_no_match %r{"_id"}, json
     assert_no_match %r{"name"}, json
     assert_no_match %r{"age"}, json
     assert_match %r{"awesome"}, json
@@ -59,26 +59,60 @@ class JsonSerializationTest < Test::Unit::TestCase
     assert_match %r{"preferences"}, json
   end
   
-  context "including methods" do
+  context "_id key" do
+    should "not be included by default" do
+      json = @contact.to_json
+      assert_no_match %r{"_id":}, json
+    end
+    
+    should "not be included even if :except is used" do
+      json = @contact.to_json(: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 "include label method" do
+    should "be included by default" do
+      json = @contact.to_json
+      assert_match %r{"id"}, json
+    end
+    
+    should "be included when single method included" do
       json = @contact.to_json(:methods => :label)
+      assert_match %r{"id"}, json
       assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+      assert_no_match %r{"favorite_quote":"Constraints are liberating"}, json
     end
     
-    should "include name and label method" do
-      json = @contact.to_json(:only => :name, :methods => :label)
-
+    should "be included when multiple methods included" do
+      json = @contact.to_json(:methods => [:label, :favorite_quote])
+      assert_match %r{"id"}, json
       assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"favorite_quote":"Constraints are liberating"}, json
       assert_match %r{"name":"Konata Izumi"}, json
-      assert_no_match %r{"age":16}, json
-      assert_no_match %r{"awesome"}, json
-      assert_no_match %r{"created_at"}, json
-      assert_no_match %r{"preferences"}, json
+    end
+    
+    should "not be included if :only is present" do
+      json = @contact.to_json(:only => :name)
+      assert_no_match %r{"id":}, json
+    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 = @contact.to_json(:methods => :label)
+      assert_match %r{"label":"Has cheezburger"}, json
     end
     
     should "include multiple methods" do
@@ -106,8 +140,8 @@ class JsonSerializationTest < Test::Unit::TestCase
     end
     
     should "allow attribute filtering with except" do
-      json = @contacts.to_json(:except => [:name, :preferences, :awesome, :created_at, :updated_at, :_id])
-      assert_equal %([{"id":"","age":39},{"id":"","age":14}]), json
+      json = @contacts.to_json(:except => [:name, :preferences, :awesome, :created_at, :updated_at])
+      assert_equal %([{"id":null,"age":39},{"id":null,"age":14}]), json
     end
   end
   

data/test/unit/test_association_base.rb

@@ -78,8 +78,16 @@ class AssociationBaseTest < Test::Unit::TestCase
     end
   end
   
-  should "have belongs_to_key_name" do
-    Base.new(:belongs_to, :foo).belongs_to_key_name.should == 'foo_id'
+  context "foreign_key" do
+    should "default to assocation_name_id" 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