djsun-mongomapper 0.3.5.5 → 0.4.1.2

data/test/unit/test_finder_options.rb

@@ -1,183 +1,183 @@
-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 "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 "offset" do
-    should "default to 0" do
-      FinderOptions.to_mongo_options({})[:offset].should == 0
-    end
-    
-    should "use offset provided" do
-      FinderOptions.to_mongo_options(:offset => 2)[:offset].should == 2
-    end
-    
-    should "covert string to integer" do
-      FinderOptions.to_mongo_options(:offset => '2')[:offset].should == 2
-    end
-  end
-  
-  context "limit" do
-    should "default to 0" do
-      FinderOptions.to_mongo_options({})[:limit].should == 0
-    end
-    
-    should "use offset 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
+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('skip' => 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 "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
+  end
+  
+  context "limit" do
+    should "default to 0" do
+      FinderOptions.to_mongo_options({})[:limit].should == 0
+    end
+    
+    should "use skip 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

@@ -1,247 +1,175 @@
-require 'test_helper'
-
-class Address
-  include MongoMapper::EmbeddedDocument
-
-  key :address, String
-  key :city,    String
-  key :state,   String
-  key :zip,     Integer
-end
-
-class KeyTest < Test::Unit::TestCase
-  include MongoMapper
-
-  context "The Key Class" do
-    should "have the native types defined" do
-      Key::NativeTypes.should == [String, Float, Time, Integer, Boolean, Array, Hash]
-    end
-  end
-
-  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
-    
-    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
-      klass = Class.new do
-        include MongoMapper::EmbeddedDocument
-      end
-      Key.new(:name, klass).embedded_document?.should be_true
-    end
-
-    should "know if it is not a embedded_document" do
-      Key.new(:name, String).embedded_document?.should be_false
-    end
-  end
-
-  context "setting a value" do
-    should "correctly typecast Strings" do
-      key = Key.new(:foo, String)
-      [21, '21'].each do |a|
-        key.set(a).should == '21'
-      end
-    end
-
-    should "correctly typecast Integers" do
-      key = Key.new(:foo, Integer)
-      [21, 21.0, '21'].each do |a|
-        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)
-      [21, 21.0, '21'].each do |a|
-        key.set(a).should == 21.0
-      end
-    end
-
-    should "correctly typecast Times" do
-      key = Key.new(:foo, Time)
-      key.set('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
-    end
-
-    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
-      key = Key.new(:foo, Boolean)
-      ['false', false, 'f', '0', 0].each do |b|
-        key.set(b).should == false
-      end
-
-      ['true', true, 't', '1', 1].each do |b|
-        key.set(b).should == true
-      end
-    end
-
-    should "correctly typecast Array" do
-      key = Key.new(:foo, Array)
-      key.set([1,2,3,4]).should == [1,2,3,4]
-      key.set({'1' => '2', '3' => '4'}).should == [['1', '2'], ['3', '4']]
-      key.set('1').should == ['1']
-    end
-
-    should "correctly typecast Hash using indifferent access" do
-      key = Key.new(:foo, Hash)
-      key.set(:foo => 'bar')[:foo].should == 'bar'
-      key.set(:foo => 'bar')['foo'].should == 'bar'
-      key.set(:foo => {:bar => 'baz'})[:foo][:bar].should == 'baz'
-      key.set(:foo => {:bar => 'baz'})['foo']['bar'].should == 'baz'
-    end
-  end
-
-  context "getting a value" do
-    should "work" 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 key with a default value 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
-    end
-
-    context "for a boolean key" do
-      should "allow setting default to false" do
-        Key.new(:active, Boolean, :default => false).get(nil).should be_false
-      end
-
-      should "allow setting default to true" do
-        Key.new(:active, Boolean, :default => true).get(nil).should be_true
-      end
-    end
-
-    context "for an array" do
-      should "return array" do
-        key = Key.new(:foo, Array)
-        key.get([1,2]).should == [1,2]
-      end
-
-      should "default to empty array" do
-        key = Key.new(:foo, Array)
-        key.get(nil).should == []
-      end
-    end
-
-    context "for a hash" do
-      should "default to empty hash" do
-        key = Key.new(:foo, Hash)
-        key.get(nil).should == {}
-      end
-
-      should "use hash with indifferent access" do
-        key = Key.new(:foo, Hash)
-        key.get({:foo => 'bar'})['foo'].should == 'bar'
-        key.get({:foo => 'bar'})[:foo].should == 'bar'
-      end
-    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
-end # KeyTest
+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