mongo_mapper 0.12.0 → 0.13.0.beta1

data/spec/unit/keys_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+
+describe "Key" do
+  context ".new with no id and _id of type integer" do
+    it "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
+    it "should be true if document has key" do
+      Address.key?(:city).should be_true
+    end
+
+    it "should be false if document does not have key" do
+      Address.key?(:foo).should be_false
+    end
+  end
+
+  context "#assign" do
+    it "should raise a deprecation warning" do
+      klass = Doc() do
+        key :_id, Integer
+      end
+      doc = klass.new
+      doc.should_receive(:warn).once
+      doc.assign({:x => :y})
+    end
+  end
+
+  # TODO: Are these methods deprecated?
+  context "#embedded and #non_embedded_keys" do
+    EmbeddableThingie = EDoc {
+      key :whiz, String
+    }
+
+    let(:klass) do
+      Doc do
+        key :foo, String
+        key :embeddable_thingie, EmbeddableThingie
+      end
+    end
+
+    it "should get non-embeddable keys" do
+      klass.new.non_embedded_keys.map(&:name).should =~ %w(_id foo)
+    end
+
+    it "should get embeddable keys" do
+      klass.new.embedded_keys.map(&:name).should == %w(embeddable_thingie)
+    end
+  end
+
+  context ".key?('string')" do
+    it "should be true if document has key" do
+      Address.key?('city').should be_true
+    end
+
+    it "should be false if document does not have key" do
+      Address.key?('foo').should be_false
+    end
+  end
+
+  context ".new (from database)" do
+    before 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
+
+    it "should use []= for keys instead of public writer" do
+      expect {
+        doc = @klass.first
+        doc.user['id'].should   == 1
+        doc.user['name'].should == 'John Nunemaker'
+      }.to_not raise_error
+    end
+  end
+
+  context ".load" do
+    it "should return nil if argument is nil" do
+      Doc().load(nil).should be_nil
+    end
+  end
+
+  context "default values" do
+    before do
+      @klass = Doc do
+        key :value, Integer, :default => 1
+      end
+    end
+
+    it "should initialize default value" do
+      @klass.new.value.should == 1
+    end
+
+    it "should allow overriding default value" do
+      @klass.new(:value => 2).value.should == 2
+    end
+
+    it "should allow re-setting a value that is defaulted" do
+      instance = @klass.new
+      instance.value = 2
+      instance.value.should == 2
+      instance.value = nil
+      instance.value.should == nil
+    end
+
+    context "for _id" do
+      before do
+        @klass.class_eval do
+          key :_id, Integer, :default => lambda { 12345 }
+        end
+      end
+
+      it "should work" do
+        @klass.new._id.should == 12345
+      end
+    end
+  end
+
+  context "when loading from the database" do
+    it "should not set default values for keys that already exist" do
+      counter = 0
+      instance = nil
+
+      klass = Doc do
+        key :value, Integer, :default => lambda { counter += 1 }
+      end
+
+      expect { instance = klass.create }.to change { counter }.by(1)
+      expect {
+        instance.reload.value.should == 1
+
+        instance.value = 10
+        instance.save
+
+        instance.reload.value.should == 10
+      }.to_not change { counter }
+    end
+  end
+end # KeyTest

data/spec/unit/model_generator_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'rails/generators'
+require 'rails/generators/test_case'
+require 'rails/generators/mongo_mapper/model/model_generator'
+
+describe MongoMapper::Generators::ModelGenerator do
+  include GeneratorSpec::TestCase
+  destination File.expand_path('../../tmp', File.dirname(__FILE__))
+
+  before do
+    prepare_destination
+  end
+
+  it 'help shows MongoMapper options' do
+    pending "Rails 4 breaks Kernel#capture on JRuby", :if => (Rails::VERSION::MAJOR >= 4 && RUBY_PLATFORM == "java") do
+      content = run_generator ['--help']
+      assert_match(/rails generate mongo_mapper:model/, content)
+    end
+  end
+
+  it 'model are properly created' do
+    run_generator ['Color']
+    assert_file 'app/models/color.rb', /class Color/
+    assert_file 'app/models/color.rb', /include MongoMapper::Document/
+  end
+
+  it 'model are properly created with attributes' do
+    run_generator ['Color', 'name:string', 'saturation:integer']
+    assert_file 'app/models/color.rb', /class Color/
+    assert_file 'app/models/color.rb', /include MongoMapper::Document/
+    assert_file 'app/models/color.rb', /key :name, String/
+    assert_file 'app/models/color.rb', /key :saturation, Integer/
+  end
+
+  it 'model are properly created with timestamps option' do
+    run_generator ['Color', '--timestamps']
+    assert_file 'app/models/color.rb', /class Color/
+    assert_file 'app/models/color.rb', /include MongoMapper::Document/
+    assert_file 'app/models/color.rb', /timestamps/
+  end
+
+  it 'model are properly created with parent option' do
+    run_generator ['Green', '--parent', 'Color']
+    assert_file 'app/models/green.rb', /class Green < Color/
+  end
+
+end

