mongoid 9.0.11 → 9.1.1

data/spec/mongoid/criteria/scopable_spec.rb

@@ -1,126 +1,115 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Scopable do
-
-  describe "#apply_default_scope" do
-
-    context "when the default scope has options" do
-
+  describe '#apply_default_scope' do
+    context 'when the default scope has options' do
       let(:scope) do
         Band.skip(20)
       end
+      let(:scoped) do
+        Band.all.tap do |criteria|
+          criteria.apply_default_scope
+        end
+      end
 
       before do
-        Band.default_scope ->{ scope }
+        Band.default_scope -> { scope }
       end
 
       after do
         Band.default_scoping = nil
       end
 
-      let(:scoped) do
-        Band.all.tap do |criteria|
-          criteria.apply_default_scope
-        end
-      end
-
-      it "merges in the options" do
+      it 'merges in the options' do
         expect(scoped.options).to eq({ skip: 20 })
       end
 
-      it "sets scoped to true" do
+      it 'sets scoped to true' do
         expect(scoped).to be_scoped
       end
     end
 
-    context "when the default scope has selection" do
-
+    context 'when the default scope has selection' do
       let(:scope) do
-        Band.where(name: "Depeche Mode")
+        Band.where(name: 'Depeche Mode')
+      end
+      let(:scoped) do
+        Band.all.tap do |criteria|
+          criteria.apply_default_scope
+        end
       end
 
       before do
-        Band.default_scope ->{ scope }
+        Band.default_scope -> { scope }
       end
 
       after do
         Band.default_scoping = nil
       end
 
-      let(:scoped) do
-        Band.all.tap do |criteria|
-          criteria.apply_default_scope
-        end
+      it 'merges in the options' do
+        expect(scoped.selector).to eq({ 'name' => 'Depeche Mode' })
       end
 
-      it "merges in the options" do
-        expect(scoped.selector).to eq({ "name" => "Depeche Mode" })
-      end
-
-      it "sets scoped to true" do
+      it 'sets scoped to true' do
         expect(scoped).to be_scoped
       end
     end
 
-    context "when the default scope has inclusions" do
-
+    context 'when the default scope has inclusions' do
       let(:scope) do
         Band.includes(:records)
       end
 
       before do
-        Band.default_scope ->{ scope }
+        Band.default_scope -> { scope }
       end
 
       after do
         Band.default_scoping = nil
       end
 
-      context "when merging with an empty criteria" do
-
+      context 'when merging with an empty criteria' do
         let(:scoped) do
           Band.all.tap do |criteria|
             criteria.apply_default_scope
           end
         end
 
-        it "merges in the inclusions" do
+        it 'merges in the inclusions' do
           expect(scoped.inclusions).to eq(
-            [ Band.relations["records"] ]
+            [ Band.relations['records'] ]
           )
         end
 
-        it "sets scoped to true" do
+        it 'sets scoped to true' do
           expect(scoped).to be_scoped
         end
       end
 
-      context "when merging with a criteria that has inclusions" do
-
+      context 'when merging with a criteria that has inclusions' do
         let(:scoped) do
           Band.includes(:label).tap do |criteria|
             criteria.apply_default_scope
           end
         end
 
-        it "merges in the inclusions" do
+        it 'merges in the inclusions' do
           expect(scoped.inclusions).to eq(
-            [ Band.relations["records"], Band.relations["label"] ]
+            [ Band.relations['records'], Band.relations['label'] ]
           )
         end
 
-        it "sets scoped to true" do
+        it 'sets scoped to true' do
           expect(scoped).to be_scoped
         end
       end
     end
   end
 
-  describe "#apply_scope" do
-
+  describe '#apply_scope' do
     let(:criteria) do
       Band.skip(20).where(name: 'Black Sabbath').includes(:same_name)
     end
@@ -129,15 +118,14 @@ describe Mongoid::Criteria::Scopable do
       criteria.apply_scope(scope)
     end
 
-    context "when the scope is a Criteria" do
-
+    context 'when the scope is a Criteria' do
       context 'when standard scope' do
         let(:scope) do
           Band.gt(member_count: 3).limit(3).includes(:artists)
         end
 
         it 'merges the criteria' do
