mongoid 8.0.3 → 8.0.4

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

@@ -2,6 +2,26 @@
 
 require "spec_helper"
 
+module RefHasManySpec
+  module OverrideInitialize
+    class Parent
+      include Mongoid::Document
+      has_many :children, inverse_of: :parent
+    end
+
+    class Child
+      include Mongoid::Document
+      belongs_to :parent
+      field :name, type: String
+
+      def initialize(*args)
+        super
+        self.name ||= "default"
+      end
+    end
+  end
+end
+
 describe Mongoid::Association::Referenced::HasMany::Proxy do
 
   before :all do
@@ -877,6 +897,14 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
   [ :build, :new ].each do |method|
 
     describe "##{method}" do
+      context 'when model has #initialize' do
+        let(:parent) { RefHasManySpec::OverrideInitialize::Parent.create }
+        let(:child)  { parent.children.send(method) }
+
+        it 'should call #initialize' do
+          expect(child.name).to be == "default"
+        end
+      end
 
       context "when the association is not polymorphic" do
 
@@ -2077,154 +2105,114 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#delete" do
-
-    let!(:person) do
-      Person.create!(username: 'arthurnn')
-    end
+  %i[ delete delete_one ].each do |method|
+    describe "##{method}" do
+      let!(:person) { Person.create!(username: 'arthurnn') }
 
-    context "when the document is found" do
+      context 'when the document is found' do
+        context 'when no dependent option is set' do
+          context 'when we are assigning attributes' do
+            let!(:drug) { person.drugs.create! }
+            let(:deleted) { person.drugs.send(method, drug) }
 
-      context "when no dependent option is set" do
+            before do
+              Mongoid::Threaded.begin_execution(:assign)
+            end
 
-        context "when we are assigning attributes" do
+            after do
+              Mongoid::Threaded.exit_execution(:assign)
+            end
 
-          let!(:drug) do
-            person.drugs.create!
+            it 'does not cascade' do
+              expect(deleted.changes.keys).to eq([ 'person_id' ])
+            end
           end
 
-          before do
-            Mongoid::Threaded.begin_execution(:assign)
-          end
+          context 'when the document is loaded' do
+            let!(:drug) { person.drugs.create! }
+            let!(:deleted) { person.drugs.send(method, drug) }
 
-          after do
-            Mongoid::Threaded.exit_execution(:assign)
-          end
+            it 'returns the document' do
+              expect(deleted).to eq(drug)
+            end
 
-          let(:deleted) do
-            person.drugs.delete(drug)
-          end
+            it 'deletes the foreign key' do
+              expect(drug.person_id).to be_nil
+            end
 
-          it "does not cascade" do
-            expect(deleted.changes.keys).to eq([ "person_id" ])
+            it 'removes the document from the association' do
+              expect(person.drugs).not_to include(drug)
+            end
           end
-        end
 
-        context "when the document is loaded" do
+          context 'when the document is not loaded' do
+            let!(:drug) { Drug.create!(person_id: person.username) }
+            let!(:deleted) { person.drugs.send(method, drug) }
 
-          let!(:drug) do
-            person.drugs.create!
-          end
+            it 'returns the document' do
+              expect(deleted).to eq(drug)
+            end
 
-          let!(:deleted) do
-            person.drugs.delete(drug)
-          end
+            it 'deletes the foreign key' do
+              expect(drug.person_id).to be_nil
+            end
 
-          it "returns the document" do
-            expect(deleted).to eq(drug)
+            it 'removes the document from the association' do
+              expect(person.drugs).not_to include(drug)
+            end
           end
+        end
 
-          it "deletes the foreign key" do
-            expect(drug.person_id).to be_nil
-          end
+        context 'when dependent is delete' do
+          context 'when the document is loaded' do
+            let!(:post) { person.posts.create!(title: 'test') }
+            let!(:deleted) { person.posts.send(method, post) }
 
-          it "removes the document from the association" do
-            expect(person.drugs).to_not include(drug)
-          end
-        end
+            it 'returns the document' do
+              expect(deleted).to eq(post)
+            end
 
-        context "when the document is not loaded" do
+            it 'deletes the document' do
+              expect(post).to be_destroyed
+            end
 
-          let!(:drug) do
-            Drug.create!(person_id: person.username)
+            it 'removes the document from the association' do
+              expect(person.posts).not_to include(post)
+            end
           end
 
-          let!(:deleted) do
-            person.drugs.delete(drug)
-          end
+          context 'when the document is not loaded' do
+            let!(:post) { Post.create!(title: 'foo', person_id: person.id) }
+            let!(:deleted) { person.posts.send(method, post) }
 
-          it "returns the document" do
-            expect(deleted).to eq(drug)
-          end
+            it 'returns the document' do
+              expect(deleted).to eq(post)
+            end
 
-          it "deletes the foreign key" do
-            expect(drug.person_id).to be_nil
-          end
+            it 'deletes the document' do
+              expect(post).to be_destroyed
+            end
 
