jnunemaker-mongomapper 0.2.0 → 0.3.0

data/test/{test_finder_options.rb → unit/test_finder_options.rb}

@@ -47,11 +47,55 @@ class FinderOptionsTest < Test::Unit::TestCase
       }
     end
     
+    should "not use $in for arrays if already using array modifier" do
+      FinderOptions.to_mongo_criteria(:foo => {'$all' => [1,2,3]}).should == {
+        :foo => {'$all' => [1,2,3]}
+      }
+    end
+    
     should "work arbitrarily deep" do
       FinderOptions.to_mongo_criteria(:foo => {:bar => [1,2,3]}).should == {
         :foo => {:bar => {'$in' => [1,2,3]}}
       }
     end
+    
+    should "convert string _ids to objectid automatically" do
+      id = XGen::Mongo::Driver::ObjectID.new
+      
+      FinderOptions.to_mongo_criteria(:_id => id.to_s).should == {
+        :_id => id
+      }
+    end
+    
+    should "leave objectid _ids alone" do
+      id = XGen::Mongo::Driver::ObjectID.new
+      
+      FinderOptions.to_mongo_criteria(:_id => id).should == {
+        :_id => id
+      }
+    end
+    
+    should "convert array of string _ids to object ids" do
+      id1 = XGen::Mongo::Driver::ObjectID.new
+      id2 = XGen::Mongo::Driver::ObjectID.new
+      
+      FinderOptions.to_mongo_criteria(:_id => [id1.to_s, id2.to_s]).should == {
+        :_id => {'$in' => [id1, id2]}
+      }
+    end
+    
+    should "convert array of string _ids when using mongo array stuff" do
+      id1 = XGen::Mongo::Driver::ObjectID.new
+      id2 = XGen::Mongo::Driver::ObjectID.new
+      
+      FinderOptions.to_mongo_criteria(:_id => {'$all' => [id1.to_s, id2.to_s]}).should == {
+        :_id => {'$all' => [id1, id2]}
+      }
+      
+      FinderOptions.to_mongo_criteria(:_id => {'$any' => [id1.to_s, id2.to_s]}).should == {
+        :_id => {'$any' => [id1, id2]}
+      }
+    end
   end
   
   context "ordering" do
@@ -90,6 +134,28 @@ class FinderOptionsTest < Test::Unit::TestCase
       hash[:baz] = 1
       FinderOptions.to_mongo_options(:order => 'foo desc, bar, baz')[:sort].should == hash
     end
+    
+    should "just use sort if sort and order are present" do
+      FinderOptions.to_mongo_options(:sort => {'$natural' => 1}, :order => 'foo asc')[:sort].should == {
+        '$natural' => 1
+      }
+    end
+    
+    should "convert natural in order to proper" do
+      hash = OrderedHash.new
+      hash[:'$natural'] = 1
+      FinderOptions.to_mongo_options(:order => '$natural asc')[:sort].should == hash
+      hash[:'$natural'] = -1
+      FinderOptions.to_mongo_options(:order => '$natural desc')[:sort].should == hash
+    end
+    
+    should "work for natural order ascending" do
+      FinderOptions.to_mongo_options(:sort => {'$natural' => 1})[:sort]['$natural'].should == 1
+    end
+    
+    should "work for natural order descending" do
+      FinderOptions.to_mongo_options(:sort => {'$natural' => -1})[:sort]['$natural'].should == -1
+    end
   end
   
   context "offset" do

data/test/{test_key.rb → unit/test_key.rb}

@@ -14,7 +14,7 @@ class KeyTest < Test::Unit::TestCase
 
   context "The Key Class" do
     should "have the native types defined" do
-      Key::NativeTypes.should == [String, Float, Time, Integer, Boolean, Array, Hash, Ref]
+      Key::NativeTypes.should == [String, Float, Time, Integer, Boolean, Array, Hash, MongoID]
     end
   end
 
@@ -30,6 +30,10 @@ class KeyTest < Test::Unit::TestCase
     should "allow setting options" do
       Key.new(:foo, Integer, :required => true).options[:required].should be(true)
     end
+    
+    should "default options to {}" do
+      Key.new(:foo, Integer, nil).options.should == {}
+    end
 
     should "symbolize option keys" do
       Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
@@ -71,6 +75,14 @@ class KeyTest < Test::Unit::TestCase
   end
 
   context "setting a value" do
+    should "correctly typecast MongoIDs" do
+      key = Key.new(:_id, MongoID)
+      id = MongoID.new
+      [id, id.to_s].each do |a|
+        key.set(a).should == id
+      end
+    end
+    
     should "correctly typecast Strings" do
       key = Key.new(:foo, String)
       [21, '21'].each do |a|

