djsun-mongo_mapper 0.5.0.1

data/test/unit/test_finder_options.rb

@@ -0,0 +1,193 @@
+require 'test_helper'
+
+class FinderOptionsTest < Test::Unit::TestCase
+  include MongoMapper
+  
+  should "raise error if provided something other than a hash" do
+    lambda { FinderOptions.new }.should raise_error(ArgumentError)
+    lambda { FinderOptions.new(1) }.should raise_error(ArgumentError)
+  end
+  
+  should "have symbolize the keys of the hash provided" do
+    FinderOptions.new('offset' => 1).options.keys.map do |key|
+      key.should be_instance_of(Symbol)
+    end
+  end
+  
+  context "#criteria" do
+    should "convert conditions to criteria" do
+      FinderOptions.expects(:to_mongo_criteria).with(:foo => 1).returns({})
+      FinderOptions.new(:conditions => {:foo => 1}).criteria
+    end
+  end
+  
+  context "#options" do
+    should "convert options to mongo options" do
+      FinderOptions.expects(:to_mongo_options).with(:order => 'foo asc', :select => 'foo,bar').returns({})
+      FinderOptions.new(:order => 'foo asc', :select => 'foo,bar').options
+    end
+  end
+  
+  context "Converting conditions to criteria" do
+    should "work with simple criteria" do
+      FinderOptions.to_mongo_criteria(:foo => 'bar').should == {
+        :foo => 'bar'
+      }
+      
+      FinderOptions.to_mongo_criteria(:foo => 'bar', :baz => 'wick').should == {
+        :foo => 'bar', 
+        :baz => 'wick'
+      }
+    end
+    
+    should "convert id to _id" do
+      FinderOptions.to_mongo_criteria(:id => '1').should == {
+        :_id => '1'
+      }
+    end
+    
+    should "use $in for arrays" do
+      FinderOptions.to_mongo_criteria(:foo => [1,2,3]).should == {
+        :foo => {'$in' => [1,2,3]}
+      }
+    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
+  
+  context "ordering" do
+    should "single field with ascending direction" do
+      hash = OrderedHash.new
+      hash[:foo] = 1
+      FinderOptions.to_mongo_options(:order => 'foo asc')[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo ASC')[:sort].should == hash
+    end
+    
+    should "single field with descending direction" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      FinderOptions.to_mongo_options(:order => 'foo desc')[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo DESC')[:sort].should == hash
+    end
+    
+    should "convert field without direction to ascending" do
+      hash = OrderedHash.new
+      hash[:foo] = 1
+      FinderOptions.to_mongo_options(:order => 'foo')[:sort].should == hash
+    end
+    
+    should "convert multiple fields with directions" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      hash[:bar] = 1
+      hash[:baz] = -1
+      FinderOptions.to_mongo_options(:order => 'foo desc, bar asc, baz desc')[:sort].should == hash
+    end
+    
+    should "convert multiple fields with some missing directions" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      hash[:bar] = 1
+      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 "skip" do
+    should "default to 0" do
+      FinderOptions.to_mongo_options({})[:skip].should == 0
+    end
+    
+    should "use skip provided" do
+      FinderOptions.to_mongo_options(:skip => 2)[:skip].should == 2
+    end
+    
+    should "covert string to integer" do
+      FinderOptions.to_mongo_options(:skip => '2')[:skip].should == 2
+    end
+    
+    should "convert offset to skip" do
+      FinderOptions.to_mongo_options(:offset => 1)[:skip].should == 1
+    end
+  end
+  
+  context "limit" do
+    should "default to 0" do
+      FinderOptions.to_mongo_options({})[:limit].should == 0
+    end
+    
+    should "use limit provided" do
+      FinderOptions.to_mongo_options(:limit => 2)[:limit].should == 2
+    end
+    
+    should "covert string to integer" do
+      FinderOptions.to_mongo_options(:limit => '2')[:limit].should == 2
+    end
+  end
+  
+  context "fields" do
+    should "default to nil" do
+      FinderOptions.to_mongo_options({})[:fields].should be(nil)
+    end
+    
+    should "be converted to nil if empty string" do
+      FinderOptions.to_mongo_options(:fields => '')[:fields].should be(nil)
+    end
+    
+    should "be converted to nil if []" do
+      FinderOptions.to_mongo_options(:fields => [])[:fields].should be(nil)
+    end
+    
+    should "should work with array" do
+      FinderOptions.to_mongo_options({:fields => %w(a b)})[:fields].should == %w(a b)
+    end
+    
+    should "convert comma separated list to array" do
+      FinderOptions.to_mongo_options({:fields => 'a, b'})[:fields].should == %w(a b)
+    end
+    
+    should "also work as select" do
+      FinderOptions.new(:select => %w(a b)).options[:fields].should == %w(a b)
+    end
+  end
+end # FinderOptionsTest

data/test/unit/test_key.rb

@@ -0,0 +1,175 @@
+require 'test_helper'
+
+class Address
+  include MongoMapper::EmbeddedDocument
+
+  key :address, String
+  key :city,    String
+  key :state,   String
+  key :zip,     Integer
+end
+
+class FooType < Struct.new(:bar)
+  def self.to_mongo(value)
+    'to_mongo'
+  end
+
+  def self.from_mongo(value)
+    'from_mongo'
+  end
+end
+
+class KeyTest < Test::Unit::TestCase
+  include MongoMapper
+
+  context "Initializing a new key" do
+    should "allow setting the name" do
+      Key.new(:foo, String).name.should == 'foo'
+    end
+
+    should "allow setting the type" do
+      Key.new(:foo, Integer).type.should be(Integer)
+    end
+
+    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)
+    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
+    should "be equal to another key with same name and type" do
+      Key.new(:name, String).should == Key.new(:name, String)
+    end
+
+    should "not be equal to another key with different name" do
+      Key.new(:name, String).should_not == Key.new(:foo, String)
+    end
+
+    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 a embedded_document" do
+      klass = Class.new do
+        include MongoMapper::EmbeddedDocument
+      end
+      Key.new(:name, klass).embeddable?.should be_true
+    end
+
+    should "know if it is not a embedded_document" do
+      Key.new(:name, String).embeddable?.should be_false
+    end
+  end
+
+  context "setting a value with a custom type" do
+    should "correctly typecast" do
+      key = Key.new(:foo, FooType)
+      key.set("something").should == 'to_mongo'
+    end
+
+    should "correctly typecast if object of that type is given" do
+      key = Key.new(:foo, FooType)
+      key.set(FooType.new('something')).should == 'to_mongo'
+    end
+  end
+  
+  context "getting a value with a custom type" do
+    should "use #from_mongo to convert back to custom type" do
+      key = Key.new(:foo, FooType)
+      key.get('something').should == 'from_mongo'
+    end
+  end
+
+  context "getting a value" do
+    should "work with a type" do
+      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 embedded_document" do
+      should "default to nil" do
+        key = Key.new(:foo, Address)
+        key.get(nil).should be_nil
+      end
+
+      should "return instance if instance" do
+        address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
+        key = Key.new(:foo, Address)
+        key.get(address).should == address
+      end
+    end
+  end
+  
+  context "string key with 'baz' default" do
+    setup do
+      @key = Key.new(:foo, String, :default => 'baz')
+    end
+
+    should "return default value if value nil" do
+      @key.get(nil).should == 'baz'
+    end
+
+    should "return value if not nil" do
+      @key.get('foobar').should == 'foobar'
+    end
+  end
+  
+  context "string key with '' default" do
+    setup do
+      @key = Key.new(:foo, String, :default => '')
+    end
+
+    should "return default value if value nil" do
+      @key.get(nil).should == ''
+    end
+  end
+  
+  context "boolean key" do
+    should "with false default" do
+      Key.new(:active, Boolean, :default => false).get(nil).should be_false
+    end
+
+    should "with true default" do
+      Key.new(:active, Boolean, :default => true).get(nil).should be_true
+    end
+  end
+end # KeyTest

data/test/unit/test_mongomapper.rb

@@ -0,0 +1,28 @@
+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 = DefaultDatabase
+    MongoMapper.database.should be_instance_of(Mongo::DB)
+    MongoMapper.database.name.should == DefaultDatabase
+  end
+  
+  should "have document not found error" do
+    lambda {
+      MongoMapper::DocumentNotFound
+    }.should_not raise_error
+  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,109 @@
+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
+        
+    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,39 @@
+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
+    
+    should "alias new to new_record?" do
+      instance = Item.new
+      instance.new_record?.should == instance.new?
+    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