mongoid 7.0.2 → 7.0.3

data/spec/mongoid/findable_spec.rb

@@ -10,7 +10,7 @@ describe Mongoid::Findable do
     end
 
     it "returns the distinct values for the field" do
-      expect(Band.distinct(:name)).to eq([ "Tool", "Photek" ])
+      expect(Band.distinct(:name).sort).to eq([ "Photek", "Tool" ])
     end
   end
 

data/spec/mongoid/matchable/eq_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Matchable::Eq do
+
+  let(:matcher) do
+    described_class.new("first")
+  end
+
+  describe "#_matches?" do
+
+    context "when the values are equal" do
+
+      it "returns true" do
+        expect(matcher._matches?("$eq" => "first")).to be true
+      end
+    end
+
+    context "when the values are not equal" do
+
+      it "returns false" do
+        expect(matcher._matches?("$eq" => "second")).to be false
+      end
+    end
+
+    context "when the value is an array" do
+
+      let(:array_matcher) do
+        described_class.new([ "first" ])
+      end
+
+      context "when the value is in the array" do
+
+        it "returns true" do
+          expect(array_matcher._matches?("$eq" => "first")).to be true
+        end
+      end
+
+      context "when the value is not in the array" do
+
+        it "returns false" do
+          expect(array_matcher._matches?("$eq" => "second")).to be false
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -66,15 +66,15 @@ describe Mongoid::Persistable::Incrementable do
       context "when providing big decimal values" do
 
         let(:five) do
-          BigDecimal.new("5.0")
+          BigDecimal("5.0")
         end
 
         let(:neg_ten) do
-          BigDecimal.new("-10.0")
+          BigDecimal("-10.0")
         end
 
         let(:thirty) do
-          BigDecimal.new("30.0")
+          BigDecimal("30.0")
         end
 
         let!(:inc) do
@@ -151,15 +151,15 @@ describe Mongoid::Persistable::Incrementable do
       context "when providing big decimal values" do
 
         let(:five) do
-          BigDecimal.new("5.0")
+          BigDecimal("5.0")
         end
 
         let(:neg_ten) do
-          BigDecimal.new("-10.0")
+          BigDecimal("-10.0")
         end
 
         let(:thirty) do
-          BigDecimal.new("30.0")
+          BigDecimal("30.0")
         end
 
         let!(:inc) do

data/spec/mongoid/persistence_context_spec.rb

@@ -536,7 +536,7 @@ describe Mongoid::PersistenceContext do
     end
 
     before do
-      Mongoid.clients[:alternative] = { database: :mongoid_test, hosts: [ "#{HOST}:#{PORT}" ] }
+      Mongoid.clients[:alternative] = { database: :mongoid_test, hosts: SpecConfig.instance.addresses }
     end
 
     after do

data/spec/mongoid/query_cache_spec.rb

@@ -123,6 +123,36 @@ describe Mongoid::QueryCache do
     end
   end
 
+  context 'querying all documents after a single document' do
+    before do
+      3.times do
+        Person.create
+      end
+    end
+
+    it 'returns all documents' do
+      expect(Person.all.to_a.count).to eq(3)
+      Person.first
+      expect(Person.all.to_a.count).to eq(3)
+    end
+
+    context 'with conditions specified' do
+      it 'returns all documents' do
+        expect(Person.gt(age: 0).to_a.count).to eq(3)
+        Person.gt(age: 0).first
+        expect(Person.gt(age: 0).to_a.count).to eq(3)
+      end
+    end
+
+    context 'with order specified' do
+      it 'returns all documents' do
+        expect(Person.order_by(name: 1).to_a.count).to eq(3)
+        Person.order_by(name: 1).first
+        expect(Person.order_by(name: 1).to_a.count).to eq(3)
+      end
+    end
+  end
+
   context "when querying in the same collection" do
 
     before do
