mongoid 7.2.1 → 9.0.0

data/spec/mongoid/indexable/specification_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -81,25 +81,143 @@ describe Mongoid::Indexable::Specification do
 
   describe "#initialize" do
 
-    let(:spec) do
-      described_class.new(
-        Band,
-        { name: 1, title: 1, years: -1 },
-        background: true,
-        drop_dups: true
-      )
+    context "standard case" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1 },
+          background: true,
+          unique: true
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(background: true, unique: true)
+      end
     end
 
-    it "sets the class" do
-      expect(spec.klass).to eq(Band)
+    context "with aliased field options" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1, d: 1 },
+          partial_filter_expression: {
+            name: { '$exists' => true },
+            years: { '$gt' => 5 },
+            d: { '$eq' => false },
+            '$and' => [
+              { views: { '$gt' => 100 } },
+              { years: { '$lte' => 50 } }
+            ]
+          },
+          weights: {
+            name: 1,
+            years: 2
+          },
+          wildcard_projection: {
+            years: 1
+          }
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1, deleted: 1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(partial_filter_expression: {
+                                     name: { '$exists' => true },
+                                     y: { '$gt' => 5 },
+                                     deleted: { '$eq' => false },
+                                     '$and': [
+                                       { views: { '$gt' => 100 } },
+                                       { y: { '$lte' => 50 } }
+                                     ]
+                                   },
+                                   weights: {
+                                     name: 1,
+                                     y: 2
+                                   },
+                                   wildcard_projection: {
+                                     y: 1
+                                   })
+      end
     end
 
-    it "normalizes the key" do
-      expect(spec.key).to eq(name: 1, title: 1, y: -1)
+    context "with aliased field options nested inside $ operators" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1 },
+          partial_filter_expression: {
+            '$foo' => { years: { '$lte' => 50 } },
+            '$bar' => [
+              { views: { '$gt' => 100 } },
+              { years: { '$lte' => 50 } }
+            ]
+          }
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(partial_filter_expression: {
+          '$foo': { y: { '$lte' => 50 } },
+          '$bar': [
+            { views: { '$gt' => 100 } },
+            { y: { '$lte' => 50 } }
+          ]
+        })
+      end
     end
 
-    it "normalizes the options" do
-      expect(spec.options).to eq(background: true, drop_dups: true)
+    context "with aliased field options double-nested" do
+
+      let(:spec) do
+        described_class.new(
+          Band,
+          { name: 1, title: 1, years: -1 },
+          partial_filter_expression: {
+            '$foo' => { years: { years: { '$lte' => 50 } } },
+          }
+        )
+      end
+
+      it "sets the class" do
+        expect(spec.klass).to eq(Band)
+      end
+
+      it "normalizes the key" do
+        expect(spec.key).to eq(name: 1, title: 1, y: -1)
+      end
+
+      it "normalizes the options" do
+        expect(spec.options).to eq(partial_filter_expression: {
+          '$foo': { y: { years: { '$lte' => 50 } } },
+        })
+      end
     end
   end
 

data/spec/mongoid/indexable_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -110,7 +110,6 @@ describe Mongoid::Indexable do
 
       after do
         klass.remove_indexes
-        Mongoid::Config.background_indexing = false
       end
 
       let(:indexes) do
@@ -119,20 +118,27 @@ describe Mongoid::Indexable do
         end
       end
 
-      it "creates the indexes by using default background_indexing option" do
-        klass.create_indexes
+      context "when the background_indexing option is false" do
+        config_override :background_indexing, false
+
+        it "creates the indexes correctly" do
+          klass.create_indexes
 
-        index = indexes.get(_type: 1)
-        expect(index[:background]).to eq(Mongoid::Config.background_indexing)
+          index = indexes.get(_type: 1)
+          expect(index[:background]).to be false
+        end
       end
 
-      it "creates the indexes by using specified background_indexing option" do
-        Mongoid::Config.background_indexing = true
+      context "when the background_indexing option is true" do
+        config_override :background_indexing, true
 
-        klass.create_indexes
+        it "creates the indexes correctly" do
 
-        index = indexes.get(_type: 1)
-        expect(index[:background]).to eq(true)
+          klass.create_indexes
+
+          index = indexes.get(_type: 1)
+          expect(index[:background]).to be true
+        end
       end
     end
 