-          it "removes the document from the association" do
-            expect(person.drugs).to_not include(drug)
+            it 'removes the document from the association' do
+              expect(person.posts).not_to include(post)
+            end
           end
         end
       end
 
-      context "when dependent is delete" do
+      context 'when the document is not found' do
+        let!(:post) { Post.create!(title: 'foo') }
+        let!(:deleted) { person.posts.send(method, post) }
 
-        context "when the document is loaded" do
-
-          let!(:post) do
-            person.posts.create!(title: "test")
-          end
-
-          let!(:deleted) do
-            person.posts.delete(post)
-          end
-
-          it "returns the document" do
-            expect(deleted).to eq(post)
-          end
-
-          it "deletes the document" do
-            expect(post).to be_destroyed
-          end
-
-          it "removes the document from the association" do
-            expect(person.posts).to_not include(post)
-          end
+        it 'returns nil' do
+          expect(deleted).to be_nil
         end
 
-        context "when the document is not loaded" do
-
-          let!(:post) do
-            Post.create!(title: "foo", person_id: person.id)
-          end
-
-          let!(:deleted) do
-            person.posts.delete(post)
-          end
-
-          it "returns the document" do
-            expect(deleted).to eq(post)
-          end
-
-          it "deletes the document" do
-            expect(post).to be_destroyed
-          end
-
-          it "removes the document from the association" do
-            expect(person.posts).to_not include(post)
-          end
+        it 'does not delete the document' do
+          expect(post).to be_persisted
         end
       end
     end
-
-    context "when the document is not found" do
-
-      let!(:post) do
-        Post.create!(title: "foo")
-      end
-
-      let!(:deleted) do
-        person.posts.delete(post)
-      end
-
-      it "returns nil" do
-        expect(deleted).to be_nil
-      end
-
-      it "does not delete the document" do
-        expect(post).to be_persisted
-      end
-    end
   end
 
   [ :delete_all, :destroy_all ].each do |method|

data/spec/mongoid/attributes_spec.rb

@@ -2499,7 +2499,7 @@ describe Mongoid::Attributes do
         end
       end
 
-      context "when doing delete_one" do
+      context "when doing _remove" do
         let(:doc) { NestedBook.create! }
         let(:page) { NestedPage.new }
         before do
@@ -2507,7 +2507,7 @@ describe Mongoid::Attributes do
           doc.pages << NestedPage.new
           doc.pages << NestedPage.new
 
-          doc.pages.send(:delete_one, page)
+          doc.pages._remove(page)
         end
 
         it "updates the attributes" do

data/spec/mongoid/criteria/queryable/extensions/string_spec.rb

@@ -253,65 +253,6 @@ describe String do
     end
   end
 
-  describe "#to_direction" do
-
-    context "when ascending" do
-
-      it "returns 1" do
-        expect("ascending".to_direction).to eq(1)
-      end
-    end
-
-    context "when asc" do
-
-      it "returns 1" do
-        expect("asc".to_direction).to eq(1)
-      end
-    end
-
-    context "when ASCENDING" do
-
-      it "returns 1" do
-        expect("ASCENDING".to_direction).to eq(1)
-      end
-    end
-
-    context "when ASC" do
-
-      it "returns 1" do
-        expect("ASC".to_direction).to eq(1)
-      end
-    end
-
-    context "when descending" do
-
-      it "returns -1" do
-        expect("descending".to_direction).to eq(-1)
-      end
-    end
-
-    context "when desc" do
-
-      it "returns -1" do
-        expect("desc".to_direction).to eq(-1)
-      end
-    end
-
-    context "when DESCENDING" do
-
-      it "returns -1" do
-        expect("DESCENDING".to_direction).to eq(-1)
-      end
-    end
-
-    context "when DESC" do
-
-      it "returns -1" do
-        expect("DESC".to_direction).to eq(-1)
-      end
-    end
-  end
-
   describe ".evolve" do
 
     context "when provided a regex" do

data/spec/mongoid/criteria/queryable/extensions/symbol_spec.rb

@@ -107,63 +107,4 @@ describe Symbol do
       end
     end
   end
-
-  describe "#to_direction" do
-
-    context "when ascending" do
-
-      it "returns 1" do
-        expect(:ascending.to_direction).to eq(1)
-      end
-    end
-
-    context "when asc" do
-
-      it "returns 1" do
-        expect(:asc.to_direction).to eq(1)
-      end
-    end
-
-    context "when ASCENDING" do
-
-      it "returns 1" do
-        expect(:ASCENDING.to_direction).to eq(1)
-      end
-    end
-
-    context "when ASC" do
-
-      it "returns 1" do
-        expect(:ASC.to_direction).to eq(1)
-      end
-    end
-
-    context "when descending" do
-
-      it "returns -1" do
-        expect(:descending.to_direction).to eq(-1)
-      end
-    end
-
-    context "when desc" do
-
-      it "returns -1" do
-        expect(:desc.to_direction).to eq(-1)
-      end
-    end
-
-    context "when DESCENDING" do
-
-      it "returns -1" do
-        expect(:DESCENDING.to_direction).to eq(-1)
-      end
-    end
-
-    context "when DESC" do
-
-      it "returns -1" do
-        expect(:DESC.to_direction).to eq(-1)
-      end
-    end
-  end
 end

