mongo_mapper 0.6.10 → 0.7.0

data/test/models.rb

@@ -109,12 +109,6 @@ class Answer
   key :body, String
 end
 
-module PeopleExtensions
-  def find_by_name(name)
-    detect { |p| p.name == name }
-  end
-end
-
 module CollaboratorsExtensions
   def top
     first
@@ -126,9 +120,7 @@ class Project
 
   key :name, String
   
-  many :people, :extend => PeopleExtensions
   many :collaborators, :extend => CollaboratorsExtensions
-  
   many :statuses, :order => 'position' do
     def open
       all(:name => %w(New Assigned))
@@ -163,37 +155,6 @@ class Status
   belongs_to :target, :polymorphic => true
 end
 
-class RealPerson
-  include MongoMapper::Document
-
-  key :room_id, ObjectId
-  key :name, String
-  
-  belongs_to :room
-  
-  many :pets
-  
-  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
 

data/test/test_helper.rb

@@ -16,12 +16,46 @@ require 'support/timing'
 
 class Test::Unit::TestCase
   include CustomMatchers
+
+  def Doc(name=nil, &block)
+    klass = Class.new do
+      include MongoMapper::Document
+      set_collection_name "test#{rand(20)}"
+
+      if name
+        class_eval "def self.name; '#{name}' end"
+        class_eval "def self.to_s; '#{name}' end"
+      end
+    end
+
+    klass.class_eval(&block) if block_given?
+    klass.collection.remove
+    klass
+  end
+
+  def EDoc(name=nil, &block)
+    klass = Class.new do
+      include MongoMapper::EmbeddedDocument
+
+      if name
+        class_eval "def self.name; '#{name}' end"
+        class_eval "def self.to_s; '#{name}' end"
+      end
+    end
+
+    klass.class_eval(&block) if block_given?
+    klass
+  end
+
+  def drop_indexes(klass)
+    if klass.database.collection_names.include?(klass.collection.name)
+      klass.collection.drop_indexes
+    end
+  end
 end
 
 test_dir = File.expand_path(File.dirname(__FILE__) + '/../tmp')
 FileUtils.mkdir_p(test_dir) unless File.exist?(test_dir)
 
-MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {
-  :logger => Logger.new(test_dir + '/test.log')
-})
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {:logger => Logger.new(test_dir + '/test.log')})
 MongoMapper.database = 'test'

data/test/unit/associations/test_base.rb

@@ -4,7 +4,7 @@ require 'models'
 class FooMonster; end
 
 class AssociationBaseTest < Test::Unit::TestCase
-  include MongoMapper::Associations
+  include MongoMapper::Plugins::Associations
   
   should "initialize with type and name" do
     base = Base.new(:many, :foos)
@@ -104,20 +104,20 @@ class AssociationBaseTest < Test::Unit::TestCase
     end
   end
   
-  context "finder_options" do
+  context "query_options" do
     should "default to empty hash" do
       base = Base.new(:many, :foos)
-      base.finder_options.should == {}
+      base.query_options.should == {}
     end
     
     should "work with order" do
       base = Base.new(:many, :foos, :order => 'position')
