mongo_mapper 0.12.0 → 0.13.0.beta1

data/spec/functional/rails_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "Documents with the Rails plugin" do
+  let(:doc) { Doc {
+    key :foo, String
+    key :long_field, String, :alias => "lf"
+   }}
+
+  context "with values from the DB" do
+    subject { doc.create(:foo => "bar", :long_field => "long value") }
+    it "should have x_before_type_cast" do
+      subject.foo_before_type_cast.should == "bar"
+    end
+
+    it "should have x_before_type_cast for aliased fields" do
+      subject.long_field_before_type_cast.should == "long value"
+    end
+
+    it "should honor app-set values over DB-set values" do
+      subject.foo = nil
+      subject.foo_before_type_cast.should == nil
+    end
+  end
+
+  context "when blank" do
+    subject { doc.create() }
+    it "should have x_before_type_cast" do
+      subject.foo_before_type_cast.should == nil
+    end
+
+    it "should honor app-set values over DB-set values" do
+      subject.foo = nil
+      subject.foo_before_type_cast.should == nil
+
+      subject.foo = :baz
+      subject.foo_before_type_cast.should == :baz
+
+      subject.save
+      subject.reload.foo_before_type_cast.should == "baz"
+    end
+  end
+
+  context "#has_one" do
+    subject do
+      Doc do
+        has_one :foo
+      end
+    end
+
+    it "should create a one association" do
+      subject.associations.should have_key :foo
+      subject.associations[:foo].should be_a MongoMapper::Plugins::Associations::OneAssociation
+    end
+  end
+end

data/spec/functional/safe_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe "Safe" do
+  context "A Document" do
+    it "should default safe to off" do
+      Doc().should_not be_safe
+    end
+
+    it "should allow turning safe on" do
+      Doc() { safe }.should be_safe
+    end
+
+    context "inherited with safe setting on" do
+      it "should set subclass safe setting on" do
+        inherited = Class.new(Doc() { safe })
+        inherited.should be_safe
+        inherited.safe_options.should == true
+      end
+
+      it "should set subclass safe setting to same options hash as superclass" do
+        inherited = Class.new(Doc() { safe(:j => true) })
+        inherited.should be_safe
+        inherited.safe_options.should == {:j => true}
+      end
+    end
+
+    context "inherited with safe setting off" do
+      it "should leave subclass safe setting off" do
+        inherited = Class.new(Doc())
+        inherited.should_not be_safe
+      end
+    end
+  end
+
+  context "An unsafe document" do
+    before do
+      @klass = Doc do
+        safe(:w => 0)
+      end
+    end
+    after { drop_indexes(@klass) }
+
+    it "should not raise an error on duplicate IDs" do
+      k = @klass.create
+      expect { j = @klass.create(:_id => k.id) }.to_not raise_error
+    end
+  end
+
+  context "A safe document" do
+    before do
+      @klass = Doc() do
+        safe
+      end
+    end
+    after { drop_indexes(@klass) }
+
+    context "#save" do
+      before do
+        @klass.ensure_index :email, :unique => true
+      end
+
+      it "should raise an error on duplicate IDs" do
+        k = @klass.create
+        expect { j = @klass.create(:_id => k.id) }.to raise_error(Mongo::OperationFailure)
+      end
+
+      context "using safe setting from class" do
+        it "should pass :w => 1 option to save" do
+          instance = @klass.new(:email => 'john@doe.com')
+          Mongo::Collection.any_instance.should_receive(:insert).once.with({'_id' => instance.id, 'email' => 'john@doe.com'}, {:w => 1})
+          instance.save!
+        end
+
+        it "should work fine when all is well" do
+          expect {
+            @klass.new(:email => 'john@doe.com').save
+          }.to_not raise_error
+        end
+
+        it "should raise error when operation fails" do
+          expect {
+            2.times do
+              @klass.new(:email => 'john@doe.com').save
+            end
+          }.to raise_error(Mongo::OperationFailure)
+        end
+      end
+
+      context "overriding safe setting" do
+        it "should raise error if safe is true" do
+          expect {
+            2.times do
+              @klass.new(:email => 'john@doe.com').save(:safe => true)
+            end
+          }.to raise_error(Mongo::OperationFailure)
+        end
+
+        it "should not raise error if safe is false" do
+          expect {
+            2.times do
+              @klass.new(:email => 'john@doe.com').save(:safe => false)
+            end
+          }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  context "a safe document with options hash" do
+    before do
+      @klass = Doc() do
+        safe(:j => true)
+      end
+    end
+    after { drop_indexes(@klass) }
+
+    context "#save" do
+      before do
+        @klass.ensure_index :email, :unique => true
+      end
+
+      context "using safe setting from class" do
+        it "should pass :safe => options_hash to save" do
+          instance = @klass.new(:email => 'john@doe.com')
+          Mongo::Collection.any_instance.should_receive(:insert).once.with({'_id' => instance.id, 'email' => 'john@doe.com'}, {:j => true})
+          instance.save!
+        end
+
+        it "should work fine when all is well" do
+          expect {
+            @klass.new(:email => 'john@doe.com').save
+          }.to_not raise_error
+        end
+
+        it "should raise error when operation fails" do
+          expect {
+            2.times do
+              @klass.new(:email => 'john@doe.com').save
+            end
+          }.to raise_error(Mongo::OperationFailure)
+        end
+      end
+
+      context "overriding safe setting" do
+        it "should raise error if safe is true" do
+          expect {
+            2.times do
+              @klass.new(:email => 'john@doe.com').save(:safe => true)
+            end
+          }.to raise_error(Mongo::OperationFailure)
+        end
+
+        it "should not raise error if safe is false" do
+          expect {
+            2.times do
+              @klass.new(:email => 'john@doe.com').save(:safe => false)
+            end
+          }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/{test/functional/test_sci.rb → spec/functional/sci_spec.rb}

