mongoid 7.1.0.rc0 → 7.2.0.rc1

data/spec/integration/matcher_operator_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+def mop_error?(spec, kind)
+  unless %w(matcher driver dsl).include?(kind)
+    raise ArgumentError, "Bogus kind: #{kind}"
+  end
+
+  spec['error'] == true || spec['error'] == kind ||
+    spec['error'].is_a?(Array) && spec['error'].include?(kind)
+end
+
+describe 'Matcher operators' do
+  Dir[File.join(File.dirname(__FILE__), 'matcher_operator_data', '*.yml')].sort.each do |path|
+    context File.basename(path) do
+      specs = YAML.load(File.read(path))
+
+      specs.each do |spec|
+        context spec['name'] do
+
+          if spec['pending']
+            before do
+              # Cannot use `pending` here because some of the queries may work
+              # as specified (e.g. when Mongoid and server behavior differ).
+              skip spec['pending'].to_s
+            end
+          end
+
+          if spec['min_server_version']
+            min_server_version spec['min_server_version'].to_s
+          end
+
+          let(:query) { spec.fetch('query') }
+          let(:result) { spec.fetch('matches') }
+
+          context 'embedded matching' do
+            let(:document) { Mop.new(spec.fetch('document')) }
+
+            if mop_error?(spec, 'matcher')
+              it 'produces an error' do
+                lambda do
+                  document._matches?(query)
+                end.should raise_error(Mongoid::Errors::InvalidQuery)
+              end
+            else
+              it 'produces the correct result' do
+                document._matches?(query).should be result
+              end
+            end
+          end
+
+          context 'server query' do
+            let!(:document) { Mop.create(spec.fetch('document')) }
+
+            context 'via driver' do
+              if mop_error?(spec, 'driver')
+                it 'produces an error' do
+                  begin
+                    Mop.collection.find(query).any?
+                  rescue Mongo::Error::OperationFailure
+                  rescue Mongo::Error::InvalidDocument
+                  rescue BSON::Error::UnserializableClass
+                  else
+                    fail "Expected an exception to be raised"
+                  end
+                end
+              else
+                it 'produces the correct result' do
+                  Mop.collection.find(query).any?.should be result
+                end
+              end
+            end
+
+            context 'via Mongoid DSL' do
+              if mop_error?(spec, 'dsl')
+                it 'produces an error' do
+                  begin
+                    Mop.where(query).any?
+                  rescue Mongo::Error::OperationFailure
+                  rescue BSON::Error::UnserializableClass
+                  rescue Mongoid::Errors::InvalidQuery
+                  rescue Mongoid::Errors::CriteriaArgumentRequired
+                  else
+                    fail "Expected the query to raise an error"
+                  end
+                end
+              else
+                it 'produces the correct result' do
+                  Mop.where(query).any?.should be result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/matcher_spec.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Matcher operators' do
+  let(:result) do
+    document._matches?(query)
+  end
+
+  shared_examples 'is true' do
+    it 'is true' do
+      result.should be true
+    end
+  end
+
+  shared_examples 'is false' do
+    it 'is false 'do
+      result.should be false
+    end
+  end
+
+  context 'when querying nested document' do
+    context 'embeds_one' do
+      let(:document) do
+        Canvas.new(
+          writer: Writer.new(speed: 3),
+        )
+      end
+
+      context 'implicit $eq' do
+        context 'matches' do
+          let(:query) do
+            {'writer.speed' => 3}
+          end
+
+          it_behaves_like 'is true'
+        end
+
+        context 'does not match' do
+          let(:query) do
+            {'speed' => 3}
+          end
+
+          it_behaves_like 'is false'
+        end
+      end
+
+      context 'field operator' do
+        # Test string and symbol operators
+        ['$gt', :$gt].each do |op|
+          context op.inspect do
+            context 'matches' do
+              let(:query) do
+                {'writer.speed' => {op => 2}}
+              end
+
+              it_behaves_like 'is true'
+            end
+
+            context 'does not match' do
+              let(:query) do
+                {'writer.speed' => {op => 3}}
+              end
+
+              it_behaves_like 'is false'
+            end
+          end
+        end
+      end
+
+      context 'hash query' do
+        context 'scalar field in embedded document' do
+          context 'matches' do
+            let(:query) do
+              {writer: {speed: 3}}
+            end
+
+            it_behaves_like 'is true'
+          end
+
+          context 'does not match' do
+            let(:query) do
+              {writer: {slow: 3}}
+            end
+
+            it_behaves_like 'is false'
+          end
+        end
+
+        context 'hash field' do
+          let(:document) do
+            Bar.new(
+              writer: {speed: 3},
+            )
+          end
+
+          context 'matches' do
+            let(:query) do
+              {writer: {speed: 3}}
+            end
+
+            it_behaves_like 'is true'
+          end
+
+          context 'does not match' do
+            let(:query) do
+              {writer: {slow: 3}}
+            end
+
+            it_behaves_like 'is false'
+          end
+        end
+      end
+    end
+
+    context 'embeds_many' do
+      let(:document) do
+        Survey.new(
+          questions: [Question.new(
+            answers: [
+              Answer.new(position: 3),
+              Answer.new(position: 4),
+            ],
+          )],
+        )
+      end
+
+      context 'implicit $eq' do
+        context 'matches' do
+          let(:query) do
+            {'questions.answers.position' => 3}
+          end
+
+          it_behaves_like 'is true'
+        end
+
+        context 'does not match' do
+          let(:query) do
+            {'questions.answers.position' => 2}
+          end
+
+          it_behaves_like 'is false'
+        end
+      end
+
+      context 'field operator' do
+        # Test string and symbol operators
+        ['$gt', :$gt].each do |op|
+          context op.inspect do
+            context 'matches' do
+              let(:query) do
+                {'questions.answers.position' => {op => 2}}
+              end
+
+              it_behaves_like 'is true'
+            end
+
+            context 'does not match' do
+              let(:query) do
+                {'questions.answers.position' => {op => 4}}
+              end
+
+              it_behaves_like 'is false'
+            end
+          end
+        end
+      end
+
+      context 'array index' do
+        context 'matches' do
+          let(:query) do
+            {'questions.answers.1' => {position: 4}}
+          end
+
+          it_behaves_like 'is true'
+        end
+
+        context 'does not match' do
+          let(:query) do
+            {'questions.answers.0' => {position: 4}}
+          end
+
+          it_behaves_like 'is false'
+        end
+      end
+    end
+  end
+end

