mongo_mapper-rails3 0.7.0.1

data/test/unit/test_keys.rb

@@ -0,0 +1,169 @@
+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::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 "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
+  end
+end # KeyTest

data/test/unit/test_lint.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class TestLint < Test::Unit::TestCase
+  def model
+    Doc().new.to_model
+  end
+  include ActiveModel::Lint::Tests
+end

data/test/unit/test_mongo_mapper.rb

@@ -0,0 +1,125 @@
+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
+
+  should "be able to read/write config" do
+    config = {
+      'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'},
+      'production'  => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test-prod'}
+    }
+
+    MongoMapper.config = config
+    MongoMapper.config.should == config
+  end
+
+  context "connecting to environment from config" do
+    should "work without authentication" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+
+      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
+      MongoMapper.expects(:database=).with('test')
+      Mongo::DB.any_instance.expects(:authenticate).never
+      MongoMapper.connect('development')
+    end
+
+    should "work with options" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+
+      connection, logger = mock('connection'), mock('logger')
+      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, :logger => logger)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    should "work with authentication" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'username' => 'john', 'password' => 'secret'}
+      }
+
+      Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
+      MongoMapper.connect('development')
+    end
+  end
+
+  context "setup" do
+    should "work as shortcut for setting config, environment and options" do
+      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.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

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+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