tpitale-mongo_mapper 0.6.9

data/test/functional/associations/test_many_embedded_proxy.rb

@@ -0,0 +1,192 @@
+require 'test_helper'
+require 'models'
+
+class ManyEmbeddedProxyTest < Test::Unit::TestCase
+  def setup
+    Project.collection.remove
+    RealPerson.collection.remove
+  end
+    
+  should "default reader to empty array" do
+    Project.new.addresses.should == []
+  end
+  
+  should "allow adding to association like it was an array" do
+    project = Project.new
+    project.addresses << Address.new
+    project.addresses.push Address.new
+    project.addresses.size.should == 2
+  end
+
+  should "be embedded in document on save" do
+    sb = Address.new(:city => 'South Bend', :state => 'IN')
+    chi = Address.new(:city => 'Chicago', :state => 'IL')
+    project = Project.new
+    project.addresses << sb
+    project.addresses << chi
+    project.save
+
+    project.reload
+    project.addresses.size.should == 2
+    project.addresses[0].should == sb
+    project.addresses[1].should == chi
+  end
+  
+  should "allow embedding arbitrarily deep" do
+    @document = Class.new do
+      include MongoMapper::Document
+      set_collection_name 'test'
+      key :person, Person
+    end
+    @document.collection.remove
+    
+    meg = Person.new(:name => "Meg")
+    meg.child = Person.new(:name => "Steve")
+    meg.child.child = Person.new(:name => "Linda")
+    
+    doc = @document.new(:person => meg)
+    doc.save
+    
+    doc.reload
+    doc.person.name.should == 'Meg'
+    doc.person.child.name.should == 'Steve'
+    doc.person.child.child.name.should == 'Linda'
+  end
+  
+  should "allow assignment of 'many' embedded documents using a hash" do
+    person_attributes = { 
+      "name" => "Mr. Pet Lover", 
+      "pets" => [
+        {"name" => "Jimmy", "species" => "Cocker Spainel"},
+        {"name" => "Sasha", "species" => "Siberian Husky"}, 
+      ] 
+    }
+    
+    pet_lover = RealPerson.new(person_attributes)
+    pet_lover.name.should == "Mr. Pet Lover"
+    pet_lover.pets[0].name.should == "Jimmy"
+    pet_lover.pets[0].species.should == "Cocker Spainel"
+    pet_lover.pets[1].name.should == "Sasha"
+    pet_lover.pets[1].species.should == "Siberian Husky"
+    pet_lover.save.should be_true
+    
+    pet_lover.reload
+    pet_lover.name.should == "Mr. Pet Lover"
+    pet_lover.pets[0].name.should == "Jimmy"
+    pet_lover.pets[0].species.should == "Cocker Spainel"
+    pet_lover.pets[1].name.should == "Sasha"
+    pet_lover.pets[1].species.should == "Siberian Husky"
+  end
+
+  context "embedding many embedded documents" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        many :people
+      end
+      @document.collection.remove
+    end
+
+    should "persist all embedded documents" do
+      meg    = Person.new(:name => "Meg")
+      sparky = Pet.new(:name => "Sparky", :species => "Dog")
+      koda   = Pet.new(:name => "Koda", :species => "Dog")
+
+      doc = @document.new
+      meg.pets << sparky
+      meg.pets << koda
+      doc.people << meg
+      doc.save
+
+      doc.reload
+      doc.people.first.name.should == "Meg"
+      doc.people.first.pets.should_not == []
+      doc.people.first.pets.first.name.should == "Sparky"
+      doc.people.first.pets.first.species.should == "Dog"
+      doc.people.first.pets[1].name.should == "Koda"
+      doc.people.first.pets[1].species.should == "Dog"
+    end
+
+    should "create a reference to the root document for all embedded documents before save" do
+      meg    = Person.new(:name => "Meg")
+      sparky = Pet.new(:name => "Sparky", :species => "Dog")
+      doc    = @document.new
+      doc.people << meg
+      meg.pets << sparky
+
+      doc.people.first._root_document.should == doc
+      doc.people.first.pets.first._root_document.should == doc
+    end
+
+    should "create a reference to the root document for all embedded documents" do
+      sparky = Pet.new(:name => "Sparky", :species => "Dog")
+      meg    = Person.new(:name => "Meg", :pets => [sparky])
+      doc    = @document.new
+      doc.people << meg
+      doc.save
+
+      doc.reload
+      doc.people.first._root_document.should == doc
+      doc.people.first.pets.first._root_document.should == doc
+    end
+  end
+  
+  should "allow finding by id" do
+    sparky = Pet.new(:name => "Sparky", :species => "Dog")
+    meg    = Person.new(:name => "Meg", :pets => [sparky])
+    
+    meg.pets.find(sparky._id).should     == sparky  # oid
+    meg.pets.find(sparky.id.to_s).should == sparky  # string
+  end
+  
+  context "extending the association" do
+    setup do
+      @address_class = Class.new do
+        include MongoMapper::EmbeddedDocument
+        key :address, String
+        key :city, String
+        key :state, String
+        key :zip, Integer
+      end
+      
+      @project_class = Class.new do
+        include MongoMapper::Document
+        key :name, String
+      end
+      
+      @project_class.collection.remove
+    end
+    
+    should "work using a block passed to many" do
+      @project_class.many :addresses, :class => @address_class do
+        def find_all_by_state(state)
+          find_all { |a| a.state == state }
+        end
+      end
+      
+      addr1 = @address_class.new(:address => "Gate-3 Lankershim Blvd.", :city => "Universal City", :state => "CA", :zip => "91608")
+      addr2 = @address_class.new(:address => "3000 W. Alameda Ave.", :city => "Burbank", :state => "CA", :zip => "91523")
+      addr3 = @address_class.new(:address => "111 Some Ln", :city => "Nashville", :state => "TN", :zip => "37211")
+      project = @project_class.create(:name => "Some Project", :addresses => [addr1, addr2, addr3])
+      
+      project.addresses.find_all_by_state("CA").should == [addr1, addr2]
+    end
+  
+    should "work using many's :extend option" do
+      module FindByCity
+        def find_by_city(city)
+          find_all { |a| a.city == city }
+        end
+      end
+      @project_class.many :addresses, :class => @address_class, :extend => FindByCity
+      
+      addr1 = @address_class.new(:address => "Gate-3 Lankershim Blvd.", :city => "Universal City", :state => "CA", :zip => "91608")
+      addr2 = @address_class.new(:address => "3000 W. Alameda Ave.", :city => "Burbank", :state => "CA", :zip => "91523")
+      addr3 = @address_class.new(:address => "111 Some Ln", :city => "Nashville", :state => "TN", :zip => "37211")
+      project = @project_class.create(:name => "Some Project", :addresses => [addr1, addr2, addr3])
+      
+      project.addresses.find_by_city('Burbank').should == [addr2]
+    end
+  end
+end