data/spec/integration/server_query_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+# This file serves as a record of server query behavior.
+
+describe 'Server queries' do
+
+  context 'scalar operator on scalar field' do
+    let!(:document) do
+      Survey.create!(
+        questions: [Question.new(
+          answers: [Answer.new(position: 3)],
+        )],
+      )
+    end
+
+    let(:query) do
+      {'questions.answers.position' => {'$gt' => 2}}
+    end
+
+    it 'finds' do
+      Survey.collection.find(query).to_a.should == [document.attributes]
+    end
+  end
+
+  context 'scalar operator on array field' do
+    let!(:document) do
+      Bar.create!(
+        questions: [
+          answers: [
+            position: [3],
+          ],
+        ],
+      )
+    end
+
+    context '$eq with scalar on array field' do
+      let(:query) do
+        {'questions.answers.position' => {'$eq' => 3}}
+      end
+
+      it 'finds' do
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+
+    context '$ne with scalar on array field' do
+      context 'same value as array item' do
+        let(:query) do
+          {'questions.answers.position' => {'$ne' => 3}}
+        end
+
+        it 'matches array and does not find' do
+          Bar.collection.find(query).to_a.should == []
+        end
+      end
+
+      context 'different value from array items' do
+        let(:query) do
+          {'questions.answers.position' => {'$ne' => 2}}
+        end
+
+        it 'finds' do
+          Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+        end
+      end
+    end
+
+    context '$gt on array field' do
+      let(:query) do
+        {'questions.answers.position' => {'$gt' => 2}}
+      end
+
+      it 'finds' do
+        # This finds the document - https://jira.mongodb.org/browse/DOCSP-10717
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+
+    context '$in on a double array field' do
+      let!(:document) do
+        Bar.create!(
+          questions: [
+            answers: [
+              position: [[3]],
+            ],
+          ],
+        )
+      end
+
+      let(:query) do
+        {'questions.answers.position' => {'$in' => [3]}}
+      end
+
+      it 'does not find' do
+        Bar.collection.find(query).to_a.should == []
+      end
+    end
+
+    context '$in on an array field' do
+      let!(:document) do
+        Bar.create!(
+          questions: [
+            answers: [
+              position: [3],
+            ],
+          ],
+        )
+      end
+
+      let(:query) do
+        {'questions.answers.position' => {'$in' => [3]}}
+      end
+
+      it 'finds' do
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+
+    context '$in on a scalar field' do
+      let!(:document) do
+        Bar.create!(
+          questions: [
+            answers: [
+              position: 3,
+            ],
+          ],
+        )
+      end
+
+      let(:query) do
+        {'questions.answers.position' => {'$in' => [3]}}
+      end
+
+      it 'finds' do
+        Bar.collection.find(query).to_a.should == [document.attributes.with_indifferent_access]
+      end
+    end
+  end
+end