@@ -411,18 +441,18 @@ describe Mongoid::QueryCache do
     end
   end
 
-  context "when querying a very large collection" do
+  context "when querying collection smaller than the batch size" do
 
     before do
-      123.times { Band.create! }
+      99.times { Band.create! }
     end
 
     it "returns the right number of records" do
-      expect(Band.all.to_a.length).to eq(123)
+      expect(Band.all.to_a.length).to eq(99)
     end
 
     it "#pluck returns the same count of objects" do
-      expect(Band.pluck(:name).length).to eq(123)
+      expect(Band.pluck(:name).length).to eq(99)
     end
 
     context "when loading all the documents" do
@@ -433,12 +463,12 @@ describe Mongoid::QueryCache do
 
       it "caches the complete result of the query" do
         expect_no_queries do
-          expect(Band.all.to_a.length).to eq(123)
+          expect(Band.all.to_a.length).to eq(99)
         end
       end
 
       it "returns the same count of objects when using #pluck" do
-        expect(Band.pluck(:name).length).to eq(123)
+        expect(Band.pluck(:name).length).to eq(99)
       end
     end
   end
@@ -450,6 +480,29 @@ describe Mongoid::QueryCache do
       Band.collection.indexes.create_one(name: 1)
     end
   end
+
+  context 'when the initial query does not exhaust the results' do
+    before do
+      Mongoid::QueryCache.enabled = true
+      10.times { Band.create! }
+
+      Band.batch_size(4).all.any?
+    end
+
+    it 'does not cache the result' do
+      expect(Band.all.map(&:id).size).to eq(10)
+    end
+
+    context 'when a batch size smaller than the result set is specified' do
+      let(:batch_size) do
+        4
+      end
+
+      it 'does not cache the result' do
+        expect(Band.batch_size(batch_size).all.map(&:id).size).to eq(10)
+      end
+    end
+  end
 end
 
 describe Mongoid::QueryCache::Middleware do

data/spec/mongoid/scopable_spec.rb

@@ -1130,6 +1130,19 @@ describe Mongoid::Scopable do
     it "sets the threading options" do
       Band.without_default_scope do
         expect(Mongoid::Threaded).to be_executing(:without_default_scope)
+        expect(Mongoid::Threaded.without_default_scope?(Band)).to be(true)
+      end
+    end
+
+    it "suppresses default scope on the given model within the given block" do
+      Appointment.without_default_scope do
+        expect(Appointment.all.selector).to be_empty
+      end
+    end
+
+    it "does not affect other models' default scopes within the given block" do
+      Appointment.without_default_scope do
+        expect(Audio.all.selector).not_to be_empty
       end
     end
   end

data/spec/mongoid/threaded_spec.rb

@@ -233,4 +233,72 @@ describe Mongoid::Threaded do
       end
     end
   end
+
+  describe "#begin_without_default_scope" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    after do
+      described_class.exit_without_default_scope(klass)
+    end
+
+    it "adds the given class to the without_default_scope stack" do
+      described_class.begin_without_default_scope(klass)
+
+      expect(described_class.stack(:without_default_scope)).to include(klass)
+    end
+  end
+
+  describe "#exit_without_default_scope" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    before do
+      described_class.begin_without_default_scope(klass)
+    end
+
+    it "removes the given class from the without_default_scope stack" do
+      described_class.exit_without_default_scope(klass)
+
+      expect(described_class.stack(:without_default_scope)).not_to include(klass)
+    end
+  end
+
+  describe "#without_default_scope?" do
+
+    let(:klass) do
+      Appointment
+    end
+
+    context "when klass has begun without_default_scope" do
+
+      before do
+        described_class.begin_without_default_scope(klass)
+      end
+
+      after do
+        described_class.exit_without_default_scope(klass)
+      end
+
+      it "returns true" do
+        expect(described_class.without_default_scope?(klass)).to be(true)
+      end
+    end
+
+    context "when klass has exited without_default_scope" do
+
+      before do
+        described_class.begin_without_default_scope(klass)
+        described_class.exit_without_default_scope(klass)
+      end
+
+      it "returns false" do
+        expect(described_class.without_default_scope?(klass)).to be(false)
+      end
+    end
+  end
 end

