mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/test/unit/test_keys.rb

@@ -1,173 +1,55 @@
 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
+require 'models'
 
 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)
+  context ".key?(:symbol)" do
+    should "be true if document has key" do
+      Address.key?(:city).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
+    should "be false if document does not have key" do
+      Address.key?(:foo).should be_false
     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)
+  context ".key?('string')" do
+    should "be true if document has key" do
+      Address.key?('city').should be_true
     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
+    should "be false if document does not have key" do
+      Address.key?('foo').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 ".new (from database)" do
+    setup do
+      @klass = Doc do
+        key :user, Hash
 
-  context "getting a value" do
-    should "work with a type" do
-      key = Key.new(:foo, String)
-      key.get('bar').should == 'bar'
-    end
+        def user=(user)
+          super(:id => user.id, :name => user.name)
+        end
+      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 == {}
+      user_class = Struct.new(:id, :name)
+      @klass.create(:user => user_class.new(1, 'John Nunemaker'))
     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
+    should "use []= for keys instead of public writer" do
+      assert_nothing_raised do
+        doc = @klass.first
+        doc.user['id'].should   == 1
+        doc.user['name'].should == 'John Nunemaker'
       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"
+  context ".load" do
+    should "return nil if argument is nil" do
+      Doc().load(nil).should be_nil
     end
   end
 end # KeyTest

data/test/unit/test_mongo_mapper.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class Address; end
 
-class MongoMapperTest < Test::Unit::TestCase  
+class MongoMapperTest < Test::Unit::TestCase
   should "be able to write and read connection" do
     conn = Mongo::Connection.new
     MongoMapper.connection = conn
@@ -89,7 +89,7 @@ class MongoMapperTest < Test::Unit::TestCase
       Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
       MongoMapper.connect('development')
     end
