mongo_mapper 0.13.0 → 0.15.1

data/spec/functional/protected_spec.rb

@@ -44,12 +44,12 @@ describe 'A document with protected attributes' do
 
   it "should assign protected attribute through accessor" do
     @doc.admin = true
-    @doc.admin.should be_true
+    @doc.admin.should be_truthy
   end
 
   it "should ignore protected attribute on #initialize" do
     doc = @doc_class.new(:name => 'John', :admin => true)
-    doc.admin.should be_false
+    doc.admin.should be_falsey
     doc.name.should == 'John'
   end
 
@@ -59,7 +59,7 @@ describe 'A document with protected attributes' do
     doc.save!
 
     doc = @doc_class.first(:name => 'John')
-    doc.admin.should be_true
+    doc.admin.should be_truthy
     doc.name.should == 'John'
   end
 
@@ -69,37 +69,37 @@ describe 'A document with protected attributes' do
     doc.save!
 
     doc.reload
-    doc.admin.should be_true
+    doc.admin.should be_truthy
     doc.name.should == 'John'
   end
 
   it "should ignore protected attribute on #update_attribute" do
     @doc.update_attribute('admin', true)
-    @doc.admin.should be_true
+    @doc.admin.should be_truthy
   end
 
   it "should ignore protected attribute on #update_attributes" do
     @doc.update_attributes(:name => 'Ren Hoek', :admin => true)
     @doc.name.should == 'Ren Hoek'
-    @doc.admin.should be_false
+    @doc.admin.should be_falsey
   end
 
   it "should ignore protected attribute on #update_attributes!" do
     @doc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
     @doc.name.should == 'Stimpson J. Cat'
-    @doc.admin.should be_false
+    @doc.admin.should be_falsey
   end
 
   it "should ignore protecteds attribute on #attributes=" do
     @doc.attributes = {:name => 'Stimpson J. Cat', :admin => true}
     @doc.name.should == 'Stimpson J. Cat'
-    @doc.admin.should be_false
+    @doc.admin.should be_falsey
   end
 
   it "should be indifferent to whether the protected keys are strings or symbols" do
     @doc.update_attributes!("name" => 'Stimpson J. Cat', "admin" => true)
     @doc.name.should == 'Stimpson J. Cat'
-    @doc.admin.should be_false
+    @doc.admin.should be_falsey
   end
 
   it "should accept nil as constructor's argument without raising exception" do
@@ -115,7 +115,7 @@ describe "Single collection inherited protected attributes" do
       key :site_id, ObjectId
       attr_protected :site_id
     end
-    GrandParent.collection.remove
+    GrandParent.collection.drop
 
     class ::Child < ::GrandParent
       key :position, Integer
@@ -177,23 +177,23 @@ describe 'An embedded document with protected attributes' do
 
   it "should assign protected attribute through accessor" do
     @edoc.admin = true
-    @edoc.admin.should be_true
+    @edoc.admin.should be_truthy
   end
 
   it "should not ignore protected attribute on #update_attribute" do
     @edoc.update_attribute('admin', true)
-    @edoc.admin.should be_true
+    @edoc.admin.should be_truthy
   end
 
   it "should ignore protected attribute on #update_attributes" do
     @edoc.update_attributes(:name => 'Ren Hoek', :admin => true)
     @edoc.name.should == 'Ren Hoek'
-    @edoc.admin.should be_false
+    @edoc.admin.should be_falsey
   end
 
   it "should ignore protected attribute on #update_attributes!" do
     @edoc.update_attributes!(:name => 'Stimpson J. Cat', :admin => true)
     @edoc.name.should == 'Stimpson J. Cat'
-    @edoc.admin.should be_false
+    @edoc.admin.should be_falsey
   end
 end

data/spec/functional/querying_spec.rb

@@ -55,7 +55,7 @@ describe "Querying" do
     end
 
     it "should no longer be new?" do
-      doc.new?.should be_false
+      doc.new?.should be_falsey
     end
 
     it "should return instance of document" do
@@ -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
 
@@ -495,12 +517,12 @@ describe "Querying" do
 
   context ".empty?" do
     it "should be true if no documents" do
-      document.empty?.should be_true
+      document.empty?.should be_truthy
     end
 
     it "should be false if documents present" do
       @doc = document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
-      document.empty?.should be_false
+      document.empty?.should be_falsey
     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
@@ -737,11 +785,11 @@ describe "Querying" do
     end
 
     it "should be true if document valid" do
-      document.new.update_attributes(:foo => 'bar').should be_true
+      document.new.update_attributes(:foo => 'bar').should be_truthy
     end
 
     it "should be false if document not valid" do
-      document.new.update_attributes({}).should be_false
+      document.new.update_attributes({}).should be_falsey
     end
   end
 
@@ -751,12 +799,12 @@ describe "Querying" do
     end
 
     it "should accept symbols as keys" do
-      @doc.update_attribute(:first_name, 'Chris').should be_true
+      @doc.update_attribute(:first_name, 'Chris').should be_truthy
       @doc.reload.first_name.should == 'Chris'
     end
 
     it "should update the attribute" do
-      @doc.update_attribute('first_name', 'Chris').should be_true
+      @doc.update_attribute('first_name', 'Chris').should be_truthy
       @doc.reload.first_name.should == 'Chris'
     end
 
@@ -764,7 +812,8 @@ describe "Querying" do
       document.key :name, String, :required => true
 
       @doc.should_receive(:valid?).never
-      @doc.update_attribute('name', '').should be_true
+      @doc.update_attribute('name', '').should be_truthy
+
       @doc.reload.name.should == ''
       document.count.should == 1
     end
@@ -884,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
 
@@ -905,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')
-          Mongo::Collection.any_instance.should_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')
-          Mongo::Collection.any_instance.should_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