mongoid 7.0.12 → 7.3.3

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

data/spec/integration/stringified_symbol_field_spec.rb

@@ -0,0 +1,190 @@
+require "spec_helper"
+
+describe "StringifiedSymbol fields" do
+
+  before do
+    Order.destroy_all
+  end
+
+  context "when querying the database" do
+
+    let!(:document) do
+      Order.create!(saved_status: :test)
+    end
+
+    let(:string_query) do
+      {'saved_status' => {'$eq' => 'test'}}
+    end
+
+    let(:symbol_query) do
+      {'saved_status' => {'$eq' => :test}}
+    end
+
+    it "can be queried with a string" do
+      doc = Order.where(string_query).first
+      expect(doc.saved_status).to eq(:test)
+    end
+
+    it "can be queried with a symbol" do
+      doc = Order.where(symbol_query).first
+      expect(doc.saved_status).to eq(:test)
+    end
+  end
+
+  # Using command monitoring to test that StringifiedSymbol sends a string and returns a symbol
+  let(:client) { Order.collection.client }
+
+  before do
+    client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  after do
+    client.unsubscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  let(:subscriber) do
+    EventSubscriber.new
+  end
+
+  let(:find_events) do
+    subscriber.started_events.select { |event| event.command_name.to_s == 'find' }
+  end
+
+  let(:insert_events) do
+    subscriber.started_events.select { |event| event.command_name.to_s == 'insert' }
+  end
+
+  let(:update_events) do
+    subscriber.started_events.select { |event| event.command_name.to_s == 'update' }
+  end
+
+  before do
+    subscriber.clear_events!
+  end
+
+  let(:query) do
+    {'saved_status' => {'$eq' => 'test'}}
+  end
+
+  let!(:document1) do
+    Order.create!(saved_status: :test)
+  end
+
+  let!(:document2) do
+    Order.where(query).first
+  end
+
+  context "when inserting document" do
+
+    it "sends the value as a string" do
+      Order.create!(saved_status: :test)
+      event = insert_events.first
+      doc = event.command["documents"].first
+      expect(doc["saved_status"]).to eq("test")
+    end
+
+    it "sends the value as a string" do
+      Order.create!(saved_status: 42)
+      event = insert_events.second
+      doc = event.command["documents"].first
+      expect(doc["saved_status"]).to eq("42")
+    end
+
+    it "sends the value as a string" do
+      Order.create(saved_status: [0, 1, 2])
+      event = insert_events.second
+      doc = event.command["documents"].first
+      expect(doc["saved_status"]).to eq("[0, 1, 2]")
+    end
+  end
+
+  context "when finding document" do
+
+    it "receives the value as a symbol" do
+      event = find_events.first
+      expect(document2.saved_status).to eq(:test)
+    end
+  end
+
+  context "when reading a BSON Symbol field" do
+
+    before do
+      client["orders"].insert_one(saved_status: BSON::Symbol::Raw.new("test"), _id: 12)
+    end
+
+    it "receives the value as a symbol" do
+      expect(Order.find(12).saved_status).to eq(:test)
+    end
+
+    it "saves the value as a string" do
+      s = Order.find(12)
+      s.saved_status = :other
+      s.save!
+      event = update_events.first
+      expect(event.command["updates"].first["u"]["$set"]["saved_status"]).to eq("other")
+    end
+  end
+
+  context "when value is nil" do
+
+    before do
+      client["orders"].insert_one(saved_status: nil, _id: 15)
+    end
+
+    it "returns nil" do
+      expect(Order.find(15).saved_status).to be_nil
+    end
+  end
+
+  context "when writing nil" do
+
+    before do
+      client["orders"].insert_one(saved_status: "hello", _id: 16)
+    end
+
+    it "saves the value as nil" do
+      s = Order.find(16)
+      s.saved_status = nil
+      s.save!
+      event = update_events.first
+      expect(event.command["updates"].first["u"]["$set"]["saved_status"]).to be_nil
+    end
+  end
+
+  context "when reading an integer" do
+
+    before do
+      client["orders"].insert_one(saved_status: 42, _id: 13)
+    end
+
+    it "receives the value as a symbol" do
+      expect(Order.find(13).saved_status).to eq(:"42")
+    end
+
+    it "saves the value as a string" do
+      s = Order.find(13)
+      s.saved_status = 24
+      s.save!
+      event = update_events.first
+      expect(event.command["updates"].first["u"]["$set"]["saved_status"]).to eq("24")
+    end
+  end
+
+  context "when reading an array" do
+    before do
+      client["orders"].insert_one(saved_status: [0, 1, 2], _id: 14)
+    end
+
+    it "receives the value as a symbol" do
+      expect(Order.find(14).saved_status).to be(:"[0, 1, 2]")
+    end
+
+    it "saves the value as a string" do
+      s = Order.find(14)
+      s.saved_status = [3, 4, 5]
+      s.save!
+      event = update_events.first
+      expect(event.command["updates"].first["u"]["$set"]["saved_status"]).to eq("[3, 4, 5]")
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
+# encoding: utf-8
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "shared", "lib"))
 
-require "mongoid"
+# Load byebug before mongoid, to place breakpoints in the lib methods.
+# But SpecConfig needs the driver code - require the driver here.
+require "mongo"
 
 # MRI 2.5 and JRuby 9.2 change visibility of Object#pp when 'pp' is required,
 # which happens when RSpec reports anything. This creates an issue for tests
@@ -11,7 +15,10 @@ require "mongoid"
 # https://github.com/jruby/jruby/issues/5599
 require 'pp'
 
+autoload :Timecop, 'timecop'
+
 require 'support/spec_config'
+require 'mrss/lite_constraints'
 require "support/session_registry"
 
 unless SpecConfig.instance.ci?
@@ -28,6 +35,8 @@ unless SpecConfig.instance.ci?
   end
 end
 
+require 'mongoid'
+
 if SpecConfig.instance.mri?
   require 'timeout_interrupt'
 else
@@ -44,11 +53,10 @@ RSpec.configure do |config|
     config.add_formatter(RSpec::Core::Formatters::JsonFormatter, File.join(File.dirname(__FILE__), '../tmp/rspec.json'))
   end
 
-  if SpecConfig.instance.ci?
+  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
     timeout = if SpecConfig.instance.app_tests?
-      # Allow 5 minutes per test for the app tests, since they install
-      # gems for Rails applications which can take a long time.
-      300
+      # App tests under JRuby take a REALLY long time (over 5 minutes per test).
+      500
     else
       # Allow a max of 30 seconds per test.
       # Tests should take under 10 seconds ideally but it seems
@@ -61,6 +69,8 @@ RSpec.configure do |config|
       end
     end
   end
+
+  config.extend(Mrss::LiteConstraints)
 end
 
 # require all shared examples