data/spec/rails/controller_extension/controller_runtime_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+require "mongoid/railties/controller_runtime"
+
+describe "Mongoid::Railties::ControllerRuntime" do
+  controller_runtime = Mongoid::Railties::ControllerRuntime
+  collector = controller_runtime::Collector
+
+  def set_metric value
+    Thread.current["Mongoid.controller_runtime"] = value
+  end
+
+  def clear_metric!
+    set_metric 0
+  end
+
+  describe "Collector" do
+
+    it "stores the metric in thread-safe manner" do
+      clear_metric!
+      expect(collector.runtime).to eq(0)
+      set_metric 42
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "sets metric on both succeeded and failed" do
+      instance = collector.new
+      event_payload = OpenStruct.new duration: 42
+
+      clear_metric!
+      instance.succeeded event_payload
+      expect(collector.runtime).to eq(42)
+
+      clear_metric!
+      instance.failed event_payload
+      expect(collector.runtime).to eq(42)
+    end
+
+    it "resets the metric and returns the value" do
+      clear_metric!
+      expect(collector.reset_runtime).to eq(0)
+      set_metric 42
+      expect(collector.reset_runtime).to eq(42)
+      expect(collector.runtime).to eq(0)
+    end
+
+  end
+
+  reference_controller_class = Class.new do
+    def process_action *_
+      @process_action = true
+    end
+
+    def cleanup_view_runtime *_
+      @cleanup_view_runtime.call
+    end
+
+    def append_info_to_payload *_
+      @append_info_to_payload = true
+    end
+
+    def self.log_process_action *_
+      @log_process_action.call
+    end
+  end
+
+  controller_class = Class.new reference_controller_class do
+    include controller_runtime::ControllerExtension
+  end
+
+  let(:controller){ controller_class.new }
+
+  it "resets the metric before each action" do
+    set_metric 42
+    controller.send(:process_action, 'foo')
+    expect(collector.runtime).to be(0)
+    expect(controller.instance_variable_get "@process_action").to be(true)
+  end
+
+  it "strips the metric of other sources of the runtime" do
+    set_metric 1
+    controller.instance_variable_set "@cleanup_view_runtime", ->{
+      controller.instance_variable_set "@cleanup_view_runtime", true
+      set_metric 13
+      42
+    }
+    returned = controller.send :cleanup_view_runtime
+    expect(controller.instance_variable_get "@cleanup_view_runtime").to be(true)
+    expect(controller.mongoid_runtime).to eq(14)
+    expect(returned).to be(29)
+  end
+
+  it "appends the metric to payload" do
+    payload = {}
+    set_metric 42
+    controller.send :append_info_to_payload, payload
+    expect(controller.instance_variable_get "@append_info_to_payload").to be(true)
+    expect(payload[:mongoid_runtime]).to eq(42)
+  end
+
+  it "adds metric to log message" do
+    controller_class.instance_variable_set "@log_process_action", ->{
+      controller_class.instance_variable_set "@log_process_action", true
+      []
+    }
+    messages = controller_class.log_process_action mongoid_runtime: 42.101
+    expect(controller_class.instance_variable_get "@log_process_action").to be(true)
+    expect(messages).to eq(["MongoDB: 42.1ms"])
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,24 +1,20 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+# frozen_string_literal: true
+
+require 'lite_spec_helper'
 
 MODELS = File.join(File.dirname(__FILE__), "app/models")
 $LOAD_PATH.unshift(MODELS)
 
 require "action_controller"