-          expect(result.selector).to eq("name" => "Black Sabbath", "member_count" => { "$gt"=>3 })
+          expect(result.selector).to eq('name' => 'Black Sabbath', 'member_count' => { '$gt' => 3 })
           expect(result.options).to eq(skip: 20, limit: 3)
           expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
         end
@@ -149,22 +137,21 @@ describe Mongoid::Criteria::Scopable do
         end
 
         it 'unscoped has no effect' do
-          expect(result.selector).to eq("name" => "Black Sabbath", "member_count" => { "$gt"=>3 })
+          expect(result.selector).to eq('name' => 'Black Sabbath', 'member_count' => { '$gt' => 3 })
           expect(result.options).to eq(skip: 20, limit: 3)
           expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
         end
       end
     end
 
-    context "when the scope is a Proc" do
-
+    context 'when the scope is a Proc' do
       context 'when standard scope' do
         let(:scope) do
           -> { gt(member_count: 3).limit(3).includes(:artists) }
         end
 
         it 'adds the scope' do
-          expect(result.selector).to eq("name" => "Black Sabbath", "member_count" => { "$gt"=>3 })
+          expect(result.selector).to eq('name' => 'Black Sabbath', 'member_count' => { '$gt' => 3 })
           expect(result.options).to eq(skip: 20, limit: 3)
           expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
         end
@@ -176,22 +163,21 @@ describe Mongoid::Criteria::Scopable do
         end
 
         it 'removes existing scopes then adds the new scope' do
-          expect(result.selector).to eq("member_count" => { "$gt"=>3 })
+          expect(result.selector).to eq('member_count' => { '$gt' => 3 })
           expect(result.options).to eq(limit: 3)
           expect(result.inclusions.map(&:name)).to eq(%i[same_name artists])
         end
       end
     end
 
-    context "when the scope is a Symbol" do
-
+    context 'when the scope is a Symbol' do
       context 'when standard scope' do
         let(:scope) do
           :highly_rated
         end
 
         it 'adds the scope' do
-          expect(result.selector).to eq("name" => "Black Sabbath", "rating" => { "$gte" => 7 })
+          expect(result.selector).to eq('name' => 'Black Sabbath', 'rating' => { '$gte' => 7 })
           expect(result.options).to eq(skip: 20)
           expect(result.inclusions.map(&:name)).to eq(%i[same_name])
         end
@@ -211,9 +197,8 @@ describe Mongoid::Criteria::Scopable do
     end
 
     context 'when model has default_scope' do
-
       before do
-        Band.default_scope ->{ Band.where(active: true).includes(:records) }
+        Band.default_scope -> { Band.where(active: true).includes(:records) }
       end
 
       after do
@@ -226,7 +211,7 @@ describe Mongoid::Criteria::Scopable do
         end
 
         it 'merges the scope' do
-          expect(result.selector).to eq("active" => true, "name" => "Black Sabbath", "member_count" => { "$gt" => 3 })
+          expect(result.selector).to eq('active' => true, 'name' => 'Black Sabbath', 'member_count' => { '$gt' => 3 })
           expect(result.options).to eq(skip: 20, limit: 3)
           expect(result.inclusions.map(&:name)).to eq(%i[records same_name artists])
         end
@@ -238,7 +223,7 @@ describe Mongoid::Criteria::Scopable do
         end
 
         it 'removes existing scopes then adds the new scope' do
-          expect(result.selector).to eq("member_count" => { "$gt" => 3 })
+          expect(result.selector).to eq('member_count' => { '$gt' => 3 })
           expect(result.options).to eq(limit: 3)
           expect(result.inclusions.map(&:name)).to eq(%i[records same_name artists])
         end
@@ -246,27 +231,23 @@ describe Mongoid::Criteria::Scopable do
     end
   end
 
-  describe "#remove_scoping" do
-
-    context "when the other has selection" do
-
+  describe '#remove_scoping' do
+    context 'when the other has selection' do
       let(:criteria) do
-        Band.where(name: "Depeche Mode")
+        Band.where(name: 'Depeche Mode')
       end
 
       before do
         criteria.remove_scoping(criteria)
       end
 
-      it "removes the selection" do
+      it 'removes the selection' do
         expect(criteria.selector).to be_empty
       end
     end
 