@@ -1,8 +1,28 @@
-require 'test_helper'
+require 'spec_helper'
+
+describe "Single collection inheritance (document)" do
+  context "without a connection", :without_connection => true do
+    it "should attempt to create a connection during inheritance" do
+      Mongo::MongoClient.should_not_receive(:new)
+      doc = Class.new
+      doc.send(:include, MongoMapper::Document)
+      expect {
+        Class.new(doc)
+      }.to_not raise_error
+    end
 
-class SciTest < Test::Unit::TestCase
-  context "Single collection inheritance (document)" do
-    setup do
+    it "should pick up a connection if one wasn't set" do
+      doc = Class.new
+      doc.send(:include, MongoMapper::Document)
+      klass = Class.new(doc)
+      klass.connection.should be_nil
+      MongoMapper.connection
+      klass.connection.should be_a Mongo::MongoClient
+    end
+  end
+
+  context "with a connection" do
+    before do
       class ::DocParent
         include MongoMapper::Document
         key :name, String
@@ -20,7 +40,7 @@ class SciTest < Test::Unit::TestCase
       @daughter = DocDaughter.new({:name => "Little Orphan Annie"})
     end
 
-    teardown do
+    after do
       Object.send :remove_const, 'DocParent'   if defined?(::DocParent)
       Object.send :remove_const, 'DocDaughter' if defined?(::DocDaughter)
       Object.send :remove_const, 'DocSon'      if defined?(::DocSon)
@@ -28,15 +48,55 @@ class SciTest < Test::Unit::TestCase
       Object.send :remove_const, 'DocGrandGrandSon' if defined?(::DocGrandGrandSon)
     end
 
-    should "automatically add _type key to store class" do
+    it "should automatically add _type key to store class" do
       DocParent.key?(:_type).should be_true
     end
 
-    should "use the same collection in the subclass" do
+    it "should use modifiers properly" do
+      DocDaughter.increment({:title => 'Home'}, {:day_count => 1}, :upsert => true)
+      DocDaughter.first.should_not be_nil
+      DocDaughter.first._type.should == "DocDaughter"
+    end
+
+    it "should use the same connection in the subclass" do
+      parent_class = Class.new do
+        include MongoMapper::Document
+        connection Mongo::MongoClient.new
+      end
+
+      child_class = Class.new(parent_class) do
+        include MongoMapper::Document
+      end
+
+      child_class.connection.should == child_class.connection
+    end
+
+    it "should use the same database in the subclass" do
+      parent_class = Class.new do
+        include MongoMapper::Document
+        set_database_name 'something'
+      end
+
+      child_class = Class.new(parent_class) do
+        include MongoMapper::Document
+      end
+
+      child_class.database.name.should == 'something'
+    end
+
+    it "should use the same collection in the subclass" do
       DocDaughter.collection.name.should == DocParent.collection.name
     end
 
