mongo_mapper 0.8.6 → 0.9.0

data/test/functional/test_embedded_document.rb

@@ -66,7 +66,7 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
       @klass.key :foo, @address_class
     end
 
-    should "be true until document is saved" do
+    should "be true until document is created" do
       address = @address_class.new(:city => 'South Bend', :state => 'IN')
       doc = @klass.new(:foo => address)
       address.new?.should be_true
@@ -89,7 +89,7 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
     end
   end
 
-  context "new? (embedded association)" do
+  context "new? (embedded many association)" do
     setup do
       @doc = @klass.new(:pets => [{:name => 'poo bear'}])
     end
@@ -110,6 +110,61 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
       @doc.reload
       @doc.pets.first.should_not be_new
     end
+
+    should "be true until existing document is saved" do
+      @doc.save
+      pet = @doc.pets.build(:name => 'Rasmus')
+      pet.new?.should be_true
+      @doc.save
+      pet.new?.should be_false
+    end
+  end
+
+  context "new? (nested embedded many association)" do
+    setup do
+      @pet_klass.many :addresses, :class=> @address_class
+      @doc = @klass.new
+      @doc.pets.build(:name => 'Rasmus')
+      @doc.save
+    end
+
+    should "be true until existing document is saved" do
+      address = @doc.pets.first.addresses.build(:city => 'Holland', :state => 'MI')
+      address.new?.should be_true
+      @doc.save
+      address.new?.should be_false
+    end
+  end
+
+  context "new? (embedded one association)" do
+    setup do
+      @klass.one :address, :class => @address_class
+      @doc = @klass.new
+    end
+
+    should "be true until existing document is saved" do
+      @doc.save
+      @doc.build_address(:city => 'Holland', :state => 'MI')
+      @doc.address.new?.should be_true
+      @doc.save
+      @doc.address.new?.should be_false
+    end
+  end
+
+  context "new? (nested embedded one association)" do
+    setup do
+      @pet_klass.one :address, :class => @address_class
+      @doc = @klass.new
+      @doc.pets.build(:name => 'Rasmus')
+      @doc.save
+    end
+
+    should "be true until existing document is saved" do
+      address = @doc.pets.first.build_address(:city => 'Holland', :stats => 'MI')
+      address.new?.should be_true
+      @doc.save
+      address.new?.should be_false
+    end
   end
 
   context "#destroyed?" do
@@ -164,6 +219,17 @@ class EmbeddedDocumentTest < Test::Unit::TestCase
     person.pets.first.should == pet
   end
 
+  should "be able to save!" do
+    person = @klass.create
+
+    pet = @pet_klass.new(:name => 'sparky')
+    person.pets << pet
+    pet.should be_new
+
+    person.expects(:save!)
+    pet.save!
+  end
+
   should "be able to dynamically add new keys and save" do
     person = @klass.create
 

data/test/functional/test_identity_map.rb

@@ -410,7 +410,6 @@ class IdentityMapTest < Test::Unit::TestCase
         assert_in_map(root)
 
         blog = Blog.create(:title => 'Jill', :parent => root)
-        blog.parent.inspect
         assert_in_map(blog)
         root.should equal(blog.parent.target)
       end
@@ -426,7 +425,7 @@ class IdentityMapTest < Test::Unit::TestCase
 
       should "work correctly with one proxy create" do
         root = Item.create(:title => 'Root')
-        blog = root.blog.create(:title => 'Blog')
+        blog = root.create_blog(:title => 'Blog')
         blog.parent.should equal(root)
       end
     end
@@ -465,11 +464,11 @@ class IdentityMapTest < Test::Unit::TestCase
           loaded.should_not equal(post)
         end
       end
-      
+
       should "not load attributes from map when finding" do
         post = @post_class.create(:title => 'Awesome!')
         post.title = 'Temporary'
-        @post_class.without_identity_map do 
+        @post_class.without_identity_map do
           @post_class.find(post.id).title.should == 'Awesome!'
         end
       end

data/test/functional/test_querying.rb

@@ -677,6 +677,17 @@ class QueryingTesting < Test::Unit::TestCase
     end
   end
 
+  context "#update_attribute" do
+    setup do
+      @doc = @document.create(:first_name => 'John', :age => '27')
+    end
+
+    should "update the attribute" do
+      @doc.update_attribute(:first_name, 'Chris').should be_true
+      @doc.reload.first_name.should == 'Chris'
+    end
+  end
+
   context "#save (new document)" do
     setup do
       @doc = @document.new(:first_name => 'John', :age => '27')

data/test/functional/test_userstamps.rb

@@ -17,11 +17,11 @@ class UserstampsTest < Test::Unit::TestCase
     end
 
     should "add belongs_to creator" do
