mongoid 3.1.6 → 4.0.2

data/spec/mongoid/{reloading_spec.rb → reloadable_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Reloading do
+describe Mongoid::Reloadable do
 
   describe "#reload" do
 
@@ -19,11 +19,11 @@ describe Mongoid::Reloading do
 
       it "reloads the object attributes from the db" do
         person.reload
-        person.age.should eq(35)
+        expect(person.age).to eq(35)
       end
 
       it "reload should return self" do
-        person.reload.should eq(from_db)
+        expect(person.reload).to eq(from_db)
       end
     end
 
@@ -42,11 +42,11 @@ describe Mongoid::Reloading do
 
       it "reloads the object attributes from the db" do
         account.reload
-        account.number.should eq("1001")
+        expect(account.number).to eq("1001")
       end
 
       it "reload should return self" do
-        account.reload.should eq(from_db)
+        expect(account.reload).to eq(from_db)
       end
     end
 
@@ -62,7 +62,7 @@ describe Mongoid::Reloading do
       end
 
       it "runs the callback" do
-        book.chapters.should eq(5)
+        expect(book.chapters).to eq(5)
       end
     end
 
@@ -78,11 +78,11 @@ describe Mongoid::Reloading do
       end
 
       it "resets the dirty modifications" do
-        person.changes.should be_empty
+        expect(person.changes).to be_empty
       end
 
       it "resets attributes_before_type_cast" do
-        person.attributes_before_type_cast.should be_empty
+        expect(person.attributes_before_type_cast).to be_empty
       end
     end
 
@@ -123,15 +123,15 @@ describe Mongoid::Reloading do
           end
 
           it "reloads the embedded document attributes" do
-            reloaded.number.should eq(3)
+            expect(reloaded.number).to eq(3)
           end
 
           it "reloads the reference on the parent" do
-            person.addresses.first.should eq(reloaded)
+            expect(person.addresses.first).to eq(reloaded)
           end
 
           it "retains the relation to the parent" do
-            reloaded.addressable.should eq(person)
+            expect(reloaded.addressable).to eq(person)
           end
         end
 
@@ -151,15 +151,15 @@ describe Mongoid::Reloading do
           end
 
           it "reloads the embedded document attributes" do
-            reloaded.last_name.should eq("Vicious")
+            expect(reloaded.last_name).to eq("Vicious")
           end
 
           it "reloads the reference on the parent" do
-            person.name.should eq(reloaded)
+            expect(person.name).to eq(reloaded)
           end
 
           it "retains the relation to the parent" do
-            reloaded.namable.should eq(person)
+            expect(reloaded.namable).to eq(person)
           end
         end
       end
@@ -184,15 +184,15 @@ describe Mongoid::Reloading do
         end
 
         it "reloads the embedded document attributes" do
-          reloaded.name.should eq("work")
+          expect(reloaded.name).to eq("work")
         end
 
         it "reloads the reference on the parent" do
-          address.locations.first.should eq(reloaded)
+          expect(address.locations.first).to eq(reloaded)
         end
 
         it "reloads the reference on the root" do
-          person.addresses.first.locations.first.should eq(reloaded)
+          expect(person.addresses.first.locations.first).to eq(reloaded)
         end
       end
     end
@@ -214,7 +214,7 @@ describe Mongoid::Reloading do
       end
 
       it "reloads the association" do
-        person.addresses.should be_empty
+        expect(person.addresses).to be_empty
       end
     end
 
@@ -237,7 +237,7 @@ describe Mongoid::Reloading do
         end
 
         it "reloads the association" do
-          person.game.score.should eq(75)
+          expect(person.game.score).to eq(75)
         end
       end
 
@@ -256,49 +256,32 @@ describe Mongoid::Reloading do
           end
 
           it "reloads the association" do
-            game.person.title.should eq("Mam")
+            expect(game.person.title).to eq("Mam")
           end
         end
+      end
+    end
 
-        context "when the identity map is enabled" do
-
-          before do
-            Mongoid.identity_map_enabled = true
-          end
-
-          after do
-            Mongoid.identity_map_enabled = false
-          end
-
-          context "when the relation type changes" do
-
-            let!(:doctor) do
-              Doctor.create
-            end
-
-            let!(:game) do
-              Game.create(:person => doctor)
-            end
-
-            before do
-              doctor.becomes(Doktor)
-            end
+    context "when overriding #id alias" do
 
-            context "when reloading the base" do
+      let!(:object) do
+        IdKey.create(key: 'foo')
+      end
 
-              it "reloads the correct type of document" do
-                game.reload.person.should be_a(Doktor)
-              end
-            end
+      let!(:from_db) do
+        IdKey.find(object._id).tap do |object|
+          object.key = 'bar'
+          object.save
+        end
+      end
 
-            context "when reloading the association" do
+      it "reloads the object attributes from the db" do
+        object.reload
+        expect(object.key).to eq('bar')
+      end
 
-              it "reloads the correct type of document" do
-                game.person(true).should be_a(Doktor)
-              end
-            end
-          end
-        end
+      it "reload should return self" do
+        expect(object.reload).to eq(from_db)
       end
     end
   end

data/spec/mongoid/{scoping_spec.rb → scopable_spec.rb}

@@ -1,32 +1,9 @@
 require "spec_helper"
 
-describe Mongoid::Scoping do
+describe Mongoid::Scopable do
 
   describe ".default_scope" do
 
-    context "when provided a criteria" do
-
-      let(:criteria) do
-        Band.where(name: "Depeche Mode")
-      end
-
-      before do
-        Band.default_scope criteria
-      end
-
-      after do
-        Band.default_scoping = nil
-      end
-
-      it "adds the default scope to the class" do
-        Band.default_scoping.call.should eq(criteria)
-      end
-
-      it "flags as being default scoped" do
-        Band.should be_default_scoping
-      end
-    end
-
     context "when provided a proc" do
 
       let(:criteria) do
@@ -42,15 +19,15 @@ describe Mongoid::Scoping do
       end
 
       it "adds the default scope to the class" do
-        Band.default_scoping.call.should eq(criteria)
+        expect(Band.default_scoping.call).to eq(criteria)
       end
 
       it "flags as being default scoped" do
-        Band.should be_default_scoping
+        expect(Band).to be_default_scoping
       end
     end
 
-    context "when provided a non proc or criteria" do
+    context "when provided a non proc" do
 
       it "raises an error" do
         expect {
@@ -62,11 +39,11 @@ describe Mongoid::Scoping do
     context "when there is more then one default_scope" do
 
       let(:criteria) do
-        Band.where(name: "Depeche Mode")
+        ->{ Band.where(name: "Depeche Mode") }
       end
 
       let(:additional_criteria) do
-        Band.where(origin: "England")
+        ->{ Band.where(origin: "England") }
       end
 
       let(:proc_criteria) do
@@ -89,23 +66,23 @@ describe Mongoid::Scoping do
       end
 
       it "adds the first default scope" do
-        Band.default_scoping.call.selector["name"].should eq("Depeche Mode")
+        expect(Band.default_scoping.call.selector["name"]).to eq("Depeche Mode")
       end
 
       it "adds the additional default scope" do
-        Band.default_scoping.call.selector["origin"].should eq("England")
+        expect(Band.default_scoping.call.selector["origin"]).to eq("England")
       end
 
       it "adds the proc default scope" do
-        Band.default_scoping.call.selector["active"].should be_true
+        expect(Band.default_scoping.call.selector["active"]).to be true
       end
 
       it "delays execution of the merge until called" do
-        Band.all.selector["likes"].should_not eq(Band.all.selector["likes"])
+        expect(Band.all.selector["likes"]).to_not eq(Band.all.selector["likes"])
       end
 
       it "flags as being default scoped" do
-        Band.should be_default_scoping
+        expect(Band).to be_default_scoping
       end
     end
   end
@@ -129,7 +106,7 @@ describe Mongoid::Scoping do
       context "when not in an unscoped block" do
 
         it "returns true" do
-          Band.should be_default_scopable
+          expect(Band).to be_default_scopable
         end
       end
 
@@ -137,7 +114,7 @@ describe Mongoid::Scoping do
 
         it "returns false" do
           Band.unscoped do
-            Band.should_not be_default_scopable
+            expect(Band).to_not be_default_scopable
           end
         end
       end
@@ -146,7 +123,7 @@ describe Mongoid::Scoping do
     context "when a default scope does not exist" do
 
       it "returns false" do
-        Band.should_not be_default_scopable
+        expect(Band).to_not be_default_scopable
       end
     end
   end
@@ -156,7 +133,7 @@ describe Mongoid::Scoping do
     context "when no criteria exists on the stack" do
 
       it "returns an empty criteria" do
-        Band.queryable.selector.should be_empty
+        expect(Band.queryable.selector).to be_empty
       end
     end
 
@@ -175,7 +152,7 @@ describe Mongoid::Scoping do
       end
 
       it "returns the criteria on the stack" do
-        Band.queryable.should eq(criteria)
+        expect(Band.queryable).to eq(criteria)
       end
     end
   end
@@ -187,7 +164,7 @@ describe Mongoid::Scoping do
       context "when a block is provided" do
 
         before do
-          Band.scope(:active, Band.where(active: true)) do
+          Band.scope(:active, ->{ Band.where(active: true) }) do
             def add_origin
               tap { |c| c.selector[:origin] = "Deutschland" }
             end
@@ -206,7 +183,7 @@ describe Mongoid::Scoping do
         end
 
         it "adds the extension to the scope" do
-          scope.selector.should eq({ "active" => true, "origin" => "Deutschland" })
+          expect(scope.selector).to eq({ "active" => true, "origin" => "Deutschland" })
         end
       end
 
@@ -215,7 +192,7 @@ describe Mongoid::Scoping do
         before do
           Record.scope(
             :tool,
-            Record.where(:name.in => [ "undertow", "aenima", "lateralus" ])
+            ->{ Record.where(:name.in => [ "undertow", "aenima", "lateralus" ]) }
           )
         end
 
@@ -241,7 +218,7 @@ describe Mongoid::Scoping do
           end
 
           it "returns the correct documents" do
-            scoped.should eq([ undertow ])
+            expect(scoped).to eq([ undertow ])
           end
         end
       end
@@ -249,7 +226,7 @@ describe Mongoid::Scoping do
       context "when no block is provided" do
 
         before do
-          Band.scope(:active, Band.where(active: true).skip(10))
+          Band.scope(:active, ->{ Band.where(active: true).skip(10) })
         end
 
         after do
@@ -260,7 +237,7 @@ describe Mongoid::Scoping do
         end
 
         it "adds a method for the scope" do
-          Band.should respond_to(:active)
+          expect(Band).to respond_to(:active)
         end
 
         context "when calling the scope" do
@@ -272,22 +249,22 @@ describe Mongoid::Scoping do
             end
 
             it "returns a criteria" do
-              scope.should be_a(Mongoid::Criteria)
+              expect(scope).to be_a(Mongoid::Criteria)
             end
 
             it "contains the proper selector" do
-              scope.selector.should eq({ "active" => true })
+              expect(scope.selector).to eq({ "active" => true })
             end
 
             it "contains the proper options" do
-              scope.options.should eq({ skip: 10 })
+              expect(scope.options).to eq({ skip: 10 })
             end
           end
 
           context "when chained to another scope" do
 
             before do
-              Band.scope(:english, Band.where(origin: "England"))
+              Band.scope(:english, ->{ Band.where(origin: "England") })
             end
 
             after do
@@ -302,19 +279,19 @@ describe Mongoid::Scoping do
             end
 
             it "returns a criteria" do
-              scope.should be_a(Mongoid::Criteria)
+              expect(scope).to be_a(Mongoid::Criteria)
             end
 
             it "contains the proper selector" do
-              scope.selector.should eq({ "active" => true, "origin" => "England" })
+              expect(scope.selector).to eq({ "active" => true, "origin" => "England" })
             end
 
             it "contains the proper options" do
-              scope.options.should eq({ skip: 10 })
+              expect(scope.options).to eq({ skip: 10 })
             end
 
             it "does not modify the original scope" do
-              Band.active.selector.should eq({ "active" => true })
+              expect(Band.active.selector).to eq({ "active" => true })
             end
           end
 
@@ -329,23 +306,23 @@ describe Mongoid::Scoping do
             end
 
             it "returns a criteria" do
-              scope.should be_a(Mongoid::Criteria)
+              expect(scope).to be_a(Mongoid::Criteria)
             end
 
             it "contains the proper selector" do
-              scope.selector.should eq({ "origin" => "England", "active" => true })
+              expect(scope.selector).to eq({ "origin" => "England", "active" => true })
             end
 
             it "contains the proper options" do
-              scope.options.should eq({ skip: 10 })
+              expect(scope.options).to eq({ skip: 10 })
             end
 
             it "does not modify the original scope" do
-              Band.active.selector.should eq({ "active" => true })
+              expect(Band.active.selector).to eq({ "active" => true })
             end
 
             it "does not modify the original criteria" do
-              criteria.selector.should eq({ "origin" => "England" })
+              expect(criteria.selector).to eq({ "origin" => "England" })
             end
           end
         end
@@ -369,8 +346,8 @@ describe Mongoid::Scoping do
 
           it "raises an exception" do
             expect {
-              Band.scope(:active, Band.where(active: true))
-              Band.scope(:active, Band.where(active: true))
+              Band.scope(:active, ->{ Band.where(active: true) })
+              Band.scope(:active, ->{ Band.where(active: true) })
             }.to raise_error(Mongoid::Errors::ScopeOverwrite)
           end
         end
@@ -386,8 +363,8 @@ describe Mongoid::Scoping do
           end
 
           it "raises no exception" do
-            Band.scope(:active, Band.where(active: true))
-            Band.scope(:active, Band.where(active: true))
+            Band.scope(:active, ->{ Band.where(active: true) })
+            Band.scope(:active, ->{ Band.where(active: true) })
           end
         end
       end
@@ -417,7 +394,7 @@ describe Mongoid::Scoping do
         end
 
         it "adds the extension to the scope" do
-          scope.selector.should eq({ "active" => true, "origin" => "Deutschland" })
+          expect(scope.selector).to eq({ "active" => true, "origin" => "Deutschland" })
         end
       end
 
@@ -425,30 +402,29 @@ describe Mongoid::Scoping do
 
         before do
           Band.scope(:active, ->{ Band.where(active: true).skip(10) })
+          Band.scope(:named_by, ->(name) { Band.where(name: name) if name })
         end
 
         after do
           class << Band
             undef_method :active
+            undef_method :named_by
           end
           Band._declared_scopes.clear
         end
 
         it "adds a method for the scope" do
-          Band.should respond_to(:active)
+          expect(Band).to respond_to(:active)
         end
 
-        context "when proc return nil" do
-          before do
-            Band.scope(:named_by, ->(name) { Band.where(name: name) if name})
-          end
+        context "when calling the scope" do
 
-          it "return a all criteral" do
-            Band.named_by(nil).should be_a(Mongoid::Criteria)
-          end
-        end
+          context "when the scope would return nil" do
 
-        context "when calling the scope" do
+            it "returns a chainable empty scope" do
+              expect(Band.named_by(nil)).to be_a(Mongoid::Criteria)
+            end
+          end
 
           context "when calling from the class" do
 
@@ -457,15 +433,15 @@ describe Mongoid::Scoping do
             end
 
             it "returns a criteria" do
-              scope.should be_a(Mongoid::Criteria)
+              expect(scope).to be_a(Mongoid::Criteria)
             end
 
             it "contains the proper selector" do
-              scope.selector.should eq({ "active" => true })
+              expect(scope.selector).to eq({ "active" => true })
             end
 
             it "contains the proper options" do
-              scope.options.should eq({ skip: 10 })
+              expect(scope.options).to eq({ skip: 10 })
             end
           end
 
@@ -487,19 +463,19 @@ describe Mongoid::Scoping do
             end
 
             it "returns a criteria" do
-              scope.should be_a(Mongoid::Criteria)
+              expect(scope).to be_a(Mongoid::Criteria)
             end
 
             it "contains the proper selector" do
-              scope.selector.should eq({ "active" => true, "origin" => "England" })
+              expect(scope.selector).to eq({ "active" => true, "origin" => "England" })
             end
 
             it "contains the proper options" do
-              scope.options.should eq({ skip: 10 })
+              expect(scope.options).to eq({ skip: 10 })
             end
 
             it "does not modify the original scope" do
-              Band.active.selector.should eq({ "active" => true })
+              expect(Band.active.selector).to eq({ "active" => true })
             end
           end
 
@@ -514,23 +490,23 @@ describe Mongoid::Scoping do
             end
 
             it "returns a criteria" do
-              scope.should be_a(Mongoid::Criteria)
+              expect(scope).to be_a(Mongoid::Criteria)
             end
 
             it "contains the proper selector" do
-              scope.selector.should eq({ "origin" => "England", "active" => true })
+              expect(scope.selector).to eq({ "origin" => "England", "active" => true })
             end
 
             it "contains the proper options" do
-              scope.options.should eq({ skip: 10 })
+              expect(scope.options).to eq({ skip: 10 })
             end
 
             it "does not modify the original scope" do
-              Band.active.selector.should eq({ "active" => true })
+              expect(Band.active.selector).to eq({ "active" => true })
             end
 
             it "does not modify the original criteria" do
-              criteria.selector.should eq({ "origin" => "England" })
+              expect(criteria.selector).to eq({ "origin" => "England" })
             end
           end
         end
@@ -587,7 +563,7 @@ describe Mongoid::Scoping do
       end
     end
 
-    context "when chaining a non proc with a proc" do
+    context "when chaining a proc with a proc" do
 
       context "when both scopes are or queries" do
 
@@ -596,7 +572,7 @@ describe Mongoid::Scoping do
         end
 
         before do
-          Band.scope(:xxx, Band.any_of({ :aaa.gt => 0 }, { :bbb.gt => 0 }))
+          Band.scope(:xxx, ->{ Band.any_of({ :aaa.gt => 0 }, { :bbb.gt => 0 }) })
           Band.scope(:yyy, ->{ Band.any_of({ :ccc => nil }, { :ccc.gt => time }) })
         end
 
@@ -613,7 +589,7 @@ describe Mongoid::Scoping do
         end
 
         it "properly chains the $or queries together" do
-          criteria.selector.should eq({
+          expect(criteria.selector).to eq({
             "$or" => [
               { "ccc" => nil },
               { "ccc" => { "$gt" => time }},
@@ -675,7 +651,7 @@ describe Mongoid::Scoping do
     context "when the scope stack has not been accessed" do
 
       it "returns an empty array" do
-        Band.scope_stack.should eq([])
+        expect(Band.scope_stack).to eq([])
       end
     end
 
@@ -694,7 +670,7 @@ describe Mongoid::Scoping do
       end
 
       it "returns the criteria in the array" do
-        Band.scope_stack.should eq([ criteria ])
+        expect(Band.scope_stack).to eq([ criteria ])
       end
     end
   end
@@ -708,15 +684,15 @@ describe Mongoid::Scoping do
       end
 
       it "returns a criteria" do
-        scoped.should be_a(Mongoid::Criteria)
+        expect(scoped).to be_a(Mongoid::Criteria)
       end
 
       it "contains an empty selector" do
-        scoped.selector.should be_empty
+        expect(scoped.selector).to be_empty
       end
 
       it "contains empty options" do
-        scoped.options.should be_empty
+        expect(scoped.options).to be_empty
       end
     end
 
@@ -727,15 +703,15 @@ describe Mongoid::Scoping do
       end
 
       it "returns a criteria" do
-        scoped.should be_a(Mongoid::Criteria)
+        expect(scoped).to be_a(Mongoid::Criteria)
       end
 
       it "contains an empty selector" do
-        scoped.selector.should be_empty
+        expect(scoped.selector).to be_empty
       end
 
       it "contains the options" do
-        scoped.options.should eq({ skip: 10, limit: 10 })
+        expect(scoped.options).to eq({ skip: 10, limit: 10 })
       end
     end
 
@@ -746,7 +722,7 @@ describe Mongoid::Scoping do
       end
 
       before do
-        Band.default_scope criteria
+        Band.default_scope ->{ criteria }
       end
 
       after do
@@ -758,7 +734,7 @@ describe Mongoid::Scoping do
       end
 
       it "allows the default scope to be added" do
-        scoped.selector.should eq({ "name" => "Depeche Mode" })
+        expect(scoped.selector).to eq({ "name" => "Depeche Mode" })
       end
 
       context "when chained after an unscoped criteria" do
@@ -768,7 +744,7 @@ describe Mongoid::Scoping do
         end
 
         it "reapplies the default scope" do
-          scoped.selector.should eq({ "name" => "Depeche Mode" })
+          expect(scoped.selector).to eq({ "name" => "Depeche Mode" })
         end
       end
     end
@@ -781,7 +757,7 @@ describe Mongoid::Scoping do
     end
 
     before do
-      Band.default_scope criteria
+      Band.default_scope ->{ criteria }
     end
 
     after do
@@ -795,7 +771,7 @@ describe Mongoid::Scoping do
       end
 
       it "removes the default scope from the criteria" do
-        unscoped.selector.should be_empty
+        expect(unscoped.selector).to be_empty
       end
 
       context "when chained after a scoped criteria" do
@@ -805,7 +781,7 @@ describe Mongoid::Scoping do
         end
 
         it "removes all scoping" do
-          unscoped.selector.should be_empty
+          expect(unscoped.selector).to be_empty
         end
       end
     end
@@ -816,7 +792,7 @@ describe Mongoid::Scoping do
 
         it "does not allow default scoping to be added in the block" do
           Band.unscoped do
-            Band.skip(10).selector.should be_empty
+            expect(Band.skip(10).selector).to be_empty
           end
         end
       end
@@ -825,7 +801,7 @@ describe Mongoid::Scoping do
 
         it "does not allow default scoping to be added in the block" do
           Band.unscoped do
-            Band.scoped.selector.should be_empty
+            expect(Band.scoped.selector).to be_empty
           end
         end
       end
@@ -833,7 +809,7 @@ describe Mongoid::Scoping do
       context "when a named scope is called in the block" do
 
         before do
-          Band.scope(:skipped, Band.skip(10))
+          Band.scope(:skipped, ->{ Band.skip(10) })
         end
 
         after do
@@ -845,7 +821,7 @@ describe Mongoid::Scoping do
 
         it "does not allow the default scope to be applied" do
           Band.unscoped do
-            Band.skipped.selector.should be_empty
+            expect(Band.skipped.selector).to be_empty
           end
         end
       end
@@ -859,7 +835,7 @@ describe Mongoid::Scoping do
     end
 
     before do
-      Band.default_scope criteria
+      Band.default_scope ->{ criteria }
     end
 
     after do
@@ -870,7 +846,7 @@ describe Mongoid::Scoping do
 
       it "returns an empty criteria" do
         Band.unscoped do
-          Band.with_default_scope.selector.should be_empty
+          expect(Band.with_default_scope.selector).to be_empty
         end
       end
     end
@@ -882,7 +858,7 @@ describe Mongoid::Scoping do
       end
 
       it "returns an empty criteria" do
-        scoped.selector.should be_empty
+        expect(scoped.selector).to be_empty
       end
     end
 
@@ -893,7 +869,7 @@ describe Mongoid::Scoping do
       end
 
       it "returns a scoped criteria" do
-        scoped.selector.should eq({ "name" => "Depeche Mode" })
+        expect(scoped.selector).to eq({ "name" => "Depeche Mode" })
       end
     end
   end
@@ -906,13 +882,13 @@ describe Mongoid::Scoping do
 
     it "yields to the criteria" do
       Band.with_scope(criteria) do |crit|
-        crit.selector.should eq({ "active" => true })
+        expect(crit.selector).to eq({ "active" => true })
       end
     end
 
     it "pops the criteria off the stack" do
       Band.with_scope(criteria) {}
-      Band.scope_stack.should be_empty
+      expect(Band.scope_stack).to be_empty
     end
   end
 
@@ -920,58 +896,7 @@ describe Mongoid::Scoping do
 
     it "sets the threading options" do
       Band.without_default_scope do
-        Mongoid::Threaded.should be_executing(:without_default_scope)
-      end
-    end
-  end
-
-  context "when the document is paranoid" do
-
-    context "when calling a class method" do
-
-      let(:criteria) do
-        Fish.fresh
-      end
-
-      it "includes the deleted_at criteria in the selector" do
-        criteria.selector.should eq({
-          "deleted_at" => nil, "fresh" => true
-        })
-      end
-    end
-
-    context "when chaining a class method to unscoped" do
-
-      let(:criteria) do
-        Fish.unscoped.fresh
-      end
-
-      it "does not include the deleted_at in the selector" do
-        criteria.selector.should eq({ "fresh" => true })
-      end
-    end
-
-    context "when chaining a class method to deleted" do
-
-      let(:criteria) do
-        Fish.deleted.fresh
-      end
-
-      it "includes the deleted_at $ne criteria in the selector" do
-        criteria.selector.should eq({
-          "deleted_at" => { "$ne" => nil }, "fresh" => true
-        })
-      end
-    end
-
-    context "when chaining a where to unscoped" do
-
-      let(:criteria) do
-        Fish.unscoped.where(fresh: true)
-      end
-
-      it "includes no default scoping information in the selector" do
-        criteria.selector.should eq({ "fresh" => true })
+        expect(Mongoid::Threaded).to be_executing(:without_default_scope)
       end
     end
   end