data/test/unit/test_mongo_id.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class MongoIDTest < Test::Unit::TestCase
+  PhonyError = Class.new(StandardError)
+  
+  class Phony
+    def to_s
+      raise PhonyError
+    end
+  end
+  
+  context "mm_typecast" do
+    should "return value if object id" do
+      id = XGen::Mongo::Driver::ObjectID.new
+      MongoID.mm_typecast(id).should == id
+    end
+    
+    should "return object id if string" do
+      id = XGen::Mongo::Driver::ObjectID.new
+      MongoID.mm_typecast(id.to_s).should == id
+    end
+    
+    should "raise DocumentNotFound if invalid id" do
+      lambda {
+        MongoID.mm_typecast(1234)
+      }.should raise_error(MongoMapper::DocumentNotFound)
+    end
+    
+    should "raise exception if message does not match illegal object id" do
+      lambda {
+        MongoID.mm_typecast(Phony.new)
+      }.should raise_error(PhonyError)
+    end
+  end
+end

data/test/unit/test_pagination.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase  
+  context "Pagination proxy" do
+    include MongoMapper::Pagination
+    
+    should "should have accessors for subject" do
+      subject = [1,2,3,4,5]
+      collection = PaginationProxy.new(25, 2)
+      collection.subject = subject
+      collection.subject.should == subject
+    end
+    
+    should "delegate any methods not defined to the subject" do
+      subject = [1,2,3,4,5]
+      collection = PaginationProxy.new(25, 2, 10)
+      collection.subject = subject
+      collection.size.should == 5
+      collection.each_with_index do |value, i|
+        value.should == subject[i]
+      end
+      collection[0..2].should == [1,2,3]
+      collection.class.should == Array
+    end
+    
+    should "return correct value for total_entries" do
+      PaginationProxy.new(25, 2, 10).total_entries.should == 25
+      PaginationProxy.new('25', 2, 10).total_entries.should == 25
+    end
+    
+    should "return correct value for per_page" do
+      PaginationProxy.new(25, 2, 10).per_page.should == 10
+      PaginationProxy.new(25, 2, '10').per_page.should == 10
+    end
+    
+    should "alias limit to per_page" do
+      PaginationProxy.new(100, 1, 300).limit.should == 300
+    end
+    
+    should "set per_page to 25 if nil or blank" do
+      PaginationProxy.new(25, 2).per_page.should == 25
+      PaginationProxy.new(25, 2, '').per_page.should == 25
+    end
+    
+    should "return correct value for current_page" do
+      PaginationProxy.new(25, 2, 10).current_page.should == 2
+      PaginationProxy.new(25, '2', 10).current_page.should == 2
+    end
+    
+    should "not allow value less than 1 for current page" do
+      PaginationProxy.new(25, -1).current_page.should == 1
+    end
+    
+    should "automatically calculate total_pages from total_entries and per page" do
+      PaginationProxy.new(25, 2, 10).total_pages.should == 3
+    end
+    
+    should "know how many records to skip" do
+      PaginationProxy.new(25, 2, 10).skip.should == 10
+    end
+    
+    should "alias offset to skip" do
+      PaginationProxy.new(25, 2, 10).offset.should == 10
+    end
+    
+    context "previous_page" do
+      should "be nil if current page 1" do
+        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+      end
+      
+      should "be one less than current page if current is > 1" do
+        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+      end
+    end
+    
+    context "next_page" do
+      should "be nil if current page is last page" do
+        PaginationProxy.new(25, 3, 10).next_page.should be_nil
+      end
+      
+      should "work for any page that is not last" do
+        PaginationProxy.new(25, 1, 10).next_page.should == 2
+        PaginationProxy.new(25, 2, 10).next_page.should == 3
+      end
+    end
+    
+    context "previous_page" do
+      should "be nil if current page is first page" do
+        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+      end
+      
+      should "work for any page other than first" do
+        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+        PaginationProxy.new(25, 3, 10).previous_page.should == 2
+      end
+    end
+    
+    context "out_of_bounds?" do
+      should "be true if current_page is greater than total_pages" do
+        PaginationProxy.new(25, 10, 4).out_of_bounds?.should be_true
+      end
+      
+      should "be false if current_page is less than total_pages" do
+        PaginationProxy.new(25, 10, 1).out_of_bounds?.should be_false
+        PaginationProxy.new(25, 2, 10).out_of_bounds?.should be_false
+      end
+      
+      should "be false if current_page is equal to total_pages" do
+        PaginationProxy.new(25, 3, 10).out_of_bounds?.should be_false
+      end
+    end
+  end # end of pagination proxy
+end # end of test case

