mongo_mapper 0.14.0 → 0.15.1

data/spec/functional/querying_spec.rb

@@ -164,7 +164,7 @@ describe "Querying" do
     end
 
     it "should raise document not found if nothing provided for find!" do
-      expect { document.find! }.to raise_error(MongoMapper::DocumentNotFound)
+      lambda { document.find! }.should raise_error(MongoMapper::DocumentNotFound)
     end
 
     context "(with a single id)" do
@@ -177,7 +177,7 @@ describe "Querying" do
       end
 
       it "should raise error if document not found with find!" do
-        expect { document.find!(123) }.to raise_error(MongoMapper::DocumentNotFound)
+        lambda { document.find!(123) }.should raise_error(MongoMapper::DocumentNotFound)
       end
     end
 
@@ -203,15 +203,15 @@ describe "Querying" do
       end
 
       it "should raise error if not all found when using find!" do
-        expect {
+        lambda {
           document.find!(@doc1._id, BSON::ObjectId.new.to_s)
-        }.to raise_error(MongoMapper::DocumentNotFound)
+        }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
       it "should raise error if not all found when using find!" do
-        expect {
+        lambda {
           document.find!([@doc1._id, BSON::ObjectId.new.to_s])
-        }.to raise_error(MongoMapper::DocumentNotFound)
+        }.should raise_error(MongoMapper::DocumentNotFound)
       end
 
       it "should return array if array with one element" do
@@ -219,6 +219,16 @@ describe "Querying" do
       end
     end
 
+    context "(with array of single id)" do
+      it "should return an array" do
+        document.find([@doc1._id]).should == [@doc1]
+      end
+
+      it "should return an array for find!" do
+        document.find!([@doc1._id]).should == [@doc1]
+      end
+    end
+
     it "should be able to find using condition auto-detection" do
       document.first(:first_name => 'John').should == @doc1
       document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
@@ -255,6 +265,18 @@ describe "Querying" do
         document.find_each(:last_name => 'Nunemaker', :order => 'age desc') {|doc| yield_documents << doc }
         yield_documents.should == [@doc1, @doc3]
       end
+
+      it "should return an enumerator when no block is given" do
+        yield_documents = []
+        enum = document.find_each(:order => "first_name")
+        enum.with_index {|doc, idx| yield_documents << [doc, idx] }
+        yield_documents.should == [[@doc1, 0], [@doc3, 1], [@doc2, 2]]
+
+        yield_documents = []
+        enum = document.find_each(:last_name => 'Nunemaker', :order => 'age desc')
+        enum.with_index {|doc, idx| yield_documents << [doc, idx] }
+        yield_documents.should == [[@doc1, 0], [@doc3, 1]]
+      end
     end
   end # finding documents
 
@@ -292,12 +314,12 @@ describe "Querying" do
     end
 
     it "should disregard non-keys when creating, but use them in the query" do