-      base.finder_options.should == {: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.finder_options.should == {:order => 'position', :somekey => 'somevalue'}
+      base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
     end
   end
   

data/test/unit/associations/test_proxy.rb

@@ -1,17 +1,19 @@
 require 'test_helper'
 
-class FakeNilProxy < MongoMapper::Associations::Proxy
+class FakeNilProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; nil end
 end
 
-class FakeBlankProxy < MongoMapper::Associations::Proxy
+class FakeBlankProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; '' end
 end
 
-class FakeProxy < MongoMapper::Associations::Proxy
-  def find_target
-    [1, 2]
-  end
+class FakeNumberProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; 17 end
+end
+
+class FakeProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; [1, 2] end
 end
 
 class ProxyTest < Test::Unit::TestCase

data/test/unit/test_descendant_appends.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class DescendantAppendsTest < Test::Unit::TestCase
+  context "Document" do
+    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)
+      article = Doc()
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'add appended extensions to classes that include Document before they are added' do
+      module Extension; def test_this_extension; end end
+      article = Doc()
+      MongoMapper::Document.append_extensions(Extension)
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'allow inclusions to Document to be appended' do
+      module Inclusion; def test_this_inclusion; end end
+      MongoMapper::Document.append_inclusions(Inclusion)
+      article = Doc()
+      article.new.should respond_to(:test_this_inclusion)
+    end
+
+    should 'add appended inclusions to classes that include Document before they are added' do
+      module Inclusion; def test_this_inclusion; end end
+      article = Doc()
+      MongoMapper::Document.append_inclusions(Inclusion)
+      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)
+      article = EDoc()
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'add appended extensions to classes that include Document before they are added' do
+      module Extension; def test_this_extension; end end
+      article = EDoc()
+      MongoMapper::EmbeddedDocument.append_extensions(Extension)
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'allow inclusions to Document to be appended' do
+      module Inclusion; def test_this_inclusion; end end
+      MongoMapper::EmbeddedDocument.append_inclusions(Inclusion)
+      article = EDoc()
+      article.new.should respond_to(:test_this_inclusion)
+    end
+
+    should 'add appended inclusions to classes that include Document before they are added' do
+      module Inclusion; def test_this_inclusion; end end
+      article = EDoc()
+      MongoMapper::EmbeddedDocument.append_inclusions(Inclusion)
+      article.new.should respond_to(:test_this_inclusion)
+    end
+  end
+end

data/test/unit/test_document.rb

@@ -4,21 +4,17 @@ require 'models'
 class DocumentTest < Test::Unit::TestCase
   context "The Document Class" do
     setup do
-      @document = Class.new do
-        include MongoMapper::Document
-        set_collection_name 'test'
-      end
-      @document.collection.remove
+      @document = Doc()
+    end
+    
+    should "return false for embeddable" do
+      Doc().embeddable?.should be_false
     end
     
     should "have logger method" do
       @document.logger.should == MongoMapper.logger
       @document.logger.should be_instance_of(Logger)
     end
-    
-    should "track its descendants" do
-      MongoMapper::Document.descendants.should include(@document)
-    end
 
     should "use default database by default" do
       @document.database.should == MongoMapper.database
@@ -40,10 +36,7 @@ class DocumentTest < Test::Unit::TestCase
       @document.database_name.should == 'test2'
       @document.database.name.should == 'test2'
 
-      another_document = Class.new do
-        include MongoMapper::Document
-        set_collection_name 'test'
-      end
+      another_document = Doc()
       another_document.database.should == MongoMapper.database
     end
     
@@ -72,38 +65,6 @@ class DocumentTest < Test::Unit::TestCase
       @document.collection.should be_instance_of(Mongo::Collection)
       @document.collection.name.should == 'foobar'
     end
-
-    should 'allow extensions to Document to be appended' do
-      module Extension; def test_this_extension; end end
-      MongoMapper::Document.append_extensions(Extension)
-      article = Class.new { include MongoMapper::Document }
-      
-      article.should respond_to(:test_this_extension)
-    end
-
-    should 'add appended extensions to classes that include Document before they are added' do
-      module Extension; def test_this_extension; end end
-      article = Class.new { include MongoMapper::Document }
-      MongoMapper::Document.append_extensions(Extension)
-      
-      article.should respond_to(:test_this_extension)
-    end
-
-    should 'allow inclusions to Document to be appended' do
-      module Inclusion; def test_this_inclusion; end end
-      MongoMapper::Document.append_inclusions(Inclusion)
-      article = Class.new { include MongoMapper::Document }
-      
-      article.new.should respond_to(:test_this_inclusion)
-    end
-
-    should 'add appended inclusions to classes that include Document before they are added' do
-      module Inclusion; def test_this_inclusion; end end
-      article = Class.new { include MongoMapper::Document }
-      MongoMapper::Document.append_inclusions(Inclusion)
-      
-      article.new.should respond_to(:test_this_inclusion)
-    end
   end # Document class
   
   context "Documents that inherit from other documents" do
@@ -113,29 +74,41 @@ class DocumentTest < Test::Unit::TestCase
       Exit.collection_name.should    == 'messages'
       Chat.collection_name.should    == 'messages'
     end
