mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/test/functional/test_modifiers.rb

@@ -3,11 +3,11 @@ 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 :title,       String
+      key :day_count,   Integer, :default => 0
+      key :week_count,  Integer, :default => 0
       key :month_count, Integer, :default => 0
-      key :tags, Array
+      key :tags,        Array
     end
   end
 
@@ -18,268 +18,343 @@ class ModifierTest < Test::Unit::TestCase
     page.month_count.should == month_count
   end
 
-  context "using class methods" do
-    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
-      })
+  def assert_keys_removed(page, *keys)
+    keys.each do |key|
+      doc = @page_class.collection.find_one({:_id => page.id})
+      doc.keys.should_not include(key)
+    end
+  end
 
-      assert_page_counts page, 1, 2, 3
-      assert_page_counts page2, 1, 2, 3
+  context "ClassMethods" do
+    context "unset" do
+      setup do
+        @page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+        @page2 = @page_class.create(:title => 'Home')
+      end
+
+      should "work with criteria and keys" do
+        @page_class.unset({:title => 'Home'}, :title, :tags)
+        assert_keys_removed @page, :title, :tags
+        assert_keys_removed @page2, :title, :tags
+      end
+
+      should "work with ids and keys" do
+        @page_class.unset(@page.id, @page2.id, :title, :tags)
+        assert_keys_removed @page, :title, :tags
+        assert_keys_removed @page2, :title, :tags
+      end
     end
 
-    should "be able to increment with ids and modifier hash" do
-      page  = @page_class.create(:title => 'Home')
-      page2 = @page_class.create(:title => 'Home')
+    context "increment" do
+      setup do
+        @page  = @page_class.create(:title => 'Home')
+        @page2 = @page_class.create(:title => 'Home')
+      end
 
-      @page_class.increment(page.id, page2.id, {
-        :day_count => 1, :week_count => 2, :month_count => 3
-      })
+      should "work with criteria and modifier hashes" do
+        @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
+        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)
+      should "work with ids and modifier hash" do
+        @page_class.increment(@page.id, @page2.id, :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
+        assert_page_counts @page, 1, 2, 3
+        assert_page_counts @page2, 1, 2, 3
+      end
     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)
+    context "decrement" do
+      setup 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)
+      end
 