@@ -192,7 +198,7 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when using a custom discriminator_key" do 
+    context "when using a custom discriminator_key" do
       context "when indexes have not been added" do
         let(:klass) do
           Class.new do
@@ -203,15 +209,15 @@ describe Mongoid::Indexable do
             end
           end
         end
-  
+
         before do
           klass.add_indexes
         end
-  
+
         let(:spec) do
           klass.index_specification(dkey: 1)
         end
-  
+
         it "adds the _type index" do
           expect(spec.options).to eq(unique: false, background: true)
         end
@@ -224,8 +230,15 @@ describe Mongoid::Indexable do
     let(:klass) do
       Class.new do
         include Mongoid::Document
-        field :a, as: :authentication_token
+
         store_in collection: :specs
+
+        field :a, as: :authentication_token
+        field :username
+
+        alias_attribute :u, :username
+
+        embeds_many :addresses, store_as: :adrs
       end
     end
 
@@ -248,14 +261,14 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when providing unique options" do
+    context "when indexing a field that is embedded" do
 
       before do
-        klass.index({ name: 1 }, unique: true)
+        klass.index({ 'addresses.house' => 1 }, unique: true)
       end
 
       let(:options) do
-        klass.index_specification(name: 1).options
+        klass.index_specification('adrs.h': 1).options
       end
 
       it "sets the index with unique options" do
@@ -263,18 +276,18 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when providing a drop_dups option" do
+    context "when providing unique options" do
 
       before do
-        klass.index({ name: 1 }, drop_dups: true)
+        klass.index({ name: 1 }, unique: true)
       end
 
       let(:options) do
         klass.index_specification(name: 1).options
       end
 
-      it "sets the index with drop_dups option" do
-        expect(options).to eq(drop_dups: true)
+      it "sets the index with unique options" do
+        expect(options).to eq(unique: true)
       end
     end
 
@@ -439,6 +452,18 @@ describe Mongoid::Indexable do
       end
     end
 
+    context "when providing a geo haystack index with a bucket_size" do
+
+      let(:message) do
+        'The geoHaystack type is deprecated.'
+      end
+
+      it "logs a deprecation warning" do
+        expect(Mongoid::Warnings).to receive(:warn_geo_haystack_deprecated)
+        klass.index({ location: "geoHaystack" }, { min: -200, max: 200, bucket_size: 0.5 })
+      end
+    end
+
     context "when providing a Spherical Geospatial index" do
 
       before do
@@ -592,6 +617,319 @@ describe Mongoid::Indexable do
       end
     end
 