data/spec/unit/mongo_mapper_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+class Address; end
+
+describe "MongoMapper" do
+  it "should be able to write and read connection" do
+    conn = Mongo::MongoClient.new
+    MongoMapper.connection = conn
+    MongoMapper.connection.should == conn
+  end
+
+  it "should default connection to new mongo ruby driver" do
+    MongoMapper.connection = nil
+    MongoMapper.connection.should be_instance_of(Mongo::MongoClient)
+  end
+
+  it "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
+
+  it "should have document not found error" do
+    lambda {
+      MongoMapper::DocumentNotFound
+    }.should_not raise_error
+  end
+
+  it "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
+    it "should work without authentication" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, {})
+      MongoMapper.should_receive(:database=).with('test')
+      Mongo::DB.any_instance.should_receive(:authenticate).never
+      MongoMapper.connect('development')
+    end
+
+    it "should work without authentication using uri" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
+      }
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, {})
+      MongoMapper.should_receive(:database=).with('test')
+      Mongo::DB.any_instance.should_receive(:authenticate).never
+      MongoMapper.connect('development')
+    end
+
+    it "should work with sinatra environment symbol" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, {})
+      MongoMapper.should_receive(:database=).with('test')
+      Mongo::DB.any_instance.should_receive(:authenticate).never
+      MongoMapper.connect(:development)
+    end
+
+    it "should work with options" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+      }
+      connection, logger = double('connection'), double('logger')
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, :logger => logger)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    it "should pass along ssl when true" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'ssl' => true}
+      }
+      connection, logger = double('connection'), double('logger')
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, :logger => logger, :ssl => true)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    it "should pass along ssl when false" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'ssl' => false}
+      }
+      connection, logger = double('connection'), double('logger')
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, :logger => logger, :ssl => false)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    it "should convert read preferences to symbols" do
+      MongoMapper.config = {
+        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'options' =>  {'read' => 'primary'}}
+      }
+      connection, logger = double('connection'), double('logger')
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, :logger => logger, :read => :primary)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    it "should work with options from config" do
+      MongoMapper.config = {
+        'development' => {'host' => '192.168.1.1', 'port' => 2222, 'database' => 'test', 'options' => {'safe' => true}}
+      }
+      connection, logger = double('connection'), double('logger')
+      Mongo::MongoClient.should_receive(:new).with('192.168.1.1', 2222, :logger => logger, :safe => true)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    it "should work with options using uri" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
+      }
+      connection, logger = double('connection'), double('logger')
+      Mongo::MongoClient.should_receive(:new).with('127.0.0.1', 27017, :logger => logger)
+      MongoMapper.connect('development', :logger => logger)
+    end
+
+    it "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.should_receive(:authenticate).with('john', 'secret')
+      MongoMapper.connect('development')
+    end
+
+    it "should work with authentication using uri" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mongodb://john:secret@127.0.0.1:27017/test'}
+      }
+      Mongo::DB.any_instance.should_receive(:authenticate).with('john', 'secret')
+      MongoMapper.connect('development')
+    end
+
+    it "should raise error for invalid scheme" do
+      MongoMapper.config = {
+        'development' => {'uri' => 'mysql://127.0.0.1:5336/foo'}
+      }
+      expect { MongoMapper.connect('development') }.to raise_error(MongoMapper::InvalidScheme)
+    end
+
+    it "should create a replica set connection if config contains multiple hosts in the old format" do
+      MongoMapper.config = {
+        'development' => {
+          'hosts' => [ ['127.0.0.1', 27017], ['localhost', 27017] ],
+          'database' => 'test'
+        }
+      }
+
+      Mongo::MongoReplicaSetClient.should_receive(:new).with( ['127.0.0.1', 27017], ['localhost', 27017], {'read_secondary' => true} )
+      MongoMapper.should_receive(:database=).with('test')
+      Mongo::DB.any_instance.should_receive(:authenticate).never
+      MongoMapper.connect('development', 'read_secondary' => true)
+    end
+
+    it "should create a replica set connection if config contains multiple hosts in the new format" do
+      MongoMapper.config = {
+        'development' => {
+          'hosts' => ['127.0.0.1:27017', 'localhost:27017'],
+          'database' => 'test'
+        }
+      }
+
+      Mongo::MongoReplicaSetClient.should_receive(:new).with( ['127.0.0.1:27017', 'localhost:27017'], {'read_secondary' => true} )
+      MongoMapper.should_receive(:database=).with('test')
+      Mongo::DB.any_instance.should_receive(:authenticate).never
+      MongoMapper.connect('development', 'read_secondary' => true)
+    end
+  end
+
+  context "setup" do
+    it "should work as shortcut for setting config, environment and options" do
+      config, logger = double('config'), double('logger')
+      MongoMapper.should_receive(:config=).with(config)
+      MongoMapper.should_receive(:connect).with('development', :logger => logger)
+      MongoMapper.should_receive(:handle_passenger_forking).once
+      MongoMapper.setup(config, 'development', :logger => logger)
+    end
+  end
+end

