mongoid 3.1.7 → 4.0.0.alpha1

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

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Scoping do
+describe Mongoid::Scopable do
 
   describe ".default_scope" do
 
@@ -19,11 +19,11 @@ 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
 
@@ -42,11 +42,11 @@ 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
 
@@ -89,23 +89,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 +129,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 +137,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 +146,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 +156,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 +175,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
@@ -206,7 +206,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
 
@@ -241,7 +241,7 @@ describe Mongoid::Scoping do
           end
 
           it "returns the correct documents" do
-            scoped.should eq([ undertow ])
+            expect(scoped).to eq([ undertow ])
           end
         end
       end
@@ -260,7 +260,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,15 +272,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
 
@@ -302,19 +302,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 +329,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
@@ -417,7 +417,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 +425,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 +456,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 +486,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 +513,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
@@ -613,7 +612,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 +674,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 +693,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 +707,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 +726,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
 
@@ -758,7 +757,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 +767,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
@@ -795,7 +794,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 +804,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 +815,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 +824,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
@@ -845,7 +844,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
@@ -870,7 +869,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 +881,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 +892,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 +905,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 +919,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