mongoid 7.0.13 → 8.0.8

data/spec/integration/associations/has_one_spec.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mongoid/association/referenced/has_one_models'
+
+describe 'has_one associations' do
+  context 'destroying parent in transaction with dependent child' do
+    require_transaction_support
+
+    let(:college) { HomCollege.create! }
+    let(:address) { HomAddress.create!(college: college) }
+
+    before do
+      HomCollege.delete_all
+      HomAddress.delete_all
+    end
+
+    context 'dependent: :destroy' do
+      before do
+        HomCollege.class_eval do
+          has_one :address, class_name: 'HomAddress', dependent: :destroy
+        end
+      end
+
+      it 'destroys' do
+        address
+
+        HomCollege.count.should == 1
+        HomAddress.count.should == 1
+
+        HomCollege.with_session do |session|
+          session.with_transaction do
+            college.destroy!
+          end
+        end
+
+        HomCollege.count.should == 0
+        HomAddress.count.should == 0
+      end
+    end
+
+    context 'dependent: :restrict_with_error' do
+      before do
+        HomCollege.class_eval do
+          has_one :address, class_name: 'HomAddress', dependent: :restrict_with_error
+        end
+      end
+
+      it 'does not destroy' do
+        address
+
+        HomCollege.count.should == 1
+        HomAddress.count.should == 1
+
+        lambda do
+          HomCollege.with_session do |session|
+            session.with_transaction do
+              college.destroy!
+            end
+          end
+        end.should raise_error(Mongoid::Errors::DocumentNotDestroyed)
+
+        HomCollege.count.should == 1
+        HomAddress.count.should == 1
+      end
+    end
+  end
+
+  context 'when calling methods on target' do
+    let(:parent) do
+      HomCollege.create!.tap do |college|
+        HomAccreditation.create!(college: college)
+      end
+    end
+
+    shared_examples 'delegates to the field' do |reloaded: false|
+      context 'non-conflicting field name' do
+        it 'delegates to the field' do
+          parent.accreditation.price.should == 42
+        end
+
+        context 'using send' do
+          it 'delegates to the field' do
+            parent.accreditation.send(:price).should == 42
+          end
+        end
+      end
+
+      context 'field name that conflicts with Kernel' do
+        it 'delegates to the field' do
+          parent.accreditation.format.should == 'fmt'
+        end
+
+        context 'using send' do
+          it 'delegates to the field' do
+            if reloaded
+              pending 'MONGOID-5018'
+            end
+
+            parent.accreditation.send(:format).should == 'fmt'
+          end
+        end
+      end
+    end
+
+    include_examples 'delegates to the field'
+
+    context 'after reloading parent' do
+      before do
+        parent.reload
+      end
+
+      include_examples 'delegates to the field', reloaded: true
+    end
+  end
+
+  context 'when child does not have parent association' do
+    context 'Child.new' do
+      it 'creates a child instance' do
+        HomBusDriver.new.should be_a(HomBusDriver)
+      end
+    end
+
+    context 'assignment to child in parent' do
+      let(:parent) { HomBus.new }
+
+      it 'raises InverseNotFound' do
+        lambda do
+          parent.driver = HomBusDriver.new
+        end.should raise_error(Mongoid::Errors::InverseNotFound)
+      end
+    end
+  end
+
+  context 're-associating the same object' do
+    context 'with dependent: destroy' do
+      let(:person) do
+        Person.create!
+      end
+
+      let!(:game) do
+        Game.create!(person: person) do
+          person.reload
+        end
+      end
+
+      it 'does not destroy the dependent object' do
+        person.game.should == game
+        person.game = person.game
+        person.save!
+        person.reload
+        person.game.should == game
+      end
+    end
+
+    context 'without dependent: destroy' do
+      let(:person) do
+        Person.create!
+      end
+
+      let!(:account) do
+        Account.create!(person: person, name: 'foo').tap do
+          person.reload
+        end
+      end
+
+      it 'does not destroy the dependent object' do
+        person.account.should == account
+        person.account = person.account
+        person.save!
+        person.reload
+        person.account.should == account
+      end
+    end
+  end
+
+  context "when assigning to a has_one" do
+    let(:post) { HomPost.create! }
+    let(:comment1) { HomComment.create!(content: "Comment 1") }
+
+    context "when assigning the same value" do
+      let(:comment2) { HomComment.create! }
+
+      it "persists it correctly" do
+        post.comment = comment1
+        post.reload
+        expect(post.comment).to eq(comment1)
+
+        post.comment = comment1
+        post.reload
+        expect(post.comment).to eq(comment1)
+      end
+    end
+
+    context "when assigning two values with the same _id" do
+      let(:comment2) { HomComment.new(id: comment1.id) }
+
+      it "raises a duplicate key error" do
+        post.comment = comment1
+        expect do
+          post.comment = comment2
+        end.to raise_error(Mongo::Error::OperationFailure, /duplicate key/)
+      end
+    end
+
+    context "when duping the object and changing attributes" do
+      let(:comment2) { comment1.dup }
+
+      before do
+        comment2.content = "Comment 2"
+
+        post.comment = comment1
+        post.reload
+      end
+
+      it "updates the attributes correctly" do
+        post.comment = comment2
+        post.reload
+
+        expect(post.comment).to eq(comment2)
+        expect(post.comment.content).to eq(comment2.content)
+      end
+    end
+
+    context "when explicitly setting the foreign key" do
+      let(:comment2) { HomComment.new(post_id: post.id, content: "2") }
+
+      it "persists the new comment" do
+        post.comment = comment1
+        post.reload
+
+        post.comment = comment2
+        post.reload
+
+        expect(post.comment).to eq(comment2)
+        expect(post.comment.content).to eq(comment2.content)
+      end
+    end
+
+    context "when reassigning the same value" do
+      let(:comment2) { HomComment.create!(content: "Comment 2") }
+
+      it "persists it correctly" do
+        post.comment = comment1
+        post.reload
+        expect(post.comment).to eq(comment1)
+
+        post.comment = comment2
+        post.reload
+        expect(post.comment).to eq(comment2)
+
+        post.comment = comment1
+        post.reload
+        expect(post.comment).to eq(nil)
+      end
+    end
+  end
+
+  context "when overwriting an association" do
+    let(:post1) { HomPost.create!(title: "post 1") }
+    let(:post2) { HomPost.create!(title: "post 2") }
+    let(:comment) { HomComment.create(post: post1) }
+
+    it "does not overwrite the original value" do
+      pending "MONGOID-3999"
+      p1 = comment.post
+      expect(p1.title).to eq("post 1")
+      comment.post = post2
+      expect(p1.title).to eq("post 1")
+    end
+  end
+end