-    
+
     should "raise error for invalid scheme" do
       MongoMapper.config = {
         'development' => {'uri' => 'mysql://127.0.0.1:5336/foo'}
@@ -103,53 +103,8 @@ class MongoMapperTest < Test::Unit::TestCase
       config, logger = mock('config'), mock('logger')
       MongoMapper.expects(:config=).with(config)
       MongoMapper.expects(:connect).with('development', :logger => logger)
-      MongoMapper.expects(:handle_passenger_forking).never
+      MongoMapper.expects(:handle_passenger_forking).once
       MongoMapper.setup(config, 'development', :logger => logger)
     end
-    
-    should "handle passenger if option present" do
-      config, logger = mock('config'), mock('logger')
-      MongoMapper.expects(:config=).with(config)
-      MongoMapper.expects(:connect).with('development', :logger => logger)
-      MongoMapper.expects(:handle_passenger_forking)
-      MongoMapper.setup(config, 'development', :logger => logger, :passenger => true)
-    end
-  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_pagination.rb

@@ -4,157 +4,8 @@ class PaginationTest < Test::Unit::TestCase
   should "default per_page to 25" do
     Doc().per_page.should == 25
   end
-  
+
   should "allow overriding per_page" do
     Doc() { def self.per_page; 1 end }.per_page.should == 1
   end
-  
-  context "Pagination proxy" do
-    include MongoMapper::Plugins::Pagination
-    
-    should "respond_to? correctly on proxy readers" do
-      proxy = Proxy.new(25, 10, 4)
-      proxy.respond_to?(:subject).should be_true
-      proxy.respond_to?(:total_entries).should be_true
-      proxy.respond_to?(:per_page).should be_true
-      proxy.respond_to?(:current_page).should be_true
-      proxy.respond_to?(:limit).should be_true
-      proxy.respond_to?(:total_pages).should be_true
-      proxy.respond_to?(:out_of_bounds?).should be_true
-      proxy.respond_to?(:previous_page).should be_true
-      proxy.respond_to?(:next_page).should be_true
-      proxy.respond_to?(:skip).should be_true
-      proxy.respond_to?(:offset).should be_true
-      
-      # make sure it doesnt respond true to everything
-      proxy.respond_to?(:blahblahblah).should be_false
-    end
-    
-    should "respond_to? correctly on proxy writers" do
-      proxy = Proxy.new(25, 10, 4)
-      proxy.respond_to?(:subject=).should be_true
-    end
-    
-    should "should have accessors for subject" do
-      subject = [1,2,3,4,5]
-      collection = Proxy.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 = Proxy.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 "should respond_to? correctly for methods defined on the subject" do
-      subject = [1,2,3,4,5]
-      def subject.blahblah
-        "BLAHBLAH"
-      end
-      collection = Proxy.new(25, 2, 10)
-      collection.subject = subject
-      collection.respond_to?(:blahblah).should be_true
-    end
-    
-    should "return correct value for total_entries" do
-      Proxy.new(25, 2, 10).total_entries.should == 25
-      Proxy.new('25', 2, 10).total_entries.should == 25
-    end
-    
-    should "return correct value for per_page" do
-      Proxy.new(25, 2, 10).per_page.should == 10
-      Proxy.new(25, 2, '10').per_page.should == 10
-    end
-    
-    should "alias limit to per_page" do
-      Proxy.new(100, 1, 300).limit.should == 300
-    end
-    
-    should "set per_page to 25 if nil or blank" do
-      Proxy.new(25, 2).per_page.should == 25
-      Proxy.new(25, 2, '').per_page.should == 25
-    end
-    
-    should "return correct value for current_page" do
-      Proxy.new(25, 2, 10).current_page.should == 2
-      Proxy.new(25, '2', 10).current_page.should == 2
-    end
-    
-    should "not allow value less than 1 for current page" do
-      Proxy.new(25, -1).current_page.should == 1
-    end
-    
-    should "automatically calculate total_pages from total_entries and per page" do
-      Proxy.new(25, 2, 10).total_pages.should == 3
-    end
-    
-    should "know how many records to skip" do
-      Proxy.new(25, 2, 10).skip.should == 10
-    end
-    
-    should "alias offset to skip" do
-      Proxy.new(25, 2, 10).offset.should == 10
-    end
-    
-    should "return true for === Array" do
-      collection = Proxy.new(25, 2, 10)
-      collection.subject = [1, 2]
-      collection.should === Array
-    end
-        
-    context "previous_page" do
-      should "be nil if current page 1" do
-        Proxy.new(25, 1, 10).previous_page.should be_nil
-      end
-      
-      should "be one less than current page if current is > 1" do
-        Proxy.new(25, 2, 10).previous_page.should == 1
-      end
-    end
-    
-    context "next_page" do
-      should "be nil if current page is last page" do
-        Proxy.new(25, 3, 10).next_page.should be_nil
-      end
-      
-      should "work for any page that is not last" do
-        Proxy.new(25, 1, 10).next_page.should == 2
-        Proxy.new(25, 2, 10).next_page.should == 3
-      end
-    end
-    
-    context "previous_page" do
-      should "be nil if current page is first page" do
-        Proxy.new(25, 1, 10).previous_page.should be_nil
-      end
-      
-      should "work for any page other than first" do
-        Proxy.new(25, 2, 10).previous_page.should == 1
-        Proxy.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
-        Proxy.new(25, 10, 4).out_of_bounds?.should be_true
-      end
-      
-      should "be false if current_page is less than total_pages" do
-        Proxy.new(25, 10, 1).out_of_bounds?.should be_false
-        Proxy.new(25, 2, 10).out_of_bounds?.should be_false
-      end
-      
-      should "be false if current_page is equal to total_pages" do
-        Proxy.new(25, 3, 10).out_of_bounds?.should be_false
-      end
-    end
-  end
 end

data/test/unit/test_rails.rb

@@ -7,7 +7,7 @@ class TestRails < Test::Unit::TestCase
         key :foo, String
       end
     end
-    
+
     context "Class methods" do
       should "alias has_many to many" do
         @klass.should respond_to(:has_many)
@@ -16,7 +16,7 @@ class TestRails < Test::Unit::TestCase
       should "alias has_one to one" do
         @klass.should respond_to(:has_one)
       end
-      
+
       should "have column names" do
         @klass.column_names.sort.should == ['_id', 'foo']
       end
@@ -25,48 +25,76 @@ class TestRails < Test::Unit::TestCase
         @klass.human_name.should == 'Post'
       end
     end
-    
+
     context "Instance methods" do
       setup do
         @klass.class_eval do
           def bar=(value)
             write_attribute(:foo, value)
           end
-          
+
           def bar_before_typecast
             read_attribute_before_typecast(:foo)
           end
-          
+
           def bar
             read_attribute(:foo)
           end
         end
       end
-      
+
       should "alias new_record? to new?" do
         @klass.new.should be_new_record
       end
-      
+
       should "be able to read key with read_attribute" do
         @klass.new(:foo => 'Bar').bar.should == 'Bar'
       end
-      
+
       should "be able to read key before typecast with read_attribute_before_typecast" do
         @klass.new(:foo => 21).bar_before_typecast.should == 21
         @klass.new(:foo => 21).bar.should == '21'
       end
-      
+
       should "be able to write key with write_attribute" do
         @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
       end
+
+      context '#to_param' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_param.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.create.tap do |doc|
+            doc.to_param.should == doc.id.to_s
+          end
+        end
+      end
+
+      context '#to_key' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_key.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.create.tap do |doc|
+            doc.to_key.should == [doc.id]
+          end
+        end
+      end
     end
   end
-  
+
   context "EmbeddedDocument" do
     setup do
       @klass = EDoc('Post') { key :foo, String }
     end
-    
+
     context "Class methods" do
       should "alias has_many to many" do
         @klass.should respond_to(:has_many)
@@ -75,7 +103,7 @@ class TestRails < Test::Unit::TestCase
       should "alias has_one to one" do
         @klass.should respond_to(:has_one)
       end
-      
+
       should "have column names" do
         @klass.column_names.sort.should == ['_id', 'foo']
       end
@@ -84,40 +112,70 @@ class TestRails < Test::Unit::TestCase
         @klass.human_name.should == 'Post'
       end
     end
-    
+
     context "Instance methods" do
       setup do
         @klass.class_eval do
           def bar=(value)
             write_attribute(:foo, value)
           end
-          
+
           def bar_before_typecast
             read_attribute_before_typecast(:foo)
           end
-          
+
           def bar
             read_attribute(:foo)
           end
         end
       end
-      
+
       should "alias new_record? to new?" do
         @klass.new.should be_new_record
       end
-      
+
       should "be able to read key with read_attribute" do
         @klass.new(:foo => 'Bar').bar.should == 'Bar'
       end
-      
+
       should "be able to read key before typecast with read_attribute_before_typecast" do
         @klass.new(:foo => 21).bar_before_typecast.should == 21
         @klass.new(:foo => 21).bar.should == '21'
       end
-      
+
       should "be able to write key with write_attribute" do
         @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
       end
+
+      context '#to_param' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_param.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.new.tap do |doc|
+            doc.expects(:persisted?).returns(true)
+            doc.to_param.should == doc.id.to_s
+          end
+        end
+      end
+
+      context '#to_key' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_key.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.new.tap do |doc|
+            doc.expects(:persisted?).returns(true)
+            doc.to_key.should == [doc.id]
+          end
+        end
+      end
     end
   end
 end

data/test/unit/test_rails_compatibility.rb

@@ -4,13 +4,13 @@ class TestRailsCompatibility < Test::Unit::TestCase
   class BigStuff
     include MongoMapper::Document
   end
-  
+
   class Item
     include MongoMapper::EmbeddedDocument
     key :for_all, String
   end
 
-  class FirstItem < Item  
+  class FirstItem < Item
     key :first_only, String
     many :second_items
   end
@@ -18,32 +18,32 @@ class TestRailsCompatibility < Test::Unit::TestCase
   class SecondItem < Item
     key :second_only, String
   end
-  
-  context "EmbeddedDocument" do    
+
+  context "EmbeddedDocument" do
     should "alias many to has_many" do
       FirstItem.should respond_to(:has_many)
     end
-    
+
     should "alias one to has_one" do
       FirstItem.should respond_to(:has_one)
     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']
+      Item.column_names.sort.should == ['_id', '_type', 'for_all']
+      FirstItem.column_names.sort.should == ['_id', '_type', 'first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['_id', '_type', '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'