mongo_mapper 0.13.1 → 0.14.0.rc1

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
@@ -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
@@ -495,12 +495,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
 
@@ -737,11 +737,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,20 +751,21 @@ 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
 
     it "should update the attribute without invoking validations" do
       document.key :name, String, :required => true
 
-      @doc.should_receive(:valid?).never
-      @doc.update_attribute('name', '').should be_true
+      expect(@doc).to receive(:valid?).never
+      @doc.update_attribute('name', '').should be_truthy
+
       @doc.reload.name.should == ''
       document.count.should == 1
     end
@@ -867,7 +868,7 @@ describe "Querying" do
 
     it "should insert invalid document" do
       doc = document.new
-      doc.should_receive(:valid?).never
+      expect(doc).to receive(:valid?).never
       doc.save(:validate => false)
       document.count.should == 1
     end

data/spec/functional/safe_spec.rb

@@ -67,7 +67,7 @@ describe "Safe" do
       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})
+          expect_any_instance_of(Mongo::Collection).to receive(:insert).once.with({'_id' => instance.id, 'email' => 'john@doe.com'}, {:w => 1})
           instance.save!
         end
 
@@ -122,7 +122,7 @@ describe "Safe" do
       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})
+          expect_any_instance_of(Mongo::Collection).to receive(:insert).once.with({'_id' => instance.id, 'email' => 'john@doe.com'}, {:j => true})
           instance.save!
         end
 

data/spec/functional/sci_spec.rb

