danielharan-mongo_mapper 0.6.5

data/test/unit/test_mongo_mapper.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class Address; end
+
+class MongoMapperTest < Test::Unit::TestCase  
+  should "be able to write and read connection" do
+    conn = Mongo::Connection.new
+    MongoMapper.connection = conn
+    MongoMapper.connection.should == conn
+  end
+  
+  should "default connection to new mongo ruby driver" do
+    MongoMapper.connection = nil
+    MongoMapper.connection.should be_instance_of(Mongo::Connection)
+  end
+  
+  should "be able to write and read default database" do
+    MongoMapper.database = 'test'
+    MongoMapper.database.should be_instance_of(Mongo::DB)
+    MongoMapper.database.name.should == 'test'
+  end
+  
+  should "have document not found error" do
+    lambda {
+      MongoMapper::DocumentNotFound
+    }.should_not raise_error
+  end
+  
+  context "use_time_zone?" do
+    should "be true if Time.zone set" do
+      Time.zone = 'Hawaii'
+      MongoMapper.use_time_zone?.should be_true
+      Time.zone = nil
+    end
+    
+    should "be false if Time.zone not set" do
+      MongoMapper.use_time_zone?.should be_false
+    end
+  end
+  
+  context "time_class" do
+    should "be Time.zone if using time zones" do
+      Time.zone = 'Hawaii'
+      MongoMapper.time_class.should == Time.zone
+      Time.zone = nil
+    end
+    
+    should "be Time if not using time zones" do
+      MongoMapper.time_class.should == Time
+    end
+  end
+  
+  context "normalize_object_id" do
+    should "turn string into object id" do
+      id = Mongo::ObjectID.new
+      MongoMapper.normalize_object_id(id.to_s).should == id
+    end
+    
+    should "leave object id alone" do
+      id = Mongo::ObjectID.new
+      MongoMapper.normalize_object_id(id).should == id
+    end
+  end
+  
+end

data/test/unit/test_observing.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+class Comment
+  include MongoMapper::Document
+  
+  key :name, String
+  key :body, String
+  
+  attr_accessor :callers
+  before_validation :record_callers
+
+  def after_validation
+    record_callers
+  end
+
+  def record_callers
+    callers << self.class if callers
+  end
+end
+
+class Article
+  include MongoMapper::Document
+  
+  key :title, String
+  key :body, String
+end
+
+class CommentObserver < MongoMapper::Observer
+  attr_accessor :callers
+
+  def after_validation(model)
+    callers << self.class if callers
+  end
+end
+
+class AuditObserver < MongoMapper::Observer
+  observe Article, Comment
+  attr_reader :document
+  
+  def after_validation(document)
+    @document = document
+  end
+end
+
+class GlobalObserver < MongoMapper::Observer
+  observe Article, Comment
+  attr_reader :document
+  
+  def before_save(document)
+    @document = document
+  end
+end
+
+class NonAutomaticObserver < MongoMapper::Observer
+  observe Comment
+  attr_reader :comment
+  
+  def after_validation(comment)
+    @comment = comment
+  end
+end
+
+class ObserverTest < Test::Unit::TestCase  
+  should "fire model callbacks before observer" do
+    callers = []
+    comment = Comment.new
+    comment.callers = callers
+
+    CommentObserver.instance.callers = callers
+
+    comment.valid?
+    callers.should == [Comment, Comment, CommentObserver]
+  end
+  
+  should "automatically observe model based on name when possible" do
+    CommentObserver.observed_class.should == Comment
+  end
+  
+  should "be able to observe other models using observe" do
+    obs = NonAutomaticObserver.instance
+    comment = Comment.new(:name => 'John Nunemaker', :body => 'is awesome')
+    comment.valid?
+    obs.comment.name.should == 'John Nunemaker'
+    obs.comment.body.should == 'is awesome'
+  end
+  
+  should "be able to observe multiple models" do
+    obs = AuditObserver.instance
+    comment = Comment.new(:name => 'Steve Smith', :body => 'is awesome')
+    comment.valid?
+    
+    obs.document.name.should == 'Steve Smith'
+    obs.document.body.should == 'is awesome'
+    
+    article = Article.new(:title => 'Ordered List Is Awesome', :body => 'Learn to accept it!')
+    article.valid?
+    
+    obs.document.title.should == 'Ordered List Is Awesome'
+    obs.document.body.should == 'Learn to accept it!'
+  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,49 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class BigStuff
+    include MongoMapper::Document
+  end
+  
+  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 "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
+    
+    should "alias new to new_record?" do
+      instance = Item.new
+      instance.new_record?.should == instance.new?
+    end
+    
+    should "implement human_name" do
+      Item.human_name.should == 'Item'
+    end
+  end
+  
+  context "Document" do
+    should "implement human_name" do
+      BigStuff.human_name.should == 'Big Stuff'
+    end
+  end
+end