-    context "when the other has options" do
-
-      context "when both are options only" do
-
+    context 'when the other has options' do
+      context 'when both are options only' do
         let(:criteria) do
           Band.skip(10)
         end
@@ -275,13 +256,12 @@ describe Mongoid::Criteria::Scopable do
           criteria.remove_scoping(criteria)
         end
 
-        it "removes the options" do
+        it 'removes the options' do
           expect(criteria.options).to be_empty
         end
       end
 
-      context "when the criteria is selection only with nil" do
-
+      context 'when the criteria is selection only with nil' do
         let(:criteria) do
           Band.where(name: nil)
         end
@@ -290,18 +270,17 @@ describe Mongoid::Criteria::Scopable do
           criteria.remove_scoping(Band.asc(:_id))
         end
 
-        it "removes the options" do
+        it 'removes the options' do
           expect(criteria.options).to be_empty
         end
 
-        it "does not remove the selector" do
-          expect(criteria.selector).to eq({ "name" => nil })
+        it 'does not remove the selector' do
+          expect(criteria.selector).to eq({ 'name' => nil })
         end
       end
     end
 
-    context "when the other has inclusions" do
-
+    context 'when the other has inclusions' do
       let(:criteria) do
         Band.includes(:records, :label)
       end
@@ -314,97 +293,90 @@ describe Mongoid::Criteria::Scopable do
         criteria.remove_scoping(other)
       end
 
-      it "removes the matching inclusions" do
-        expect(criteria.inclusions).to eq([ Band.relations["records"] ])
+      it 'removes the matching inclusions' do
+        expect(criteria.inclusions).to eq([ Band.relations['records'] ])
       end
     end
   end
 
-  describe "#scoped" do
-
+  describe '#scoped' do
     let(:empty) do
       Mongoid::Criteria.new(Band)
     end
 
-    context "when no options are provided" do
-
+    context 'when no options are provided' do
       let(:scoped) do
         empty.scoped
       end
 
-      it "returns a criteria" do
+      it 'returns a criteria' do
         expect(scoped).to be_a(Mongoid::Criteria)
       end
 
-      it "contains an empty selector" do
+      it 'contains an empty selector' do
         expect(scoped.selector).to be_empty
       end
 
-      it "contains empty options" do
+      it 'contains empty options' do
         expect(scoped.options).to be_empty
       end
     end
 
-    context "when options are provided" do
-
+    context 'when options are provided' do
       let(:scoped) do
         empty.scoped(skip: 10, limit: 10)
       end
 
-      it "returns a criteria" do
+      it 'returns a criteria' do
         expect(scoped).to be_a(Mongoid::Criteria)
       end
 
-      it "contains an empty selector" do
+      it 'contains an empty selector' do
         expect(scoped.selector).to be_empty
       end
 
-      it "contains the options" do
+      it 'contains the options' do
         expect(scoped.options).to eq({ skip: 10, limit: 10 })
       end
     end
 
-    context "when a default scope exists" do
-
+    context 'when a default scope exists' do
       let(:criteria) do
-        Band.where(name: "Depeche Mode")
+        Band.where(name: 'Depeche Mode')
+      end
+      let(:scoped) do
+        empty.scoped
       end
 
       before do
-        Band.default_scope ->{ criteria }
+        Band.default_scope -> { criteria }
       end
 
       after do
         Band.default_scoping = nil
       end
 
-      let(:scoped) do
-        empty.scoped
-      end
-
-      it "allows the default scope to be added" do
-        expect(scoped.selector).to eq({ "name" => "Depeche Mode" })
+      it 'allows the default scope to be added' do
+        expect(scoped.selector).to eq({ 'name' => 'Depeche Mode' })
       end
 
-      it "flags as scoped" do
+      it 'flags as scoped' do
         expect(scoped).to be_scoped
       end
 
-      context "when chained after an unscoped criteria" do
-
+      context 'when chained after an unscoped criteria' do
         let(:scoped) do
           empty.unscoped.scoped
         end
 
-        it "reapplies the default scope" do
-          expect(scoped.selector).to eq({ "name" => "Depeche Mode" })
+        it 'reapplies the default scope' do
+          expect(scoped.selector).to eq({ 'name' => 'Depeche Mode' })
         end
       end
     end
   end
 