data/test/unit/test_rails_compatibility.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class Item
+    include MongoMapper::EmbeddedDocument
+    key :for_all, String
+  end
+
+  class FirstItem < Item  
+    key :first_only, String
+    many :second_items
+  end
+
+  class SecondItem < Item
+    key :second_only, String
+  end
+  
+  context "EmbeddedDocument" do
+    should "raise error for to_param as embedded do not have id's" do
+      lambda { Item.new.to_param }.should raise_error
+    end
+    
+    should "alias many to has_many" do
+      FirstItem.should respond_to(:has_many)
+      FirstItem.method(:has_many).should == FirstItem.method(:many)
+    end
+    
+    should "have column names" do
+      Item.column_names.sort.should == ['for_all']
+      FirstItem.column_names.sort.should == ['first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['for_all', 'second_only']
+    end
+  end
+end

data/test/{test_serializations.rb → unit/test_serializations.rb}

@@ -20,7 +20,6 @@ class SerializationTest < Test::Unit::TestCase
     )
   end
   
-  # [:xml, :json].each do |format|
   [:json].each do |format|
     context format do
       should "be reversable" do
@@ -48,7 +47,6 @@ class SerializationTest < Test::Unit::TestCase
         assert_nil unserialized.age
         assert_equal @instance.awesome, unserialized.awesome
       end
-      
     end
   end
 end

data/test/{test_validations.rb → unit/test_validations.rb}

@@ -154,46 +154,6 @@ class ValidationsTest < Test::Unit::TestCase
         doc.should have_error_on(:name)
       end
     end
-
-    context "validating uniqueness of" do
-      setup do
-        @document.key :name, String
-        @document.validates_uniqueness_of :name
-      end
-
-      should "not fail if object is new" do
-        doc = @document.new
-        doc.should_not have_error_on(:name)
-      end
-
-      should "allow to update an object" do
-        doc = @document.new("name" => "joe")
-        doc.save
-        doc.name = "joe"
-        doc.valid?.should be_true
-        doc.should_not have_error_on(:name)
-      end
-
-      should "fail if object name is not unique" do
-        doc = @document.new("name" => "joe")
-        doc.save.should be_true
-        sleep 0.2 # hack to avoid race condition
-        doc2 = @document.new("name" => "joe")
-        doc2.should have_error_on(:name)
-      end
-    end
-    
-    context "validates uniqueness of with :unique shortcut" do
-      should "work" do
-        @document.key :name, String, :unique => true
-        
-        doc = @document.create(:name => 'John')
-        doc.should_not have_error_on(:name)
-        sleep 0.2 # hack to avoid race condition
-        second_john = @document.create(:name => 'John')
-        second_john.should have_error_on(:name, 'has already been taken')
-      end
-    end
     
     context "validating exclusion of" do
       should "throw error if enumerator not provided" do
@@ -274,70 +234,6 @@ class ValidationsTest < Test::Unit::TestCase
     end
   end # Validations
 
-  context "Saving a new document that is invalid" do
-    setup do
-      @document = Class.new do
-        include MongoMapper::Document
-        key :name, String, :required => true
-      end
-
-      @document.collection.clear
-    end
-
-    should "not insert document" do
-      doc = @document.new
-      doc.save
-      @document.count.should == 0
-    end
-
-    should "populate document's errors" do
-      doc = @document.new
-      doc.errors.size.should == 0
-      doc.save
-      doc.errors.full_messages.should == ["Name can't be empty"]
-    end
-  end
-
-  context "Saving a document that is invalid (destructive)" do
-    setup do
-      @document = Class.new do
-        include MongoMapper::Document
-        key :name, String, :required => true
-      end
-
-      @document.collection.clear
-    end
-
-    should "raise error" do
-      doc = @document.new
-      lambda { doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
-    end
-  end
-
-  context "Saving an existing document that is invalid" do
-    setup do
-      @document = Class.new do
-        include MongoMapper::Document
-        key :name, String, :required => true
-      end
-
-      @document.collection.clear
-      @doc = @document.create(:name => 'John Nunemaker')
-    end
-
-    should "not update document" do
-      @doc.name = nil
-      @doc.save
-      @document.find(@doc.id).name.should == 'John Nunemaker'
-    end
-
-    should "populate document's errors" do
-      @doc.name = nil
-      @doc.save
-      @doc.errors.full_messages.should == ["Name can't be empty"]
-    end
-  end
-
   context "Adding validation errors" do
     setup do
       @document = Class.new do
@@ -359,35 +255,5 @@ class ValidationsTest < Test::Unit::TestCase
       doc.action = 'kick'
       doc.should_not have_error_on(:action)
     end
-
-    should "work with validate_on_create callback" do
-      @document.validate_on_create :action_present
-
-      doc = @document.new
-      doc.action = nil
-      doc.should have_error_on(:action)
-
-      doc.action = 'kick'
-      doc.should_not have_error_on(:action)
-      doc.save
-
-      doc.action = nil
-      doc.should_not have_error_on(:action)
-    end
-
-    should "work with validate_on_update callback" do
-      @document.validate_on_update :action_present
-
-      doc = @document.new
-      doc.action = nil
-      doc.should_not have_error_on(:action)
-      doc.save
-
-      doc.action = nil
-      doc.should have_error_on(:action)
-
-      doc.action = 'kick'
-      doc.should_not have_error_on(:action)
-    end
   end
 end