mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/test/unit/{test_support.rb → test_extensions.rb}

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class SupportTest < Test::Unit::TestCase
-  context "Array#to_mongo" do
+  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']
@@ -9,74 +9,78 @@ class SupportTest < Test::Unit::TestCase
     end
   end
 
-  context "Array#from_mongo" do
+  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
+
+  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
+      Binary.to_mongo('asdfsadasdfs').is_a?(BSON::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
+      Binary.to_mongo(BSON::ByteBuffer.new('asdfsadasdfs')).is_a?(BSON::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
+
+  context "Binary.from_mongo" do
     should "return value" do
-      buffer = ByteBuffer.new('asdfasdfasdf')
+      buffer = BSON::ByteBuffer.new('asdfasdfasdf')
       Binary.from_mongo(buffer).to_s.should == buffer.to_s
     end
   end
-  
-  context "Boolean#to_mongo" do
+
+  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
+
+    should "be nil for nil" do
+      Boolean.to_mongo(nil).should be_nil
+    end
   end
-  
-  context "Boolean#from_mongo" do
+
+  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
+
+    should "be nil for nil" do
+      Boolean.from_mongo(nil).should be_nil
     end
   end
-  
-  context "Date#to_mongo" do
+
+  context "Date.to_mongo" do
     should "be time if string" do
       date = Date.to_mongo('2009-10-01')
       date.should == Time.utc(2009, 10, 1)
@@ -85,25 +89,25 @@ class SupportTest < Test::Unit::TestCase
       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 date if time" do
       Date.to_mongo(Time.parse("2009-10-1T12:30:00")).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
+
+  context "Date.from_mongo" do
     should "be date if date" do
       date = Date.new(2009, 10, 1)
       from_date = Date.from_mongo(date)
@@ -112,116 +116,117 @@ class SupportTest < Test::Unit::TestCase
       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
+
+  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
+
+    should "leave nil values nil" do
+      Float.to_mongo(nil).should == nil
+    end
   end
-  
-  context "Hash#from_mongo" do
+
+  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
+
+  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
+
+  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 "NilClass#from_mongo" do
+    should "return nil" do
+      nil.from_mongo(nil).should be_nil
+    end
+  end
+
+  context "NilClass#to_mongo" do
+    should "return nil" do
+      nil.to_mongo(nil).should be_nil
+    end
+  end
+
   context "ObjectId#to_mongo" do
+    should "call class to_mongo with self" do
+      object = Object.new
+      object.class.expects(:to_mongo).with(object)
+      object.to_mongo
+    end
+  end
+
+  context "ObjectId.to_mongo" do
     should "return nil for nil" do
       ObjectId.to_mongo(nil).should be_nil
     end
-    
+
     should "return nil if blank string" do
       ObjectId.to_mongo('').should be_nil
     end
-    
+
     should "return value if object id" do
-      id = Mongo::ObjectID.new
+      id = BSON::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
+
+  context "ObjectId.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
+
+      id = BSON::ObjectID.new
+      ObjectId.from_mongo(id).should == id
     end
   end
-  
-  context "Set#to_mongo" do
+
+  context "Set.to_mongo" do
     should "convert value to_a" do
       Set.to_mongo(Set.new([1,2,3])).should == [1,2,3]
     end
@@ -231,7 +236,7 @@ class SupportTest < Test::Unit::TestCase
     end
   end
 
-  context "Set#from_mongo" do
+  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
@@ -240,127 +245,136 @@ class SupportTest < Test::Unit::TestCase
       Set.from_mongo(nil).should == Set.new([])
     end
   end
-  
-  context "String#to_mongo" do
+
+  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
+  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 "Symbol" do
-    %w(gt lt gte lte ne in nin mod all size where exists asc desc).each do |operator|
-      should "have $#{operator} operator" do
-        :foo.respond_to?(operator)
-      end
-    end
-  end
-  
-  context "Time#to_mongo without Time.zone" do
+
+  context "Time.to_mongo without Time.zone" do
     setup do
       Time.zone = nil
     end
 
     should "be time to milliseconds if string" do
-      Time.to_mongo('2000-01-01 01:01:01.123456').to_f.should == Time.local(2000, 1, 1, 1, 1, 1, 123000).utc.to_f
+      Time.to_mongo('2000-01-01 01:01:01.123456').to_f.should == Time.local(2000, 1, 1, 1, 1, 1, 0).utc.to_f
     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
+
+  context "Time.to_mongo with Time.zone" do
     should "be time to milliseconds if time" do
       Time.zone = 'Hawaii'
-      Time.to_mongo(Time.zone.local(2009, 8, 15, 14, 0, 0, 123456)).to_f.should == Time.utc(2009, 8, 16, 0, 0, 0, 123000).to_f
+      Time.to_mongo(Time.zone.local(2009, 8, 15, 14, 0, 0, 123456)).to_f.should == Time.utc(2009, 8, 16, 0, 0, 0, 0).to_f
       Time.zone = nil
     end
 
     should "be time to milliseconds if string" do
       Time.zone = 'Hawaii'
-      Time.to_mongo('2009-08-15 14:00:00.123456').to_f.should == Time.utc(2009, 8, 16, 0, 0, 0, 123000).to_f
+      Time.to_mongo('2009-08-15 14:00:00.123456').to_f.should == Time.utc(2009, 8, 16, 0, 0, 0, 0).to_f
       Time.zone = nil
     end
-    
+
+    should "not round up times at the end of the month" do
+      Time.to_mongo(Time.now.end_of_month).to_i.should == Time.now.end_of_month.utc.to_i
+    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
+
+  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
+
+  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 == %Q("#{id}")
+
+  context "BSON::ObjectID" do
+    context "#as_json" do
+      should "convert object id to string" do
+        id = BSON::ObjectID.new
+        id.as_json.should == id.to_s
+      end
     end
-    
-    should "support ruby driver syntax also" do
-      id = Mongo::ObjectID.new
-      id.original_to_json.should == %Q({"$oid": "#{id}"})
+
+    context "#to_json" do
+      should "convert object id to string" do
+        id = BSON::ObjectID.new
+        id.to_json.should == %Q("#{id}")
+      end
+
+      should "support ruby driver syntax also" do
+        id = BSON::ObjectID.new
+        id.original_to_json.should == %Q({"$oid": "#{id}"})
+      end
     end
   end
+
+  context "BSON::ObjectID.to_json" do
+
+  end
 end

data/test/unit/test_key.rb

@@ -0,0 +1,185 @@
+require 'test_helper'
+require 'models'
+
+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::Plugins::Keys
+
+  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
+      Key.new(:name, EDoc()).embeddable?.should be_true
+    end
+
+    should "know if it is not a embedded_document" do
+      Key.new(:name, String).embeddable?.should be_false
+    end
+
+    should "know if it is a number" do
+      Key.new(:age, Integer).number?.should be_true
+      Key.new(:age, Float).number?.should be_true
+    end
+
+    should "know if it is not a number" do
+      Key.new(:age, String).number?.should be_false
+    end
+  end
+
+  context "for an array with :typecast option" do
+    setup   { @key = Key.new(:user_ids, Array, :typecast => 'ObjectId') }
+    subject { @key }
+
+    should "cast each element correctly" do
+      ids = [BSON::ObjectID.new, BSON::ObjectID.new, BSON::ObjectID.new.to_s, BSON::ObjectID.new.to_s]
+      subject.set(ids).should == ids.map { |id| ObjectId.to_mongo(id) }
+    end
+  end
+
+  context "for a set with :typecast option" do
+    setup   { @key = Key.new(:user_ids, Set, :typecast => 'ObjectId') }
+    subject { @key }
+
+    should "cast each element correctly" do
+      ids = [BSON::ObjectID.new, BSON::ObjectID.new, BSON::ObjectID.new.to_s, BSON::ObjectID.new.to_s]
+      subject.set(ids).should == ids.map { |id| ObjectId.to_mongo(id) }
+    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 "getting a value with a default set" 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 blank" do
+      @key.get('foobar').should == 'foobar'
+    end
+
+    should "work with Boolean type and false value" do
+      Key.new(:active, Boolean, :default => false).get(nil).should be_false
+    end
+
+    should "work with Boolean type and true value" do
+      Key.new(:active, Boolean, :default => true).get(nil).should be_true
+    end
+
+    should "work with procs" do
+       Key.new(:foo, String, :default => lambda { return 'hello world' }).get(nil).should == "hello world"
+    end
+  end
+end # KeyTest