mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/test/functional/test_dynamic_querying.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class DynamicQueryingTest < Test::Unit::TestCase
+  def setup
+    @document = Doc do
+      scope :nunes, where(:last_name => 'Nunemaker')
+
+      key :first_name, String
+      key :last_name, String
+      key :age, Integer
+      key :date, Date
+    end
+
+    @doc1 = @document.create(:first_name => 'John',   :last_name => 'Nunemaker', :age => 27)
+    @doc2 = @document.create(:first_name => 'Steve',  :last_name => 'Smith',     :age => 28)
+    @doc3 = @document.create(:first_name => 'Steph',  :last_name => 'Nunemaker', :age => 26)
+  end
+
+  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
+
+  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 "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 when using !" do
+    lambda {
+      @document.find_by_first_name_and_last_name!(1,2)
+    }.should raise_error(MongoMapper::DocumentNotFound)
+  end
+
+  should "work on scopes" do
+    @document.nunes.find_by_first_name('Steph').should == @doc3
+    @document.nunes.find_all_by_first_name('Steph').should == [@doc3]
+  end
+end

data/test/functional/test_embedded_document.rb

@@ -42,6 +42,14 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
       address._parent_document.should be(doc)
       address._root_document.should be(doc)
     end
+
+    should "assign _parent_document and _root_document when loading" do
+      address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      doc = @klass.create(:foo => address)
+      doc.reload
+      doc.foo._parent_document.should be(doc)
+      doc.foo._root_document.should be(doc)
+    end
   end
 
   should "correctly instantiate single collection inherited embedded documents" do
@@ -53,31 +61,93 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
     doc1.reload.message.class.should be(Enter)
   end
 
-  context "new?" do
+  context "new? (embedded key)" do
     setup do
       @klass.key :foo, @address_class
     end
 
-    should "be new until document is saved" do
+    should "be true until document is saved" do
       address = @address_class.new(:city => 'South Bend', :state => 'IN')
       doc = @klass.new(:foo => address)
-      address.new?.should == true
+      address.new?.should be_true
     end
 
-    should "not be new after document is saved" do
+    should "be false after document is saved" do
       address = @address_class.new(:city => 'South Bend', :state => 'IN')
       doc = @klass.new(:foo => address)
       doc.save
-      doc.foo.new?.should == false
+      doc.foo.new?.should be_false
     end
 
-    should "not be new when document is read back" do
+    should "be false when loaded from database" do
       address = @address_class.new(:city => 'South Bend', :state => 'IN')
       doc = @klass.new(:foo => address)
       doc.save
 
-      doc = doc.reload
-      doc.foo.new?.should == false
+      doc.reload
+      doc.foo.new?.should be_false
+    end
+  end
+
+  context "new? (embedded association)" do
+    setup do
+      @doc = @klass.new(:pets => [{:name => 'poo bear'}])
+    end
+
+    should "be true until document is saved" do
+      @doc.should be_new
+      @doc.pets.first.should be_new
+    end
+
+    should "be false after document is saved" do
+      @doc.save
+      @doc.pets.first.should_not be_new
+    end
+
+    should "be false when loaded from database" do
+      @doc.save
+      @doc.pets.first.should_not be_new
+      @doc.reload
+      @doc.pets.first.should_not be_new
+    end
+  end
+
+  context "#destroyed?" do
+    setup do
+      @doc = @klass.create(:pets => [@pet_klass.new(:name => 'sparky')])
+    end
+
+    should "be false if root document is not destroyed" do
+      @doc.should_not be_destroyed
+      @doc.pets.first.should_not be_destroyed
+    end
+
+    should "be true if root document is destroyed" do
+      @doc.destroy
+      @doc.should be_destroyed
+      @doc.pets.first.should be_destroyed
+    end
+  end
+
+  context "#persisted?" do
+    setup do
+      @doc = @klass.new(:name => 'persisted doc', :pets => [@pet_klass.new(:name => 'persisted pet')])
+    end
+
+    should "be false if new" do
+      @doc.pets.first.should_not be_persisted
+    end
+
+    should "be false if destroyed" do
+      @doc.save
+      @doc.destroy
+      @doc.pets.first.should be_destroyed
+      @doc.pets.first.should_not be_persisted
+    end
+
+    should "be true if not new or destroyed" do
+      @doc.save
+      @doc.pets.first.should be_persisted
     end
   end
 
@@ -127,4 +197,14 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
     pet.expects(:save!)
     pet.update_attributes!(attributes)
   end
