jmonteiro-mongo_mapper 0.1.0

data/test/functional/test_embedded_document.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+require 'models'
+
+class EmbeddedDocumentTest < Test::Unit::TestCase
+  def setup
+    @klass = Doc do
+      key :first_name, String
+      key :last_name, String
+    end
+    
+    @pet_klass = EDoc do
+      key :name, String
+    end
+    
+    @klass.many :pets, :class => @pet_klass
+    
+    @address_class = EDoc do
+      key :city, String
+      key :state, String
+    end
+  end
+    
+  context "Saving a document with an embedded document" do
+    setup do
+      @klass.key :foo, @address_class
+      
+      @address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      @doc = @klass.new(:foo => @address)
+    end
+    
+    should "embed embedded document" do
+      @doc.save
+      @doc.foo.city.should == 'South Bend'
+      @doc.foo.state.should == 'IN'
+
+      doc = @doc.reload
+      doc.foo.city.should == 'South Bend'
+      doc.foo.state.should == 'IN'
+    end
+  end
+  
+  should "correctly instantiate single collection inherited embedded documents" do
+    document = Doc('Foo') do
+      key :message, Message
+    end
+    
+    doc1 = document.create(:message => Enter.new)
+    doc1.reload.message.class.should be(Enter)
+  end
+  
+  context "new?" do
+    setup do
+      @klass.key :foo, @address_class
+    end
+
+    should "be new until document is saved" do
+      address = @address_class.new(:city => 'South Bend', :state => 'IN')
+      doc = @klass.new(:foo => address)
+      address.new?.should == true
+    end
+    
+    should "not be new 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
+    end
+    
+    should "not be new when document is read back" 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
+    end
+  end
+  
+  should "be able to save" do
+    person = @klass.create
+    
+    pet = @pet_klass.new(:name => 'sparky')
+    person.pets << pet
+    pet.should be_new
+    pet.save
+    pet.should_not be_new
+    
+    person.reload
+    person.pets.first.should == pet
+  end
+  
+  should "be able to dynamically add new keys and save" do
+    person = @klass.create
+    
+    pet = @pet_klass.new(:name => 'sparky', :crazy_key => 'crazy')
+    person.pets << pet
+    pet.save
+    
+    person.reload
+    person.pets.first.crazy_key.should == 'crazy'
+  end
+  
+  should "be able to update_attributes" do
+    pet = @pet_klass.new(:name => 'sparky')
+    person = @klass.create(:pets => [pet])
+    person.reload
+    pet = person.pets.first
+    
+    pet.update_attributes(:name => 'koda').should be_true
+    person.reload
+    person.pets.first._id.should == pet._id
+    person.pets.first.name.should == 'koda'
+  end
+  
+  should "be able to update_attributes!" do
+    person = @klass.create(:pets => [@pet_klass.new(:name => 'sparky')])
+    person.reload
+    pet = person.pets.first
+    
+    attributes = {:name => 'koda'}
+    pet.expects(:attributes=).with(attributes)
+    pet.expects(:save!)
+    pet.update_attributes!(attributes)
+  end
+end

data/test/functional/test_identity_map.rb