-    should "know single_collection_parent" do
+    it "should negate SCI if the subclass changes its collection" do
+      klass = Class.new(DocParent) do
+        set_collection_name "foobars"
+      end
+      klass.collection.name.should == "foobars"
+      klass.should_not be_single_collection_inherited
+    end
+
+    it "should know single_collection_parent" do
       DocParent.single_collection_parent.should be_nil
       DocDaughter.single_collection_parent.should      == DocParent
       DocSon.single_collection_parent.should           == DocParent
@@ -44,7 +104,7 @@ class SciTest < Test::Unit::TestCase
       DocGrandGrandSon.single_collection_parent.should == DocGrandSon
     end
 
-    should "know single_collection_root" do
+    it "should know single_collection_root" do
       DocParent.single_collection_root.should        == DocParent
       DocDaughter.single_collection_root.should      == DocParent
       DocSon.single_collection_root.should           == DocParent
@@ -53,29 +113,29 @@ class SciTest < Test::Unit::TestCase
     end
 
     context ".single_collection_inherited?" do
-      should "be false if has not inherited" do
+      it "should be false if has not inherited" do
         DocParent.should_not be_single_collection_inherited
       end
 
-      should "be true if inherited" do
+      it "should be true if inherited" do
         DocDaughter.should be_single_collection_inherited
         DocSon.should be_single_collection_inherited
         DocGrandSon.should be_single_collection_inherited
       end
     end
 
-    should "set _type on initialize" do
+    it "should set _type on initialize" do
       DocDaughter.new._type.should  == 'DocDaughter'
       DocSon.new._type.should       == 'DocSon'
       DocGrandSon.new._type.should  == 'DocGrandSon'
     end
 
-    should "set _type based on class and ignore assigned values" do
+    it "should set _type based on class and ignore assigned values" do
       DocSon.new(:_type => 'DocDaughter')._type.should == 'DocSon'
     end
 
     context "loading" do
-      should "be based on _type" do
+      it "should be based on _type" do
         @parent.save
         @daughter.save
 
@@ -87,7 +147,7 @@ class SciTest < Test::Unit::TestCase
         collection.last.name.should == "Little Orphan Annie"
       end
 
-      should "gracefully handle when _type cannot be constantized" do
+      it "should gracefully handle when _type cannot be constantized" do
         doc = DocParent.new(:name => 'Nunes')
         doc._type = 'FoobarBaz'
         doc.save
@@ -99,7 +159,7 @@ class SciTest < Test::Unit::TestCase
     end
 
     context "querying" do
-      should "find scoped to class" do
+      it "should find scoped to class" do
         john = DocSon.create(:name => 'John')
         steve = DocSon.create(:name => 'Steve')
         steph = DocDaughter.create(:name => 'Steph')
@@ -119,13 +179,13 @@ class SciTest < Test::Unit::TestCase
         DocParent.all(:order => 'name').should    == [boris, carrie, john, sigmund, steph, steve]
       end
 
-      should "work with nested hash conditions" do
+      it "should work with nested hash conditions" do
         john = DocSon.create(:name => 'John')
         steve = DocSon.create(:name => 'Steve')
         DocSon.all(:name => {'$ne' => 'Steve'}).should == [john]
       end
 
-      should "raise error if not found scoped to class" do
+      it "should raise error if not found scoped to class" do
         john = DocSon.create(:name => 'John')
         steph = DocDaughter.create(:name => 'Steph')
 
@@ -134,13 +194,13 @@ class SciTest < Test::Unit::TestCase
         }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
-      should "not raise error for find with parent" do
+      it "should not raise error for find with parent" do
         john = DocSon.create(:name => 'John')
 
         DocParent.find!(john._id).should == john
       end
 
-      should "count scoped to class" do
+      it "should count scoped to class" do
         john = DocSon.create(:name => 'John')
         steve = DocSon.create(:name => 'Steve')
         steph = DocDaughter.create(:name => 'Steph')