-    
+
     should "default associations to inherited class" do
-     Message.associations.keys.should include("room")
-     Enter.associations.keys.should   include("room")
-     Exit.associations.keys.should    include("room")
-     Chat.associations.keys.should    include("room")
-   end
-    
-    should "track subclasses" do
-      Message.subclasses.should == [Enter, Exit, Chat]
+      Message.associations.keys.should include("room")
+      Enter.associations.keys.should   include("room")
+      Exit.associations.keys.should    include("room")
+      Chat.associations.keys.should    include("room")
+    end
+  end
+  
+  context "descendants" do
+    should "default to nil" do
+      Enter.descendants.should be_nil
+    end
+
+    should "be recorded" do
+      Message.descendants.should == [Enter, Exit, Chat]
     end
   end
 
   context "An instance of a document" do
     setup do
-      @document = Class.new do
-        include MongoMapper::Document
-        set_collection_name 'test'
-
+      @document = Doc do
         key :name, String
         key :age, Integer
       end
-      @document.collection.remove
+    end
+    
+    should "create id during initialization" do
+      @document.new._id.should be_instance_of(Mongo::ObjectID)
+    end
+    
+    should "have to_param that is string representation of id" do
+      doc = @document.new(:id => Mongo::ObjectID.new)
+      doc.to_param.should == doc.id.to_s
+      doc.to_param.should be_instance_of(String)
     end
     
     should "have access to logger" do
@@ -164,18 +137,10 @@ class DocumentTest < Test::Unit::TestCase
     end
 
     context "root document" do
-      should "have a nil _root_document" do
-        @document.new._root_document.should be_nil
-      end
-
       should "set self to the root document on embedded documents" do        
-        klass = Class.new do
-          include MongoMapper::Document
-        end
+        klass = Doc()
+        pets = EDoc()
         
-        pets = Class.new do
-          include MongoMapper::EmbeddedDocument
-        end
         klass.many :pets, :class => pets
         
         doc = klass.new(:pets => [{}])
@@ -197,7 +162,7 @@ class DocumentTest < Test::Unit::TestCase
     end
 
     context "clone" do
-      should "not set the id" do
+      should "be new" do
         doc = @document.create(:name => "foo", :age => 27)
         clone = doc.clone
         clone.should be_new
@@ -211,10 +176,44 @@ class DocumentTest < Test::Unit::TestCase
       end
     end
 
+    should "call inspect on the document's attributes instead of to_s when inspecting the document" do
+      doc = @document.new(:animals => %w(dog cat))
+      doc.inspect.should include(%(animals: ["dog", "cat"]))
+    end
+
     context "equality" do
       setup do
         @oid = Mongo::ObjectID.new
       end
+      
+      should "delegate hash to _id" do
+        doc = @document.new
+        doc.hash.should == doc._id.hash
+      end
+      
+      should "delegate eql to ==" do
+        doc = @document.new
+        other = @document.new
+        doc.eql?(other).should == (doc == other)
+        doc.eql?(doc).should == (doc == doc)
+      end
+      
+      should "know if same object as another" do
+        doc = @document.new
+        doc.should equal(doc)
+        doc.should_not equal(@document.new)
+      end
+      
+      should "allow set operations on array of documents" do
+        @document.key :parent_id, ObjectId
+        @document.belongs_to :parent, :class => @document
+        
+        parent = @document.create
+        child = @document.create(:parent => parent)
+        
+        ([child.parent] & [parent]).should == [parent]
+      end
+      
       should "be equal if id and class are the same" do
         (@document.new('_id' => @oid) == @document.new('_id' => @oid)).should be(true)
       end
@@ -224,12 +223,8 @@ class DocumentTest < Test::Unit::TestCase
       end
 
       should "not be equal if id same but class different" do
-        @another_document = Class.new do
-          include MongoMapper::Document
-          set_collection_name 'test'
-        end
-
-        (@document.new('_id' => @oid) == @another_document.new('_id' => @oid)).should be(false)
+        another_document = Doc()
+        (@document.new('_id' => @oid) == another_document.new('_id' => @oid)).should be(false)
       end
     end
   end # instance of a document