data/spec/integration/shardable_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+require_relative '../mongoid/shardable_models'
+
+describe 'Sharding helpers' do
+  require_topology :sharded
+
+  describe 'shard_collection rake task' do
+    let(:shard_collections) do
+      Mongoid::Tasks::Database.shard_collections([model_cls])
+    end
+
+    let(:create_indexes) do
+      Mongoid::Tasks::Database.create_indexes([model_cls])
+    end
+
+    shared_examples_for 'shards collection' do
+      it 'returns the model class' do
+        shard_collections.should == [model_cls]
+      end
+
+      it 'shards collection' do
+        shard_collections
+
+        stats = model_cls.collection.database.command(collStats: model_cls.collection.name).first
+        stats[:sharded].should be true
+      end
+    end
+
+    context 'simple model' do
+      let(:model_cls) { SmMovie }
+
+      before do
+        SmMovie.collection.drop
+      end
+
+      it_behaves_like 'shards collection'
+
+      it 'makes inserts work' do
+        shard_collections
+        create_indexes
+
+        SmMovie.create!(year: 2020)
+      end
+    end
+
+    context 'when database does not exist' do
+      let(:model_cls) { SmMovie }
+
+      before do
+        SmMovie.collection.database.drop
+      end
+
+      it_behaves_like 'shards collection'
+    end
+
+    context 'when database exists but collection does not exist' do
+      let(:model_cls) { SmMovie }
+
+      before do
+        SmMovie.collection.database.drop
+        SmMovie.collection.create
+        SmMovie.collection.drop
+      end
+
+      it_behaves_like 'shards collection'
+    end
+
+    context 'when collection is already sharded' do
+      let(:model_cls) { SmMovie }
+
+      before do
+        Mongoid::Tasks::Database.shard_collections([model_cls])
+      end
+
+      it_behaves_like 'shards collection'
+    end
+
+    context 'when hashed shard key is given' do
+      let(:model_cls) { SmAssistant }
+
+      before do
+        SmAssistant.collection.drop
+      end
+
+      it_behaves_like 'shards collection'
+
+      it 'makes inserts work' do
+        shard_collections
+        create_indexes
+
+        SmAssistant.create!(gender: 'm')
+      end
+    end
+
+    context 'when shard configuration is invalid' do
+      let(:model_cls) { SmActor }
+
+      it 'returns empty array' do
+        shard_collections.should == []
+      end
+
+      it 'does not shards collection' do
+        shard_collections
+
+        stats = model_cls.collection.database.command(collStats: model_cls.collection.name).first
+        stats[:sharded].should be false
+      end
+
+    end
+
+    context 'when models have no sharded configuration' do
+      let(:model_cls) { SmNotSharded }
+
+      before do
+        model_cls.shard_config.should be nil
+      end
+
+      it 'returns empty array' do
+        shard_collections.should == []
+      end
+
+      context 'pre-4.2' do
+        max_server_version '4.0'
+
+        it 'does not shards collection' do
+          shard_collections
+
+          lambda do
+            model_cls.collection.database.command(collStats: model_cls.collection.name).first
+          end.should raise_error(Mongo::Error::OperationFailure, /Collection.*not found/)
+        end
+      end
+
+      context '4.2+' do
+        min_server_version '4.2'
+
+        it 'does not shards collection' do
+          shard_collections
+
+          stats = model_cls.collection.database.command(collStats: model_cls.collection.name).first
+          stats[:sharded].should be false
+        end
+      end
+    end
+  end
+end