-      @page_class.decrement(page.id, page2.id, {
-        :day_count => 1, :week_count => 2, :month_count => 3
-      })
+      should "work with criteria and modifier hashes" do
+        @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
+        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)
+      should "work with ids and modifier hash" do
+        @page_class.decrement(@page.id, @page2.id, :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
 
-      assert_page_counts page, 0, 0, 0
-      assert_page_counts page2, 0, 0, 0
+      should "decrement with positive or negative numbers" do
+        @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
     end
 
-    should "be able to set with criteria and modifier hashes" do
-      page  = @page_class.create(:title => 'Home')
-      page2 = @page_class.create(:title => 'Home')
+    context "set" do
+      setup do
+        @page  = @page_class.create(:title => 'Home')
+        @page2 = @page_class.create(:title => 'Home')
+      end
+
+      should "work with criteria and modifier hashes" do
+        @page_class.set({:title => 'Home'}, :title => 'Home Revised')
+
+        @page.reload
+        @page.title.should == 'Home Revised'
+
+        @page2.reload
+        @page2.title.should == 'Home Revised'
+      end
+
+      should "work with ids and modifier hash" do
+        @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 "typecast values before querying" do
+        @page_class.key :tags, Set
+
+        assert_nothing_raised do
+          @page_class.set(@page.id, :tags => ['foo', 'bar'].to_set)
+          @page.reload
+          @page.tags.should == Set.new(['foo', 'bar'])
+        end
+      end
+
+      should "not typecast keys that are not defined in document" do
+        assert_raises(BSON::InvalidDocument) do
+          @page_class.set(@page.id, :colors => ['red', 'green'].to_set)
+        end
+      end
+
+      should "set keys that are not defined in document" do
+        @page_class.set(@page.id, :colors => %w[red green])
+        @page.reload
+        @page[:colors].should == %w[red green]
+      end
+    end
 
-      @page_class.set({:title => 'Home'}, :title => 'Home Revised')
+    context "push" do
+      setup do
+        @page  = @page_class.create(:title => 'Home')
+        @page2 = @page_class.create(:title => 'Home')
+      end
 
-      page.reload
-      page.title.should == 'Home Revised'
+      should "work with criteria and modifier hashes" do
+        @page_class.push({:title => 'Home'}, :tags => 'foo')
 
-      page2.reload
-      page2.title.should == 'Home Revised'
-    end
+        @page.reload
+        @page.tags.should == %w(foo)
 
-    should "be able to set with ids and modifier hash" do
-      page  = @page_class.create(:title => 'Home')
-      page2 = @page_class.create(:title => 'Home')
+        @page2.reload
+        @page.tags.should == %w(foo)
+      end
 
-      @page_class.set(page.id, page2.id, :title => 'Home Revised')
+      should "work with ids and modifier hash" do
+        @page_class.push(@page.id, @page2.id, :tags => 'foo')
 
-      page.reload
-      page.title.should == 'Home Revised'
+        @page.reload
+        @page.tags.should == %w(foo)
 
-      page2.reload
-      page2.title.should == 'Home Revised'
+        @page2.reload
+        @page.tags.should == %w(foo)
+      end
     end
 
-    should "be able to push with criteria and modifier hashes" do
-      page  = @page_class.create(:title => 'Home')
-      page2 = @page_class.create(:title => 'Home')
+    context "push_all" do
+      setup do
+        @page  = @page_class.create(:title => 'Home')
+        @page2 = @page_class.create(:title => 'Home')
+        @tags = %w(foo bar)
+      end
 
-      @page_class.push({:title => 'Home'}, :tags => 'foo')
+      should "work with criteria and modifier hashes" do
+        @page_class.push_all({:title => 'Home'}, :tags => @tags)
 
-      page.reload
-      page.tags.should == %w(foo)
+        @page.reload
+        @page.tags.should == @tags
 
-      page2.reload
-      page.tags.should == %w(foo)
-    end
+        @page2.reload
+        @page.tags.should == @tags
+      end
 
-    should "be able to push with ids and modifier hash" do
-      page  = @page_class.create(:title => 'Home')
-      page2 = @page_class.create(:title => 'Home')
+      should "work with ids and modifier hash" do
+        @page_class.push_all(@page.id, @page2.id, :tags => @tags)
 
-      @page_class.push(page.id, page2.id, :tags => 'foo')
+        @page.reload
+        @page.tags.should == @tags
 
-      page.reload
-      page.tags.should == %w(foo)
-
-      page2.reload
-      page.tags.should == %w(foo)
+        @page2.reload
+        @page.tags.should == @tags
+      end
     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)
+    context "pull" do
+      setup do
+        @page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+        @page2 = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+      end
 
-      @page_class.push_all({:title => 'Home'}, :tags => tags)
+      should "work with criteria and modifier hashes" do
+        @page_class.pull({:title => 'Home'}, :tags => 'foo')
 
-      page.reload
-      page.tags.should == tags
+        @page.reload
+        @page.tags.should == %w(bar)
 
-      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)
+        @page2.reload
+        @page.tags.should == %w(bar)
+      end
 
-      @page_class.push_all(page.id, page2.id, :tags => tags)
+      should "be able to pull with ids and modifier hash" do
+        @page_class.pull(@page.id, @page2.id, :tags => 'foo')
 
-      page.reload
-      page.tags.should == tags
+        @page.reload
+        @page.tags.should == %w(bar)
 
-      page2.reload
-      page.tags.should == tags
+        @page2.reload
+        @page.tags.should == %w(bar)
+      end
     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))
+    context "pull_all" do
+      setup do
+        @page  = @page_class.create(:title => 'Home', :tags => %w(foo bar baz))
+        @page2 = @page_class.create(:title => 'Home', :tags => %w(foo bar baz))
+      end
 
-      @page_class.pull({:title => 'Home'}, :tags => 'foo')
+      should "work with criteria and modifier hashes" do
+        @page_class.pull_all({:title => 'Home'}, :tags => %w(foo bar))
 
-      page.reload
-      page.tags.should == %w(bar)
+        @page.reload
+        @page.tags.should == %w(baz)
 