-require "mongoid"
-require "rspec"
-
-# These environment variables can be set if wanting to test against a database
-# that is not on the local machine.
-ENV["MONGOID_SPEC_HOST"] ||= "127.0.0.1"
-ENV["MONGOID_SPEC_PORT"] ||= "27017"
-
-# These are used when creating any connection in the test suite.
-HOST = ENV["MONGOID_SPEC_HOST"]
-PORT = ENV["MONGOID_SPEC_PORT"].to_i
+require 'rspec/retry'
 
-Mongo::Logger.logger.level = Logger::INFO
-# Mongoid.logger.level = Logger::DEBUG
+if SpecConfig.instance.client_debug?
+  Mongoid.logger.level = Logger::DEBUG
+  Mongo::Logger.logger.level = Logger::DEBUG
+else
+  Mongoid.logger.level = Logger::INFO
+  Mongo::Logger.logger.level = Logger::INFO
+end
 
 # When testing locally we use the database named mongoid_test. However when
 # tests are running in parallel on Travis we need to use different database
@@ -34,11 +30,13 @@ end
 
 require 'support/authorization'
 require 'support/expectations'
+require 'support/macros'
+require 'support/constraints'
 
 # Give MongoDB time to start up on the travis ci environment.
 if (ENV['CI'] == 'travis' || ENV['CI'] == 'evergreen')
   starting = true
-  client = Mongo::Client.new(['127.0.0.1:27017'])
+  client = Mongo::Client.new(SpecConfig.instance.addresses)
   while starting
     begin
       client.command(Mongo::Server::Monitor::Connection::ISMASTER)
@@ -54,10 +52,10 @@ CONFIG = {
   clients: {
     default: {
       database: database_id,
-      hosts: [ "#{HOST}:#{PORT}" ],
+      hosts: SpecConfig.instance.addresses,
       options: {
-        server_selection_timeout: 0.5,
-        wait_queue_timeout: 5,
+        server_selection_timeout: 3.42,
+        wait_queue_timeout: 1,
         max_pool_size: 5,
         heartbeat_frequency: 180,
         user: MONGOID_ROOT_USER.name,
@@ -67,7 +65,12 @@ CONFIG = {
     }
   },
   options: {
-    belongs_to_required_by_default: false
+    belongs_to_required_by_default: false,
+    log_level: if SpecConfig.instance.client_debug?
+      :debug
+    else
+      :info
+    end,
   }
 }
 
@@ -89,6 +92,12 @@ def array_filters_supported?
 end
 alias :sessions_supported? :array_filters_supported?
 
+def testing_geo_near?
+  $geo_near_enabled ||= (Mongoid::Clients.default
+                             .command(serverStatus: 1)
+                             .first['version'] < '4.1')
+end
+
 def transactions_supported?
   Mongoid::Clients.default.cluster.next_primary.features.transactions_enabled?
 end
@@ -138,9 +147,11 @@ I18n.config.enforce_available_locales = false
 RSpec.configure do |config|
   config.raise_errors_for_deprecations!
   config.include(Mongoid::Expectations)
+  config.extend(Constraints)
+  config.extend(Mongoid::Macros)
 
   config.before(:suite) do
-    client = Mongo::Client.new(["#{HOST}:#{PORT}"])
+    client = Mongo::Client.new(SpecConfig.instance.addresses, server_selection_timeout: 3.03)
     begin
       # Create the root user administrator as the first user to be added to the
       # database. This user will need to be authenticated in order to add any
@@ -153,14 +164,13 @@ RSpec.configure do |config|
 
   # Drop all collections and clear the identity map before each spec.
   config.before(:each) do
+    unless Mongoid.default_client.cluster.connected?
+      Mongoid.default_client.reconnect
+    end
     Mongoid.default_client.collections.each do |coll|
       coll.delete_many
     end
   end
-
-  config.after(:suite) do
-    Mongoid.purge!
-  end
 end
 
 # A subscriber to be used with the Ruby driver for testing.