data/spec/integration/associations/nested_attributes_assignment_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'nested attributes assignment' do
+  context 'when creating parent document' do
+    context 'when setting deeply nested attributes' do
+      context 'embeds_many' do
+        let(:truck) { Truck.new }
+
+        it 'persists all documents' do
+          truck.attributes = {
+            capacity: 1,
+            crates_attributes: {
+              '0' => {
+                volume: 2,
+                toys_attributes: {
+                  '0' => {
+                    name: 'Bear',
+                  },
+                },
+              },
+            },
+          }
+
+          truck.save!
+
+          _truck = Truck.find(truck.id)
+          _truck.capacity.should == 1
+          _truck.crates.length.should == 1
+          _truck.crates.first.volume.should == 2
+          _truck.crates.first.toys.length.should == 1
+          _truck.crates.first.toys.first.name.should == 'Bear'
+        end
+      end
+    end
+  end
+
+  context 'when updating parent document' do
+    context 'when setting deeply nested attributes' do
+      context 'embeds_many' do
+        let(:truck) do
+          Truck.create!(
+            capacity: 1,
+            crates: [Crate.new(
+              volume: 2,
+              toys: [Toy.new(name: 'Bear')],
+            )],
+          )
+        end
+
+        context 'updating embedded documents' do
+
+          it 'persists all documents' do
+            truck.attributes = {
+              capacity: 2,
+              crates_attributes: {
+                '0' => {
+                  id: truck.crates.first.id,
+                  volume: 3,
+                  toys_attributes: {
+                    '0' => {
+                      id: truck.crates.first.toys.first.id,
+                      name: 'Rhino',
+                    },
+                  },
+                },
+              },
+            }
+
+            truck.save!
+
+            _truck = Truck.find(truck.id)
+            _truck.capacity.should == 2
+            _truck.crates.length.should == 1
+            _truck.crates.first.volume.should == 3
+            _truck.crates.first.toys.length.should == 1
+            _truck.crates.first.toys.first.name.should == 'Rhino'
+          end
+        end
+
+        context 'adding embedded documents' do
+
+          it 'persists all changes' do
+            truck.attributes = {
+              capacity: 2,
+              crates_attributes: {
+                '0' => {
+                  volume: 3,
+                  toys_attributes: {
+                    '0' => {
+                      name: 'Rhino',
+                    },
+                  },
+                },
+              },
+            }
+
+            truck.save!
+
+            _truck = Truck.find(truck.id)
+            _truck.capacity.should == 2
+            _truck.crates.length.should == 2
+            _truck.crates.first.volume.should == 2
+            _truck.crates.first.toys.length.should == 1
+            _truck.crates.first.toys.first.name.should == 'Bear'
+            _truck.crates.last.volume.should == 3
+            _truck.crates.last.toys.length.should == 1
+            _truck.crates.last.toys.last.name.should == 'Rhino'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/associations/reverse_population_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative './reverse_population_spec_models'
+
+describe 'Association reverse population' do
+  describe 'has_many/belongs_to' do
+    it 'populates child in parent' do
+      company = ReversePopulationSpec::Company.create!
+      email = ReversePopulationSpec::Email.create!(company: company)
+      expect(company.emails).to eq([email])
+    end
+  end
+
+  describe 'has_one/belongs_to' do
+    it 'populates child in parent' do
+      company = ReversePopulationSpec::Company.create!
+      founder = ReversePopulationSpec::Founder.create!(company: company)
+      expect(company.founder).to eq(founder)
+    end
+  end
+
+  describe 'has_and_belongs_to_many' do
+    it 'persists association on the other side' do
+      animal = ReversePopulationSpec::Animal.create!
+      zoo = ReversePopulationSpec::Zoo.create!
+      animal.zoos << zoo
+      animal.save!
+      expect(zoo.animals).to eq([animal])
+      zoo = ReversePopulationSpec::Zoo.find(zoo.id)
+      expect(zoo.animals).to eq([animal])
+    end
+  end
+end

