mongoid 7.1.11 → 7.2.0

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

@@ -51,10 +51,11 @@ RSpec.configure do |config|
     config.add_formatter(RSpec::Core::Formatters::JsonFormatter, File.join(File.dirname(__FILE__), '../tmp/rspec.json'))
   end
 
-  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
+  if SpecConfig.instance.ci?
     timeout = if SpecConfig.instance.app_tests?
-      # App tests under JRuby take a REALLY long time (over 5 minutes per test).
-      500
+      # Allow 5 minutes per test for the app tests, since they install
+      # gems for Rails applications which can take a long time.
+      300
     else
       # Allow a max of 30 seconds per test.
       # Tests should take under 10 seconds ideally but it seems

data/spec/mongoid/association/depending_spec.rb

@@ -489,7 +489,7 @@ describe Mongoid::Association::Depending do
           end
         end
 
-        context "when dependent is restrict_with_error" do
+        context "when dependent is restrict_with_exception" do
 
           context "when restricting a references many" do
 
@@ -825,44 +825,96 @@ describe Mongoid::Association::Depending do
 
   context 'when the strategy is :restrict_with_error' do
 
-    let(:person) do
-      Person.new
-    end
+    context "when restricting a one-to-many" do
+      
+      let(:person) do
+        Person.new
+      end
+  
+      let(:post) do
+        Post.new
+      end
 
-    let(:post) do
-      Post.new
-    end
+      let!(:association) do
+        Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_error
+      end
 
-    let!(:association) do
-      Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_error
-    end
+      after do
+        Person.dependents.delete(association)
+      end
 
-    after do
-      Person.dependents.delete(association)
-    end
+      context 'when there are related objects' do
 
-    context 'when there are related objects' do
+        before do
+          person.restrictable_posts << post
+        end
 
-      before do
-        person.restrictable_posts << post
+        it 'adds an error to the parent object' do
+          expect(person.delete).to be(false)
+  
+          person.errors[:restrictable_posts].first.should ==
+            "is not empty and prevents the document from being destroyed"
+        end
       end
 
-      it 'adds an error to the parent object' do
-        expect(person.delete).to be(false)
-        expect(person.errors[:restrictable_posts].first).to be(
-          Mongoid::Association::Depending::RESTRICT_ERROR_MSG)
+      context 'when there are no related objects' do
+
+        before do
+          expect(post).to receive(:delete).never
+          expect(post).to receive(:destroy).never
+        end
+
+        it 'deletes the object and leaves the other one intact' do
+          expect(person.delete).to be(true)
+        end
+      end
+
+      context 'when deleted inside a transaction' do
+        require_transaction_support
+        
+        before do
+          person.restrictable_posts << post
+        end
+
+        it 'doesn\'t raise an exception' do
+          person.with_session do |session|
+            session.with_transaction do 
+              expect { person.destroy }.to_not raise_error
+            end
+          end
+        end
       end
     end
 
-    context 'when there are no related objects' do
+    context "when restricting a many to many" do
 
-      before do
-        expect(post).to receive(:delete).never
-        expect(post).to receive(:destroy).never
+      let!(:association) do
+        Person.has_and_belongs_to_many :houses, dependent: :restrict_with_error
       end
 
-      it 'deletes the object and leaves the other one intact' do
-        expect(person.delete).to be(true)
+      after do
+        Person.dependents.delete(association)
+        Person.has_and_belongs_to_many :houses, validate: false
+      end
+
+      let(:person) do
+        Person.new houses: [House.new]
+      end
+
+      it "returns false" do
+        expect(person.destroy).to be false
+      end
+
+      context "when inside a transaction" do
+        require_transaction_support
+        
+        it 'doesn\'t raise an exception inside a transaction' do
+          person.with_session do |session|
+            session.with_transaction do
+              expect { person.destroy }.to_not raise_error
+            end
+          end
+        end
       end
     end
   end

data/spec/mongoid/association/embedded/embedded_in/proxy_spec.rb

@@ -507,54 +507,4 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
       end
     end
   end
-
-  context "when the same class is embedded multiple times" do
-
-    let(:customer) do
-      Customer.new
-    end
-
-    context "assignment after saving" do
-
-      it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
-
-        customer.home_address = CustomerAddress.new
-        customer.work_address = CustomerAddress.new
-
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
-
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
-
-        customer.save!
-
-        customer.home_address = CustomerAddress.new
-        customer.work_address = CustomerAddress.new
-
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
-
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
-      end
-    end
-
-    context "inverse assignment" do
-
-      it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
-
-        customer.work_address = CustomerAddress.new
-        customer.work_address.addressable = customer
-
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
-
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
-      end
-    end
-  end
 end

data/spec/mongoid/association/embedded/embeds_many/proxy_spec.rb

@@ -1402,6 +1402,39 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     end
   end
 
+  describe "#any?" do
+
+    let(:person) do
+      Person.create
+    end
+
+    context "when documents are persisted" do
+      before do
+        person.addresses.create(street: "Upper")
+      end
+
+      it "returns true" do
+        expect(person.addresses.any?).to be true
+      end
+    end
+    
+    context "when documents are not persisted" do
+      before do
+        person.addresses.build(street: "Bond")
+      end
+      
+      it "returns true" do
+        expect(person.addresses.any?).to be true
+      end
+    end
+
+    context "when documents are not created" do
+      it "returns false" do
+        expect(person.addresses.any?).to be false
+      end
+    end
+  end
+
   describe "#create" do
 
     context "when providing multiple attributes" do
@@ -2416,26 +2449,13 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     end
 
     context "when providing a criteria class method" do
-      context "without keyword arguments" do
-
-        let(:addresses) do
-          person.addresses.california
-        end
 
-        it "applies the criteria to the documents" do
-          expect(addresses).to eq([ address_one ])
-        end
+      let(:addresses) do
+        person.addresses.california
       end
 
-      context "with keyword arguments" do
-
-        let(:addresses) do
-          person.addresses.city_and_state(city: "Sacramento", state: "CA")
-        end
-
-        it "applies the criteria to the documents" do
-          expect(addresses).to eq([])
-        end
+      it "applies the criteria to the documents" do
+        expect(addresses).to eq([ address_one ])
       end
     end
 

data/spec/mongoid/association/embedded/embeds_many_models.rb

@@ -3,6 +3,7 @@
 
 class EmmCongress
   include Mongoid::Document
+  include Mongoid::Timestamps
 
   embeds_many :legislators, class_name: 'EmmLegislator'
 

data/spec/mongoid/association/embedded/embeds_one_models.rb

@@ -3,6 +3,7 @@
 
 class EomParent
   include Mongoid::Document
+  include Mongoid::Timestamps
 
   embeds_one :child, class_name: 'EomChild'
 

data/spec/mongoid/association/referenced/belongs_to/proxy_spec.rb

@@ -1332,21 +1332,4 @@ describe Mongoid::Association::Referenced::BelongsTo::Proxy do
       end
     end
   end
-
-  describe "#method_missing" do
-      let!(:person) do
-        Person.create
-      end
-
-      let!(:game) do
-        Game.create(person: person)
-      end
-
-    it 'handles keyword args' do
-      expect do
-        game.person.set_personal_data(ssn: '123', age: 25)
-      end.not_to raise_error
-    end
-
-  end
 end