@@ -0,0 +1,233 @@
+require 'test_helper'
+
+class IdentityMapTest < Test::Unit::TestCase
+  def assert_in_map(resource)
+    resource.identity_map.keys.should include(resource.identity_map_key)
+    mapped_resource = resource.identity_map[resource.identity_map_key]
+    resource.object_id.should == mapped_resource.object_id
+  end
+  
+  def assert_not_in_map(resource)
+    resource.identity_map.keys.should_not include(resource.identity_map_key)
+  end
+  
+  context "Document" do
+    setup do
+      @person_class = Doc('Person') do
+        key :name, String
+        plugin MongoMapper::Plugins::IdentityMap
+      end
+      
+      @post_class = Doc('Post') do
+        key :title, String
+        plugin MongoMapper::Plugins::IdentityMap
+      end
+      
+      @person_class.identity_map = {}
+      @post_class.identity_map   = {}
+    end
+
+    should "default identity map to hash" do
+      Doc() do
+        plugin MongoMapper::Plugins::IdentityMap
+      end.identity_map.should == {}
+    end
+
+    should "share identity map with other classes" do
+      map = @post_class.identity_map
+      map.object_id.should == @person_class.identity_map.object_id
+    end
+
+    should "have identity map key that is always unique per document and class" do
+      person = @person_class.new
+      person.identity_map_key.should == "Person:#{person.id}"
+      @person_class.identity_map_key(person.id).should == person.identity_map_key
+
+      post = @post_class.new
+      post.identity_map_key.should == "Post:#{post.id}"
+      @post_class.identity_map_key(post.id).should == post.identity_map_key
+
+      person.identity_map_key.should_not == post.identity_map_key
+    end
+
+    should "add key to map when saved" do
+      person = @person_class.new
+      assert_not_in_map(person)
+      person.save.should be_true
+      assert_in_map(person)
+    end
+
+    should "remove key from map when deleted" do
+      person = @person_class.create(:name => 'Fred')
+      assert_in_map(person)
+      person.destroy
+      assert_not_in_map(person)
+    end
+    
+    context "#load" do
+      setup do
+        @id = Mongo::ObjectID.new
+      end
+      
+      should "add document to map with _id key as symbol" do
+        loaded = @person_class.load({:_id => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "add document to map with _id key as string" do
+        loaded = @person_class.load({'_id' => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "add document to map with id key as symbol" do
+        loaded = @person_class.load({:id => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "add document to map with id key as string" do
+        loaded = @person_class.load({'id' => @id, :name => 'Frank'})
+        assert_in_map(loaded)
+      end
+      
+      should "return document if already in map" do
+        first_load = @person_class.load({:_id => @id, :name => 'Frank'})
+        @person_class.identity_map.expects(:[]=).never
+        second_load = @person_class.load({:_id => @id, :name => 'Frank'})
+        first_load.object_id.should == second_load.object_id
+      end
+    end
+    
+    context "#find (with one id)" do
+      context "for object not in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+          @person_class.identity_map.clear
+        end
+
+        should "query the database" do
+          Mongo::Collection.any_instance.expects(:find_one).once
+          @person_class.find(@person.id)
+        end
+
+        should "add object to map" do
+          assert_not_in_map(@person)
+          found_person = @person_class.find(@person.id)
+          assert_in_map(found_person)
+        end
+      end
+
+      context "for object in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+        end
+
+        should "not query database" do
+          Mongo::Collection.any_instance.expects(:find).never
+          Mongo::Collection.any_instance.expects(:find_one).never
+          @person_class.find(@person.id)
+        end
+        
+        should "return exact object" do
+          assert_in_map(@person)
+          found_person = @person_class.find(@person.id)
+          found_person.object_id.should == @person.object_id
+        end
+      end
+    end
+    
+    context "#find (with multiple ids)" do
+      should "add all documents to map" do
+        person1 = @person_class.create(:name => 'Fred')
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+        @person_class.identity_map.clear
+
+        people = @person_class.find(person1.id, person2.id, person3.id)
+        people.each { |person| assert_in_map(person) }
+      end
+
+      should "add missing documents to map and return existing ones" do
+        person1 = @person_class.create(:name => 'Fred')
+        @person_class.identity_map.clear
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+
+        assert_not_in_map(person1)
+        assert_in_map(person2)
+        assert_in_map(person3)
+
+        people = @person_class.find(person1.id, person2.id, person3.id)
+        assert_in_map(people.first) # making sure one that wasn't mapped now is
+        assert_in_map(person2)
+        assert_in_map(person3)
+      end
+    end
+    
+    context "#first" do
+      context "for object not in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+          @person_class.identity_map.clear
+        end
+
+        should "query the database" do
+          Mongo::Collection.any_instance.expects(:find_one).once
+          @person_class.first(:_id => @person.id)
+        end
+
+        should "add object to map" do
+          assert_not_in_map(@person)
+          found_person = @person_class.first(:_id => @person.id)
+          assert_in_map(found_person)
+        end
+      end
+
+      context "for object in map" do
+        setup do
+          @person = @person_class.create(:name => 'Fred')
+        end
+
+        should "not query database" do
+          Mongo::Collection.any_instance.expects(:find).never
+          Mongo::Collection.any_instance.expects(:find_one).never
+          @person_class.first(:_id => @person.id)
+        end
+        
+        should "return exact object" do
+          assert_in_map(@person)
+          found_person = @person_class.first(:_id => @person.id)
+          found_person.object_id.should == @person.object_id
+        end
+      end
+    end
+    
+    context "#all" do
+      should "add all documents to map" do
+        person1 = @person_class.create(:name => 'Fred')
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+        @person_class.identity_map.clear
+
+        people = @person_class.all(:_id => [person1.id, person2.id, person3.id])
+        people.each { |person| assert_in_map(person) }
+      end
+
+      should "add missing documents to map and return existing ones" do
+        person1 = @person_class.create(:name => 'Fred')
+        @person_class.identity_map.clear
+        person2 = @person_class.create(:name => 'Bill')
+        person3 = @person_class.create(:name => 'Jesse')
+
+        assert_not_in_map(person1)
+        assert_in_map(person2)
+        assert_in_map(person3)
+
+        people = @person_class.all(:_id => [person1.id, person2.id, person3.id])
+        assert_in_map(people.first) # making sure one that wasn't mapped now is
+        assert_in_map(person2)
+        assert_in_map(person3)
+      end
+    end
+    
+  end
+end

data/test/functional/test_logger.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class LoggerTest < Test::Unit::TestCase
+  context "with connection that has logger" do
+    setup do
+      @output = StringIO.new
+      @logger = Logger.new(@output)
+      MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => @logger)
+    end
+
+    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
+    end
+  end
+end

data/test/functional/test_modifiers.rb

@@ -0,0 +1,252 @@
+require 'test_helper'
+
+class ModifierTest < Test::Unit::TestCase
+  def setup
+    @page_class = Doc do
+      key :title, String
+      key :day_count, Integer, :default => 0
+      key :week_count, Integer, :default => 0
+      key :month_count, Integer, :default => 0
+      key :tags, Array
+    end
+  end
+  
+  def assert_page_counts(page, day_count, week_count, month_count)
+    page.reload
+    page.day_count.should == day_count
+    page.week_count.should == week_count
+    page.month_count.should == month_count
+  end
+  
+  should "be able to increment with criteria and modifier hashes" do
+    page = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.increment({:title => 'Home'}, {
+      :day_count => 1, :week_count => 2, :month_count => 3
+    })
+    
+    assert_page_counts page, 1, 2, 3
+    assert_page_counts page2, 1, 2, 3
+  end
+  
+  should "be able to increment with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.increment(page.id, page2.id, {
+      :day_count => 1, :week_count => 2, :month_count => 3
+    })
+    
+    assert_page_counts page, 1, 2, 3
+    assert_page_counts page2, 1, 2, 3
+  end
+  
+  should "be able to decrement with criteria and modifier hashes" do
+    page = @page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3)
+    page2 = @page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3)
+    
+    @page_class.decrement({:title => 'Home'}, {
+      :day_count => 1, :week_count => 2, :month_count => 3
+    })
+    
+    assert_page_counts page, 0, 0, 0
+    assert_page_counts page2, 0, 0, 0
+  end
+  
+  should "be able to decrement with ids and modifier hash" do
+    page = @page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3)
+    page2 = @page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3)
+    
+    @page_class.decrement(page.id, page2.id, {
+      :day_count => 1, :week_count => 2, :month_count => 3
+    })
+    
+    assert_page_counts page, 0, 0, 0
+    assert_page_counts page2, 0, 0, 0
+  end
+  
+  should "always decrement when decrement is called whether number is positive or negative" do
+    page = @page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3)
+    page2 = @page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3)
+    
+    @page_class.decrement(page.id, page2.id, {
+      :day_count => -1, :week_count => 2, :month_count => -3
+    })
+    
+    assert_page_counts page, 0, 0, 0
+    assert_page_counts page2, 0, 0, 0
+  end
+  
+  should "be able to set with criteria and modifier hashes" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.set({:title => 'Home'}, :title => 'Home Revised')
+    
+    page.reload
+    page.title.should == 'Home Revised'
+    
+    page2.reload
+    page2.title.should == 'Home Revised'
+  end
+  
+  should "be able to set with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.set(page.id, page2.id, :title => 'Home Revised')
+    
+    page.reload
+    page.title.should == 'Home Revised'
+    
+    page2.reload
+    page2.title.should == 'Home Revised'
+  end
+  
+  should "be able to push with criteria and modifier hashes" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.push({:title => 'Home'}, :tags => 'foo')
+    
+    page.reload
+    page.tags.should == %w(foo)
+    
+    page2.reload
+    page.tags.should == %w(foo)
+  end
+  
+  should "be able to push with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.push(page.id, page2.id, :tags => 'foo')
+    
+    page.reload
+    page.tags.should == %w(foo)
+    
+    page2.reload
+    page.tags.should == %w(foo)
+  end
+
+  should "be able to push all with criteria and modifier hashes" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    tags = %w(foo bar)
+    
+    @page_class.push_all({:title => 'Home'}, :tags => tags)
+    
+    page.reload
+    page.tags.should == tags
+    
+    page2.reload
+    page.tags.should == tags
+  end
+  
+  should "be able to push all with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home')
+    page2 = @page_class.create(:title => 'Home')
+    tags = %w(foo bar)
+    
+    @page_class.push_all(page.id, page2.id, :tags => tags)
+    
+    page.reload
+    page.tags.should == tags
+    
+    page2.reload
+    page.tags.should == tags
+  end
+  
+  should "be able to pull with criteria and modifier hashes" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    page2 = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    
+    @page_class.pull({:title => 'Home'}, :tags => 'foo')
+    
+    page.reload
+    page.tags.should == %w(bar)
+    
+    page2.reload
+    page.tags.should == %w(bar)
+  end
+  
+  should "be able to pull with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    page2 = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    
+    @page_class.pull(page.id, page2.id, :tags => 'foo')
+    
+    page.reload
+    page.tags.should == %w(bar)
+    
+    page2.reload
+    page.tags.should == %w(bar)
+  end
+
+  should "be able to pull all with criteria and modifier hashes" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar baz))
+    page2 = @page_class.create(:title => 'Home', :tags => %w(foo bar baz))
+    
+    @page_class.pull_all({:title => 'Home'}, :tags => %w(foo bar))
+    
+    page.reload
+    page.tags.should == %w(baz)
+    
+    page2.reload
+    page.tags.should == %w(baz)
+  end
+  
+  should "be able to pull all with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar baz))
+    page2 = @page_class.create(:title => 'Home', :tags => %w(foo bar baz))
+    
+    @page_class.pull_all(page.id, page2.id, :tags => %w(foo bar))
+    
+    page.reload
+    page.tags.should == %w(baz)
+    
+    page2.reload
+    page.tags.should == %w(baz)
+  end
+
+  should "be able to push uniq with criteria and modifier hash" do
+    page  = @page_class.create(:title => 'Home', :tags => 'foo')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.push_uniq({:title => 'Home'}, :tags => 'foo')
+    
+    page.reload
+    page.tags.should == %w(foo)
+    
+    page2.reload
+    page.tags.should == %w(foo)
+  end
+  
+  should "be able to push uniq with ids and modifier hash" do
+    page  = @page_class.create(:title => 'Home', :tags => 'foo')
+    page2 = @page_class.create(:title => 'Home')
+    
+    @page_class.push_uniq(page.id, page2.id, :tags => 'foo')
+    
+    page.reload
+    page.tags.should == %w(foo)
+    
+    page2.reload
+    page.tags.should == %w(foo)
+  end
+  
+  should "be able to remove the last element the array" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    @page_class.pop(page.id, :tags => 1)
+    page.reload
+    page.tags.should == %w(foo)
+  end
+
+  should "be able to remove the first element of the array" do
+    page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+    @page_class.pop(page.id, :tags => -1)
+    page.reload
+    page.tags.should == %w(bar)
+  end
+end