+
+  should "have database instance method that is equal to root document" do
+    person = @klass.create(:pets => [@pet_klass.new(:name => 'sparky')])
+    person.pets.first.database.should == person.database
+  end
+
+  should "have collection instance method that is equal to root document" do
+    person = @klass.create(:pets => [@pet_klass.new(:name => 'sparky')])
+    person.pets.first.collection.name.should == person.collection.name
+  end
 end

data/test/functional/test_identity_map.rb

@@ -29,16 +29,14 @@ class IdentityMapTest < Test::Unit::TestCase
       MongoMapper::Plugins::IdentityMap.models.clear
 
       @person_class = Doc('Person') do
-        set_collection_name 'people'
         plugin MongoMapper::Plugins::IdentityMap
-        
+
         key :name, String
       end
 
       @post_class = Doc('Post') do
-        set_collection_name 'posts'
         plugin MongoMapper::Plugins::IdentityMap
-        
+
         key :title, String
         key :person_id, ObjectId
       end
@@ -66,7 +64,7 @@ class IdentityMapTest < Test::Unit::TestCase
 
       [@person_class, @post_class].each { |klass| klass.identity_map.should == {} }
     end
-    
+
     context "IM on off status" do
       teardown do
         @post_class.identity_map_on
@@ -131,7 +129,7 @@ class IdentityMapTest < Test::Unit::TestCase
         expects_one_query
         @person.reload
       end
-      
+
       should "add object back into map" do
         assert_in_map(@person)
         before_reload = @person
@@ -142,7 +140,7 @@ class IdentityMapTest < Test::Unit::TestCase
 
     context "#load" do
       setup do
-        @id = Mongo::ObjectID.new
+        @id = BSON::ObjectID.new
       end
 
       should "add document to map" do
@@ -208,7 +206,7 @@ class IdentityMapTest < Test::Unit::TestCase
 
       # There are times when even though the id matches, other criteria doesn't
       # so we need to do the query to ensure that when criteria doesn't match
-      # the document is in fact not found. 
+      # the document is in fact not found.
       #
       # I'm open to not making this query if someone can figure out reliable
       # way to check if document matches criteria without querying.
@@ -217,13 +215,13 @@ class IdentityMapTest < Test::Unit::TestCase
         expects_one_query
         @person.posts.find(@post1.id)
       end
-      
+
       should "return exact object" do
         assert_in_map(@post1)
         @person.posts.find(@post1.id)
         assert_in_map(@post1)
       end
-      
+
       should "return nil if not found " do
         @person.posts.find(1234).should be_nil
       end
@@ -272,7 +270,7 @@ class IdentityMapTest < Test::Unit::TestCase
           found_person = @person_class.first(:_id => @person.id)
           assert_in_map(found_person)
         end
-        
+
         should "return nil if not found" do
           @person_class.first(:name => 'Bill').should be_nil
         end
@@ -321,15 +319,15 @@ class IdentityMapTest < Test::Unit::TestCase
         assert_in_map(people.first, person2, person3)
       end
     end
-    
+
     context "#find_by_id" do
       setup do
         @person = @person_class.create(:name => 'Bill')
       end
-      
+
       should "return nil for document id not found in collection" do
         assert_in_map(@person)
-        @person_class.find_by_id(1234).should be_nil
+        @person_class.find_by_id(BSON::ObjectID.new).should be_nil
       end
     end
 
@@ -344,13 +342,13 @@ class IdentityMapTest < Test::Unit::TestCase
         @person_class.first(:_id => @person.id, :select => 'name').should == @person
         @person_class.first(:_id => @person.id, 'fields' => ['name']).should == @person
         @person_class.last(:_id => @person.id, :select => 'name', :order => 'name').should == @person
-        @person_class.find(@person.id, :select => 'name').should == @person
+        @person_class.fields(:name).find(@person.id).should == @person
         @person_class.all(:_id => @person.id, :select => 'name').should == [@person]
         assert_not_in_map(@person)
       end
-      
+
       should "return nil if not found" do
-        @person_class.find(1234, :select => 'name').should be_nil
+        @person_class.fields(:name).find(BSON::ObjectID.new).should be_nil
       end
     end
 
@@ -359,11 +357,10 @@ class IdentityMapTest < Test::Unit::TestCase
         class ::Item
           include MongoMapper::Document
           plugin MongoMapper::Plugins::IdentityMap
-          
-          key :_type, String
+
           key :title, String
           key :parent_id, ObjectId
-          
+
           belongs_to :parent, :class_name => 'Item'
           one :blog, :class_name => 'Blog', :foreign_key => 'parent_id'
         end
@@ -388,44 +385,45 @@ class IdentityMapTest < Test::Unit::TestCase
         assert_in_map(blog)
         Item.identity_map.should equal(Blog.identity_map)
       end
