mongoid 7.1.6 → 7.2.0.rc1

data/spec/mongoid/matcher/extract_attribute_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Matcher.extract_attribute' do
+  Dir[File.join(File.dirname(__FILE__), 'extract_attribute_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']
+            pending spec['pending'].to_s
+          end
+
+          let(:document) do
+            spec['document']
+          end
+
+          let(:key) { spec['key'] }
+
+          let(:actual) do
+            Mongoid::Matcher.extract_attribute(document, key)
+          end
+
+          let(:expected_exists) { spec['exists'] }
+          let(:expected_value) { spec['value'] }
+          let(:expected_expanded) { spec['expanded'] }
+
+          it 'has the expected exists flag' do
+            actual[0].should == expected_exists
+          end
+
+          it 'has the expected value' do
+            actual[1].should == expected_value
+          end
+
+          it 'has the expected expanded flag' do
+            actual[2].should == expected_expanded
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/persistable/creatable_spec.rb

@@ -143,29 +143,84 @@ describe Mongoid::Persistable::Creatable do
     end
 
     context "when the document is a subclass of a root class" do
+      context "when using the default discriminator key" do
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
 
-      let!(:browser) do
-        Browser.create(version: 3, name: "Test")
-      end
+        let(:collection) do
+          Canvas.collection
+        end
 
-      let(:collection) do
-        Canvas.collection
-      end
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
 
-      let(:attributes) do
-        collection.find({ name: "Test"}).first
-      end
+        it "persists the versions" do
+          expect(attributes["version"]).to eq(3)
+        end
 
-      it "persists the versions" do
-        expect(attributes["version"]).to eq(3)
+        it "persists the type" do
+          expect(attributes["_type"]).to eq("Browser")
+        end
+
+        it "persists the attributes" do
+          expect(attributes["name"]).to eq("Test")
+        end
       end
 
-      it "persists the type" do
-        expect(attributes["_type"]).to eq("Browser")
+      context "when using a custom discriminator key" do
+        before do
+          Canvas.discriminator_key = "dkey"
+        end
+
+        after do
+          Canvas.discriminator_key = nil
+        end
+
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
+
+        let(:collection) do
+          Canvas.collection
+        end
+
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
+
+        it "persists the new discriminator key" do
+          expect(attributes["dkey"]).to eq("Browser")
+        end
       end
 
-      it "persists the attributes" do
-        expect(attributes["name"]).to eq("Test")
+      context "when using a custom discriminator key and discriminator value" do
+        before do
+          Canvas.discriminator_key = "dkey"
+          Browser.discriminator_value = "dvalue"
+        end
+
+        after do
+          Canvas.discriminator_key = nil
+          Browser.discriminator_value = nil
+        end
+
+        let!(:browser) do
+          Browser.create(version: 3, name: "Test")
+        end
+
+        let(:collection) do
+          Canvas.collection
+        end
+
+        let(:attributes) do
+          collection.find({ name: "Test"}).first
+        end
+
+        it "persists the new discriminator key" do
+          expect(attributes["dkey"]).to eq("dvalue")
+        end
       end
     end
 
@@ -207,7 +262,7 @@ describe Mongoid::Persistable::Creatable do
         expect(Canvas.where(name: "Testy").first).to eq(firefox)
       end
 
-      it "returnss on of this subclasses if you find by _type" do
+      it "returns on of this subclasses if you find by _type" do
         expect(Canvas.where(:_type.in => ['Firefox']).count).to eq(1)
       end
     end
@@ -266,8 +321,8 @@ describe Mongoid::Persistable::Creatable do
       end
 
       it "does not bleed relations from one subclass to another" do
-        expect(Truck.relations.keys).to eq(%w/ shipping_container driver bed /)
-        expect(Car.relations.keys).to eq(%w/ shipping_container driver /)
+        expect(Truck.relations.keys).to eq(%w/ shipping_container driver crates seats bed /)
+        expect(Car.relations.keys).to eq(%w/ shipping_container driver crates seats /)
       end
 
       context "when appending new documents" do
@@ -343,17 +398,45 @@ describe Mongoid::Persistable::Creatable do
       end
 
       context "#find_or_initialize_by" do
+        context "when using the default discriminator key" do
+          before do
+            container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
+          end
 
-        before do
-          container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
-        end
+          it "initializes the given type document" do
+            expect(container.vehicles.map(&:class)).to eq([ Car ])
+          end
 
-        it "initializes the given type document" do
-          expect(container.vehicles.map(&:class)).to eq([ Car ])
+          it "initializes with the given attributes" do
+            expect(container.vehicles.map(&:driver)).to eq([ driver ])
+          end
+
+          it "initializes with a type field that equals the class" do
+            expect(
+              container.vehicles.first.attributes["_type"]
+            ).to eq("Car")
+          end
         end
 
-        it "initializes with the given attributes" do
-          expect(container.vehicles.map(&:driver)).to eq([ driver ])
+        context "when using a custom discriminator key" do
+          before do
+            Vehicle.discriminator_key = "dkey"
+            container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
+          end
+
+          it "initializes the given type document" do
+            expect(container.vehicles.map(&:class)).to eq([ Car ])
+          end
+
+          it "initializes with the given attributes" do
+            expect(container.vehicles.map(&:driver)).to eq([ driver ])
+          end
+
+          it "initializes with a dkey field that equals the class" do
+            expect(
+              container.vehicles.first.attributes["dkey"]
+            ).to eq("Car")
+          end
         end
       end
 

data/spec/mongoid/persistable/deletable_spec.rb

@@ -173,6 +173,92 @@ describe Mongoid::Persistable::Deletable do
         end
       end
     end
+
+    context "when deleting all documents with a custom discriminator key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
+
+      after do
+        Canvas.discriminator_key = nil
+      end
+
+      let!(:firefox) do
+        Firefox.create(name: "firefox")
+      end
+
+      let!(:firefox2) do
+        Firefox.create(name: "firefox 2")
+      end
+
+      let!(:browser) do
+        Browser.create(name: "browser")
+      end
+
+      let!(:canvas) do
+        Canvas.create(name: "canvas")
+      end
+
+      before do
+        Firefox.delete_all
+      end
+
+      it "deletes from the parent class collection" do
+        expect(Canvas.count).to eq(2)
+      end
+
+      it "returns correct counts for child classes" do
+        expect(Firefox.count).to eq(0)
+      end
+
+      it "returns correct counts for root subclasses" do
+        expect(Browser.count).to eq(1)
+      end
+    end
+
+    context "when deleting all documents with a custom discriminator value" do
+      before do
+        Canvas.discriminator_key = "dkey"
+        Firefox.discriminator_value = "dvalue"
+      end
+
+      after do
+        Canvas.discriminator_key = nil
+        Firefox.discriminator_value = nil
+      end
+
+      let!(:firefox) do
+        Firefox.create(name: "firefox")
+      end
+
+      let!(:firefox2) do
+        Firefox.create(name: "firefox 2")
+      end
+
+      let!(:browser) do
+        Browser.create(name: "browser")
+      end
+
+      let!(:canvas) do
+        Canvas.create(name: "canvas")
+      end
+
+      before do
+        Firefox.delete_all
+      end
+
+      it "deletes from the parent class collection" do
+        expect(Canvas.count).to eq(2)
+      end
+
+      it "returns correct counts for child classes" do
+        expect(Firefox.count).to eq(0)
+      end
+
+      it "returns correct counts for root subclasses" do
+        expect(Browser.count).to eq(1)
+      end
+    end
   end
 
   describe "#delete_all" do

data/spec/mongoid/persistable/savable_spec.rb

@@ -165,35 +165,35 @@ describe Mongoid::Persistable::Savable do
 
       context "when performing modification and insert ops" do
 
-        let(:person) do
-          Person.create(title: "Blah")
+        let(:owner) do
+          Owner.create(name: "Blah")
         end
 
-        let!(:address) do
-          person.addresses.build(street: "Bond St")
+        let!(:birthday) do
+          owner.birthdays.build(title: "First")
         end
 
-        let!(:name) do
-          person.create_name(first_name: "Tony")
+        let!(:scribe) do
+          owner.create_scribe(name: "Josh")
         end
 
         let(:from_db) do
-          Person.find(person.id)
+          Owner.find(owner.id)
         end
 
         before do
-          person.title = "King"
-          name.first_name = "Ryan"
+          owner.name = "King"
+          scribe.name = "Tosh"
         end
 
         it "persists with proper set and push modifiers" do
-          expect(person.atomic_updates).to eq({
+          expect(owner.atomic_updates).to eq({
             "$set" => {
-              "title" => "King",
-              "name.first_name" => "Ryan"
+              "name" => "King",
+              "scribe.name" => "Tosh"
             },
             "$push"=> {
-              "addresses" => { '$each' => [ { "_id" => address.id, "street" => "Bond St" } ] }
+              "birthdays" => { '$each' => [ { "_id" => birthday.id, "title" => "First" } ] }
             }
           })
         end
@@ -201,15 +201,15 @@ describe Mongoid::Persistable::Savable do
         context "when saving the document" do
 
           it "saves the root document" do
-            expect(person.title).to eq("King")
+            expect(owner.name).to eq("King")
           end
 
           it "saves embedded many relations" do
-            expect(person.addresses.first.street).to eq("Bond St")
+            expect(owner.birthdays.first.title).to eq("First")
           end
 
           it "saves embedded one relations" do
-            expect(person.name.first_name).to eq("Ryan")
+            expect(owner.scribe.name).to eq("Tosh")
           end
         end
       end
@@ -258,6 +258,164 @@ describe Mongoid::Persistable::Savable do
         end
       end
 
+      context 'when adding documents to embedded associations on multiple levels' do
+        let!(:truck) { Truck.create! }
+        let!(:crate) { truck.crates.create!(volume: 0.4) }
+
+        it 'persists the new documents' do
+          expect(truck.crates.size).to eq 1
+          expect(truck.crates[0].volume).to eq 0.4
+          expect(truck.crates[0].toys.size).to eq 0
+
+          truck.crates.first.toys.build(name: "Teddy bear")
+          truck.crates.build(volume: 0.8)
+
+          # The following is equivalent to the two lines above:
+          #
+          # truck.crates_attributes = {
+          #   '0' => {
+          #     "toys_attributes" => {
+          #       "0" => {
+          #         "name" => "Teddy bear"
+          #       }
+          #     },
+          #     "id" => crate.id.to_s
+          #   },
+          #   "1" => {
+          #     "volume" => 0.8
+          #   }
+          # }
+
+          expect(truck.crates.size).to eq 2
+          expect(truck.crates[0].volume).to eq 0.4
+          expect(truck.crates[0].toys.size).to eq 1
+          expect(truck.crates[0].toys[0].name).to eq "Teddy bear"
+          expect(truck.crates[1].volume).to eq 0.8
+          expect(truck.crates[1].toys.size).to eq 0
+
+          #expect(truck.atomic_updates[:conflicts]).to eq nil
+
+          expect { truck.save! }.not_to raise_error
+
+          _truck = Truck.find(truck.id)
+          expect(_truck.crates.size).to eq 2
+          expect(_truck.crates[0].volume).to eq 0.4
+          expect(_truck.crates[0].toys.size).to eq 1
+          expect(_truck.crates[0].toys[0].name).to eq "Teddy bear"
+          expect(_truck.crates[1].volume).to eq 0.8
+          expect(_truck.crates[1].toys.size).to eq 0
+        end
+      end
+
+      context 'when adding documents to embedded association and updating parent fields' do
+        let!(:truck) { Truck.create! }
+        let!(:crate) { truck.crates.create!(volume: 0.4) }
+
+        it 'performs all writes' do
+          truck.crates.build(volume: 1)
+          truck.crates.first.volume = 2
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.crates.length.should == 2
+          _truck.crates.first.volume.should == 2
+          _truck.crates.last.volume.should == 1
+        end
+      end
+
+      context 'when adding documents to nested embedded association and updating first association fields' do
+        let!(:truck) { Truck.create! }
+        let!(:seat) { truck.seats.create!(rating: 1) }
+
+        it 'performs all writes' do
+          truck.seats.first.armrests.build(side: 'left')
+          truck.seats.first.rating = 2
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.seats.length.should == 1
+          _truck.seats.first.armrests.length.should == 1
+          _truck.seats.first.armrests.first.side.should == 'left'
+        end
+      end
+
+      context 'when adding documents to nested embedded association and adding another top level association' do
+        let!(:truck) { Truck.create! }
+        let!(:crate) { truck.crates.create!(volume: 1) }
+
+        it 'performs all writes' do
+          truck.crates.first.toys.build(name: 'Bear')
+          truck.crates.build
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.crates.length.should == 2
+          _truck.crates.first.toys.length.should == 1
+          _truck.crates.first.toys.first.name.should == 'Bear'
+          _truck.crates.last.toys.length.should == 0
+        end
+
+        context 'when also updating first embedded top level association' do
+          it 'performs all writes' do
+            pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+            truck.crates.first.volume = 2
+            truck.crates.first.toys.build(name: 'Bear')
+            truck.crates.build
+
+            truck.save!
+
+            _truck = Truck.find(truck.id)
+            _truck.crates.length.should == 2
+            _truck.crates.first.toys.length.should == 1
+            _truck.crates.first.toys.first.name.should == 'Bear'
+            _truck.crates.last.toys.length.should == 0
+          end
+        end
+      end
+
+      context 'when adding documents to embedded associations with cascaded callbacks on update' do
+        let!(:truck) { Truck.create! }
+        let!(:seat) { truck.seats.create!(rating: 1) }
+
+        it 'persists the new documents' do
+          expect(truck.seats.size).to eq 1
+          expect(truck.seats[0].rating).to eq 1
+
+          truck.seats.build
+
+          expect { truck.save! }.not_to raise_error
+
+          _truck = Truck.find(truck.id)
+          expect(_truck.seats.size).to eq 2
+          expect(_truck.seats[0].rating).to eq 1
+          expect(_truck.seats[1].rating).to eq 100
+        end
+
+        context 'when embedded association embeds another association' do
+          it 'persists the new documents' do
+            pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+            expect(truck.seats.size).to eq 1
+            expect(truck.seats[0].rating).to eq 1
+
+            truck.seats.first.armrests.build
+            truck.seats.build
+
+            expect { truck.save! }.not_to raise_error
+
+            _truck = Truck.find(truck.id)
+            expect(_truck.seats.size).to eq 2
+            expect(_truck.seats[0].rating).to eq 1
+            expect(_truck.seats[0].armrests.length).to eq 1
+            expect(_truck.seats[1].rating).to eq 100
+          end
+        end
+      end
+
       context "when removing elements without using delete or destroy" do
 
         let!(:person) do