-      expect {
+      lambda {
         document.create(:first_name => 'John', :age => 9)
         lambda {
           document.first_or_create(:first_name => 'John', :age.gt => 10).first_name.should == 'John'
         }.should change { document.count }.by(1)
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 
@@ -320,10 +342,10 @@ describe "Querying" do
     end
 
     it "should disregard non-keys when initializing, but use them in the query" do
-      expect {
+      lambda {
         document.create(:first_name => 'John', :age => 9)
         document.first_or_new(:first_name => 'John', :age.gt => 10).first_name.should == 'John'
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 
@@ -616,6 +638,32 @@ describe "Querying" do
     it "should be chainable" do
       @query.sort(:age).all.map(&:age).should == [26, 27, 28]
     end
+
+    it "supports hash" do
+      @query = document.fields({:age => 0})
+      docs = @query.all
+      docs.should include(@doc1)
+      docs.should include(@doc3)
+      docs.should include(@doc2)
+      docs.each do |doc|
+        doc.age.should              be_nil # key was not loaded
+        doc.first_name.should_not   be_nil
+        doc.last_name.should_not    be_nil # key was not loaded
+      end
+    end
+
+    it "supports array" do
+      @query = document.fields([:age,:first_name])
+      docs = @query.all
+      docs.should include(@doc1)
+      docs.should include(@doc3)
+      docs.should include(@doc2)
+      docs.each do |doc|
+        doc.age.should_not          be_nil
+        doc.first_name.should_not   be_nil
+        doc.last_name.should        be_nil # key was not loaded
+      end
+    end
   end
 
   context ".limit" do
@@ -763,7 +811,7 @@ describe "Querying" do
     it "should update the attribute without invoking validations" do
       document.key :name, String, :required => true
 
-      expect(@doc).to receive(:valid?).never
+      @doc.should_receive(:valid?).never
       @doc.update_attribute('name', '').should be_truthy
 
       @doc.reload.name.should == ''
@@ -868,7 +916,7 @@ describe "Querying" do
 
     it "should insert invalid document" do
       doc = document.new
-      expect(doc).to receive(:valid?).never
+      doc.should_receive(:valid?).never
       doc.save(:validate => false)
       document.count.should == 1
     end
@@ -885,15 +933,15 @@ describe "Querying" do
 
     it "should allow passing safe" do
       @document.create(:name => 'John')
-      expect {
+      lambda {
         @document.new(:name => 'John').save(:safe => true)
-      }.to raise_error(Mongo::OperationFailure)
+      }.should raise_error(Mongo::Error::OperationFailure)
     end
 
     it "should raise argument error if options has unsupported key" do
-      expect {
+      lambda {
         @document.new.save(:foo => true)
-      }.to raise_error(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
   end
 
@@ -906,21 +954,21 @@ describe "Querying" do
 
     it "should allow passing safe" do
       @document.create(:name => 'John')
-      expect {
+      lambda {
         @document.new(:name => 'John').save!(:safe => true)
-      }.to raise_error(Mongo::OperationFailure)
+      }.should raise_error(Mongo::Error::OperationFailure)
     end
 
     it "should raise argument error if options has unsupported key" do
-      expect {
+      lambda {
         @document.new.save!(:foo => true)
-      }.to raise_error(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
 
     it "should raise argument error if using validate as that would be pointless with save!" do
-      expect {
+      lambda {
         @document.new.save!(:validate => false)
-      }.to raise_error(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
   end
 

data/spec/functional/safe_spec.rb

@@ -42,7 +42,7 @@ describe "Safe" do
 
     it "should not raise an error on duplicate IDs" do
       k = @klass.create
-      expect { j = @klass.create(:_id => k.id) }.to_not raise_error
+      lambda { j = @klass.create(:_id => k.id) }.should_not raise_error
     end
   end
 
@@ -61,46 +61,44 @@ describe "Safe" do
 
       it "should raise an error on duplicate IDs" do
         k = @klass.create
-        expect { j = @klass.create(:_id => k.id) }.to raise_error(Mongo::OperationFailure)
+        lambda { j = @klass.create(:_id => k.id) }.should raise_error(Mongo::Error::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')
-          expect_any_instance_of(Mongo::Collection).to receive(:insert).once.with({'_id' => instance.id, 'email' => 'john@doe.com'}, {:w => 1})
-          instance.save!
+        it "should pass :w => 1 option to the collection" do
+          @klass.collection.write_concern.options.should == { w: 1 }
         end
 
         it "should work fine when all is well" do
-          expect {
+          lambda {
             @klass.new(:email => 'john@doe.com').save
-          }.to_not raise_error
+          }.should_not raise_error
         end
 
         it "should raise error when operation fails" do
-          expect {
+          lambda {
             2.times do
               @klass.new(:email => 'john@doe.com').save
             end
-          }.to raise_error(Mongo::OperationFailure)
+          }.should raise_error(Mongo::Error::OperationFailure)
         end
       end
 
       context "overriding safe setting" do
         it "should raise error if safe is true" do
-          expect {
+          lambda {
             2.times do
               @klass.new(:email => 'john@doe.com').save(:safe => true)
             end
-          }.to raise_error(Mongo::OperationFailure)
+          }.should raise_error(Mongo::Error::OperationFailure)
         end
 
         it "should not raise error if safe is false" do
-          expect {
+          lambda {
             2.times do
               @klass.new(:email => 'john@doe.com').save(:safe => false)
             end
-          }.to_not raise_error
+          }.should_not raise_error
         end
       end
     end
@@ -120,44 +118,42 @@ describe "Safe" do
       end
 
       context "using safe setting from class" do
-        it "should pass :safe => options_hash to save" do
-          instance = @klass.new(:email => 'john@doe.com')
-          expect_any_instance_of(Mongo::Collection).to receive(:insert).once.with({'_id' => instance.id, 'email' => 'john@doe.com'}, {:j => true})
-          instance.save!
+        it "should pass :safe => options_hash to the collection" do
+          @klass.collection.write_concern.options.should == { j: true }
         end
 
         it "should work fine when all is well" do
-          expect {
+          lambda {
             @klass.new(:email => 'john@doe.com').save
-          }.to_not raise_error
+          }.should_not raise_error
         end
 
         it "should raise error when operation fails" do
-          expect {
+          lambda {
             2.times do
               @klass.new(:email => 'john@doe.com').save
             end
-          }.to raise_error(Mongo::OperationFailure)
+          }.should raise_error(Mongo::Error::OperationFailure)
         end
       end
 
       context "overriding safe setting" do
         it "should raise error if safe is true" do
-          expect {
+          lambda {
             2.times do
               @klass.new(:email => 'john@doe.com').save(:safe => true)
             end
-          }.to raise_error(Mongo::OperationFailure)
+          }.should raise_error(Mongo::Error::OperationFailure)
         end
 
         it "should not raise error if safe is false" do
-          expect {
+          lambda {
             2.times do
               @klass.new(:email => 'john@doe.com').save(:safe => false)
             end
-          }.to_not raise_error
+          }.should_not raise_error
         end
       end
     end
   end
-end
+end

data/spec/functional/sci_spec.rb

@@ -3,12 +3,12 @@ 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
-      expect(Mongo::MongoClient).to_not receive(:new)
+      Mongo::Client.should_not_receive(:new)
       doc = Class.new
       doc.send(:include, MongoMapper::Document)
-      expect {
+      lambda {
         Class.new(doc)
-      }.to_not raise_error
+      }.should_not raise_error
     end
 
     it "should pick up a connection if one wasn't set" do
@@ -17,7 +17,7 @@ describe "Single collection inheritance (document)" do
       klass = Class.new(doc)
       klass.connection.should be_nil
       MongoMapper.connection
-      klass.connection.should be_a Mongo::MongoClient
+      klass.connection.should be_a Mongo::Client
     end
   end
 
@@ -27,7 +27,7 @@ describe "Single collection inheritance (document)" do
         include MongoMapper::Document
         key :name, String
       end
-      DocParent.collection.remove
+      DocParent.collection.drop
 
       class ::DocDaughter < ::DocParent; end
       class ::DocSon < ::DocParent; end
@@ -61,7 +61,7 @@ describe "Single collection inheritance (document)" do
     it "should use the same connection in the subclass" do
       parent_class = Class.new do
         include MongoMapper::Document
-        connection Mongo::MongoClient.new
+        connection Mongo::Client.new(['127.0.0.1:27017'])
       end
 
       child_class = Class.new(parent_class) do
@@ -377,4 +377,4 @@ describe "Single collection inheritance (document)" do
       p.reload.article_parent.sci_polymorphic_posts.all.should include(p)
     end
   end
-end
+end

data/spec/functional/scopes_spec.rb

@@ -170,7 +170,7 @@ describe "Scopes" do
           key   :title, String
           key   :published_at, Time
         end
-        Item.collection.remove
+        Item.collection.drop
 
         class ::Page < ::Item; end
         class ::Blog < ::Item

data/spec/functional/static_keys_spec.rb

@@ -92,7 +92,7 @@ describe MongoMapper::Plugins::Keys::Static do
     end
 
     it "should not blow up when loading if there is a key defined in the db that has not been defined (but it should not load it)" do
-      @klass.collection.insert({ :foo => "bar", :valid_key => "something" })
+      @klass.collection.insert_one({ :foo => "bar", :valid_key => "something" })
       @obj = @klass.first
       @obj.valid_key.should == "something"
 
@@ -147,7 +147,7 @@ describe MongoMapper::Plugins::Keys::Static do
 
       lambda {
         @static_key_object['foo'] = 'bar'
-      }.should raise_error
+      }.should raise_error(MongoMapper::Plugins::Keys::Static::MissingKeyError)
     end
   end
 end

data/spec/functional/stats_spec.rb

@@ -13,7 +13,11 @@ describe "Stats" do
 
   context "with no documents present" do
     it "should return nil" do
-      expect(Docs.stats).to eq(nil)
+      if Docs.stats == nil
+        Docs.stats.should == nil
+      else
+        Docs.stats['count'].should == 0
+      end
     end
   end
 
@@ -23,48 +27,60 @@ describe "Stats" do
       Docs.create!
     end
 
+    def get_stats
+      MongoMapper.database.command(:collstats => 'docs').documents[0]
+    end
+
     it "should have the correct count" do
-      expect(Docs.stats.count).to eq(Docs.collection.stats['count'])
+      Docs.stats.count.should == get_stats['count']
     end
 
     it "should have the correct namespace" do
-      expect(Docs.stats.ns).to eq(Docs.collection.stats['ns'])
+      Docs.stats.ns.should == get_stats['ns']
     end
 
     it "should have the correct size" do
-      expect(Docs.stats.size).to eq(Docs.collection.stats['size'])
+      Docs.stats.size.should == get_stats['size']
     end
 
     it "should have the correct storage size" do
-      expect(Docs.stats.storage_size).to eq(Docs.collection.stats['storageSize'])
+      Docs.stats.storage_size.should == get_stats['storageSize']
     end
 
     it "should have the correct average object size" do
-      expect(Docs.stats.avg_obj_size).to eq(Docs.collection.stats['avgObjSize'])
+      Docs.stats.avg_obj_size.should == get_stats['avgObjSize']
     end
 
     it "should have the correct number of extents" do
-      expect(Docs.stats.num_extents).to eq(Docs.collection.stats['numExtents'])
+      if get_stats['numExtents']
+        Docs.stats.num_extents.should == get_stats['numExtents']
+      end
     end
 
     it "should have the correct number of indexes" do
-      expect(Docs.stats.nindexes).to eq(Docs.collection.stats['nindexes'])
+      Docs.stats.nindexes.should == get_stats['nindexes']
     end
 
     it "should have the correct last extent size" do
-      expect(Docs.stats.last_extent_size).to eq(Docs.collection.stats['lastExtentSize'])
+      if get_stats['lastExtentSize']
+        Docs.stats.last_extent_size.should == get_stats['lastExtentSize']
+      end
     end
 
     it "should have the correct padding factor" do
-      expect(Docs.stats.padding_factor).to eq(Docs.collection.stats['paddingFactor'])
+      if get_stats['paddingFactor']
+        Docs.stats.padding_factor.should == get_stats['paddingFactor']
+      end
     end
 
     it "should have the correct user flags" do
-      expect(Docs.stats.user_flags).to eq(Docs.collection.stats['userFlags'])
+      if get_stats['userFlags']
+        Docs.stats.user_flags.should == get_stats['userFlags']
+      end
     end
 
     it "should have the correct total index size" do
-      expect(Docs.stats.total_index_size).to eq(Docs.collection.stats['totalIndexSize'])
+      Docs.stats.total_index_size.should == get_stats['totalIndexSize']
     end
   end
 end

data/spec/functional/strong_parameters_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "Strong parameters" do
+  context 'A document with strong parameters protection' do
+    if ::ActiveModel.const_defined?(:ForbiddenAttributesProtection)
+      require "action_controller/metal/strong_parameters"
+
+      before do
+        @doc_class = Doc do
+          plugin MongoMapper::Plugins::StrongParameters
+
+          key :name, String
+          key :admin, Boolean, :default => false
+        end
+
+        @doc = @doc_class.create(:name => 'Steve Sloan')
+      end
+
+      let(:params) {
+        {name: "Permitted", admin: true}
+      }
+
+      let(:strong_params) {
+        ActionController::Parameters.new params
+      }
+
+      it "allows assignment of attribute hashes" do
+        @doc.attributes = params
+        @doc.name.should =="Permitted"
+      end
+
+      it "doesn't allow mass assignment of ActionController::Parameters" do
+        lambda {
+          @doc.attributes = strong_params
+        }.should raise_error(ActiveModel::ForbiddenAttributesError)
+      end
+
+      it "does not allow mass assignment of non-permitted attributes" do
+        @doc.attributes = strong_params.permit(:name)
+        @doc.admin.should == false
+      end
+
+      it "allows mass assignment of permitted attributes" do
+        @doc.attributes = strong_params.permit(:name)
+        @doc.name.should == "Permitted"
+      end
+    end
+  end
+end

data/spec/functional/validations_spec.rb

@@ -157,8 +157,7 @@ describe "Validations" do
       doc = @document.new("name" => "joe")
       doc.save.should be_truthy
 
-      allow(@document).to \
-        receive(:first).
+      @document.stub(:first).
         with(:name => 'joe').
         and_return(doc)
 
@@ -171,8 +170,7 @@ describe "Validations" do
       doc = @document.new("name" => "joe")
       doc.save.should be_truthy
 
-      allow(@document).to \
-        receive(:first).
+      @document.stub(:first).
         with(:name => 'joe').
         and_return(doc)
 
@@ -189,8 +187,7 @@ describe "Validations" do
       doc = document.new("name" => "")
       doc.save.should be_truthy
 
-      allow(@document).to \
-        receive(:first).
+      @document.stub(:first).
         with(:name => '').
         and_return(doc)
 
@@ -272,8 +269,7 @@ describe "Validations" do
         doc = @document.new("name" => "joe", "scope" => "one")
         doc.save.should be_truthy
 
-        allow(@document).to \
-          receive(:first).
+        @document.stub(:first).
           with(:name => 'joe', :scope => "one").
           and_return(doc)
 
@@ -285,8 +281,7 @@ describe "Validations" do
         doc = @document.new("name" => "joe", "scope" => "one")
         doc.save.should be_truthy
 
-        allow(@document).to \
-          receive(:first).
+        @document.stub(:first).
           with(:name => 'joe', :scope => 'two').
           and_return(nil)
 
@@ -309,8 +304,7 @@ describe "Validations" do
         doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
         doc.save.should be_truthy
 
-        allow(@document).to \
-          receive(:first).
+        @document.stub(:first).
           with(:name => 'joe', :first_scope => 'one', :second_scope => 'two').
           and_return(doc)
 
@@ -322,8 +316,7 @@ describe "Validations" do
         doc = @document.new("name" => "joe", "first_scope" => "one", "second_scope" => "two")
         doc.save.should be_truthy
 
-        allow(@document).to \
-          receive(:first).
+        @document.stub(:first).
           with(:name => 'joe', :first_scope => 'one', :second_scope => 'one').
           and_return(nil)
 
@@ -403,8 +396,7 @@ describe "Validations" do
   #     doc = @document.create(:name => 'John')
   #     doc.should_not have_error_on(:name)
   #
-  #     allow(@document).to \
-  #       receive(:first).
+  #     @document.stub(:first).
   #       with(:name => 'John').
   #       and_return(doc)
   #

data/spec/quality_spec.rb

@@ -46,6 +46,6 @@ describe "The library itself" do
         error_messages << check_for_extra_spaces(filename)
       end
     end
-    expect(error_messages.compact).to be_well_formed
+    error_messages.compact.should be_well_formed
   end
 end