mongoid-ultra 9.0.0.0.alpha1

data/spec/mongoid/association/referenced/has_one/binding_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasOne::Binding do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:game) do
+    Game.new
+  end
+
+  let(:association) do
+    Person.relations["game"]
+  end
+
+  describe "#bind_one" do
+
+    let(:binding) do
+      described_class.new(person, game, association)
+    end
+
+    context "when the document is bindable" do
+
+      before do
+        expect(person).to receive(:save).never
+        expect(game).to receive(:save).never
+        binding.bind_one
+      end
+
+      it "sets the inverse relation" do
+        expect(game.person).to eq(person)
+      end
+
+      it "sets the foreign key" do
+        expect(game.person_id).to eq(person.id)
+      end
+    end
+
+    context "when the document is not bindable" do
+
+      before do
+        game.person = person
+      end
+
+      it "does nothing" do
+        expect(person).to receive(:game=).never
+        binding.bind_one
+      end
+    end
+  end
+
+  describe "#unbind_one" do
+
+    let(:binding) do
+      described_class.new(person, game, association)
+    end
+
+    context "when the document is unbindable" do
+
+      before do
+        binding.bind_one
+        expect(person).to receive(:delete).never
+        expect(game).to receive(:delete).never
+        binding.unbind_one
+      end
+
+      it "removes the inverse relation" do
+        expect(game.person).to be_nil
+      end
+
+      it "removed the foreign key" do
+        expect(game.person_id).to be_nil
+      end
+    end
+
+    context "when the document is not unbindable" do
+
+      it "does nothing" do
+        expect(person).to receive(:game=).never
+        binding.unbind_one
+      end
+    end
+  end
+
+  context "when binding frozen documents" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when the child is frozen" do
+
+      let(:game) do
+        Game.new.freeze
+      end
+
+      before do
+        person.game = game
+      end
+
+      it "does not set the foreign key" do
+        expect(game.person_id).to be_nil
+      end
+    end
+  end
+
+  context "when unbinding frozen documents" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when the child is frozen" do
+
+      let(:game) do
+        Game.new
+      end
+
+      before do
+        person.game = game
+        game.freeze
+        person.game = nil
+      end
+
+      it "does not unset the foreign key" do
+        expect(game.person_id).to eq(person.id)
+      end
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_one/buildable_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Association::Referenced::HasOne::Buildable do
+
+  let(:base) do
+    double(new_record?: false)
+  end
+
+  describe "#build" do
+
+    let(:document) do
+      association.build(base, object)
+    end
+
+    let(:options) do
+      {}
+    end
+
+    let(:association) do
+      Mongoid::Association::Referenced::HasOne.new(Person, :account, options)
+    end
+
+    context "when provided an id" do
+
+      let!(:account) do
+        Account.create!(person_id: object, name: 'banking', balance: 200)
+      end
+
+      let(:object) do
+        BSON::ObjectId.new
+      end
+
+      before do
+        expect_any_instance_of(Mongoid::Criteria).to receive(:where).with(association.foreign_key => object).and_call_original
+      end
+
+      it "sets the document" do
+        expect(document).to eq(account)
+      end
+    end
+
+    context "when scope is specified" do
+
+      let!(:account) do
+        Account.create!(person_id: object, name: 'banking', balance: 200)
+      end
+
+      let(:object) do
+        BSON::ObjectId.new
+      end
+
+      let(:options) do
+        {
+            scope: -> { gt(balance: 100) }
+        }
+      end
+
+      before do
+        expect_any_instance_of(Mongoid::Criteria).to receive(:where).with(association.foreign_key => object).and_call_original
+        expect_any_instance_of(Mongoid::Criteria).to receive(:gt).with(balance: 100).and_call_original
+      end
+
+      context "when document satisfies scope" do
+
+        it "sets the document" do
+          expect(document).to eq(account)
+        end
+      end
+
+      context "when document does not satisfy scope" do
+
+        let!(:account) do
+          Account.create!(person_id: object, name: 'banking', balance: 50)
+        end
+
+        it "returns nil" do
+          expect(document).to eq(nil)
+        end
+      end
+    end
+
+    context "when provided a object" do
+
+      let(:object) do
+        Account.new
+      end
+
+      it "returns the object" do
+        expect(document).to eq(object)
+      end
+
+      context 'when the object is already associated with another object' do
+
+        let(:original_person) do
+          Person.new
+        end
+
+        let(:object) do
+          Account.new(person: original_person)
+        end
+
+        let!(:document) do
+          association.build(Person.new, object)
+        end
+
+        it 'clears the object of its previous association' do
+          expect(original_person.account).to be_nil
+        end
+
+        it 'returns the object' do
+          expect(document).to eq(object)
+        end
+      end
+    end
+
+    context "when the document is not found" do
+
+      let(:object) do
+        BSON::ObjectId.new
+      end
+
+      it "returns nil" do
+        expect(document).to be_nil
+      end
+    end
+
+    context "when the document is persisted" do
+
+      let(:person) do
+        Person.create!
+      end
+
+      let!(:game) do
+        Game.create!(person: person)
+      end
+
+      it "returns the document" do
+        expect(person.game).to eq(game)
+      end
+    end
+
+    context "when the document have a non standard pk" do
+
+      let(:person) do
+        Person.create!
+      end
+
+      let!(:cat) do
+        Cat.create!(person: person)
+      end
+
+      it "returns the document" do
+        expect(person.cat).to eq(cat)
+      end
+    end
+  end
+end