-      @document.associations.keys.should include('creator')
+      @document.associations.keys.should include(:creator)
     end
 
     should "add belongs_to updater" do
-      @document.associations.keys.should include('updater')
+      @document.associations.keys.should include(:updater)
     end
   end
 end

data/test/functional/test_validations.rb

@@ -18,7 +18,7 @@ class ValidationsTest < Test::Unit::TestCase
       doc = @document.new
       doc.errors.size.should == 0
       doc.save
-      doc.errors.full_messages.should == ["Name can't be empty"]
+      doc.errors.full_messages.should == ["Name can't be blank"]
     end
   end
 
@@ -70,7 +70,7 @@ class ValidationsTest < Test::Unit::TestCase
     should "populate document's errors" do
       @doc.name = nil
       @doc.save
-      @doc.errors.full_messages.should == ["Name can't be empty"]
+      @doc.errors.full_messages.should == ["Name can't be blank"]
     end
   end
 
@@ -84,23 +84,19 @@ class ValidationsTest < Test::Unit::TestCase
       end
     end
 
-    should "work with validate_on_create callback" do
-      @document.validate_on_create :action_present
+    should "work with validate :on => :create callback" do
+      @document.validate :action_present, :on => :create
 
-      doc = @document.new
-      doc.action = nil
+      doc = @document.create(:action => nil)
       doc.should have_error_on(:action)
 
       doc.action = 'kick'
-      doc.should_not have_error_on(:action)
       doc.save
-
-      doc.action = nil
       doc.should_not have_error_on(:action)
     end
 
-    should "work with validate_on_update callback" do
-      @document.validate_on_update :action_present
+    should "work with validate :on => :update callback" do
+      @document.validate :action_present, :on => :update
 
       doc = @document.new
       doc.action = nil
@@ -141,6 +137,12 @@ class ValidationsTest < Test::Unit::TestCase
       doc2.should be_valid
     end
 
+    should "work with i18n taken message" do
+      @document.create(:name => 'joe')
+      doc = @document.create(:name => 'joe')
+      doc.should have_error_on(:name, 'has already been taken')
+    end
+
     should "allow to update an object" do
       doc = @document.new("name" => "joe")
       doc.save.should be_true
@@ -321,22 +323,22 @@ class ValidationsTest < Test::Unit::TestCase
     end
   end
 
-  context "validates uniqueness of with :unique shortcut" do
-    should "work" do
-      @document = Doc do
-        key :name, String, :unique => true
-      end
-
-      doc = @document.create(:name => 'John')
-      doc.should_not have_error_on(:name)
-
-      @document \
-        .stubs(:first) \
-        .with(:name => 'John') \
-        .returns(doc)
-
-      second_john = @document.create(:name => 'John')
-      second_john.should have_error_on(:name, 'has already been taken')
-    end
-  end
+  # context "validates uniqueness of with :unique shortcut" do
+  #   should "work" do
+  #     @document = Doc do
+  #       key :name, String, :unique => true
+  #     end
+  #
+  #     doc = @document.create(:name => 'John')
+  #     doc.should_not have_error_on(:name)
+  #
+  #     @document \
+  #       .stubs(:first) \
+  #       .with(:name => 'John') \
+  #       .returns(doc)
+  #
+  #     second_john = @document.create(:name => 'John')
+  #     second_john.should have_error_on(:name, 'has already been taken')
+  #   end
+  # end
 end

data/test/models.rb

@@ -231,3 +231,13 @@ module TrModels
     key :name, String
   end
 end
+
+module News
+  class Paper
+    include MongoMapper::Document
+  end
+
+  class Article
+    include MongoMapper::Document
+  end
+end

data/test/test_active_model_lint.rb

@@ -5,7 +5,7 @@ require 'active_model'
 require 'models'
 
 class ActiveModelLintTest < ActiveModel::TestCase
-  include ActiveModel::Lint::Tests
+  include ::ActiveModel::Lint::Tests
 
   def setup
     @model = Post.new

data/test/test_helper.rb

@@ -6,17 +6,18 @@ require 'mongo_mapper'
 require 'fileutils'
 require 'ostruct'
 
-require 'active_support/version'
 require 'json'
 require 'log_buddy'
 require 'matchy'
 require 'shoulda'
 require 'timecop'
 require 'mocha'
+require 'ruby-debug'
 
 class Test::Unit::TestCase
-  def Doc(name=nil, &block)
-    klass = Class.new do
+  def Doc(name='Class', &block)
+    klass = Class.new
+    klass.class_eval do
       include MongoMapper::Document
       set_collection_name :test
 
@@ -31,7 +32,7 @@ class Test::Unit::TestCase
     klass
   end
 