-  describe "#scoping_options" do
-
+  describe '#scoping_options' do
     let(:criteria) do
       Band.all
     end
@@ -413,13 +385,12 @@ describe Mongoid::Criteria::Scopable do
       criteria.scoping_options = true, false
     end
 
-    it "returns the scoping options" do
+    it 'returns the scoping options' do
       expect(criteria.scoping_options).to eq([ true, false ])
     end
   end
 
-  describe "#scoping_options=" do
-
+  describe '#scoping_options=' do
     let(:criteria) do
       Band.all
     end
@@ -428,79 +399,72 @@ describe Mongoid::Criteria::Scopable do
       criteria.scoping_options = true, true
     end
 
-    it "sets the scoped flag" do
+    it 'sets the scoped flag' do
       expect(criteria).to be_scoped
     end
 
-    it "sets the unscoped flag" do
+    it 'sets the unscoped flag' do
       expect(criteria).to be_unscoped
     end
   end
 
-  describe ".unscoped" do
-
+  describe '.unscoped' do
     let(:empty) do
       Mongoid::Criteria.new(Band)
     end
 
     let(:criteria) do
-      Band.where(name: "Depeche Mode")
+      Band.where(name: 'Depeche Mode')
     end
 
     before do
-      Band.default_scope ->{ criteria }
+      Band.default_scope -> { criteria }
     end
 
     after do
       Band.default_scoping = nil
     end
 
-    context "when called directly" do
-
+    context 'when called directly' do
       let(:unscoped) do
         empty.unscoped
       end
 
-      it "removes the default scope from the criteria" do
+      it 'removes the default scope from the criteria' do
         expect(unscoped.selector).to be_empty
       end
 
-      context "when chained after a scoped criteria" do
-
+      context 'when chained after a scoped criteria' do
         let(:unscoped) do
           empty.scoped.unscoped
         end
 
-        it "removes all scoping" do
+        it 'removes all scoping' do
           expect(unscoped.selector).to be_empty
         end
       end
     end
 
-    context "when used with a block" do
-
-      context "when a criteria is called in the block" do
-
-        it "does not allow default scoping to be added in the block" do
+    context 'when used with a block' do
+      context 'when a criteria is called in the block' do
+        it 'does not allow default scoping to be added in the block' do
           Band.unscoped do
             expect(empty.skip(10).selector).to be_empty
           end
         end
       end
 
-      context "when a call is made to scoped in the block" do
-
-        it "does not allow default scoping to be added in the block" do
+      context 'when a call is made to scoped in the block' do
+        it 'does not allow default scoping to be added in the block' do
           Band.unscoped do
             expect(empty.scoped.selector).to be_empty
           end
         end
       end
 
-      context "when a named scope is called in the block" 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
@@ -510,7 +474,7 @@ describe Mongoid::Criteria::Scopable do
           Band._declared_scopes.clear
         end
 
-        it "does not allow the default scope to be applied" do
+        it 'does not allow the default scope to be applied' do
           Band.unscoped do
             expect(empty.skipped.selector).to be_empty
           end
@@ -550,12 +514,12 @@ describe Mongoid::Criteria::Scopable do
     class ArgumentScopeWhereModel
       include Mongoid::Document
 
-      scope :my_text_search, ->(search) { where('$text' => {'$search' => search}) }
+      scope :my_text_search, ->(search) { where('$text' => { '$search' => search }) }
     end
 
     shared_examples_for 'restricts to both' do
       it 'restricts to both' do
-        expect(result.selector['$text']).to eq({'$search' => 'bar'})
+        expect(result.selector['$text']).to eq({ '$search' => 'bar' })
         expect(result.selector['hello']).to eq('world')
       end
     end
@@ -582,7 +546,7 @@ describe Mongoid::Criteria::Scopable do
 
     shared_examples_for 'restricts to both' do
       it 'restricts to both' do
-        expect(result.selector['$text']).to eq({'$search' => 'bar'})
+        expect(result.selector['$text']).to eq({ '$search' => 'bar' })
         expect(result.selector['hello']).to eq('world')
       end
     end