crnixon-mongomapper 0.2.0 → 0.3.4

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

@@ -28,7 +28,6 @@ class FinderOptionsTest < Test::Unit::TestCase
     end
   end
   
-  
   context "Converting conditions to criteria" do
     should "work with simple criteria" do
       FinderOptions.to_mongo_criteria(:foo => 'bar').should == {
@@ -47,10 +46,24 @@ class FinderOptionsTest < Test::Unit::TestCase
       }
     end
     
+    should "not use $in for arrays if already using array operator" do
+      FinderOptions.to_mongo_criteria(:foo => {'$all' => [1,2,3]}).should == {
+        :foo => {'$all' => [1,2,3]}
+      }
+
+      FinderOptions.to_mongo_criteria(:foo => {'$any' => [1,2,3]}).should == {
+        :foo => {'$any' => [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]}}
       }
+      
+      FinderOptions.to_mongo_criteria(:foo => {:bar => {'$any' => [1,2,3]}}).should == {
+        :foo => {:bar => {'$any' => [1,2,3]}}
+      }
     end
   end
   
@@ -90,6 +103,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]
     end
   end
 
@@ -31,9 +31,37 @@ class KeyTest < Test::Unit::TestCase
       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)
     end
+    
+    should "work with just name" do
+      key = Key.new(:foo)
+      key.name.should == 'foo'
+    end
+    
+    should "work with name and type" do
+      key = Key.new(:foo, String)
+      key.name.should == 'foo'
+      key.type.should == String
+    end
+    
+    should "work with name, type, and options" do
+      key = Key.new(:foo, String, :required => true)
+      key.name.should == 'foo'
+      key.type.should == String
+      key.options[:required].should be_true
+    end
+    
+    should "work with name and options" do
+      key = Key.new(:foo, :required => true)
+      key.name.should == 'foo'
+      key.options[:required].should be_true
+    end
   end
 
   context "A key" do
@@ -48,14 +76,19 @@ class KeyTest < Test::Unit::TestCase
     should "not be equal to another key with different type" do
       Key.new(:name, String).should_not == Key.new(:name, Integer)
     end
-
-    should "know if it is native" do
-      Key.new(:name, String).native?.should be_true
-    end
-
-    should "know if it is not native" do
-      klass = Class.new
-      Key.new(:name, klass).native?.should be_false
+    
+    context "native?" do
+      should "be true if native type" do
+        Key.new(:name, String).native?.should be_true
+      end
+      
+      should "be true if no type" do
+        Key.new(:name).native?.should be_true
+      end
+      
+      should "be false if not native" do
+        Key.new(:name, Class.new).native?.should be_false
+      end
     end
 
     should "know if it is a embedded_document" do
@@ -84,6 +117,13 @@ class KeyTest < Test::Unit::TestCase
         key.set(a).should == 21
       end
     end
+    
+    should "work fine with long integers" do
+      key = Key.new(:foo, Integer)
+      [9223372036854775807, '9223372036854775807'].each do |value|
+        key.set(value).should == 9223372036854775807
+      end
+    end
 
     should "correctly typecast Floats" do
       key = Key.new(:foo, Float)
@@ -97,9 +137,9 @@ class KeyTest < Test::Unit::TestCase
       key.set('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
     end
 
-    should_eventually "correctly typecast Dates" do
-      key = Key.new(:foo, Date)
-      key.set('2000-01-01').should == Date.new(2000, 1, 1)
+    should "correctly typecast Times into UTC time zone" do
+      key = Key.new(:foo, Time)
+      key.set('2000-01-01 01:01:01.123456').zone.should == "UTC"
     end
 
     should "correctly typecast Boolean" do
@@ -134,6 +174,13 @@ class KeyTest < Test::Unit::TestCase
       key = Key.new(:foo, String)
       key.get('bar').should == 'bar'
     end
+    
+    should "work without type" do
+      key = Key.new(:foo)
+      key.get([1,"2"]).should == [1, "2"]
+      key.get(false).should   == false
+      key.get({}).should      == {}
+    end
 
     context "for a key with a default value set" do
       setup do

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 == ['_id', 'for_all']
+      FirstItem.column_names.sort.should == ['_id', 'first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['_id', '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