data/test/functional/associations/test_many_polymorphic_proxy.rb

@@ -0,0 +1,339 @@
+require 'test_helper'
+require 'models'
+
+class ManyPolymorphicProxyTest < Test::Unit::TestCase
+  def setup
+    Room.collection.remove
+    Message.collection.remove
+  end
+  
+  should "default reader to empty array" do
+    Room.new.messages.should == []
+  end
+  
+  should "add type key to polymorphic class base" do
+    Message.keys.keys.should include('_type')
+  end
+  
+  should "allow adding to assiciation like it was an array" do
+    room = Room.new
+    room.messages << Enter.new
+    room.messages.push Exit.new
+    room.messages.concat Exit.new
+    room.messages.size.should == 3
+  end
+  
+  should "be able to replace the association" do
+    room = Room.create(:name => 'Lounge')
+    
+    lambda {
+      room.messages = [
+        Enter.new(:body => 'John entered room', :position => 1),
+        Chat.new(:body => 'Heyyyoooo!',         :position => 2),
+        Exit.new(:body => 'John exited room',   :position => 3)
+      ]
+    }.should change { Message.count }.by(3)
+    
+    room = room.reload
+    messages = room.messages.all :order => "position"
+    messages.size.should == 3
+    messages[0].body.should == 'John entered room'
+    messages[1].body.should == 'Heyyyoooo!'
+    messages[2].body.should == 'John exited room'
+  end
+  
+  should "correctly store type when using <<, push and concat" do
+    room = Room.new
+    room.messages <<      Enter.new(:body => 'John entered the room', :position => 1)
+    room.messages.push    Exit.new(:body => 'John entered the room', :position => 2)
+    room.messages.concat  Chat.new(:body => 'Holla!'             , :position => 3)
+    
+    room = room.reload
+    messages = room.messages.all :order => "position"
+    messages[0]._type.should == 'Enter'
+    messages[1]._type.should == 'Exit'
+    messages[2]._type.should == 'Chat'
+  end
+  
+  context "build" do
+    should "assign foreign key" do
+      room = Room.create
+      message = room.messages.build
+      message.room_id.should == room._id
+    end
+    
+    should "assign _type" do
+      room = Room.create
+      message = room.messages.build
+      message._type.should == 'Message'
+    end
+    
+    should "allow assigning attributes" do
+      room = Room.create
+      message = room.messages.build(:body => 'Foo!')
+      message.body.should == 'Foo!'
+    end
+  end
+  
+  context "create" do
+    should "assign foreign key" do
+      room = Room.create
+      message = room.messages.create
+      message.room_id.should == room._id
+    end
+    
+    should "assign _type" do
+      room = Room.create
+      message = room.messages.create
+      message._type.should == 'Message'
+    end
+    
+    should "save record" do
+      room = Room.create
+      lambda {
+        room.messages.create
+      }.should change { Message.count }
+    end
+    
+    should "allow passing attributes" do
+      room = Room.create
+      message = room.messages.create(:body => 'Foo!')
+      message.body.should == 'Foo!'
+    end
+  end
+  
+  context "count" do
+    should "work scoped to association" do
+      room = Room.create
+      3.times { room.messages.create }
+      
+      other_room = Room.create
+      2.times { other_room.messages.create }
+      
+      room.messages.count.should == 3
+      other_room.messages.count.should == 2
+    end
+    
+    should "work with conditions" do
+      room = Room.create
+      room.messages.create(:body => 'Foo')
+      room.messages.create(:body => 'Other 1')
+      room.messages.create(:body => 'Other 2')
+      
+      room.messages.count(:body => 'Foo').should == 1
+    end
+  end
+  
+  context "Finding scoped to association" do
+    setup do
+      @lounge = Room.create(:name => 'Lounge')
+      @lm1 = Message.create(:body => 'Loungin!', :position => 1)
+      @lm2 = Message.create(:body => 'I love loungin!', :position => 2)
+      @lounge.messages = [@lm1, @lm2]
+      @lounge.save
+      
+      @hall = Room.create(:name => 'Hall')
+      @hm1 = Message.create(:body => 'Do not fall in the hall', :position => 1)
+      @hm2 = Message.create(:body => 'Hall the king!', :position => 2)
+      @hm3 = Message.create(:body => 'Loungin!', :position => 3)
+      @hall.messages = [@hm1, @hm2, @hm3]
+      @hall.save
+    end
+    
+    context "dynamic finders" do
+      should "work with single key" do
+        @lounge.messages.find_by_position(1).should == @lm1
+        @hall.messages.find_by_position(2).should == @hm2
+      end
+      
+      should "work with multiple keys" do
+        @lounge.messages.find_by_body_and_position('Loungin!', 1).should == @lm1
+        @lounge.messages.find_by_body_and_position('Loungin!', 2).should be_nil
+      end
+      
+      should "raise error when using !" do
+        lambda {
+          @lounge.messages.find_by_position!(222)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+      
+      context "find_or_create_by" do
+        should "not create document if found" do
+          lambda {
+            message = @lounge.messages.find_or_create_by_body('Loungin!')
+            message.room.should == @lounge
+            message.should == @lm1
+          }.should_not change { Message.count }
+        end
+
+        should "create document if not found" do
+          lambda {
+            message = @lounge.messages.find_or_create_by_body('Yo dawg!')
+            message.room.should == @lounge
+            message._type.should == 'Message'
+          }.should change { Message.count }.by(1)
+        end
+      end
+    end
+    
+    context "with :all" do
+      should "work" do
+        @lounge.messages.find(:all, :order => "position").should == [@lm1, @lm2]
+      end
+      
+      should "work with conditions" do
+        messages = @lounge.messages.find(:all, :body => 'Loungin!', :order => "position")
+        messages.should == [@lm1]
+      end
+      
+      should "work with order" do
+        messages = @lounge.messages.find(:all, :order => 'position desc')
+        messages.should == [@lm2, @lm1]
+      end
+    end
+    
+    context "with #all" do
+      should "work" do
+        @lounge.messages.all(:order => "position").should == [@lm1, @lm2]
+      end
+      
+      should "work with conditions" do
+        messages = @lounge.messages.all(:body => 'Loungin!', :order => "position")
+        messages.should == [@lm1]
+      end
+      
+      should "work with order" do
+        messages = @lounge.messages.all(:order => 'position desc')
+        messages.should == [@lm2, @lm1]
+      end
+    end
+    
+    context "with :first" do
+      should "work" do
+        @lounge.messages.find(:first, :order => "position asc").should == @lm1
+      end
+      
+      should "work with conditions" do
+        message = @lounge.messages.find(:first, :body => 'I love loungin!', :order => "position asc")
+        message.should == @lm2
+      end
+    end
+    
+    context "with #first" do
+      should "work" do
+        @lounge.messages.first(:order => "position asc").should == @lm1
+      end
+      
+      should "work with conditions" do
+        message = @lounge.messages.first(:body => 'I love loungin!', :order => "position asc")
+        message.should == @lm2
+      end
+    end
+    
+    context "with :last" do
+      should "work" do
+        @lounge.messages.find(:last, :order => "position asc").should == @lm2
+      end
+      
+      should "work with conditions" do
+        message = @lounge.messages.find(:last, :body => 'Loungin!', :order => "position asc")
+        message.should == @lm1
+      end
+    end
+    
+    context "with #last" do
+      should "work" do
+        @lounge.messages.last(:order => "position asc").should == @lm2
+      end
+      
+      should "work with conditions" do
+        message = @lounge.messages.last(:body => 'Loungin!', :order => "position asc")
+        message.should == @lm1
+      end
+    end
+    
+    context "with one id" do
+      should "work for id in association" do
+        @lounge.messages.find(@lm2._id).should == @lm2
+      end
+      
+      should "not work for id not in association" do
+        lambda {
+          @lounge.messages.find!(@hm2._id)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+    end
+    
+    context "with query options/criteria" do
+      should "work with order on association" do
+        @lounge.messages.should == [@lm1, @lm2]
+      end
+      
+      should "allow overriding the order provided to the association" do
+        @lounge.messages.all(:order => 'position desc').should == [@lm2, @lm1]
+      end
+      
+      should "allow using conditions on association" do
+        @hall.latest_messages.should == [@hm3, @hm2]
+      end
+    end
+    
+    context "with multiple ids" do
+      should "work for ids in association" do
+        messages = @lounge.messages.find(@lm1._id, @lm2._id)
+        messages.should == [@lm1, @lm2]
+      end
+      
+      should "not work for ids not in association" do
+        lambda {
+          @lounge.messages.find!(@lm1._id, @lm2._id, @hm2._id)
+        }.should raise_error(MongoMapper::DocumentNotFound)
+      end
+    end
+    
+    context "with #paginate" do
+      setup do
+        @messages = @hall.messages.paginate(:per_page => 2, :page => 1, :order => 'position asc')
+      end
+      
+      should "return total pages" do
+        @messages.total_pages.should == 2
+      end
+      
+      should "return total entries" do
+        @messages.total_entries.should == 3
+      end
+      
+      should "return the subject" do
+        @messages.should == [@hm1, @hm2]
+      end
+    end
+  end
+  
+  context "extending the association" do
+    should "work using a block passed to many" do
+      room = Room.new(:name => "Amazing Room")
+      messages = room.messages = [
+        Enter.new(:body => 'John entered room',  :position => 3),
+        Chat.new(:body => 'Heyyyoooo!',          :position => 4),
+        Exit.new(:body => 'John exited room',    :position => 5),
+        Enter.new(:body => 'Steve entered room', :position => 6),
+        Chat.new(:body => 'Anyone there?',       :position => 7),
+        Exit.new(:body => 'Steve exited room',   :position => 8)
+      ]
+      room.save
+      room.messages.older.should == messages[3..5]
+    end
+  
+    should "work using many's :extend option" do
+      room = Room.new(:name => "Amazing Room")
+      accounts = room.accounts = [
+        Bot.new(:last_logged_in => 3.weeks.ago),
+        User.new(:last_logged_in => nil),
+        Bot.new(:last_logged_in => 1.week.ago)
+      ]
+      room.save
+      room.accounts.inactive.should == [accounts[1]]
+    end
+  end
+end

data/test/functional/test_associations.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+require 'models'
+
+class AssociationsTest < Test::Unit::TestCase    
+  should "allow changing class names" do
+    class AwesomeUser
+      include MongoMapper::Document
+      
+      many :posts, :class_name => 'AssociationsTest::AwesomePost', :foreign_key => :creator_id
+    end
+    AwesomeUser.collection.remove
+    
+    class AwesomeTag
+      include MongoMapper::EmbeddedDocument
+      
+      key :name, String
+      key :post_id, ObjectId
+      
+      belongs_to :post, :class_name => 'AssociationsTest::AwesomeUser'
+    end
+    
+    class AwesomePost
+      include MongoMapper::Document
+      
+      key :creator_id, ObjectId
+      
+      belongs_to :creator, :class_name => 'AssociationsTest::AwesomeUser'
+      many :tags, :class_name => 'AssociationsTest::AwesomeTag', :foreign_key => :post_id
+    end
+    
+    AwesomeUser.collection.remove
+    AwesomePost.collection.remove
+    
+    user = AwesomeUser.create
+    tag1 = AwesomeTag.new(:name => 'awesome')
+    tag2 = AwesomeTag.new(:name => 'grand')
+    post1 = AwesomePost.create(:creator => user, :tags => [tag1])
+    post2 = AwesomePost.create(:creator => user, :tags => [tag2])
+    user.posts.should == [post1, post2]
+    
+    post1 = post1.reload
+    post1.tags.should == [tag1]
+  end
+end

data/test/functional/test_binary.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class BinaryTest < Test::Unit::TestCase  
+  should "serialize and deserialize correctly" do
+    klass = Class.new do
+      include MongoMapper::Document
+      set_collection_name 'test'
+      key :contents, Binary
+    end
+    klass.collection.remove
+    
+    doc = klass.new(:contents => '010101')
+    doc.save
+    
+    doc = doc.reload
+    doc.contents.to_s.should == ByteBuffer.new('010101').to_s
+  end
+end

data/test/functional/test_callbacks.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class CallbacksTest < Test::Unit::TestCase
+  context "Defining and running callbacks" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::Document
+        set_collection_name 'test'
+        
+        key :name, String
+        
+        [ :before_validation_on_create, :before_validation_on_update,
+          :before_validation, :after_validation,
+          :before_create,     :after_create, 
+          :before_update,     :after_update,
+          :before_save,       :after_save,
+          :before_destroy,    :after_destroy].each do |callback|
+          callback_method = "#{callback}_callback"
+          send(callback, callback_method)
+          define_method(callback_method) do
+            history << callback.to_sym
+          end
+        end
+        
+        def history
+          @history ||= []
+        end
+        
+        def clear_history
+          @history = nil
+        end
+      end
+      @document.collection.remove
+    end
+    
+    should "get the order right for creating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should == [:before_validation, :before_validation_on_create, :after_validation, :before_save, :before_create, :after_create, :after_save]
+    end
+    
+    should "get the order right for updating documents" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.clear_history
+      doc.name = 'John'
+      doc.save
+      doc.history.should == [:before_validation, :before_validation_on_update, :after_validation, :before_save, :before_update, :after_update, :after_save]
+    end
+    
+    should "work for before and after validation" do
+      doc = @document.new(:name => 'John Nunemaker')
+      doc.valid?
+      doc.history.should include(:before_validation)
+      doc.history.should include(:after_validation)
+    end
+    
+    should "work for before and after create" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.history.should include(:before_create)
+      doc.history.should include(:after_create)
+    end
+    
+    should "work for before and after update" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_update)
+      doc.history.should include(:after_update)
+    end
+    
+    should "work for before and after save" do
+      doc = @document.new
+      doc.name = 'John Doe'
+      doc.save
+      doc.history.should include(:before_save)
+      doc.history.should include(:after_save)
+    end
+    
+    should "work for before and after destroy" do
+      doc = @document.create(:name => 'John Nunemaker')
+      doc.destroy
+      doc.history.should include(:before_destroy)
+      doc.history.should include(:after_destroy)
+    end
+  end
+end