mongoid 7.0.13 → 8.0.8

data/spec/integration/dots_and_dollars_spec.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "Dots and Dollars" do
+  min_server_version '5.0'
+
+  before(:all) do
+    class DADMUser
+      include Mongoid::Document
+      field :"first.last", type: String, default: "Neil.Shweky"
+      field :"$_amount", type: Integer, default: 0
+      field :"$a.b", type: Boolean, default: true
+    end
+  end
+
+  let!(:user) { DADMUser.create! }
+
+  describe "accessing the fields" do
+
+    context "when using the field getters" do
+
+      context "on dotted fields" do
+        it "gets the right value" do
+          expect(user.send(:"first.last")).to eq("Neil.Shweky")
+        end
+      end
+
+      context "on dollared fields" do
+        it "gets the right value" do
+          expect(user.send(:"$_amount")).to eq(0)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "gets the right value" do
+          expect(user.send(:"$a.b")).to be true
+        end
+      end
+    end
+
+    context "when using the read_attribute" do
+
+      context "on dotted fields" do
+        it "gets the right value" do
+          expect(user.read_attribute("first.last")).to eq("Neil.Shweky")
+        end
+      end
+
+      context "on dollared fields" do
+        it "gets the right value" do
+          expect(user.read_attribute("$_amount")).to eq(0)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "gets the right value" do
+          expect(user.read_attribute("$a.b")).to be true
+        end
+      end
+    end
+
+    context "when using the field setters" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.send(:"first.last=", "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.send(:"$_amount=", 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.send(:"$a.b=", false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via write_attribute" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.write_attribute("first.last", "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.write_attribute("$_amount", 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.write_attribute("$a.b", false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via update_attribute" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.update_attribute("first.last", "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attribute("$_amount", 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attribute("$a.b", false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via update_attributes!" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.update_attributes!("first.last": "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attributes!("$_amount": 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attributes!("$a.b": false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via []=" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user[:"first.last"] = "Nissim.Shweky"
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user[:"$_amount"] = 1
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user[:"$a.b"] = false
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via remove_attribute" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.remove_attribute("first.last")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.remove_attribute("$_amount")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.remove_attribute("$a.b")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+  end
+
+  describe "persisting to the db" do
+
+    context "when saving to the db" do
+
+      let(:user) { DADMUser.new }
+
+      it "the save succeeds" do
+        expect do
+          user.save!
+        end.to_not raise_error
+      end
+    end
+
+    context "when retrieving it from the db" do
+
+      let(:from_db) { DADMUser.first }
+
+      it "has the fields populated correctly" do
+        expect(from_db.attributes["first.last"]).to eq("Neil.Shweky")
+        expect(from_db.attributes["$_amount"]).to eq(0)
+        expect(from_db.attributes["$a.b"]).to eq(true)
+      end
+    end
+  end
+
+  describe "querying that field" do
+
+    context "when attempting to query a dotted field" do
+
+      let(:queried) do
+        DADMUser.where("first.last": "Neil.Shweky").first
+      end
+
+      it "does not work" do
+        expect(queried).to be nil
+      end
+    end
+
+    context "when attempting to query a dollared field" do
+
+      let(:queried) do
+        DADMUser.where("$_amount": 0).first
+      end
+
+      it "raise an error" do
+        expect do
+          queried
+        end.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

data/spec/integration/i18n_fallbacks_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'i18n fallbacks' do
+  with_i18n_fallbacks
+
+  context 'when fallbacks are enabled with a locale list' do
+    before do
+      I18n.default_locale = :en
+      I18n.fallbacks[:de] = [ :en ]
+    end
+
+    context 'when translation is present in active locale' do
+      it 'uses active locale' do
+        product = Product.new
+        I18n.locale = :de
+        product.description = "Marvelous in German"
+        I18n.locale = :en
+        product.description = "Marvelous!"
+        I18n.locale = :de
+        product.description.should == 'Marvelous in German'
+      end
+    end
+
+    context 'when translation is missing in active locale and present in fallback locale' do
+      it 'falls back on default locale' do
+        product = Product.new
+        I18n.locale = :en
+        product.description = "Marvelous!"
+        I18n.locale = :de
+        product.description.should == 'Marvelous!'
+      end
+    end
+
+    context 'when translation is missing in all locales' do
+
+      context 'i18n >= 1.1' do
+
+        before(:all) do
+          unless Gem::Version.new(I18n::VERSION) >= Gem::Version.new('1.1')
+            skip "Test requires i18n >= 1.1, we have #{I18n::VERSION}"
+          end
+        end
+
+        it 'returns nil' do
+          product = Product.new
+          I18n.locale = :en
+          product.description = "Marvelous!"
+          I18n.locale = :ru
+          product.description.should be nil
+        end
+      end
+
+      context 'i18n 1.0' do
+
+        before(:all) do
+          unless Gem::Version.new(I18n::VERSION) < Gem::Version.new('1.1')
+            skip "Test requires i18n < 1.1, we have #{I18n::VERSION}"
+          end
+        end
+
+        it 'falls back on default locale' do
+          product = Product.new
+          I18n.locale = :en
+          product.description = "Marvelous!"
+          I18n.locale = :ru
+          product.description.should == 'Marvelous!'
+        end
+      end
+    end
+  end
+end

data/spec/integration/{matchable_spec.rb → matcher_examples_spec.rb}

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require 'spec_helper'
 
+# Some of these tests duplicate the tests in matcher_operator_spec.rb.
+# The tests in this file are retained because they use model instances
+# rather than simple hashes as the YAML tests do, hence in theory these tests
+# could provide additional coverage.
+
 describe 'Matcher' do
   context 'when attribute is a scalar' do
     describe 'exact match' do
@@ -65,12 +69,12 @@ describe 'Matcher' do
       end
     end
 
-    describe 'range match on number' do
+    describe 'range match on scalar' do
 
       let!(:circuit) do
         Circuit.create!(buses: [
-          Bus.new(number: '10'),
-          Bus.new(number: '30'),
+          Bus.new(number: 10),
+          Bus.new(number: 30),
         ])
       end
 
@@ -79,9 +83,17 @@ describe 'Matcher' do
           Circuit.where('buses.number' => 10..15).first
         end
 
+        let(:not_found_circuit) do
+          Circuit.where('buses.number' => 35..45).first
+        end
+
         it 'finds' do
           expect(found_circuit).to eq(circuit)
         end
+
+        it 'does not find' do
+          expect(not_found_circuit).to be nil
+        end
       end
 
       describe 'Mongoid matcher' do
@@ -89,9 +101,17 @@ describe 'Matcher' do
           circuit.buses.where(number: 10..15).first
         end
 
+        let(:not_found_bus) do
+          circuit.buses.where(number: 12..15).first
+        end
+
         it 'finds' do
           expect(found_bus).to be circuit.buses.first
         end
+
+        it 'does not find' do
+          expect(not_found_bus).to be nil
+        end
       end
     end
 
@@ -445,17 +465,12 @@ describe 'Matcher' do
               {'number' => 1},
             ]}).first
           end
-        end
 
-        it 'is prohibited' do
-          # MongoDB prohibits $and operator in values when matching on
-          # fields. Mongoid does not have such a prohibition and
-          # also returns the address where different locations match the
-          # different branches.
-          pending 'Mongoid behavior differs from MongoDB'
-          expect do
-            actual_object_matching_condition
-          end.to raise_error(Mongoid::Errors::InvalidFind)
+          it 'is prohibited' do
+            expect do
+              actual_object_matching_condition
+            end.to raise_error(Mongoid::Errors::InvalidFieldOperator)
+          end
         end
       end
     end
@@ -502,17 +517,12 @@ describe 'Matcher' do
               {'number' => 1},
             ]}).first
           end