@@ -3,7 +3,7 @@ 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)
+      expect(Mongo::MongoClient).to_not receive(:new)
       doc = Class.new
       doc.send(:include, MongoMapper::Document)
       expect {
@@ -49,7 +49,7 @@ describe "Single collection inheritance (document)" do
     end
 
     it "should automatically add _type key to store class" do
-      DocParent.key?(:_type).should be_true
+      DocParent.key?(:_type).should be_truthy
     end
 
     it "should use modifiers properly" do
@@ -323,7 +323,7 @@ describe "Single collection inheritance (document)" do
     end
 
     it "should automatically add _type key" do
-      Grandparent.key?(:_type).should be_true
+      Grandparent.key?(:_type).should be_truthy
     end
 
     context ".single_collection_inherited?" do

data/spec/functional/scopes_spec.rb

@@ -66,7 +66,7 @@ describe "Scopes" do
         @document.class_eval do
           scope :age,     lambda { |age| {:age => age} }
           scope :ages,    lambda { |low, high| {:age.gte => low, :age.lte => high} }
-          scope :ordered, lambda { |sort| sort(sort) }
+          scope :ordered, lambda { |s| sort(s) }
         end
       end
 
@@ -201,4 +201,237 @@ describe "Scopes" do
       end
     end
   end
+
+  describe "with_scope" do
+    describe "with a base query" do
+      before do
+        @klass = Doc do
+        end
+      end
+
+      it "should scope" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        run = false
+
+        @klass.with_scope(:first_name => "Scott") do
+          run = true
+          @klass.all.should == [u1]
+        end
+
+        run.should == true
+      end
+
+      it "should return the scope at the end of the block" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        run = false
+
+        @klass.with_scope(:first_name => "Scott") do
+          run = true
+          @klass.all.should == [u1]
+        end
+
+        run.should == true
+
+        @klass.all.should include(u1)
+        @klass.all.should include(u2)
+      end
+
+      it "should be able to use an unscoped query" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        run = false
+
+        @klass.with_scope(:first_name => "Scott") do
+          @klass.unscoped do
+            run = true
+            @klass.all.should include(u1)
+            @klass.all.should include(u2)
+          end
+
+          @klass.all.should == [u1]
+        end
+
+        run.should == true
+
+        @klass.all.should include(u1)
+        @klass.all.should include(u2)
+      end
+
+      it "should return the value of the block" do
+        u1 = @klass.create!(:first_name => "Scott")
+        u2 = @klass.create!(:first_name => "Andrew")
+
+        result = @klass.with_scope(:first_name => "Scott") do
+          @klass.all
+        end
+
+        result.should == [u1]
+      end
+
+      it "should have an empty list of default scope" do
+        @klass.default_scopes.should == []
+      end
+
+      it "should apply the default scope to all queries" do
+        @klass.key :active, Boolean, :default => true
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+
+        @klass.default_scope do
+          {
+            :active => true
+          }
+        end
+
+        @klass.all.should == [normal]
+      end
+
+      it "should allow multiple default scopes" do
+        @klass.key :active, Boolean, :default => true
+        @klass.key :soft_deleted, Boolean, :default => false
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+        deleted = @klass.create!(:soft_deleted => true)
+
+        @klass.default_scope do
+          {
+            :active => true,
+          }
+        end
+
+        @klass.default_scope do
+          {
+            :soft_deleted => false
+          }
+        end
+
+        @klass.all.should == [normal]
+      end
+
+      it "should allow a where inside a default_scope" do
+        @klass.key :active, Boolean, :default => true
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+
+        @klass.default_scope do
+          where(:active => true)
+        end
+
+        @klass.all.should == [normal]
+      end
+
+      it "should allow a hash directly" do
+        @klass.key :active, Boolean, :default => true
+
+        normal = @klass.create!
+        inactive = @klass.create!(:active => false)
+
+        @klass.default_scope :active => true
+
+        @klass.all.should == [normal]
+      end
+
+      it "should inherit default scopes, but only downwards" do
+        @klass.default_scope do
+          where(:active => true)
+        end
+        @subclass = Class.new(@klass)
+        @subclass.default_scopes.length.should == 1
+
+        @subclass.default_scope do
+          {
+            :foo => :bar
+          }
+        end
+
+        @subclass.default_scopes.length.should == 2
+        @klass.default_scopes.length.should == 1
+      end
+    end
+  end
+
+  describe "regression - multiple named scopes" do
+    it "should merge the hashes from multiple scopes" do
+      klass = Doc do
+        key :a, Boolean
+        key :b, Boolean
+        key :c, Boolean
+
+        scope :one, where(:a => true, :b => true)
+        scope :two, where(:c => true)
+      end
+
+      obj = klass.create!(:a => false, :b => true, :c => true)
+      klass.one.two.all.should == []
+
+      obj2 = klass.create(:a => true, :b => true, :c => true)
+      klass.one.two.all.should == [obj2]
+    end
+  end
+
+  describe "regression - with multiple scopes that set a key to nil" do
+    it "should still have the query as nil" do
+      klass = Doc do
+        key :a, Boolean
+
+        scope :one, lambda {
+          {
+            :a => nil
+          }
+        }
+        scope :two, lambda {
+          {
+            :a => nil
+          }
+        }
+      end
+
+      obj = klass.create!(:a => nil)
+      klass.one.two.all.should == [obj]
+    end
+  end
+
+  describe "regression - multiple scopes leading to empty query (array bug?)" do
+    before do
+      @klass = Doc do
+        key :send_at, Time
+
+        scope :unsent, lambda {
+          now = Time.now
+
+          {
+            send_at: {
+              '$lte' => now,
+              '$gte' => now - 30.days,
+            },
+            sent_at: nil,
+          }
+        }
+
+        scope :sorted, lambda {
+          sort(send_at: 1)
+        }
+      end
+    end
+
+    it "should filter properly by dates" do
+      old_obj = @klass.create(send_at: 3.months.ago)
+      one_day_ago = @klass.create(send_at: 1.day.ago)
+      two_days_ago = @klass.create(send_at: 2.days.ago)
+
+      all_unsorted = @klass.unsent.all
+
+      all_unsorted.should include(one_day_ago)
+      all_unsorted.should include(two_days_ago)
+      @klass.unsent.sorted.all.should == [two_days_ago, one_day_ago]
+    end
+  end
 end