data/test/unit/test_serializations.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class SerializationTest < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::EmbeddedDocument
+      key :name, String
+      key :age, Integer
+      key :awesome, Boolean
+      key :preferences, Hash
+      key :created_at, Time
+    end
+    
+    @instance = @document.new(
+      :name        => 'John Doe',
+      :age         => 25,
+      :awesome     => true,
+      :preferences => {:language => 'Ruby'},
+      :created_at  => Time.now.change(:usec => 0)
+    )
+  end
+  
+  [:json].each do |format|
+    context format do
+      should "be reversable" do
+        serialized = @instance.send("to_#{format}")
+        unserialized = @document.new.send("from_#{format}", serialized)
+
+        assert_equal @instance, unserialized
+      end
+      
+      should "allow attribute only filtering" do
+        serialized = @instance.send("to_#{format}", :only => [ :age, :name ])
+        unserialized = @document.new.send("from_#{format}", serialized)
+
+        assert_equal @instance.name, unserialized.name
+        assert_equal @instance.age, unserialized.age
+        assert ! unserialized.awesome
+        assert_nil unserialized.created_at
+      end
+      
+      should "allow attribute except filtering" do
+        serialized = @instance.send("to_#{format}", :except => [ :age, :name ])
+        unserialized = @document.new.send("from_#{format}", serialized)
+        
+        assert_nil unserialized.name
+        assert_nil unserialized.age
+        assert_equal @instance.awesome, unserialized.awesome
+      end
+    end
+  end
+end

data/test/unit/test_support.rb