-  def EDoc(name=nil, &block)
+  def EDoc(name='Class', &block)
     klass = Class.new do
       include MongoMapper::EmbeddedDocument
 
@@ -71,12 +72,12 @@ class Test::Unit::TestCase
     if expected_message.nil?
       matcher.positive_failure_message = "#{receiver} had no errors on #{attribute}"
       matcher.negative_failure_message = "#{receiver} had errors on #{attribute} #{receiver.errors.inspect}"
-      !receiver.errors.on(attribute).blank?
+      !receiver.errors[attribute].blank?
     else
-      actual = receiver.errors.on(attribute)
+      actual = receiver.errors[attribute]
       matcher.positive_failure_message = %Q(Expected error on #{attribute} to be "#{expected_message}" but was "#{actual}")
       matcher.negative_failure_message = %Q(Expected error on #{attribute} not to be "#{expected_message}" but was "#{actual}")
-      actual == expected_message
+      actual.include? expected_message
     end
   end
 
@@ -94,7 +95,5 @@ logger = Logger.new(log_dir + '/test.log')
 
 LogBuddy.init(:logger => logger)
 MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => logger)
-MongoMapper.database = "mm-test-#{RUBY_VERSION.gsub('.', '-')}"
+MongoMapper.database = "test"
 MongoMapper.database.collections.each { |c| c.drop_indexes }
-
-puts "\n--- Active Support Version: #{ActiveSupport::VERSION::STRING} ---\n"

data/test/unit/associations/test_base.rb

@@ -7,206 +7,130 @@ class AssociationBaseTest < Test::Unit::TestCase
   include MongoMapper::Plugins::Associations
 
   should "initialize with type and name" do
-    base = Base.new(:many, :foos)
-    base.type.should == :many
+    base = ManyAssociation.new(:foos)
     base.name.should == :foos
   end
 
   should "also allow options when initializing" do
-    base = Base.new(:many, :foos, :polymorphic => true)
+    base = ManyAssociation.new(:foos, :polymorphic => true)
     base.options[:polymorphic].should be_true
   end
 
-  context "class_name" do
-    should "work for belongs_to" do
-      Base.new(:belongs_to, :user).class_name.should == 'User'
-    end
-
-    should "work for many" do
-      Base.new(:many, :smart_people).class_name.should == 'SmartPerson'
-    end
-
-    should "be changeable using class_name option" do
-      base = Base.new(:many, :smart_people, :class_name => 'IntelligentPerson')
-      base.class_name.should == 'IntelligentPerson'
-    end
-  end
-
   context "klass" do
     should "default to class_name constantized" do
-      Base.new(:belongs_to, :foo_monster).klass.should == FooMonster
+      BelongsToAssociation.new(:foo_monster).klass.should == FooMonster
     end
 
     should "be the specified class" do
       anonnymous_class = Class.new
-      Base.new(:belongs_to, :foo_monster, :class => anonnymous_class).klass.should == anonnymous_class
-    end
-  end
-
-  context "many?" do
-    should "be true if many" do
-      Base.new(:many, :foos).many?.should be_true
-    end
-
-    should "be false if not many" do
-      Base.new(:belongs_to, :foo).many?.should be_false
-      Base.new(:one, :foo).many?.should be_false
-    end
-  end
-
-  context "one?" do
-    should "be true if one" do
-      Base.new(:one, :foo).one?.should be_true
-    end
-
-    should "be false if not one" do
-      Base.new(:many, :foo).one?.should be_false
-    end
-  end
-
-  context "belongs_to?" do
-    should "be true if belongs_to" do
-      Base.new(:belongs_to, :foo).belongs_to?.should be_true
-    end
-
-    should "be false if not belongs_to" do
-      Base.new(:many, :foos).belongs_to?.should be_false
+      BelongsToAssociation.new(:foo_monster, :class => anonnymous_class).klass.should == anonnymous_class
     end
   end
 
   context "polymorphic?" do
     should "be true if polymorphic" do
-      Base.new(:many, :foos, :polymorphic => true).polymorphic?.should be_true
+      ManyAssociation.new(:foos, :polymorphic => true).polymorphic?.should be_true
     end
 
     should "be false if not polymorphic" do
-      Base.new(:many, :bars).polymorphic?.should be_false
+      ManyAssociation.new(:bars).polymorphic?.should be_false
     end
   end
 
   context "as?" do
     should "be true if one" do
-      Base.new(:one, :foo, :as => :commentable).as?.should be_true
+      OneAssociation.new(:foo, :as => :commentable).as?.should be_true
     end
 
     should "be false if not one" do
-      Base.new(:many, :foo).as?.should be_false
+      ManyAssociation.new(:foo).as?.should be_false
     end
   end
 
   context "in_array?" do
     should "be true if one" do
-      Base.new(:one, :foo, :in => :list_ids).in_array?.should be_true
+      OneAssociation.new(:foo, :in => :list_ids).in_array?.should be_true
     end
 
     should "be false if not one" do
-      Base.new(:many, :foo).in_array?.should be_false
+      ManyAssociation.new(:foo).in_array?.should be_false
     end
   end
 
   context "query_options" do
     should "default to empty hash" do
-      base = Base.new(:many, :foos)
+      base = ManyAssociation.new(:foos)
       base.query_options.should == {}
     end
 
     should "work with order" do
-      base = Base.new(:many, :foos, :order => 'position')
+      base = ManyAssociation.new(:foos, :order => 'position')
       base.query_options.should == {:order => 'position'}
     end
 
     should "correctly parse from options" do
-      base = Base.new(:many, :foos, :order => 'position', :somekey => 'somevalue')
+      base = ManyAssociation.new(:foos, :order => 'position', :somekey => 'somevalue')
       base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
     end
   end
 
   context "type_key_name" do
-    should "be _type for many" do
-      Base.new(:many, :foos).type_key_name.should == '_type'
-    end
-
     should "be association name _ type for belongs_to" do
-      Base.new(:belongs_to, :foo).type_key_name.should == 'foo_type'
+      BelongsToAssociation.new(:foo).type_key_name.should == 'foo_type'
     end
   end
 
   context "foreign_key" do
     should "default to assocation name _id for belongs to" do
-      base = Base.new(:belongs_to, :foo)
+      base = BelongsToAssociation.new(:foo)
       base.foreign_key.should == 'foo_id'
     end
 
     should "be overridable with :foreign_key option" do
-      base = Base.new(:belongs_to, :foo, :foreign_key => 'foobar_id')
+      base = BelongsToAssociation.new(:foo, :foreign_key => 'foobar_id')
       base.foreign_key.should == 'foobar_id'
     end
   end
 
   should "have ivar that is association name" do
-    Base.new(:belongs_to, :foo).ivar.should == '@_foo'
+    BelongsToAssociation.new(:foo).ivar.should == '@_foo'
   end
 
   context "embeddable?" do
     should "be true if class is embeddable" do
-      base = Base.new(:many, :medias)
+      base = ManyAssociation.new(:medias)
       base.embeddable?.should be_true
     end
 
     should "be false if class is not embeddable" do
-      base = Base.new(:many, :statuses)
+      base = ManyAssociation.new(:statuses)
       base.embeddable?.should be_false
 
-      base = Base.new(:belongs_to, :project)
+      base = BelongsToAssociation.new(:project)
       base.embeddable?.should be_false
     end
   end
 
   context "proxy_class" do
-    should "be ManyDocumentsProxy for many" do
-      base = Base.new(:many, :statuses)
-      base.proxy_class.should == ManyDocumentsProxy
-    end
-
-    should "be ManyPolymorphicProxy for polymorphic many" do
-      base = Base.new(:many, :messages, :polymorphic => true)
-      base.proxy_class.should == ManyPolymorphicProxy
-    end
-
-    should "be ManyEmbeddedProxy for many embedded" do
-      base = Base.new(:many, :medias)
-      base.proxy_class.should == ManyEmbeddedProxy
-    end
-
-    should "be ManyEmbeddedPolymorphicProxy for polymorphic many embedded" do
-      base = Base.new(:many, :medias, :polymorphic => true)
-      base.proxy_class.should == ManyEmbeddedPolymorphicProxy
-    end
-
     should "be BelongsToProxy for belongs_to" do
-      base = Base.new(:belongs_to, :project)
+      base = BelongsToAssociation.new(:project)
       base.proxy_class.should == BelongsToProxy
     end
 
     should "be BelongsToPolymorphicProxy for polymorphic belongs_to" do
-      base = Base.new(:belongs_to, :target, :polymorphic => true)
+      base = BelongsToAssociation.new(:target, :polymorphic => true)
       base.proxy_class.should == BelongsToPolymorphicProxy
     end
 
     should "be OneProxy for one" do
-      base = Base.new(:one, :status, :polymorphic => true)
+      base = OneAssociation.new(:status, :polymorphic => true)
       base.proxy_class.should == OneProxy
     end
 
     should "be OneEmbeddedProxy for one embedded" do
-      base = Base.new(:one, :media)
+      base = OneAssociation.new(:media)
       base.proxy_class.should == OneEmbeddedProxy
     end
-
-    should "be InArrayProxy for many with :in option" do
-      base = Base.new(:many, :messages, :in => :message_ids)
-      base.proxy_class.should == InArrayProxy
-    end
   end
 
 end