@@ -152,7 +212,7 @@ class SciTest < Test::Unit::TestCase
         DocParent.count.should    == 4
       end
 
-      should "not be able to destroy each other" do
+      it "should not be able to destroy each other" do
         john = DocSon.create(:name => 'John')
         steph = DocDaughter.create(:name => 'Steph')
 
@@ -161,7 +221,7 @@ class SciTest < Test::Unit::TestCase
         }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
-      should "not be able to delete each other" do
+      it "should not be able to delete each other" do
         john = DocSon.create(:name => 'John')
         steph = DocDaughter.create(:name => 'Steph')
 
@@ -170,7 +230,7 @@ class SciTest < Test::Unit::TestCase
         }.should_not change { DocParent.count }
       end
 
-      should "be able to destroy using parent" do
+      it "should be able to destroy using parent" do
         john = DocSon.create(:name => 'John')
         steph = DocDaughter.create(:name => 'Steph')
 
@@ -179,7 +239,7 @@ class SciTest < Test::Unit::TestCase
         }.should change { DocParent.count }.by(-2)
       end
 
-      should "be able to delete using parent" do
+      it "should be able to delete using parent" do
         john = DocSon.create(:name => 'John')
         steph = DocDaughter.create(:name => 'Steph')
 
@@ -189,7 +249,7 @@ class SciTest < Test::Unit::TestCase
       end
     end
 
-    should "be able to reload single collection inherited parent class" do
+    it "should be able to reload single collection inherited parent class" do
       brian = DocParent.create(:name => 'Brian')
       brian.name = 'B-Dawg'
       brian.reload
@@ -197,8 +257,8 @@ class SciTest < Test::Unit::TestCase
     end
   end
 
-  context "Single collection inheritance (embedded document)" do
-    setup do
+  describe "Single collection inheritance (embedded document)" do
+    before do
       class ::Grandparent
         include MongoMapper::EmbeddedDocument
         key :grandparent, String
@@ -220,37 +280,66 @@ class SciTest < Test::Unit::TestCase
       end
     end
 
-    teardown do
+    after do
       Object.send :remove_const, 'Grandparent' if defined?(::Grandparent)
       Object.send :remove_const, 'Parent'      if defined?(::Parent)
       Object.send :remove_const, 'Child'       if defined?(::Child)
       Object.send :remove_const, 'OtherChild'  if defined?(::OtherChild)
     end
 
-    should "automatically add _type key" do
+    it "should automatically add _type key" do
       Grandparent.key?(:_type).should be_true
     end
 
     context ".single_collection_inherited?" do
-      should "be false if has not inherited" do
+      it "should be false if has not inherited" do
         Grandparent.should_not be_single_collection_inherited
       end
 
-      should "be true if inherited" do
+      it "should be true if inherited" do
         Parent.should be_single_collection_inherited
         Child.should be_single_collection_inherited
         OtherChild.should be_single_collection_inherited
       end
     end
 
-    should "set _type on initialize" do
+    it "should set _type on initialize" do
       Parent.new._type.should     == 'Parent'
       Child.new._type.should      == 'Child'
       OtherChild.new._type.should == 'OtherChild'
     end
 
-    should "set _type based on class and ignore assigned values" do
+    it "should set _type based on class and ignore assigned values" do
       Child.new(:_type => 'OtherChild')._type.should == 'Child'
     end
   end
-end
+
+  describe "With polymorphism" do
+    before :all do
+      class SciPolymorphicPost
+        include MongoMapper::Document
+        belongs_to :article_parent, :polymorphic => true
+      end
+
+      class GalleryItem
+        include MongoMapper::Document
+        belongs_to :gallery_album
+        key :text, Hash
+        timestamps!
+      end
+
+      class TextGalleryItem < GalleryItem;
+        many :sci_polymorphic_posts, :as => :article_parent
+      end
+    end
+
+    it "should find polymorphic SCI items" do
+      item = TextGalleryItem.new()
+      p = SciPolymorphicPost.create(:article_parent => item)
+      p.article_parent_id.should be_a BSON::ObjectId
+      p.article_parent_type.should == "TextGalleryItem"
+
+      p.reload.article_parent.sci_polymorphic_posts.all.should include(p)
+    end
+  end
+end