-      page2.reload
-      page.tags.should == %w(bar)
-    end
+        @page2.reload
+        @page.tags.should == %w(baz)
+      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))
+      should "work with ids and modifier hash" do
+        @page_class.pull_all(@page.id, @page2.id, :tags => %w(foo bar))
 
-      @page_class.pull(page.id, page2.id, :tags => 'foo')
+        @page.reload
+        @page.tags.should == %w(baz)
 
-      page.reload
-      page.tags.should == %w(bar)
-
-      page2.reload
-      page.tags.should == %w(bar)
+        @page2.reload
+        @page.tags.should == %w(baz)
+      end
     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))
+    context "add_to_set" do
+      setup do
+        @page  = @page_class.create(:title => 'Home', :tags => 'foo')
+        @page2 = @page_class.create(:title => 'Home')
+      end
 
-      @page_class.pull_all({:title => 'Home'}, :tags => %w(foo bar))
+      should "be able to add to set with criteria and modifier hash" do
+        @page_class.add_to_set({:title => 'Home'}, :tags => 'foo')
 
-      page.reload
-      page.tags.should == %w(baz)
+        @page.reload
+        @page.tags.should == %w(foo)
 
-      page2.reload
-      page.tags.should == %w(baz)
-    end
+        @page2.reload
+        @page.tags.should == %w(foo)
+      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))
+      should "be able to add to set with ids and modifier hash" do
+        @page_class.add_to_set(@page.id, @page2.id, :tags => 'foo')
 
-      @page_class.pull_all(page.id, page2.id, :tags => %w(foo bar))
+        @page.reload
+        @page.tags.should == %w(foo)
 
-      page.reload
-      page.tags.should == %w(baz)
-
-      page2.reload
-      page.tags.should == %w(baz)
+        @page2.reload
+        @page.tags.should == %w(foo)
+      end
     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')
+    context "push_uniq" do
+      setup do
+        @page  = @page_class.create(:title => 'Home', :tags => 'foo')
+        @page2 = @page_class.create(:title => 'Home')
+      end
 
-      @page_class.push_uniq({:title => 'Home'}, :tags => 'foo')
+      should "be able to push uniq with criteria and modifier hash" do
+        @page_class.push_uniq({:title => 'Home'}, :tags => 'foo')
 
-      page.reload
-      page.tags.should == %w(foo)
+        @page.reload
+        @page.tags.should == %w(foo)
 
-      page2.reload
-      page.tags.should == %w(foo)
-    end
+        @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')
+      should "be able to push uniq with ids and modifier hash" do
+        @page_class.push_uniq(@page.id, @page2.id, :tags => 'foo')
 
-      @page_class.push_uniq(page.id, page2.id, :tags => 'foo')
-
-      page.reload
-      page.tags.should == %w(foo)
+        @page.reload
+        @page.tags.should == %w(foo)
 
-      page2.reload
-      page.tags.should == %w(foo)
+        @page2.reload
+        @page.tags.should == %w(foo)
+      end
     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)
+    context "pop" do
+      setup do
+        @page  = @page_class.create(:title => 'Home', :tags => %w(foo bar))
+      end
+
+      should "be able to remove the last element the array" do
+        @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_class.pop(@page.id, :tags => -1)
+        @page.reload
+        @page.tags.should == %w(bar)
+      end
     end
+  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)
+  context "InstanceMethods" do
+    should "be able to unset with keys" do
+      page = @page_class.create(:title => 'Foo', :tags => %w(foo))
+      page.unset(:title, :tags)
+      assert_keys_removed page, :title, :tags
     end
-  end
 
-  context "using instance methods" do
     should "be able to increment with modifier hashes" do
       page = @page_class.create
-
-      page.increment({:day_count => 1, :week_count => 2, :month_count => 3})
+      page.increment(:day_count => 1, :week_count => 2, :month_count => 3)
 
       assert_page_counts page, 1, 2, 3
     end
 
     should "be able to decrement with modifier hashes" do
       page = @page_class.create(:day_count => 1, :week_count => 2, :month_count => 3)