-        end
 
-        it 'is prohibited' do
-          # MongoDB prohibits $and operator in values when matching on
-          # fields. Mongoid does not have such a prohibition and
-          # also returns the address where different locations match the
-          # different branches.
-          pending 'Mongoid behavior differs from MongoDB'
-          expect do
-            actual_object_matching_condition
-          end.to raise_error(Mongoid::Errors::InvalidFind)
+          it 'is prohibited' do
+            expect do
+              actual_object_matching_condition
+            end.to raise_error(Mongoid::Errors::InvalidFieldOperator)
+          end
         end
       end
     end
@@ -520,9 +530,6 @@ describe 'Matcher' do
     describe '$not' do
       let!(:person) do
         Person.new(addresses: [
-          Address.new(locations: [
-            Location.new(name: 'City', number: 1),
-          ]),
           Address.new(locations: [
             # Both criteria are on the same object
             Location.new(name: 'Hall', number: 1),
@@ -542,9 +549,9 @@ describe 'Matcher' do
       end
 
       let(:actual_object_not_matching_condition) do
-        person.addresses.where(operator => [
-          {'locations.number' => {'$exists' => true}},
-        ]).first
+        person.addresses.where('locations.name' => {operator =>
+          {'$eq' => 'Hall'},
+        }).first
       end
 
       it_behaves_like 'a field operator', '$not'
@@ -573,17 +580,12 @@ describe 'Matcher' do
               {'number' => 1},
             ]}).first
           end
-        end
 
-        it 'is prohibited' do
-          # MongoDB prohibits $and operator in values when matching on
-          # fields. Mongoid does not have such a prohibition and
-          # also returns the address where different locations match the
-          # different branches.
-          pending 'Mongoid behavior differs from MongoDB'
-          expect do
-            actual_object_matching_condition
-          end.to raise_error(Mongoid::Errors::InvalidFind)
+          it 'is prohibited' do
+            expect do
+              actual_object_matching_condition
+            end.to raise_error(Mongoid::Errors::InvalidQuery)
+          end
         end
       end
     end
@@ -650,10 +652,12 @@ describe 'Matcher' do
 
     describe 'range match on array element' do
 
+      let(:record) do
+        Record.new(producers: [123, 456])
+      end
+
       let!(:band) do
-        Band.create!(records: [
-          Record.new(producers: [123, 456]),
-        ])
+        Band.create!(records: [ record ])
       end
 
       describe 'MongoDB query' do
@@ -664,6 +668,19 @@ describe 'Matcher' do
         it 'finds' do
           expect(found_band).to eq(band)
         end
+
+        context 'no match' do
+
+          let!(:band) do
+            Band.create!(records: [
+              Record.new(producers: [50, 250]),
+            ])
+          end
+
+          it 'does not find' do
+            expect(found_band).to be nil
+          end
+        end
       end
 
       describe 'Mongoid matcher' do
@@ -671,8 +688,76 @@ describe 'Matcher' do
           band.records.where(producers: 100..200).first
         end
 
-        it 'finds' do
-          expect(found_record).to be band.records.first
+        let(:no_record) do
+          band.records.where(producers: 199..200).first
+        end
+
+        it 'finds correctly' do
+          expect(found_record).to eq(record)
+        end
+
+        it "correctly does not find" do
+          expect(no_record).to eq(nil)
+        end
+      end
+    end
+  end
+
+  describe '$elemMatch' do
+    context 'hash match against scalar value in embeds_many' do
+      context 'string value' do
+        let(:band) do
+          Band.new(records: [
+            Record.new(producers: ['Sunrise']),
+          ])
+        end
+
+        it 'does not find' do
+          band.records.where(producers: {'$elemMatch': {foo: 'bar'}}).first.should be nil
+        end
+
+        context 'primitive value query' do
+
+          it 'does not find' do
+            lambda do
+              band.records.where(producers: {'$elemMatch': 'bar'}).first
+            end.should raise_error(Mongoid::Errors::InvalidQuery, /elemMatch requires a Hash operand/)
+          end
+        end
+
+        context '$not with primitive value' do
+
+          it 'does not find' do
+            lambda do
+              band.records.where(producers: {'$elemMatch': {'$not': 'bar'}}).first
+            end.should raise_error(Mongoid::Errors::InvalidQuery, /\$not argument must be a Hash or a regular expression/)
+          end
+        end
+
+        context '$not with regexp' do
+
+          it 'finds' do
+            band.records.where(producers: {'$elemMatch': {'$not': /bar/}}).count.should == 1
+          end
+        end
+
+        context '$not with operator' do
+
+          it 'finds' do
+            band.records.where(producers: {'$elemMatch': {'$not': {'$eq': 'bar'}}}).count.should == 1
+          end
+        end
+      end
+
+      context 'integer value' do
+        let(:band) do
+          Band.new(records: [
+            Record.new(producers: [42]),
+          ])
+        end
+
+        it 'does not find' do
+          band.records.where(producers: {'$elemMatch': {foo: 'bar'}}).first.should be nil
         end
       end
     end