mongo_mapper 0.14.0.rc1 → 0.15.3

data/spec/functional/callbacks_spec.rb

@@ -148,11 +148,11 @@ describe "Callbacks" do
       @root_class.define_callbacks :after_publish
       @root_class.after_save { |d| d.run_callbacks(:after_publish) }
 
-      expect {
+      lambda {
         child = @child_class.new(:name => 'Child')
         root  = @root_class.create(:name => 'Parent', :children => [child])
         child.history.should_not include(:after_publish)
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 

data/spec/functional/counter_cache_spec.rb

@@ -171,42 +171,42 @@ describe MongoMapper::Plugins::CounterCache do
     end
 
     it "should update the counter cache on save" do
-      expect {
+      lambda {
         @comment.save!
         @article.reload
-      }.to change(@article, :commentable_count).by(1)
+      }.should change(@article, :commentable_count).by(1)
     end
 
     it "should increment with a second object" do
       @comment.save!
 
-      expect {
+      lambda {
         second_comment = CounterCacheFixtureModels::Comment.new
         second_comment.commentable = @article
         second_comment.save!
         @article.reload
-      }.to change(@article, :commentable_count).by(1)
+      }.should change(@article, :commentable_count).by(1)
     end
 
     it "should decrement the counter cache on destroy" do
       @comment.save!
 
-      expect {
+      lambda {
         @comment.destroy
         @article.reload
-      }.to change(@article, :commentable_count).by(-1)
+      }.should change(@article, :commentable_count).by(-1)
     end
 
     it "should increment with a different type of object" do
       @comment.save!
 
-      expect {
+      lambda {
         second_comment = CounterCacheFixtureModels::Comment.new
         second_comment.commentable = @article
         second_comment.save!
 
         @article.reload
-      }.to change(@article, :commentable_count).by(1)
+      }.should change(@article, :commentable_count).by(1)
     end
 
     describe "without a counter cache field" do
@@ -226,9 +226,9 @@ describe MongoMapper::Plugins::CounterCache do
       it "should raise at save (runtime) if there is no counter cache field" do
         @comment.commentable = @obj
 
-        expect {
+        lambda {
           @comment.save!
-        }.to raise_error(MongoMapper::Plugins::CounterCache::InvalidCounterCacheError)
+        }.should raise_error(MongoMapper::Plugins::CounterCache::InvalidCounterCacheError)
       end
     end
   end

data/spec/functional/dirty_spec.rb

@@ -9,6 +9,13 @@ describe "Dirty" do
   end
 
   context "marking changes" do
+    it "should have the changed? methods" do
+      obj = @document.new
+      obj.should respond_to(:changed?)
+      obj.should respond_to(:phrase_changed?)
+      obj.should respond_to(:paragraph_changed?)
+    end
+
     it "should not happen if there are none" do
       doc = @document.new
       doc.phrase_changed?.should be_falsey
@@ -48,8 +55,8 @@ describe "Dirty" do
 
     it "should not happen when loading from database" do
       doc = @document.create(:phrase => 'Foo')
-      expect_any_instance_of(@document).to receive(:attribute_will_change!).never
-      expect_any_instance_of(@document).to receive(:attribute_changed?).never
+      @document.any_instance.should_receive(:attribute_will_change!).never
+      @document.any_instance.should_receive(:attribute_changed?).never
       doc = @document.find(doc.id)
       doc.changed?.should be_falsey
     end
@@ -220,19 +227,25 @@ describe "Dirty" do
       doc.a = "d"
       doc.a_change.should == ["b","d"]
     end
-    it "should reset changes when set back to the original value" do
-      doc = @document.create(:a=>"b")
-      doc.a = "c"
-      doc.a = "b"
-      doc.changed?.should be_falsey
-    end
+
+    # TODO: ? Is this consistent with how ActiveRecord now works with changes?
+    # it "should reset changes when set back to the original value" do
+    #   doc = @document.create(:a=>"b")
+    #   doc.a = "c"
+    #   doc.a = "b"
+    #   doc.changed?.should be_falsey
+    # end
   end
 
   context "reset_attribute!" do
     it "should reset the attribute back to the previous value" do
       doc = @document.create(:a=>"b")
       doc.a = "c"
-      doc.reset_a!
+      if doc.respond_to?(:restore_a!)
+        doc.restore_a!
+      else
+        doc.reset_a!
+      end
       doc.changed?.should be_falsey
       doc.a.should == "b"
     end
@@ -241,7 +254,11 @@ describe "Dirty" do
       doc.a = "c"
       doc.a = "d"
       doc.a = "e"
-      doc.reset_a!
+      if doc.respond_to?(:restore_a!)
+        doc.restore_a!
+      else
+        doc.reset_a!
+      end
       doc.changed?.should be_falsey
       doc.a.should == "b"
     end
@@ -263,6 +280,27 @@ describe "Dirty" do
     end
   end
 
+  context "Document having Array key with typecast option" do
+    before do
+      @author_id = BSON::ObjectId.new
+      @doc = Doc('Book') { key :author_ids, Array, typecast: "ObjectId" }
+      @doc.plugin MongoMapper::Plugins::Dirty
+      @book = @doc.create!(author_ids: [@author_id])
+    end
+
+    context "changed" do
+      it "should be empty if assigned the same array" do
+        @book.author_ids = [@author_id]
+        @book.changed.should be_empty
+      end
+
+      it "should be empty if assigned the same but before-typecasted array" do
+        @book.author_ids = [@author_id.to_s]
+        @book.changed.should be_empty
+      end
+    end
+  end
+
   context "Embedded documents" do
     before do
       @edoc = EDoc('Duck') { key :name, String }

data/spec/functional/dirty_with_callbacks_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'DirtyWithCallbacks' do
+  it 'should update its changes/previous_changes before after_create/after_update callbacks' do
+    history = {}
+
+    document = Doc {
+      key :x, String
+
+      after_save {
+        history[:after_save] = {
+          changes: changes,
+          previous_changes: previous_changes,
+        }
+      }
+      after_create {
+        history[:after_create] = {
+          changes: changes,
+          previous_changes: previous_changes,
+        }
+      }
+      after_update {
+        history[:after_update] = {
+          changes: changes,
+          previous_changes: previous_changes,
+        }
+      }
+    }
+
+    d = document.new(x: 'hello')
+    d.save
+
+    history.should == {
+      after_save: {
+        changes: {},
+        previous_changes: {'x' => [nil, 'hello']},
+      },
+      after_create: {
+        changes: {},
+        previous_changes: {'x' => [nil, 'hello']},
+      },
+    }
+    history.clear
+
+    d.x = 'world'
+    d.save!
+
+    history.should == {
+      after_save: {
+        changes: {},
+        previous_changes: {'x' => ['hello', 'world']},
+      },
+      after_update: {
+        changes: {},
+        previous_changes: {'x' => ['hello', 'world']},
+      },
+    }
+  end
+end

data/spec/functional/document_spec.rb

@@ -240,8 +240,8 @@ describe "Document" do
     end
 
     it "should reset many associations" do
-      expect(@instance.foos).to receive(:reset).at_least(1).times
-      expect(@instance.bars).to receive(:reset).at_least(1).times
+      @instance.foos.should_receive(:reset).at_least(1).times
+      @instance.bars.should_receive(:reset).at_least(1).times
       @instance.reload
     end
 
@@ -257,9 +257,6 @@ describe "Document" do
       @instance.bar.should_not be_nil
     end
 
-    it "should reset nil one association" do
-    end
-
     it "should reinstantiate embedded associations" do
       @instance.reload
       @instance.bars.first.name.should == '1'
@@ -271,7 +268,7 @@ describe "Document" do
 
     it "should raise DocumentNotFound if not found" do
       @instance.destroy
-      expect { @instance.reload }.to raise_error(MongoMapper::DocumentNotFound)
+      lambda { @instance.reload }.should raise_error(MongoMapper::DocumentNotFound)
     end
 
     it "should clear keys that were removed from the database" do
@@ -283,7 +280,7 @@ describe "Document" do
   context "database has keys not defined in model" do
     before do
       @id = BSON::ObjectId.new
-      @document.collection.insert({
+      @document.collection.insert_one({
         :_id            => @id,
         :first_name     => 'John',
         :last_name      => 'Nunemaker',
@@ -304,7 +301,7 @@ describe "Document" do
   end
 
   it "should not walk ObjectSpace when creating a model" do
-    expect(ObjectSpace).to receive(:each_object).never
+    ObjectSpace.should_receive(:each_object).never
     Doc()
   end
 end

data/spec/functional/dumpable_spec.rb

@@ -7,7 +7,7 @@ describe "Documents with the Dumpable plugin" do
   let(:store)  { ActiveSupport::Cache::MemoryStore.new(:size => 1.megabyte) }
 
   it "should be able to be marshalled" do
-    expect { Marshal.dump(answer) }.to_not raise_error
+    lambda { Marshal.dump(answer) }.should_not raise_error
   end
 
   it "should be able to be unmarshalled" do

data/spec/functional/embedded_document_spec.rb

@@ -227,7 +227,7 @@ describe "EmbeddedDocument" do
     person.pets << pet
     pet.should be_new
 
-    expect(person).to receive(:save!)
+    person.should_receive(:save!)
     pet.save!
   end
 
@@ -272,8 +272,8 @@ describe "EmbeddedDocument" do
     pet = person.pets.first
 
     attributes = {:name => 'koda'}
-    expect(pet).to receive(:attributes=).with(attributes)
-    expect(pet).to receive(:save!)
+    pet.should_receive(:attributes=).with(attributes)
+    pet.should_receive(:save!)
     pet.update_attributes!(attributes)
   end
 
@@ -288,8 +288,8 @@ describe "EmbeddedDocument" do
   end
 
   it "should not fail if the source document contains nils in the embedded document list" do
-    @klass.collection.insert(:pets => [nil, {:name => "Sasha"}])
-    expect { @klass.all.first.pets }.to_not raise_error
+    @klass.collection.insert_one(:pets => [nil, {:name => "Sasha"}])
+    lambda { @klass.all.first.pets }.should_not raise_error
     @klass.all.first.pets.tap do |pets|
       pets.length.should == 1
       pets[0].name.should == "Sasha"

data/spec/functional/identity_map_spec.rb

@@ -14,12 +14,12 @@ describe "IdentityMap" do
   end
 
   def expect_no_queries
-    expect_any_instance_of(Mongo::Collection).to receive(:find_one).never
-    expect_any_instance_of(Mongo::Collection).to receive(:find).never
+    Mongo::Collection.any_instance.should_receive(:find_one).never
+    Mongo::Collection.any_instance.should_receive(:find).never
   end
 
   def expects_one_query
-    expect_any_instance_of(Mongo::Collection).to receive(:find_one).once.and_return({})
+    Mongo::Collection.any_instance.should_receive(:find).once.and_call_original
   end
 
   def clear_identity_map
@@ -185,11 +185,11 @@ describe "IdentityMap" do
           key :created_at, Time
         end
 
-        expect do
+        lambda do
           loaded = person_with_time_class.load({'_id' => @id, 'name' => 'Frank', 'created_at' => '2014-12-07T20:36:45.529-08:00'}, true)
           loaded.should be_present
           loaded.created_at.should be_an_instance_of(Time)
-        end.to_not raise_error
+        end.should_not raise_error
       end
     end
 
@@ -420,7 +420,7 @@ describe "IdentityMap" do
           belongs_to :parent, :class_name => 'Item'
           one :blog, :class_name => 'Blog', :foreign_key => 'parent_id'
         end
-        Item.collection.remove
+        Item.collection.drop
 
         class ::Blog < ::Item; end
 
@@ -461,7 +461,7 @@ describe "IdentityMap" do
 
         blog = Blog.create(:title => 'Jill', :parent => root)
         assert_in_map(blog)
-        root.should equal(blog.parent.target)
+        root.should equal(blog.parent)
       end
 
       it "should work correctly with one proxy" do
@@ -470,7 +470,7 @@ describe "IdentityMap" do
 
         root = Item.create(:title => 'Root', :blog => blog)
         assert_in_map(root)
-        blog.should equal(root.blog.target)
+        blog.should equal(root.blog)
       end
 
       it "should work correctly with one proxy create" do

data/spec/functional/indexes_spec.rb

@@ -13,22 +13,25 @@ describe "Indexing" do
 
   context "against a known collection" do
     before do
-      allow(@document).to receive(:collection).and_return(double(:name => :foo))
+      @document.stub(:collection).and_return(double(:name => :foo, :indexes => double()))
     end
-    [:create_index, :ensure_index].each do |method|
-      it "should delegate #{method} to collection" do
-        expect(@document.collection).to receive(method).with(:arg, {})
-        @document.send(method, :arg)
-      end
+
+    it "should delegate create_index to collection#create_one" do
+      @document.collection.indexes.should_receive(:create_one).with({:arg => 1}, {})
+      @document.create_index(:arg)
     end
 
+    it "should delegate ensure_index to collection#create_one" do
+      @document.collection.indexes.should_receive(:create_one).with({:arg => 1}, {})
+      @document.create_index(:arg)
+    end
     it "should delegate drop_index to collection" do
-      expect(@document.collection).to receive(:drop_index).with(:arg)
+      @document.collection.indexes.should_receive(:drop_one).with(:arg)
       @document.drop_index(:arg)
     end
 
     it "should delegate drop_indexes to collection" do
-      expect(@document.collection).to receive(:drop_indexes)
+      @document.collection.indexes.should_receive(:drop_all)
       @document.drop_indexes
     end
   end
@@ -48,6 +51,11 @@ describe "Indexing" do
     @document.should have_index('last_name_1')
   end
 
+  it "should allow specifying as a hash" do
+    @document.ensure_index({last_name: -1})
+    @document.should have_index('last_name_-1')
+  end
+
   it "should allow creating unique index for a key" do
     @document.ensure_index :first_name, :unique => true
     @document.should have_index('fn_1')
@@ -55,18 +63,11 @@ describe "Indexing" do
 
   it "should allow creating index on multiple keys" do
     @document.ensure_index [[:first_name, 1], [:last_name, -1]]
-
-    # order is different for different versions of ruby so instead of
-    # just checking have_index('first_name_1_last_name_-1') I'm checking
-    # the values of the indexes to make sure the index creation was successful
-    @document.collection.index_information.detect do |index|
-      keys = index[0]
-      keys.include?('fn_1') && keys.include?('last_name_-1')
-    end.should_not be_nil
+    @document.should have_index('fn_1_last_name_-1')
   end
 
   it "should work with :index shortcut when defining key" do
-    silence_stderr { @document.key :father, String, :index => true }
+    suppress_stderr { @document.key :father, String, :index => true }
     @document.should have_index('father_1')
   end
-end
+end

data/spec/functional/keys_spec.rb

@@ -34,28 +34,46 @@ describe "Keys" do
     instance.foo.should == 'baz'
   end
 
-  context "when persisting an typecasted array" do
-    TypecastedKeyModel = Doc do
-      key :people, Array, :typecast => "Person"
-    end
-
+  context "when persisting typecasts" do
     Person = Struct.new(:name) do
       def self.to_mongo(value)
         value.name
       end
 
       def self.from_mongo(value)
-        Person.new value
+        new(value)
       end
     end
 
-    it "should not mutate the model's state" do
-      person = Person.new "Bob"
-      doc = TypecastedKeyModel.new(:people => [person])
+    context "when persisting a typecast Array" do
+      typecast_key_model = Doc do
+        key :people, Array, :typecast => "Person"
+      end
+
+      it "should not mutate the model's state" do
+        person = Person.new "Bob"
+        doc = typecast_key_model.new(:people => [person])
 
-      doc.save
+        doc.save!
+
+        doc.people.should == [person]
+      end
+    end
 
-      doc.people.should == [person]
+    context "when persisting a typecast Set" do
+      typecast_key_model = Doc do
+        key :people, Set, :typecast => "Person"
+      end
+
+      it "should not mutate the model's state" do
+        person = Person.new "Bob"
+
+        doc = typecast_key_model.new(:people => Set.new([person]))
+
+        doc.save!
+
+        doc.people.should == Set.new([person])
+      end
     end
   end
 
@@ -70,7 +88,7 @@ describe "Keys" do
       end
     end
 
-    expect { doc.new }.to_not raise_error
+    lambda { doc.new }.should_not raise_error
   end
 
   it "should not bomb if a key is read before Keys#initialize gets to get called" do
@@ -84,7 +102,7 @@ describe "Keys" do
       end
     end
 
-    expect { doc.new }.to_not raise_error
+    lambda { doc.new }.should_not raise_error
   end
 
   it "should permit for key overrides" do
@@ -93,7 +111,7 @@ describe "Keys" do
       key :class, String, :accessors => :skip
     end
 
-    doc.collection.insert('class' => 'String')
+    doc.collection.insert_one('class' => 'String')
     doc.all.first.tap do |d|
       d.class.should == doc
       d["class"].should == "String"
@@ -109,7 +127,7 @@ describe "Keys" do
     }
 
     before do
-      doc.collection.insert(:dynamic => "foo")
+      doc.collection.insert_one(:dynamic => "foo")
       doc.first
     end
 
@@ -129,7 +147,7 @@ describe "Keys" do
   describe "with invalid names" do
     it "should warn when key names start with an uppercase letter" do
       doc = Doc {}
-      expect(Kernel).to receive(:warn).once.with(/may not start with uppercase letters/)
+      Kernel.should_receive(:warn).once.with(/may not start with uppercase letters/)
       doc.class_eval do
         key :NotConstant
       end
@@ -137,30 +155,30 @@ describe "Keys" do
 
     it "should handle keys that start with uppercase letters by translating their first letter to lowercase" do
       doc = Doc {}
-      allow(Kernel).to receive(:warn)
+      Kernel.stub(:warn)
       doc.class_eval do
         key :NotConstant
       end
-      doc.collection.insert("NotConstant" => "Just data!")
+      doc.collection.insert_one("NotConstant" => "Just data!")
       doc.first.notConstant.should == "Just data!"
     end
 
     it "should not create accessors for bad keys" do
       doc = Doc {}
-      expect(doc).to_not receive(:create_accessors_for)
+      doc.should_not_receive(:create_accessors_for)
       doc.class_eval do
         key :"bad-name", :__dynamic => true
       end
-      expect { doc.new.method(:"bad-name") }.to raise_error(NameError)
+      lambda { doc.new.method(:"bad-name") }.should raise_error(NameError)
     end
 
     it "should not create accessors for reserved keys" do
       doc = Doc {}
-      expect(doc).to_not receive(:create_accessors_for)
+      doc.should_not_receive(:create_accessors_for)
       doc.class_eval do
         key :"class", :__dynamic => true
       end
-      expect(doc.new.class).to eq doc
+      doc.new.class.should == doc
     end
 
     it "should create accessors for good keys" do
@@ -168,13 +186,13 @@ describe "Keys" do
         key :good_name
       }
       doc.new.good_name.should be_nil
-      expect { doc.new.method("good_name") }.to_not raise_error
+      lambda { doc.new.method("good_name") }.should_not raise_error
     end
   end
 
   it "should handle loading dynamic fields from the database that have bad names" do
     doc = Doc {}
-    doc.collection.insert("foo-bar" => "baz-bin")
+    doc.collection.insert_one("foo-bar" => "baz-bin")
 
     doc.first["foo-bar"].should == "baz-bin"
   end
@@ -195,7 +213,7 @@ describe "Keys" do
       end
 
       it "should serialize with aliased keys" do
-        AliasedKeyModel.collection.find_one.keys.should =~ %w(_id f bar)
+        AliasedKeyModel.collection.find.first.keys.should =~ %w(_id f bar)
 
         AliasedKeyModel.first.tap do |d|
           d.foo.should == "whee!"
@@ -219,15 +237,15 @@ describe "Keys" do
       it "should permit dealiasing of atomic operations" do
         m = AliasedKeyModel.first
         m.set(:foo => 1)
-        AliasedKeyModel.collection.find_one["f"].should == 1
-        AliasedKeyModel.collection.find_one["foo"].should be_nil
+        AliasedKeyModel.collection.find.first["f"].should == 1
+        AliasedKeyModel.collection.find.first["foo"].should be_nil
       end
 
       it "should permit dealiasing of update operations" do
         m = AliasedKeyModel.first
         m.update_attributes(:foo => 1)
-        AliasedKeyModel.collection.find_one["f"].should == 1
-        AliasedKeyModel.collection.find_one["foo"].should be_nil
+        AliasedKeyModel.collection.find.first["f"].should == 1
+        AliasedKeyModel.collection.find.first["foo"].should be_nil
       end
 
       it "should not break when unaliasing non-keys" do
@@ -246,7 +264,7 @@ describe "Keys" do
       before { AliasedKeyModel.create(:with_underscores => "foobar") }
       it "should work" do
         AliasedKeyModel.first.with_underscores.should == "foobar"
-        AliasedKeyModel.collection.find_one["with-hyphens"].should == "foobar"
+        AliasedKeyModel.collection.find.first["with-hyphens"].should == "foobar"
       end
     end
 
@@ -254,7 +272,7 @@ describe "Keys" do
       before { AliasedKeyModel.create(:field_name => "foobar") }
       it "should work" do
         AliasedKeyModel.first.field_name.should == "foobar"
-        AliasedKeyModel.collection.find_one["alternate_field_name"].should == "foobar"
+        AliasedKeyModel.collection.find.first["alternate_field_name"].should == "foobar"
       end
     end
 
@@ -291,7 +309,7 @@ describe "Keys" do
         owner.reload
         owner.associated_documents.to_a.should =~ associated_documents.to_a
 
-        AssociatedKeyWithAlias.collection.find_one.keys.should =~ %w(_id n aid)
+        AssociatedKeyWithAlias.collection.find.first.keys.should =~ %w(_id n aid)
       end
 
       it "should work with embedded documents" do
@@ -301,7 +319,7 @@ describe "Keys" do
 
         owner.reload
         owner.other_documents[0].embedded_name.should == "Underling"
-        owner.collection.find_one["other_documents"][0]["en"].should == "Underling"
+        owner.collection.find.first["other_documents"][0]["en"].should == "Underling"
       end
     end
   end