data/spec/mongoid/association/referenced/has_one/eager_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative '../has_one_models'
+
+describe Mongoid::Association::Referenced::HasOne::Eager do
+
+  describe ".grouped_doc" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:association) do
+      Person.reflect_on_association(:cat)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Cat.create!(person: person)
+    end
+
+    it "aggregates by the relation primary key" do
+      expect(eager.send(:grouped_docs).keys).to eq([person.username])
+    end
+  end
+
+  describe ".set_on_parent" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:association) do
+      Person.reflect_on_association(:cat)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Cat.create!(person: person)
+      eager
+    end
+
+    it "sets the relation into the parent" do
+      docs.each do |doc|
+        expect(doc).to receive(:set_relation).once.with(:cat, :foo)
+      end
+      eager.send(:set_on_parent, person.username, :foo)
+    end
+
+    context 'when able to make query count assertions' do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "doesnt call an extra query" do
+        expect_query(0) do
+          eager.send(:set_on_parent, person.username, :foo)
+        end
+      end
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    before do
+      3.times { Cat.create!(person: person) }
+      Cat.create!(person: Person.create!)
+    end
+
+    context "when including the has_one relation" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "queries twice" do
+
+        expect_query(2) do
+
+          Person.all.includes(:cat).each do |person|
+            expect(person.cat).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when including more than one has_one relation" do
+      # Query count assertions require that all queries are sent using the
+      # same connection object.
+      require_no_multi_shard
+
+      it "queries 3 times" do
+
+        expect_query(3) do
+
+          Person.all.includes(:cat, :account).each do |person|
+            expect(person.cat).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let!(:game) do
+        person.create_game(name: "Tron")
+      end
+
+      let!(:eager) do
+        Person.where(_id: person.id).includes(:game).first
+      end
+
+      it "puts the documents in the parent document" do
+        expect(eager.ivar(:game)).to eq(game)
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.game).to eq(game)
+        end
+      end
+
+      it "does not query when updating the association" do
+        expect_query(0) do
+          eager.game.name = "Revenge of Racing of Magic"
+          expect(eager.game.name).to eq("Revenge of Racing of Magic")
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let!(:book) do
+        Book.create!(name: "Game of Thrones")
+      end
+
+      let!(:rating) do
+        book.create_rating(value: 10)
+      end
+
+      let!(:eager) do
+        Book.all.includes(:rating).first
+      end
+
+      it "puts the found documents in the parent document" do
+        expect(eager.ivar(:rating)).to eq(rating)
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.rating).to eq(rating)
+        end
+      end
+    end
+
+    context "when the association has scope" 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(:eager) do
+        HomTrainer.includes(:animal).where(_id: trainer1._id).to_a.first
+      end
+
+      it 'eager loads the included docs' do
+        expect(eager.animal).to eq animal1
+      end
+    end
+  end
+end