+    context "when using partial_filter_expression option" do
+
+      context 'when not using an alias' do
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: { username: { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { username: { '$exists' => true } })
+        end
+      end
+
+      context 'when using an alias via field :as option' do
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: { authentication_token: { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { a: { '$exists' => true } })
+        end
+      end
+
+      context 'when using an alias via alias_attribute' do
+
+        before do
+          klass.index({ u: 1 }, partial_filter_expression: { u: { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(username: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { username: { '$exists' => true } })
+        end
+      end
+
+      context 'when using an embedded field' do
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: { 'addresses.house' => { '$exists' => true } })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(partial_filter_expression: { 'adrs.h': { '$exists' => true } })
+        end
+      end
+
+      context 'when using nested $and operator' do
+        let(:partial_filter_expression) do
+          {
+            '$and' => [
+              { 'authentication_token' => { '$gte' => 0 } },
+              { 'authentication_token' => { '$type' => 16 } }
+            ]
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            '$and': [
+              { 'a': { '$gte' => 0 } },
+              { 'a': { '$type' => 16 } }
+            ]
+          }
+        end
+
+        it "resolves alias on $and option" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
+      end
+
+      context 'when using nested operators other than $and' do
+        let(:partial_filter_expression) do
+          {
+            'username' => { '$eq' => 'authentication_token' },
+            'addresses.house' => { '$exists' => true }
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            username: { '$eq' => 'authentication_token' },
+            'adrs.h': { '$exists' => true }
+          }
+        end
+
+        it "preserves other operators" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
+      end
+
+      context 'when using mixed nested operators' do
+        let(:partial_filter_expression) do
+          {
+            'username' => { '$eq' => 'authentication_token' },
+            'addresses.house' => { '$exists' => true },
+            '$and' => [
+              { 'authentication_token' => { '$gte' => 0 } },
+              { 'authentication_token' => { '$type' => 16 } }
+            ]
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            username: { '$eq' => 'authentication_token' },
+            'adrs.h': { '$exists' => true },
+            '$and': [
+              { 'a': { '$gte' => 0 } },
+              { 'a': { '$type' => 16 } }
+            ]
+          }
+        end
+
+        it "resolves aliases on $ operators" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
+      end
+
+      context 'when using multiple levels of nonsensical nested operators' do
+        let(:partial_filter_expression) do
+          {
+            '$foo' => {
+              '$eq' => [{
+                '$bar' => {
+                  '$and' => [
+                    { 'authentication_token' => { '$gte' => { 'aliased_timestamp' => 16 } } },
+                    { 'authentication_token' => { 'aliased_timestamp' => 16 } },
+                    { 'addresses.house' => { 'authentication_token' => [{ 'aliased_timestamp' => 16 }] } }
+                  ]
+                }
+              }]
+            }
+          }
+        end
+
+        before do
+          klass.index({ authentication_token: 1 }, partial_filter_expression: partial_filter_expression)
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        let(:expected) do
+          {
+            '$foo': {
+              '$eq': [{
+                '$bar': {
+                  '$and': [
+                    { a: { '$gte' => { 'aliased_timestamp' => 16 } } },
+                    { a: { 'aliased_timestamp' => 16 } },
+                    { 'adrs.h': { 'authentication_token' => [{ 'aliased_timestamp' => 16 }] } }
+                  ]
+                }
+              }]
+            }
+          }
+        end
+
+        it "resolves aliases recursively only on $ operators" do
+          expect(options[:partial_filter_expression]).to eq(expected)
+        end
+      end
+    end
+
+    context "when using weights option" do
+
+      context 'when not using aliases' do
+
+        before do
+          klass.index({ authentication_token: 1 }, weights: { a: 1, username: 2 })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(weights: { a: 1, username: 2 })
+        end
+      end
+
+      context 'when using aliases via field :as option' do
+
+        before do
+          klass.index({ authentication_token: 1 }, weights: { 'addresses.house' => 1, authentication_token: 2 })
+        end
+
+        let(:options) do
+          klass.index_specification(a: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(weights: { 'adrs.h': 1, a: 2 })
+        end
+      end
+
+      context 'when using aliases via alias_attribute' do
+
+        before do
+          klass.index({ u: 1 }, weights: { 'addresses.n' => 1, u: 2 })
+        end
+
+        let(:options) do
+          klass.index_specification(username: 1).options
+        end
+
+        it "sets the index with correct options" do
+          expect(options).to eq(weights: { 'adrs.name': 1, username: 2 })
+        end
+      end
+    end
+
+    context "when using wildcard indexes" do
+
+      context 'when not using an alias' do
+
+        before do
+          klass.index({ '$**': 1 }, wildcard_projection: { _id: 1, username: 0 })
+        end
+
+        let(:spec) do
+          klass.index_specification('$**': 1)
+        end
+
+        it "creates the index" do
+          expect(spec).to be_a(Mongoid::Indexable::Specification)
+        end
+
+        it "sets the index with correct options" do
+          expect(spec.options).to eq(wildcard_projection: { _id: 1, username: 0 })
+        end
+      end
+
+      context 'when using an alias via field :as option' do
+
+        before do
+          klass.index({ 'addresses.$**': 1 }, wildcard_projection: { 'addresses.house' => 1 })
+        end
+
+        let(:spec) do
+          klass.index_specification('adrs.$**': 1)
+        end
+
+        it "creates the index" do
+          expect(spec).to be_a(Mongoid::Indexable::Specification)
+        end
+
+        it "sets the index with correct options" do
+          expect(spec.options).to eq(wildcard_projection: { 'adrs.h': 1 })
+        end
+      end
+
+      context 'when using aliases via alias_attribute' do
+
+        before do
+          klass.index({ 'addresses.$**': 1 }, wildcard_projection: { 'addresses.n' => 1 })
+        end
+
+        let(:spec) do
+          klass.index_specification('adrs.$**': 1)
+        end
+
+        it "creates the index" do
+          expect(spec).to be_a(Mongoid::Indexable::Specification)
+        end
+
+        it "sets the index with correct options" do
+          expect(spec.options).to eq(wildcard_projection: { 'adrs.name': 1 })
+        end
+      end
+    end
+
     context "when providing an invalid option" do
 
       it "raises an error" do