-      
+
       should "not query when finding by _id and _type" do
         blog = Blog.create(:title => 'Blog')
         post = BlogPost.create(:title => 'Mongo Rocks', :blog => blog)
         Item.identity_map.clear
-        
+
         blog = Item.find(blog.id)
         post = Item.find(post.id)
         assert_in_map(blog, post)
-        
+
         expect_no_queries
         post.blog
         Blog.find(blog.id)
       end
-      
+
       should "load from map when using parent collection inherited class" do
         blog = Blog.create(:title => 'Jill')
         Item.find(blog.id).should equal(blog)
       end
-      
+
       should "work correctly with belongs to proxy" do
         root = Item.create(:title => 'Root')
         assert_in_map(root)
-        
+
         blog = Blog.create(:title => 'Jill', :parent => root)
+        blog.parent.inspect
         assert_in_map(blog)
-        root.should equal(blog.parent)
+        root.should equal(blog.parent.target)
       end
-      
+
       should "work correctly with one proxy" do
         blog = Blog.create(:title => 'Jill')
         assert_in_map(blog)
 
         root = Item.create(:title => 'Root', :blog => blog)
         assert_in_map(root)
-        root.blog.should equal(blog)
+        blog.should equal(root.blog.target)
       end
-      
+
       should "work correctly with one proxy create" do
         root = Item.create(:title => 'Root')
         blog = root.blog.create(:title => 'Blog')
@@ -440,65 +438,65 @@ class IdentityMapTest < Test::Unit::TestCase
           assert_not_in_map(post)
         end
       end
-      
+
       should "not remove from map on delete" do
         post = @post_class.create(:title => 'Bill')
         assert_in_map(post)
-        
+
         @post_class.without_identity_map do
           post.destroy
         end
-        
+
         assert_in_map(post)
       end
-      
+
       should "not add to map when loading" do
         @post_class.without_identity_map do
-          post = @post_class.load({'_id' => Mongo::ObjectID.new, 'title' => 'Awesome!'})
+          post = @post_class.load({'_id' => BSON::ObjectID.new, 'title' => 'Awesome!'})
           assert_not_in_map(post)
         end
       end
-      
+
       should "not load from map when loading" do
         post = @post_class.create(:title => 'Awesome!')
-        
+
         @post_class.without_identity_map do
           loaded = @post_class.load('_id' => post._id, 'title' => 'Awesome!')
           loaded.should_not equal(post)
         end
       end
-      
+
       context "all" do
         should "not add to map" do
           @post_class.without_identity_map do
             post1 = @post_class.create(:title => 'Foo')
             post2 = @post_class.create(:title => 'Bar')
             @post_class.identity_map.clear
-            
+
             assert_not_in_map(@post_class.all)
           end
         end
       end
-      
+
       context "first" do
         should "not add to map" do
           @post_class.without_identity_map do
             post1 = @post_class.create(:title => 'Foo')
             post2 = @post_class.create(:title => 'Bar')
             @post_class.identity_map.clear
-            
+
             assert_not_in_map(@post_class.first)
           end
         end
       end
-      
+
       context "last" do
         should "not add to map" do
           @post_class.without_identity_map do
             post1 = @post_class.create(:title => 'Foo')
             post2 = @post_class.create(:title => 'Bar')
             @post_class.identity_map.clear
-            
+
             assert_not_in_map(@post_class.last(:order => 'title'))
           end
         end

data/test/functional/{test_indexing.rb → test_indexes.rb}

@@ -4,15 +4,13 @@ class IndexingTest < Test::Unit::TestCase
   context "Indexing" do
     setup do
       @document = Doc do
-        set_collection_name 'users'
-
         key :first_name, String
         key :last_name, String
         key :age, Integer
         key :date, Date
       end
-      drop_indexes(@document)
     end
+    teardown { drop_indexes(@document) }
 
     should "allow creating index for a key" do
       @document.ensure_index :first_name
@@ -31,8 +29,8 @@ class IndexingTest < Test::Unit::TestCase
       # just checking have_index('first_name_1_last_name_-1') I'm checking
       # the values of the indexes to make sure the index creation was successful
       @document.collection.index_information.detect do |index|
-        keys = index[1]
-        keys.include?(['first_name', 1]) && keys.include?(['last_name', -1])
+        keys = index[0]
+        keys.include?('first_name_1') && keys.include?('last_name_-1')
       end.should_not be_nil
     end
 

data/test/functional/test_logger.rb

@@ -11,7 +11,7 @@ class LoggerTest < Test::Unit::TestCase
     should "be able to get access to that logger" do
       MongoMapper.logger.should == @logger
     end
-    
+
     should "be able to log messages" do
       MongoMapper.logger.debug 'testing'
       @output.string.include?('testing').should be_true