data/spec/integration/associations/reverse_population_spec_models.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ReversePopulationSpec
+  class Company
+    include Mongoid::Document
+
+    has_many :emails, class_name: 'ReversePopulationSpec::Email'
+    has_one :founder, class_name: 'ReversePopulationSpec::Founder'
+  end
+
+  class Email
+    include Mongoid::Document
+
+    belongs_to :company, class_name: 'ReversePopulationSpec::Company'
+  end
+
+  class Founder
+    include Mongoid::Document
+
+    belongs_to :company, class_name: 'ReversePopulationSpec::Company'
+  end
+
+  class Animal
+    include Mongoid::Document
+
+    field :a, type: String
+    has_and_belongs_to_many :zoos, class_name: 'ReversePopulationSpec::Zoo'
+  end
+
+  class Zoo
+    include Mongoid::Document
+
+    field :z, type: String
+    has_and_belongs_to_many :animals, class_name: 'ReversePopulationSpec::Animal'
+  end
+end

data/spec/integration/associations/scope_option_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../mongoid/association/referenced/has_and_belongs_to_many_models'
+require_relative '../../mongoid/association/referenced/has_many_models'
+require_relative '../../mongoid/association/referenced/has_one_models'
+
+describe 'association :scope option' do
+
+  context 'has_many and belongs_to' do
+    let!(:trainer1) { HmmTrainer.create!(name: 'Dave') }
+    let!(:trainer2) { HmmTrainer.create!(name: 'Ash') }
+    let!(:animal1) { HmmAnimal.create!(taxonomy: 'reptile', trainer: trainer1) }
+    let!(:animal2) { HmmAnimal.create!(taxonomy: 'bird', trainer: trainer1) }
+    let!(:animal3) { HmmAnimal.create!(taxonomy: 'mammal', trainer: trainer2) }
+
+    it 'initially associates the documents in-memory' do
+      expect(trainer1.animals).to eq [animal1, animal2]
+      expect(trainer2.animals).to eq [animal3]
+      expect(animal1.trainer).to eq trainer1
+      expect(animal2.trainer).to eq trainer1
+      expect(animal3.trainer).to eq trainer2
+    end
+
+    it 'loads correct documents when queried' do
+      expect(trainer1.reload.animals).to eq [animal1]
+      expect(trainer2.reload.animals).to eq []
+      expect(animal1.reload.trainer).to eq trainer1
+      expect(animal2.reload.trainer).to eq trainer1
+      expect(animal3.reload.trainer).to be_nil
+    end
+
+    it 'eager loads correct documents' do
+      expect(HmmTrainer.includes(:animals).find(trainer1._id).animals).to eq [animal1]
+      expect(HmmTrainer.includes(:animals).find(trainer2._id).animals).to eq []
+      expect(HmmAnimal.includes(:trainer).find(animal1._id).trainer).to eq trainer1
+      expect(HmmAnimal.includes(:trainer).find(animal2._id).trainer).to eq trainer1
+      expect(HmmAnimal.includes(:trainer).find(animal3._id).trainer).to be_nil
+    end
+  end
+
+  context 'has_one and belongs_to' do
+    let!(:trainer1) { HomTrainer.create!(name: 'Dave') }
+    let!(:trainer2) { HomTrainer.create!(name: 'Ash') }
+    let!(:animal1) { HomAnimal.create!(taxonomy: 'reptile', trainer: trainer1) }
+    let!(:animal2) { HomAnimal.create!(taxonomy: 'bird', trainer: trainer1) }
+    let!(:animal3) { HomAnimal.create!(taxonomy: 'mammal', trainer: trainer2) }
+
+    it 'initially associates the documents in-memory' do
+      expect(trainer1.animal).to eq animal2
+      expect(trainer2.animal).to eq animal3
+      expect(animal1.trainer).to be_nil
+      expect(animal2.trainer).to eq trainer1
+      expect(animal3.trainer).to eq trainer2
+    end
+
+    it 'loads correct documents when queried' do
+      expect(trainer1.reload.animal).to eq animal1
+      expect(trainer2.reload.animal).to be_nil
+      expect(animal1.reload.trainer).to eq trainer1
+      expect(animal2.reload.trainer).to eq trainer1
+      expect(animal3.reload.trainer).to be_nil
+    end
+
+    it 'eager loads correct documents' do
+      expect(HomTrainer.includes(:animal).find(trainer1._id).animal).to eq animal1
+      expect(HomTrainer.includes(:animal).find(trainer2._id).animal).to be_nil
+      expect(HomAnimal.includes(:trainer).find(animal1._id).trainer).to eq trainer1
+      expect(HomAnimal.includes(:trainer).find(animal2._id).trainer).to eq trainer1
+      expect(HomAnimal.includes(:trainer).find(animal3._id).trainer).to be_nil
+    end
+  end
+
+  context 'has_and_belongs_to_many' do
+    let!(:trainer1) { HabtmmTrainer.create!(name: 'Dave') }
+    let!(:trainer2) { HabtmmTrainer.create!(name: 'Ash') }
+    let!(:animal1) { HabtmmAnimal.create!(taxonomy: 'reptile', trainers: [trainer1, trainer2]) }
+    let!(:animal2) { HabtmmAnimal.create!(taxonomy: 'bird', trainers: [trainer1, trainer2]) }
+
+    it 'initially associates the documents in-memory' do
+      expect(trainer1.animals).to eq [animal1]
+      expect(trainer2.animals).to eq [animal1]
+      expect(animal1.trainers).to eq [trainer1, trainer2]
+      expect(animal2.trainers).to eq [trainer1, trainer2]
+    end
+
+    it 'loads correct documents when queried' do
+      expect(trainer1.reload.animals).to eq [animal1]
+      expect(trainer2.reload.animals).to eq [animal1]
+      expect(animal1.reload.trainers).to eq [trainer1]
+      expect(animal2.reload.trainers).to eq [trainer1]
+    end
+
+    it 'eager loads correct documents' do
+      expect(HabtmmTrainer.includes(:animals).find(trainer1._id).animals).to eq [animal1]
+      expect(HabtmmTrainer.includes(:animals).find(trainer2._id).animals).to eq [animal1]
+      expect(HabtmmAnimal.includes(:trainers).find(animal1._id).trainers).to eq [trainer1]
+      expect(HabtmmAnimal.includes(:trainers).find(animal2._id).trainers).to eq [trainer1]
+    end
+  end
+end