@@ -0,0 +1,342 @@
+require 'test_helper'
+
+class SupportTest < Test::Unit::TestCase
+  context "Array#to_mongo" do
+    should "convert value to_a" do
+      Array.to_mongo([1, 2, 3, 4]).should == [1, 2, 3, 4]
+      Array.to_mongo('1').should == ['1']
+      Array.to_mongo({'1' => '2', '3' => '4'}).should == [['1', '2'], ['3', '4']]
+    end
+  end
+
+  context "Array#from_mongo" do
+    should "be array if array" do
+      Array.from_mongo([1, 2]).should == [1, 2]
+    end
+    
+    should "be empty array if nil" do
+      Array.from_mongo(nil).should == []
+    end
+  end
+  
+  context "Binary#to_mongo" do
+    should "convert to byte buffer if not byte buffer" do
+      Binary.to_mongo('asdfsadasdfs').is_a?(ByteBuffer).should be_true
+    end
+    
+    should "be byte buffer if byte buffer" do
+      Binary.to_mongo(ByteBuffer.new('asdfsadasdfs')).is_a?(ByteBuffer).should be_true
+    end
+    
+    should "be nil if nil" do
+      Binary.to_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Binary#from_mongo" do
+    should "return value" do
+      buffer = ByteBuffer.new('asdfasdfasdf')
+      Binary.from_mongo(buffer).to_s.should == buffer.to_s
+    end
+  end
+  
+  context "Boolean#to_mongo" do
+    should "be true for true" do
+      Boolean.to_mongo(true).should be_true
+    end
+    
+    should "be false for false" do
+      Boolean.to_mongo(false).should be_false
+    end
+    
+    should "handle odd assortment of other values" do
+      Boolean.to_mongo('true').should be_true
+      Boolean.to_mongo('t').should be_true
+      Boolean.to_mongo('1').should be_true
+      Boolean.to_mongo(1).should be_true
+      
+      Boolean.to_mongo('false').should be_false
+      Boolean.to_mongo('f').should be_false
+      Boolean.to_mongo('0').should be_false
+      Boolean.to_mongo(0).should be_false
+    end
+  end
+  
+  context "Boolean#from_mongo" do
+    should "be true for true" do
+      Boolean.from_mongo(true).should be_true
+    end
+    
+    should "be false for false" do
+      Boolean.from_mongo(false).should be_false
+    end
+    
+    should "be false for nil" do
+      Boolean.from_mongo(nil).should be_false
+    end
+  end
+  
+  context "Date#to_mongo" do
+    should "be time if string" do
+      date = Date.to_mongo('10/1/2009')
+      date.should == Time.utc(2009, 10, 1)
+      date.should == date
+      date.month.should == 10
+      date.day.should == 1
+      date.year.should == 2009
+    end
+    
+    should "be time if date" do
+      Date.to_mongo(Date.new(2009, 10, 1)).should == Time.utc(2009, 10, 1)
+    end
+    
+    should "be nil if bogus string" do
+      Date.to_mongo('jdsafop874').should be_nil
+    end
+    
+    should "be nil if empty string" do
+      Date.to_mongo('').should be_nil
+    end
+  end
+  
+  context "Date#from_mongo" do
+    should "be date if date" do
+      date = Date.new(2009, 10, 1)
+      from_date = Date.from_mongo(date)
+      from_date.should == date
+      from_date.month.should == 10
+      from_date.day.should == 1
+      from_date.year.should == 2009
+    end
+    
+    should "be date if time" do
+      time = Time.now
+      Date.from_mongo(time).should == time.to_date
+    end
+    
+    should "be nil if nil" do
+      Date.from_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Float#to_mongo" do
+    should "convert value to_f" do
+      [21, 21.0, '21'].each do |value|
+        Float.to_mongo(value).should == 21.0
+      end
+    end
+  end
+  
+  context "Hash#from_mongo" do
+    should "convert hash to hash with indifferent access" do
+      hash = Hash.from_mongo(:foo => 'bar')
+      hash[:foo].should  == 'bar'
+      hash['foo'].should == 'bar'
+    end
+    
+    should "be hash if nil" do
+      hash = Hash.from_mongo(nil)
+      hash.should == {}
+      hash.is_a?(HashWithIndifferentAccess).should be_true
+    end
+  end
+  
+  context "Hash#to_mongo instance method" do
+    should "have instance method that returns self" do
+      hash = HashWithIndifferentAccess.new('foo' => 'bar')
+      hash.to_mongo.should == {'foo' => 'bar'}
+    end
+  end
+  
+  context "Integer#to_mongo" do
+    should "convert value to integer" do
+      [21, 21.0, '21'].each do |value|
+        Integer.to_mongo(value).should == 21
+      end
+    end
+    
+    should "work fine with big integers" do
+      [9223372036854775807, '9223372036854775807'].each do |value|
+        Integer.to_mongo(value).should == 9223372036854775807
+      end
+    end
+  end
+  
+  context "ObjectId#to_mongo" do
+    should "return nil for nil" do
+      ObjectId.to_mongo(nil).should be_nil
+    end
+    
+    should "return value if object id" do
+      id = Mongo::ObjectID.new
+      ObjectId.to_mongo(id).should be(id)
+    end
+    
+    should "return object id if string" do
+      id = Mongo::ObjectID.new
+      ObjectId.to_mongo(id.to_s).should be(id)
+    end
+  end
+  
+  context "ObjectId#from_mongo" do
+    should "return value" do
+      id = Mongo::ObjectID.new
+      ObjectId.from_mongo(id).should == id
+    end
+  end
+  
+  context "NilClass#to_mongo" do
+    should "return nil" do
+      nil.to_mongo(nil).should be_nil
+    end
+  end
+  
+  context "NilClass#from_mongo" do
+    should "return nil" do
+      nil.from_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Object#to_mongo" do
+    should "return value" do
+      Object.to_mongo(21).should == 21
+      Object.to_mongo('21').should == '21'
+      Object.to_mongo(9223372036854775807).should == 9223372036854775807
+    end
+  end
+  
+  context "Object#from_mongo" do
+    should "return value" do
+      Object.from_mongo(21).should == 21
+      Object.from_mongo('21').should == '21'
+      Object.from_mongo(9223372036854775807).should == 9223372036854775807
+    end
+  end
+  
+  context "Set#to_mongo" do
+    should "convert value to_a" do
+      Set.to_mongo(Set.new([1,2,3])).should == [1,2,3]
+    end
+
+    should "convert to empty array if nil" do
+      Set.to_mongo(nil).should == []
+    end
+  end
+
+  context "Set#from_mongo" do
+    should "be a set if array" do
+      Set.from_mongo([1,2,3]).should == Set.new([1,2,3])
+    end
+
+    should "be empty set if nil" do
+      Set.from_mongo(nil).should == Set.new([])
+    end
+  end
+  
+  context "String#to_mongo" do
+    should "convert value to_s" do
+      [21, '21'].each do |value|
+        String.to_mongo(value).should == '21'
+      end
+    end
+    
+    should "be nil if nil" do
+      String.to_mongo(nil).should be_nil
+    end
+  end
+
+  context "String#from_mongo" do
+    should "be string if value present" do
+      String.from_mongo('Scotch! Scotch! Scotch!').should == 'Scotch! Scotch! Scotch!'
+    end
+    
+    should "return nil if nil" do
+      String.from_mongo(nil).should be_nil
+    end
+    
+    should "return empty string if blank" do
+      String.from_mongo('').should == ''
+    end
+  end
+  
+  context "Time#to_mongo without Time.zone" do
+    should "be time if string" do
+      Time.to_mongo('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123456).utc
+    end
+    
+    should "be time in utc if time" do
+      Time.to_mongo(Time.local(2009, 8, 15, 0, 0, 0)).zone.should == 'UTC'
+    end
+    
+    should "be nil if blank string" do
+      Time.to_mongo('').should be_nil
+    end
+    
+    should "not be nil if nil" do
+      Time.to_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Time#to_mongo with Time.zone" do
+    should "be time if time" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo(Time.zone.local(2009, 8, 15, 14, 0, 0)).should == Time.utc(2009, 8, 16, 0, 0, 0)
+      Time.zone = nil
+    end
+
+    should "be time if string" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo('2009-08-15 14:00:00').should == Time.utc(2009, 8, 16, 0, 0, 0)
+      Time.zone = nil
+    end
+    
+    should "be nil if blank string" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo('').should be_nil
+      Time.zone = nil
+    end
+    
+    should "be nil if nil" do
+      Time.zone = 'Hawaii'
+      Time.to_mongo(nil).should be_nil
+      Time.zone = nil
+    end
+  end
+  
+  context "Time#from_mongo without Time.zone" do
+    should "be time" do
+      time = Time.now
+      Time.from_mongo(time).should == time
+    end
+    
+    should "be nil if nil" do
+      Time.from_mongo(nil).should be_nil
+    end
+  end
+  
+  context "Time#from_mongo with Time.zone" do
+    should "be time in Time.zone" do
+      Time.zone = 'Hawaii'
+      
+      time = Time.from_mongo(Time.utc(2009, 10, 1))
+      time.should == Time.zone.local(2009, 9, 30, 14)
+      time.is_a?(ActiveSupport::TimeWithZone).should be_true
+      
+      Time.zone = nil
+    end
+    
+    should "be nil if nil" do
+      Time.zone = 'Hawaii'
+      Time.from_mongo(nil).should be_nil
+      Time.zone = nil
+    end
+  end
+  
+  context "Mongo::ObjectID.to_json" do
+    should "convert object id to string" do
+      id = Mongo::ObjectID.new
+      id.to_json.should == id.to_s
+    end
+  end
+  
+end