data/spec/mongoid/criteria/queryable/optional_spec.rb

@@ -741,6 +741,21 @@ describe Mongoid::Criteria::Queryable::Optional do
 
             it_behaves_like "a cloning option"
           end
+
+          context "when the hash has hash values" do
+
+            let(:selection) do
+              query.send("#{method}", score: { "$meta" => "textScore"})
+            end
+
+            it "adds the sorting criteria" do
+              expect(selection.options).to eq(
+                { sort: { "score" => { "$meta" => "textScore" } }}
+              )
+            end
+
+            it_behaves_like "a cloning option"
+          end
         end
 
         context "when provided an array" do

data/spec/mongoid/criteria/translator_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Criteria::Translator do
+  describe "#to_direction" do
+    context "when the value is a string" do
+      context "when ascending" do
+        it "returns 1" do
+          expect(described_class.to_direction("ascending")).to eq(1)
+        end
+      end
+
+      context "when asc" do
+        it "returns 1" do
+          expect(described_class.to_direction("asc")).to eq(1)
+        end
+      end
+
+      context "when ASCENDING" do
+        it "returns 1" do
+          expect(described_class.to_direction("ASCENDING")).to eq(1)
+        end
+      end
+
+      context "when ASC" do
+        it "returns 1" do
+          expect(described_class.to_direction("ASC")).to eq(1)
+        end
+      end
+
+      context "when descending" do
+        it "returns -1" do
+          expect(described_class.to_direction("descending")).to eq(-1)
+        end
+      end
+
+      context "when desc" do
+        it "returns -1" do
+          expect(described_class.to_direction("desc")).to eq(-1)
+        end
+      end
+
+      context "when DESCENDING" do
+        it "returns -1" do
+          expect(described_class.to_direction("DESCENDING")).to eq(-1)
+        end
+      end
+
+      context "when DESC" do
+        it "returns -1" do
+          expect(described_class.to_direction("DESC")).to eq(-1)
+        end
+      end
+    end
+
+    context "when the value is a symbol" do
+      context "when ascending" do
+        it "returns 1" do
+          expect(described_class.to_direction(:ascending)).to eq(1)
+        end
+      end
+  
+      context "when asc" do
+        it "returns 1" do
+          expect(described_class.to_direction(:asc)).to eq(1)
+        end
+      end
+  
+      context "when ASCENDING" do
+        it "returns 1" do
+          expect(described_class.to_direction(:ASCENDING)).to eq(1)
+        end
+      end
+  
+      context "when ASC" do
+        it "returns 1" do
+          expect(described_class.to_direction(:ASC)).to eq(1)
+        end
+      end
+  
+      context "when descending" do
+        it "returns -1" do
+          expect(described_class.to_direction(:descending)).to eq(-1)
+        end
+      end
+  
+      context "when desc" do
+        it "returns -1" do
+          expect(described_class.to_direction(:desc)).to eq(-1)
+        end
+      end
+  
+      context "when DESCENDING" do
+        it "returns -1" do
+          expect(described_class.to_direction(:DESCENDING)).to eq(-1)
+        end
+      end
+  
+      context "when DESC" do
+        it "returns -1" do
+          expect(described_class.to_direction(:DESC)).to eq(-1)
+        end
+      end
+    end
+
+    context "when the value is numeric" do
+      it "should pass the value through unchanged" do
+        expect(described_class.to_direction(1)).to eq(1)
+        expect(described_class.to_direction(-1)).to eq(-1)
+        expect(described_class.to_direction(Math::PI)).to eq(Math::PI)
+      end
+    end
+
+    context "when the value is a hash" do
+      it "should pass the value through unchanged" do
+        expect(described_class.to_direction({})).to eq({})
+        expect(described_class.to_direction(scope: { "$meta" => "textScore" }))
+          .to eq(scope: { "$meta" => "textScore" })
+        expect(described_class.to_direction(a: 1, b: 2)).to eq(a: 1, b: 2)
+      end
+    end
+
+    context "when the value is an unrecognized type" do
+      it "should raise ArgumentError" do
+        expect { described_class.to_direction([]) }.to raise_error(ArgumentError)
+        expect { described_class.to_direction(/a/) }.to raise_error(ArgumentError)
+        expect { described_class.to_direction(Object.new) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/mongoid/shardable_models.rb

@@ -59,3 +59,17 @@ end
 class SmNotSharded
   include Mongoid::Document
 end
+
+class SmReviewAuthor
+  include Mongoid::Document
+  embedded_in :review, class_name: "SmReview", touch: false
+  field :name, type: String
+end
+
+class SmReview
+  include Mongoid::Document
+
+  embeds_one :author, class_name: "SmReviewAuthor"
+
+  shard_key "author.name" => 1
+end