honkster-mongo_mapper 0.8.4

data/test/unit/test_keys.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+require 'models'
+
+class KeyTest < Test::Unit::TestCase
+  include MongoMapper::Plugins::Keys
+
+  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
+        klass.new.id.should be_nil
+      }.should_not raise_error
+    end
+  end
+
+  context ".new with no id and _id of type string" do
+    should "not error" do
+      lambda {
+        klass = Doc() do
+          key :_id, String
+        end
+        klass.new.id.should_not be_nil
+      }.should_not raise_error
+    end
+  end
+
+  context ".new with no id and _id of type object id" do
+    should "not error" do
+      lambda {
+        klass = Doc() do
+          key :_id, ObjectId
+        end
+        klass.new.should_not 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,110 @@
+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 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 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
+  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

data/test/unit/test_pagination.rb

@@ -0,0 +1,11 @@
+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
+end

data/test/unit/test_plugins.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module MyPlugin
+  def self.configure(model)
+    model.class_eval { attr_accessor :from_configure }
+  end
+
+  module ClassMethods
+    def class_foo
+      'class_foo'
+    end
+  end
+
+  module InstanceMethods
+    def instance_foo
+      'instance_foo'
+    end
+  end
+end
+
+class PluginsTest < Test::Unit::TestCase
+  context "plugin" do
+    setup do
+      @document = Class.new do
+        extend MongoMapper::Plugins
+        plugin MyPlugin
+      end
+    end
+
+    should "include instance methods" do
+      @document.new.instance_foo.should == 'instance_foo'
+    end
+
+    should "extend class methods" do
+      @document.class_foo.should == 'class_foo'
+    end
+
+    should "pass model to configure" do
+      @document.new.should respond_to(:from_configure)
+    end
+
+    should "default plugins to empty array" do
+      Class.new { extend MongoMapper::Plugins }.plugins.should == []
+    end
+
+    should "add plugin to plugins" do
+      @document.plugins.should include(MyPlugin)
+    end
+  end
+end

data/test/unit/test_rails.rb

@@ -0,0 +1,181 @@
+require 'test_helper'
+
+class TestRails < Test::Unit::TestCase
+  context "Document" do
+    setup do
+      @klass = Doc('Post') do
+        key :foo, String
+      end
+    end
+
+    context "Class methods" do
+      should "alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      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
+
+      should "implement human_name" do
+        @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)
+      end
+
+      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
+
+      should "implement human_name" do
+        @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

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class BigStuff
+    include MongoMapper::Document
+  end
+
+  class Item
+    include MongoMapper::EmbeddedDocument
+    key :for_all, String
+  end
+
+  class FirstItem < Item
+    key :first_only, String
+    many :second_items
+  end
+
+  class SecondItem < Item
+    key :second_only, String
+  end
+
+  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', '_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'
+    end
+  end
+end