data/spec/integration/atomic/modifiers_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Atomic::Modifiers do
+
+  let(:modifiers) do
+    described_class.new
+  end
+
+  context 'when performing multiple operations with similar keys' do
+
+    let(:pushes) do
+      { "addresses.0.locations" => { "street" => "Bond St" } }
+    end
+
+    let(:similar1) do
+      { "dresses" => { "color" => "red" } }
+    end
+
+    let(:similar2) do
+      { "ses.0.foo" => { "baz" => "qux" } }
+    end
+
+    before do
+      modifiers.send(operation, pushes)
+      modifiers.send(operation, similar1)
+      modifiers.send(operation, similar2)
+    end
+
+    context "push" do
+      let(:operation) { :push }
+
+      it "adds all modifiers to top level" do
+        expect(modifiers).to eq({ "$push" => {
+                                    "addresses.0.locations" => { '$each' => [{ "street" => "Bond St" }] },
+                                    "dresses" => { '$each' => [{ "color" => "red" }] },
+                                    "ses.0.foo" => { '$each' => [{ "baz" => "qux" }] }
+                                 } })
+      end
+    end
+
+    context "pull" do
+      let(:operation) { :pull }
+
+      it "adds all modifiers to top level" do
+        expect(modifiers).to eq({ "$pull" => {
+                                    "addresses.0.locations" => { "street" => "Bond St" },
+                                    "dresses" => { "color" => "red" },
+                                    "ses.0.foo" => { "baz" => "qux" },
+                                 } })
+      end
+    end
+
+    context "pull_all" do
+      let(:operation) { :pull_all }
+
+      it "adds all modifiers to top level" do
+        expect(modifiers).to eq({ "$pullAll" => {
+                                    "addresses.0.locations" => { "street" => "Bond St" },
+                                    "dresses" => { "color" => "red" },
+                                    "ses.0.foo" => { "baz" => "qux" },
+                                 } })
+      end
+    end
+
+    context "add_to_set" do
+      let(:operation) { :add_to_set }
+
+      it "adds all modifiers to top level" do
+        expect(modifiers).to eq({ "$addToSet" => {
+                                    "addresses.0.locations" => { '$each' => { "street" => "Bond St" } },
+                                    "dresses" => { '$each' => { "color" => "red" } },
+                                    "ses.0.foo" => { '$each' => { "baz" => "qux" } }
+                                 } })
+      end
+    end
+
+    context "set" do
+      let(:operation) { :set }
+
+      it "adds all modifiers to top level" do
+        expect(modifiers).to eq({ "$set" => {
+                                    "addresses.0.locations" => { "street" => "Bond St" },
+                                    "dresses" => { "color" => "red" },
+                                    "ses.0.foo" => { "baz" => "qux" },
+                                 } })
+      end
+    end
+
+    context "unset" do
+      let(:operation) { :unset }
+
+      let(:pushes) do
+        [:foobar]
+      end
+
+      let(:similar1) do
+        [:foo]
+      end
+
+      let(:similar2) do
+        [:bar]
+      end
+
+      it "adds all modifiers to top level" do
+        expect(modifiers).to eq("$unset" => {
+          foobar: true,
+          foo: true,
+          bar: true,
+        })
+      end
+    end
+  end
+
+end

data/spec/integration/bson_regexp_raw_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BSON::Regexp::Raw do
+  context 'fully qualified name' do
+    it 'can be created' do
+      regexp = BSON::Regexp::Raw.new('foo')
+      regexp.pattern.should == 'foo'
+    end
+  end
+
+  context 'via ::Regexp' do
+    it 'can be created' do
+      regexp = Regexp::Raw.new('foo')
+      regexp.pattern.should == 'foo'
+    end
+  end
+end