data/spec/unit/pagination_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "Pagination" do
+  it "should default per_page to 25" do
+    Doc().per_page.should == 25
+  end
+
+  it "should allow overriding per_page" do
+    Doc() { def self.per_page; 1 end }.per_page.should == 1
+  end
+end

data/{test/unit/test_plugins.rb → spec/unit/plugins_spec.rb}

@@ -1,7 +1,7 @@
-require 'test_helper'
+require 'spec_helper'
 
-class PluginsTest < Test::Unit::TestCase
-  should "default plugins to empty array" do
+describe "Plugins" do
+  it "should default plugins to empty array" do
     Class.new { extend MongoMapper::Plugins }.plugins.should == []
   end
 
@@ -24,41 +24,41 @@ class PluginsTest < Test::Unit::TestCase
       end
     end
 
-    setup do
+    before do
       @document = Class.new do
         extend MongoMapper::Plugins
         plugin MyConcern
       end
     end
 
-    should "include instance methods" do
+    it "should include instance methods" do
       @document.new.instance_foo.should == 'instance_foo'
     end
 
-    should "extend class methods" do
+    it "should extend class methods" do
       @document.class_foo.should == 'class_foo'
     end
 
-    should "pass model to configure" do
+    it "should pass model to configure" do
       @document.new.should respond_to(:from_concern)
     end
 
-    should "add plugin to plugins" do
+    it "should add plugin to plugins" do
       @document.plugins.should include(MyConcern)
     end
 
     context "Document" do
-      setup do
+      before do
         MongoMapper::Document.plugins.delete(MyConcern)
       end
 
-      should 'allow plugins on Document' do
+      it 'should allow plugins on Document' do
         MongoMapper::Document.plugin(MyConcern)
         Doc().should respond_to(:class_foo)
         Doc().new.should respond_to(:instance_foo)
       end
 
-      should 'add plugins to classes that include Document before they are added' do
+      it 'should add plugins to classes that include Document before they are added' do
         article = Doc()
         MongoMapper::Document.plugin(MyConcern)
         article.should respond_to(:class_foo)
@@ -67,18 +67,18 @@ class PluginsTest < Test::Unit::TestCase
     end
 
     context "EmbeddedDocument" do
-      setup do
+      before do
         MongoMapper::EmbeddedDocument.plugins.delete(MyConcern)
       end
 
-      should 'allow plugins on EmbeddedDocument' do
+      it 'should allow plugins on EmbeddedDocument' do
         MongoMapper::EmbeddedDocument.plugin(MyConcern)
         article = EDoc()
         article.should respond_to(:class_foo)
         article.new.should respond_to(:instance_foo)
       end
 
-      should 'add plugins to classes that include EmbeddedDocument before they are added' do
+      it 'should add plugins to classes that include EmbeddedDocument before they are added' do
         article = EDoc()
         MongoMapper::EmbeddedDocument.plugin(MyConcern)
         article.should respond_to(:class_foo)