mongoid 8.0.3 → 8.1.0

data/spec/mongoid/criteria/queryable/selectable_logical_spec.rb

@@ -2116,4 +2116,423 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
   end
+
+  describe "#none_of" do
+    context 'when argument is a mix of Criteria and hashes' do
+      let(:query) { Mongoid::Query.new.where(hello: 'world') }
+      let(:other1) { Mongoid::Query.new.where(foo: 'bar') }
+      let(:other2) { { bar: 42 } }
+      let(:other3) { Mongoid::Query.new.where(a: 2) }
+
+      let(:result) { query.none_of(other1, other2, other3) }
+
+      it 'combines' do
+        expect(result.selector).to eq(
+          'hello' => 'world',
+          '$nor' => [
+            {'foo' => 'bar'},
+            {'bar' => 42},
+            {'a' => 2},
+          ],
+        )
+      end
+    end
+
+    context "when provided no arguments" do
+      let(:selection) { query.none_of }
+
+      it_behaves_like 'returns a cloned query'
+
+      it "does not add any criteria" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+    end
+
+    context "when provided nil" do
+      let(:selection) { query.none_of(nil) }
+
+      it_behaves_like 'returns a cloned query'
+
+      it "does not add any criteria" do
+        expect(selection.selector).to eq({})
+      end
+
+      it "returns the query" do
+        expect(selection).to eq(query)
+      end
+    end
+
+    context "when provided a single criterion" do
+      let(:selection) { query.none_of(field: [ 1, 2 ]) }
+
+      it_behaves_like 'returns a cloned query'
+
+      it 'adds the $nor selector' do
+        expect(selection.selector).to eq(
+          '$nor' => [ { 'field' => [ 1, 2 ] } ],
+        )
+      end
+
+      context 'when the criterion is wrapped in array' do
+        let(:selection) { query.none_of([{ field: [ 1, 2 ] }]) }
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the condition' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'field' => [ 1, 2 ] } ],
+          )
+        end
+
+        context 'when the array has nil as one of the elements' do
+          let(:selection) { query.none_of([{ field: [ 1, 2 ] }, nil]) }
+
+          it_behaves_like 'returns a cloned query'
+
+          it 'adds the $nor selector ignoring the nil element' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => [ 1, 2 ] } ],
+            )
+          end
+        end
+      end
+
+      context 'when query already has a condition on another field' do
+        context 'when there is one argument' do
+          let(:selection) { query.where(foo: 'bar').none_of(field: [ 1, 2 ]) }
+
+          it 'adds the new condition' do
+            expect(selection.selector).to eq(
+              'foo' => 'bar',
+              '$nor' => [ { 'field' => [1, 2] } ],
+            )
+          end
+        end
+
+        context 'when there are multiple arguments' do
+          let(:selection) do
+            query.where(foo: 'bar').none_of({ field: [ 1, 2 ] }, { hello: 'world' })
+          end
+
+          it 'adds the new condition' do
+            expect(selection.selector).to eq(
+              'foo' => 'bar',
+              '$nor' => [
+                { 'field' => [1, 2] },
+                { 'hello' => 'world' },
+              ],
+            )
+          end
+        end
+      end
+
+      context 'when query already has a $nor condition and another condition' do
+        let(:selection) do
+          query.nor(field: [ 1, 2 ]).where(foo: 'bar').none_of(test: 1)
+        end
+
+        it 'adds the new condition' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'field' => [1, 2] } ],
+            'foo' => 'bar',
+            '$and' => [ { '$nor' => [ { 'test' => 1 } ] } ]
+          )
+        end
+      end
+
+      context 'when none_of has multiple arguments' do
+        let(:selection) do
+          query.nor(field: [ 1, 2 ]).where(foo: 'bar').none_of({a: 1}, {b: 2})
+        end
+
+        it 'adds the new condition to top level' do
+          expect(selection.selector).to eq(
+            'foo' => 'bar',
+            '$nor' => [ { 'field' => [1, 2] } ],
+            '$and' => [ { '$nor' => [ { 'a' => 1 }, { 'b' => 2 } ] } ]
+          )
+        end
+
+        context 'when query already has a top-level $and' do
+          let(:selection) do
+            query.nor(field: [ 1, 2 ]).where('$and' => [foo: 'bar']).none_of({a: 1}, {b: 2})
+          end
+
+          it 'adds the new condition to top level $and' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => [1, 2] } ],
+              '$and' => [
+                { 'foo' => 'bar' },
+                { '$nor' => [ { 'a' => 1 }, { 'b' => 2 } ] }
+              ],
+            )
+          end
+        end
+      end
+    end
+
+    context "when provided multiple criteria" do
+      context "when the criteria are for different fields" do
+        let(:selection) do
+          query.none_of({ first: [ 1, 2 ] }, { second: [ 3, 4 ] })
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it "adds the $nor selector" do
+          expect(selection.selector).to eq({
+            "$nor" => [
+              { "first" => [ 1, 2 ] },
+              { "second" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+
+      context "when the criteria uses a Key instance" do
+        let(:selection) do
+          query.none_of({ first: [ 1, 2 ] }, { :second.gt => 3 })
+        end
+
+        it "adds the $nor selector" do
+          expect(selection.selector).to eq({
+            "$nor" => [
+              { "first" => [ 1, 2 ] },
+              { "second" => { "$gt" => 3 }}
+            ]
+          })
+        end
+
+        it_behaves_like 'returns a cloned query'
+      end
+
+      context 'when criteria are simple and handled via Key' do
+        shared_examples_for 'adds conditions with $nor' do
+          it "adds conditions with $nor" do
+            expect(selection.selector).to eq({
+              '$nor' => [
+                {'field' => 3},
+                {'field' => {'$lt' => 5}},
+              ],
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $eq' do
+          it "combines conditions with $eq" do
+            expect(selection.selector).to eq({
+              '$nor' => [ { 'field' => { '$eq' => 3, '$lt' => 5 } } ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $regex' do
+          it 'combines conditions with $regex' do
+            expect(selection.selector).to eq({
+              '$nor' => [ { 'field' => { '$regex' => /t/, '$lt' => 5 } } ]
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'criteria are provided in the same hash' do
+          context 'non-regexp argument' do
+            let(:selection) { query.none_of(:field => 3, :field.lt => 5) }
+            it_behaves_like 'combines conditions with $eq'
+          end
+
+          context 'regexp argument' do
+            let(:selection) { query.none_of(:field => /t/, :field.lt => 5) }
+            it_behaves_like 'combines conditions with $regex'
+          end
+        end
+
+        context 'criteria are provided in separate hashes' do
+          let(:selection) { query.none_of({:field => 3}, {:field.lt => 5}) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) { query.none_of([:field => 3], [:field.lt => 5]) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+      end
+
+      context 'when criteria are handled via Key and simple' do
+        shared_examples_for 'adds conditions with $nor' do
+          it 'adds conditions with $nor' do
+            expect(selection.selector).to eq({
+              '$nor' => [
+                { 'field' => { '$gt' => 3 } },
+                { 'field' => 5 },
+              ],
+            })
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $eq' do
+          it 'combines conditions with $eq' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => {'$gt' => 3, '$eq' => 5} } ],
+            )
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        shared_examples_for 'combines conditions with $regex' do
+          it 'combines conditions with $regex' do
+            expect(selection.selector).to eq(
+              '$nor' => [ { 'field' => {'$gt' => 3, '$regex' => /t/} } ],
+            )
+          end
+
+          it_behaves_like 'returns a cloned query'
+        end
+
+        context 'criteria are provided in the same hash' do
+          context 'non-regexp argument' do
+            let(:selection) { query.none_of(:field.gt => 3, :field => 5) }
+            it_behaves_like 'combines conditions with $eq'
+          end
+
+          context 'regexp argument' do
+            let(:selection) { query.none_of(:field.gt => 3, :field => /t/) }
+            it_behaves_like 'combines conditions with $regex'
+          end
+        end
+
+        context 'criteria are provided in separate hashes' do
+          let(:selection) { query.none_of({:field.gt => 3}, {:field => 5}) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+
+        context 'when the criterion is wrapped in an array' do
+          let(:selection) { query.none_of([:field.gt => 3], [:field => 5]) }
+          it_behaves_like 'adds conditions with $nor'
+        end
+      end
+
+      context 'when a criterion has an aliased field' do
+        let(:selection) { query.none_of({ id: 1 }) }
+        
+        it 'adds the $nor selector and aliases the field' do
+          expect(selection.selector).to eq('$nor' => [{ '_id' => 1 }])
+        end
+
+        it_behaves_like 'returns a cloned query'
+      end
+
+      context 'when a criterion is wrapped in an array' do
+        let(:selection) do
+          query.none_of([{ first: [ 1, 2 ] }, { :second.gt => 3 }])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the $ nor selector' do
+          expect(selection.selector).to eq({
+            '$nor' => [
+              { 'first' => [ 1, 2 ] },
+              { 'second' => { '$gt' => 3 }}
+            ]
+          })
+        end
+      end
+
+      context "when the criteria are on the same field" do
+        let(:selection) do
+          query.none_of({ first: [ 1, 2 ] }, { first: [ 3, 4 ] })
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'appends both $nor expressions' do
+          expect(selection.selector).to eq({
+            "$nor" => [
+              { "first" => [ 1, 2 ] },
+              { "first" => [ 3, 4 ] }
+            ]
+          })
+        end
+      end
+    end
+
+    context 'when chaining the criteria' do
+      context 'when the criteria are for different fields' do
+        let(:selection) do
+          query.none_of(first: [ 1, 2 ]).none_of(second: [ 3, 4 ])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the conditions separately' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'first' => [ 1, 2 ] } ],
+            '$and' => [ { '$nor' => [ { 'second' => [ 3, 4 ] } ] } ],
+          )
+        end
+      end
+
+      context "when the criteria are on the same field" do
+        let(:selection) do
+          query.none_of(first: [ 1, 2 ]).none_of(first: [ 3, 4 ])
+        end
+
+        it_behaves_like 'returns a cloned query'
+
+        it 'adds the conditions separately' do
+          expect(selection.selector).to eq(
+            '$nor' => [ { 'first' => [ 1, 2 ] } ],
+            '$and' => [ { '$nor' => [ { 'first' => [ 3, 4 ] } ] } ]
+          )
+        end
+      end
+    end
+
+    context 'when using multiple criteria and symbol operators' do
+      context 'when using fields that meaningfully evolve values' do
+        let(:query) do
+          Dictionary.none_of({a: 1}, :published.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$nor' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in local time,
+            # because we are querying on a Time field and dates are interpreted
+            # in local time when assigning to Time fields
+            {'published' => {'$gt' => Time.local(2020, 2, 3) } },
+          ] }
+        end
+      end
+
+      context 'when using fields that do not meaningfully evolve values' do
+        let(:query) do
+          Dictionary.none_of({a: 1}, :submitted_on.gt => Date.new(2020, 2, 3))
+        end
+
+        it 'generates the expected query' do
+          query.selector.should == {'$nor' => [
+            {'a' => 1},
+            # Date instance is converted to a Time instance in UTC,
+            # because we are querying on a Date field and dates are interpreted
+            # in UTC when persisted as dates by Mongoid
+            {'submitted_on' => {'$gt' => Time.utc(2020, 2, 3)}},
+          ]}
+        end
+      end
+    end
+  end
 end

data/spec/mongoid/criteria/queryable/selectable_spec.rb

@@ -2045,7 +2045,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
 
       # MongoDB server can only handle one text expression at a time,
-      # per https://docs.mongodb.com/manual/reference/operator/query/text/.
+      # per https://www.mongodb.com/docs/manual/reference/operator/query/text/.
       # Nonetheless we test that the query is built correctly when
       # a user supplies more than one text condition.
       it 'merges conditions' do

data/spec/mongoid/criteria/queryable/selector_spec.rb

@@ -608,6 +608,7 @@ describe Mongoid::Criteria::Queryable::Selector do
         end
 
         context "when the serializer is localized" do
+          with_default_i18n_configs
 
           before(:all) do
             class Field
@@ -623,7 +624,6 @@ describe Mongoid::Criteria::Queryable::Selector do
 
           after(:all) do
             Object.send(:remove_const, :Field)
-            ::I18n.locale = :en
           end
 
           let(:selector) do

data/spec/mongoid/criteria/translator_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Criteria::Translator do
+  describe "#to_direction" do
+    context "when the value is a string" do
+      context "when ascending" do
+        it "returns 1" do
+          expect(described_class.to_direction("ascending")).to eq(1)
+        end
+      end
+
+      context "when asc" do
+        it "returns 1" do
+          expect(described_class.to_direction("asc")).to eq(1)
+        end
+      end
+
+      context "when ASCENDING" do
+        it "returns 1" do
+          expect(described_class.to_direction("ASCENDING")).to eq(1)
+        end
+      end
+
+      context "when ASC" do
+        it "returns 1" do
+          expect(described_class.to_direction("ASC")).to eq(1)
+        end
+      end
+
+      context "when descending" do
+        it "returns -1" do
+          expect(described_class.to_direction("descending")).to eq(-1)
+        end
+      end
+
+      context "when desc" do
+        it "returns -1" do
+          expect(described_class.to_direction("desc")).to eq(-1)
+        end
+      end
+
+      context "when DESCENDING" do
+        it "returns -1" do
+          expect(described_class.to_direction("DESCENDING")).to eq(-1)
+        end
+      end
+
+      context "when DESC" do
+        it "returns -1" do
+          expect(described_class.to_direction("DESC")).to eq(-1)
+        end
+      end
+    end
+
+    context "when the value is a symbol" do
+      context "when ascending" do
+        it "returns 1" do
+          expect(described_class.to_direction(:ascending)).to eq(1)
+        end
+      end
+  
+      context "when asc" do
+        it "returns 1" do
+          expect(described_class.to_direction(:asc)).to eq(1)
+        end
+      end
+  
+      context "when ASCENDING" do
+        it "returns 1" do
+          expect(described_class.to_direction(:ASCENDING)).to eq(1)
+        end
+      end
+  
+      context "when ASC" do
+        it "returns 1" do
+          expect(described_class.to_direction(:ASC)).to eq(1)
+        end
+      end
+  
+      context "when descending" do
+        it "returns -1" do
+          expect(described_class.to_direction(:descending)).to eq(-1)
+        end
+      end
+  
+      context "when desc" do
+        it "returns -1" do
+          expect(described_class.to_direction(:desc)).to eq(-1)
+        end
+      end
+  
+      context "when DESCENDING" do
+        it "returns -1" do
+          expect(described_class.to_direction(:DESCENDING)).to eq(-1)
+        end
+      end
+  
+      context "when DESC" do
+        it "returns -1" do
+          expect(described_class.to_direction(:DESC)).to eq(-1)
+        end
+      end
+    end
+
+    context "when the value is numeric" do
+      it "should pass the value through unchanged" do
+        expect(described_class.to_direction(1)).to eq(1)
+        expect(described_class.to_direction(-1)).to eq(-1)
+        expect(described_class.to_direction(Math::PI)).to eq(Math::PI)
+      end
+    end
+
+    context "when the value is a hash" do
+      it "should pass the value through unchanged" do
+        expect(described_class.to_direction({})).to eq({})
+        expect(described_class.to_direction(scope: { "$meta" => "textScore" }))
+          .to eq(scope: { "$meta" => "textScore" })
+        expect(described_class.to_direction(a: 1, b: 2)).to eq(a: 1, b: 2)
+      end
+    end
+
+    context "when the value is an unrecognized type" do
+      it "should raise ArgumentError" do
+        expect { described_class.to_direction([]) }.to raise_error(ArgumentError)
+        expect { described_class.to_direction(/a/) }.to raise_error(ArgumentError)
+        expect { described_class.to_direction(Object.new) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/mongoid/criteria_projection_spec.rb

@@ -154,6 +154,7 @@ describe Mongoid::Criteria do
     end
 
     context 'when the field is localized' do
+      with_default_i18n_configs
 
       before do
         I18n.locale = :en
@@ -163,10 +164,6 @@ describe Mongoid::Criteria do
         d.save!
       end
 
-      after do
-        I18n.locale = :en
-      end
-
       context 'when entire field is included' do
 
         let(:dictionary) do

data/spec/mongoid/criteria_spec.rb

@@ -1953,6 +1953,7 @@ describe Mongoid::Criteria do
     end
 
     context 'when plucking a localized field' do
+      with_default_i18n_configs
 
       before do
         I18n.locale = :en
@@ -1962,10 +1963,6 @@ describe Mongoid::Criteria do
         d.save!
       end
 
-      after do
-        I18n.locale = :en
-      end
-
       context 'when plucking the entire field' do
         let(:plucked) do
           Dictionary.all.pluck(:description)
@@ -2059,13 +2056,10 @@ describe Mongoid::Criteria do
       end
 
       context 'when fallbacks are enabled with a locale list' do
-        with_i18n_fallbacks
+        require_fallbacks
 
-        around(:all) do |example|
-          prev_fallbacks = I18n.fallbacks.dup
+        before do
           I18n.fallbacks[:he] = [ :en ]
-          example.run
-          I18n.fallbacks = prev_fallbacks
         end
 
         let(:plucked) do
@@ -2093,6 +2087,8 @@ describe Mongoid::Criteria do
       end
 
       context "when the localized field is embedded" do
+        with_default_i18n_configs
+
         before do
           p = Passport.new
           I18n.locale = :en

data/spec/mongoid/errors/readonly_document_spec.rb

@@ -12,13 +12,13 @@ describe Mongoid::Errors::ReadonlyDocument do
 
     it "contains the problem in the message" do
       expect(error.message).to include(
-        "Attempted to persist the readonly document 'Band'."
+        "Attempted to persist a readonly document of class 'Band'."
       )
     end
 
     it "contains the summary in the message" do
       expect(error.message).to include(
-        "Documents loaded from the database using #only"
+        "Documents that are marked readonly cannot be persisted"
       )
     end