jamieorc-mongo_mapper 0.11.1.1

data/test/unit/test_inspect.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class InspectTest < Test::Unit::TestCase
+  context "#inspect" do
+    setup do
+      @document = Doc('User') do
+        key :name,  String
+        key :age,   Integer
+        key :email, String
+      end
+
+      @doc = @document.new(:name => 'John', :age => 29)
+    end
+
+    should "print out non-nil attributes in alpha sorted order" do
+      @doc.inspect.should =~ /_id:.*, age: 29, name: "John"/
+    end
+    
+    should "print out all attributes when (optional) include_super argument is true" do
+      @doc.inspect(true).should =~ /_id:.*, age: 29, email: nil, name: "John"/
+    end
+
+    should "include class name" do
+      @doc.inspect.should =~ /^#<User/
+    end
+    
+    should "include embedded documents" do
+      klass = Doc()
+      pets = EDoc()
+
+      klass.many :pets, :class => pets
+
+      doc = klass.new(:pets => [{:name => "Kitten"}])
+      doc.inspect.should =~ /_id:.*, pets: \[.*_id.*, name: "Kitten".*\]/
+    end
+    
+    should "include embedded document" do
+      klass = Doc()
+      pet = EDoc()
+
+      klass.one :pet, :class => pet
+
+      doc = klass.new(:pet => {:name => "Kitten"})
+      doc.inspect.should =~ /_id:.*, pet: .*_id.*, name: "Kitten".*/
+    end
+  end
+end

data/test/unit/test_key.rb

@@ -0,0 +1,205 @@
+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
+  Key = MongoMapper::Plugins::Keys::Key
+
+  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 an array with :typecast option of Date" do
+    setup   { @key = Key.new(:dates, Array, :typecast => 'Date') }
+    subject { @key }
+
+    should "cast each element correctly when get" do
+      dates = [Date.yesterday, Date.today, Date.tomorrow.to_s]
+      subject.get(dates).should == dates.map { |date| Date.from_mongo(date) }
+    end
+
+    should "cast each element correctly when set" do
+      dates = [Date.yesterday, Date.today, Date.tomorrow.to_s]
+      subject.set(dates).should == dates.map { |date| Date.to_mongo(date) }
+    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 a dup of the default value" do
+      @key.get(nil).replace('bar')
+      @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

data/test/unit/test_keys.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+require 'models'
+
+class KeyTest < Test::Unit::TestCase
+  context ".new with no id and _id of type integer" do
+    should "not error" do
+      lambda {
+        klass = Doc() do
+          key :_id, Integer
+        end
+        # No sensible default id for integer, people better pass them in if they user this
+        silence_stderr { klass.new.id.should be_nil }
+      }.should_not raise_error
+    end
+  end
+
+  context ".key?(:symbol)" do
+    should "be true if document has key" do
+      Address.key?(:city).should be_true
+    end
+
+    should "be false if document does not have key" do
+      Address.key?(:foo).should be_false
+    end
+  end
+
+  context ".key?('string')" do
+    should "be true if document has key" do
+      Address.key?('city').should be_true
+    end
+
+    should "be false if document does not have key" do
+      Address.key?('foo').should be_false
+    end
+  end
+
+  context ".new (from database)" do
+    setup do
+      @klass = Doc do
+        key :user, Hash
+
+        def user=(user)
+          super(:id => user.id, :name => user.name)
+        end
+      end
+
+      user_class = Struct.new(:id, :name)
+      @klass.create(:user => user_class.new(1, 'John Nunemaker'))
+    end
+
+    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 ".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

@@ -0,0 +1,143 @@
+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 without authentication using uri" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mongodb://127.0.0.1:27017/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 sinatra environment symbol" 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 options from config" do
+      MongoMapper.config = {
+        'development' => {'host' => '192.168.1.1', 'port' => 2222, 'database' => 'test', 'options' => {'safe' => true}}
+      }
+      connection, logger = mock('connection'), mock('logger')
+      Mongo::Connection.expects(:new).with('192.168.1.1', 2222, :logger => logger, :safe => true)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    should "work with options using uri" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mongodb://127.0.0.1:27017/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
+
+    should "work with authentication using uri" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mongodb://john:secret@127.0.0.1:27017/test'}
+      }
+      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'}
+      }
+      assert_raises(MongoMapper::InvalidScheme) { MongoMapper.connect('development') }
+    end
+
+    should "create a replica set connection if config contains multiple hosts" do
+      MongoMapper.config = {
+        'development' => {
+          'hosts' => [ ['127.0.0.1', 27017], ['localhost', 27017] ],
+          'database' => 'test'
+        }
+      }
+
+      Mongo::ReplSetConnection.expects(:new).with( ['127.0.0.1', 27017], ['localhost', 27017], {'read_secondary' => true} )
+      MongoMapper.expects(:database=).with('test')
+      Mongo::DB.any_instance.expects(:authenticate).never
+      MongoMapper.connect('development', 'read_secondary' => true)
+    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).once
+      MongoMapper.setup(config, 'development', :logger => logger)
+    end
+  end
+end