-
-      page.decrement({:day_count => 1, :week_count => 2, :month_count => 3})
+      page.decrement(:day_count => 1, :week_count => 2, :month_count => 3)
 
       assert_page_counts page, 0, 0, 0
     end
 
     should "always decrement when decrement is called whether number is positive or negative" do
       page = @page_class.create(:day_count => 1, :week_count => 2, :month_count => 3)
-
-      page.decrement({:day_count => -1, :week_count => 2, :month_count => -3})
+      page.decrement(:day_count => -1, :week_count => 2, :month_count => -3)
 
       assert_page_counts page, 0, 0, 0
     end
 
     should "be able to set with modifier hashes" do
       page  = @page_class.create(:title => 'Home')
-
       page.set(:title => 'Home Revised')
 
       page.reload
@@ -288,7 +363,6 @@ class ModifierTest < Test::Unit::TestCase
 
     should "be able to push with modifier hashes" do
       page = @page_class.create
-
       page.push(:tags => 'foo')
 
       page.reload
@@ -296,14 +370,27 @@ class ModifierTest < Test::Unit::TestCase
     end
 
     should "be able to pull with criteria and modifier hashes" do
-      page  = @page_class.create(:tags => %w(foo bar))
-
+      page = @page_class.create(:tags => %w(foo bar))
       page.pull(:tags => 'foo')
 
       page.reload
       page.tags.should == %w(bar)
     end
 
+    should "be able to add_to_set with criteria and modifier hash" do
+      page  = @page_class.create(:tags => 'foo')
+      page2 = @page_class.create
+
+      page.add_to_set(:tags => 'foo')
+      page.add_to_set(:tags => 'foo')
+
+      page.reload
+      page.tags.should == %w(foo)
+
+      page2.reload
+      page.tags.should == %w(foo)
+    end
+
     should "be able to push uniq with criteria and modifier hash" do
       page  = @page_class.create(:tags => 'foo')
       page2 = @page_class.create
@@ -317,6 +404,13 @@ class ModifierTest < Test::Unit::TestCase
       page2.reload
       page.tags.should == %w(foo)
     end
-  end
 
+    should "be able to pop with modifier hashes" do
+      page = @page_class.create(:tags => %w(foo bar))
+      page.pop(:tags => 1)
+
+      page.reload
+      page.tags.should == %w(foo)
+    end
+  end
 end

data/test/functional/test_pagination.rb

@@ -4,30 +4,28 @@ class PaginationTest < Test::Unit::TestCase
   context "Paginating" do
     setup do
       @document = Doc do
-        set_collection_name 'users'
-
         key :first_name, String
         key :last_name, String
         key :age, Integer
-        
+
         def self.per_page; 1 end
       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'})
+
+      @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 "return the total pages" do
       result = @document.paginate(:per_page => 2, :page => 1)
       result.total_pages.should == 2
     end
-    
+
     should "return the total pages when defaulting to the document class per_page" do
       result = @document.paginate(:page => 1)
       result.total_pages.should == 3
     end
-    
+
     should "return the total of records" do
       result = @document.paginate(:per_page => 2, :page => 1)
       result.total_entries.should == 3
@@ -43,7 +41,7 @@ class PaginationTest < Test::Unit::TestCase
       result = @document.paginate({
         :last_name => 'Nunemaker',
         :order     => "age DESC",
-        :per_page  => 2, 
+        :per_page  => 2,
         :page      => 1,
       })
       result.should == [@doc1, @doc3]
@@ -58,17 +56,17 @@ class PaginationTest < Test::Unit::TestCase
       result.first.age.should == 27
     end
 
-    should "withstand rigor" do      
+    should "withstand rigor" do
       result = @document.paginate({
-        :per_page  => 1, 
+        :per_page  => 1,
         :page      => 1,
-        :order     => 'age desc', 
+        :order     => 'age desc',
         :last_name => 'Nunemaker'
       })
       result.should == [@doc1]
       result.total_entries.should == 2
       result.total_pages.should == 2
-      
+
       result = @document.paginate({
         :per_page  => 1,
         :page      => 2,
@@ -78,7 +76,7 @@ class PaginationTest < Test::Unit::TestCase
       result.should == [@doc3]
       result.total_entries.should == 2
       result.total_pages.should == 2
-      
+
       result = @document.paginate({
         :per_page  => 2,
         :page      => 1,