mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/relations/proxy_spec.rb

@@ -19,7 +19,9 @@ describe Mongoid::Relations::Proxy do
 
     it 'uses the new persistence options' do
       expect {
-        animal.with(write: { w: 100 }).update_attribute(:name, 'kangaroo')
+        animal.with(write: { w: 100 }) do |an|
+          an.update_attribute(:name, 'kangaroo')
+        end
       }.to raise_exception(Mongo::Error::OperationFailure)
     end
   end

data/spec/mongoid/relations/referenced/in_spec.rb

@@ -264,6 +264,44 @@ describe Mongoid::Relations::Referenced::In do
 
       context "when the relation is not polymorphic" do
 
+        context 'when the child has persistence options set' do
+
+          let(:person) do
+            Person.new
+          end
+
+          let(:post) do
+            Post.new
+          end
+
+          before do
+            post.with(collection: 'other-posts') do |p|
+              person.with(collection: 'other-people') do |per|
+                p.person = person
+                per.save
+                p.save
+              end
+            end
+          end
+
+          let(:other_people_count) do
+            Person.with(collection: 'other-people') do |person_class|
+              person_class.count
+            end
+          end
+
+          let(:other_posts_count) do
+            Post.with(collection: 'other-posts') do |post_class|
+              post_class.count
+            end
+          end
+
+          it 'applies the persistence options when saving the child' do
+            expect(other_people_count).to eq(1)
+            expect(other_posts_count).to eq(1)
+          end
+        end
+
         context "when the child is a new record" do
 
           let(:person) do
@@ -1028,7 +1066,9 @@ describe Mongoid::Relations::Referenced::In do
           :index,
           :polymorphic,
           :primary_key,
-          :touch
+          :touch,
+          :optional,
+          :required
         ]
       )
     end

data/spec/mongoid/relations/referenced/many_spec.rb

@@ -2936,17 +2936,6 @@ describe Mongoid::Relations::Referenced::Many do
       end
     end
 
-    context 'when providing a collation', if: collation_supported? do
-
-      let(:posts) do
-        person.posts.where(title: "FIRST").collation(locale: 'en_US', strength: 2)
-      end
-
-      it "applies the collation option to the query" do
-        expect(posts).to eq([ post_one ])
-      end
-    end
-
     context "when providing a criteria class method" do
 
       let(:posts) do
@@ -3504,12 +3493,10 @@ describe Mongoid::Relations::Referenced::Many do
 
       before do
         expect(artist).to receive(:before_add_album).and_raise
+        begin; artist.albums << album; rescue; end
       end
 
       it "does not add the document to the relation" do
-        expect {
-          artist.albums << album
-        }.to raise_error
         expect(artist.albums).to be_empty
       end
     end
@@ -3534,12 +3521,10 @@ describe Mongoid::Relations::Referenced::Many do
 
       before do
         expect(artist).to receive(:after_add_album).and_raise
+        begin; artist.albums << album; rescue; end
       end
 
       it "adds the document to the relation" do
-        expect {
-          artist.albums << album
-        }.to raise_error
         expect(artist.albums).to eq([ album ])
       end
     end
@@ -3618,9 +3603,7 @@ describe Mongoid::Relations::Referenced::Many do
         describe "#delete" do
 
           before do
-            expect {
-              artist.albums.delete album
-            }.to raise_error
+            begin; artist.albums.delete(album); rescue; end
           end
 
           it "does not remove the document from the relation" do
@@ -3631,9 +3614,7 @@ describe Mongoid::Relations::Referenced::Many do
         describe "#clear" do
 
           before do
-            expect {
-              artist.albums.clear
-            }.to raise_error
+            begin; artist.albums.clear; rescue; end
           end
 
           it "does not clear the relation" do
@@ -3693,9 +3674,7 @@ describe Mongoid::Relations::Referenced::Many do
       describe "#delete" do
 
         before do
-          expect {
-            artist.albums.delete album
-          }.to raise_error
+          begin; artist.albums.delete(album); rescue; end
         end
 
         it "removes the documents from the relation" do
@@ -3706,9 +3685,7 @@ describe Mongoid::Relations::Referenced::Many do
       describe "#clear" do
 
         before do
-          expect {
-            artist.albums.clear
-          }.to raise_error
+          begin; artist.albums.clear; rescue; end
         end
 
         it "removes the documents from the relation" do

data/spec/mongoid/relations/referenced/many_to_many_spec.rb

@@ -516,12 +516,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
             before do
               expect(post).to receive(:before_add_tag).and_raise
+              begin; post.tags.send(method, tag); rescue; end;
             end
 
             it "does not add the document to the relation" do
-              expect {
-                post.tags.send(method, tag)
-              }.to raise_error
               expect(post.tags).to be_empty
             end
           end
@@ -538,12 +536,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
             before do
               expect(post).to receive(:after_add_tag).and_raise
+              begin; post.tags.send(method, tag); rescue; end
             end
 
             it "adds the document to the relation" do
-              expect {
-                post.tags.send(method, tag)
-              }.to raise_error
               expect(post.tags).to eq([ tag ])
             end
           end
@@ -1186,12 +1182,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           before do
             expect(post).to receive(:before_remove_tag).and_raise
+            begin; post.tags.clear; rescue; end
           end
 
           it "does not remove the document from the relation" do
-            expect {
-              post.tags.clear
-            }.to raise_error
             expect(post.tags).to eq([ tag ])
           end
         end
@@ -1218,12 +1212,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           before do
             expect(post).to receive(:after_remove_tag).and_raise
+            begin; post.tags.clear; rescue; end
           end
 
           it "removes the document from the relation" do
-            expect {
-              post.tags.clear
-            }.to raise_error
             expect(post.tags).to be_empty
           end
         end
@@ -2120,12 +2112,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           before do
             expect(post).to receive(:before_remove_tag).and_raise
+            begin; post.tags.delete(tag); rescue; end
           end
 
           it "does not remove the document from the relation" do
-            expect {
-              post.tags.delete tag
-            }.to raise_error
             expect(post.tags).to eq([ tag ])
           end
         end
@@ -2152,12 +2142,10 @@ describe Mongoid::Relations::Referenced::ManyToMany do
 
           before do
             expect(post).to receive(:after_remove_tag).and_raise
+            begin; post.tags.delete(tag); rescue; end
           end
 
           it "removes the document from the relation" do
-            expect {
-              post.tags.delete(tag)
-            }.to raise_error
             expect(post.tags).to be_empty
           end
         end
@@ -2654,17 +2642,6 @@ describe Mongoid::Relations::Referenced::ManyToMany do
       end
     end
 
-    context 'when providing a collation', if: collation_supported? do
-
-      let(:preferences) do
-        person.preferences.where(name: "FIRST").collation(locale: 'en_US', strength: 2).to_a
-      end
-
-      it "applies the collation option to the query" do
-        expect(preferences).to eq([ preference_one ])
-      end
-    end
-
     context "when providing a criteria on id" do
 
       let(:preferences) do

data/spec/mongoid/relations/reflections_spec.rb

@@ -74,23 +74,23 @@ describe Mongoid::Relations::Reflections do
           expect(relations.size).to eq(1)
         end
       end
+    end
 
-      context "when no argument supplied" do
+    context "when no relations exist for the macros" do
 
-        let(:relations) do
-          klass.reflect_on_all_associations
-        end
+      let(:relations) do
+        klass.reflect_on_all_associations(:embeds_one)
+      end
 
-        it "returns an array of all relations" do
-          expect(relations.size).to eq(3)
-        end
+      it "returns an empty array" do
+        expect(relations).to be_empty
       end
     end
 
-    context "when no relations exist for the macros" do
+    context "when no argument supplied" do
 
       let(:relations) do
-        klass.reflect_on_all_associations(:embeds_one)
+        klass.reflect_on_all_associations
       end
 
       it "returns an empty array" do

data/spec/mongoid/reloadable_spec.rb

@@ -4,6 +4,25 @@ describe Mongoid::Reloadable do
 
   describe "#reload" do
 
+    context 'when persistence options are set' do
+
+      let(:person) do
+        Person.with(collection: 'other') do |person_class|
+          person_class.create
+        end
+      end
+
+      let(:reloaded) do
+        Person.with(collection: 'other') do |person_class|
+          person_class.first
+        end
+      end
+
+      it 'applies the persistence options' do
+        expect(person).to eq(reloaded)
+      end
+    end
+
     context "when using bson ids" do
 
       let(:person) do
@@ -106,6 +125,38 @@ describe Mongoid::Reloadable do
 
       context "when embedded a single level" do
 
+        context 'when persistence options are set' do
+
+          let(:person) do
+            Person.with(collection: 'other') do |person_class|
+              person_class.create
+            end
+          end
+
+          let!(:address) do
+            person.with(collection: 'other') do |person_object|
+              person_object.addresses.create(street: "Abbey Road", number: 4)
+            end
+          end
+
+          before do
+            Person.mongo_client[:other].find(
+                { "_id" => person.id }
+            ).update_one({ "$set" => { "addresses.0.number" => 3 }})
+          end
+
+          let!(:reloaded) do
+            person.with(collection: 'other') do |person_class|
+              person.addresses.first.reload
+            end
+          end
+
+          it "reloads the embedded document attributes" do
+            expect(reloaded.number).to eq(3)
+          end
+
+        end
+
         context "when the relation is an embeds many" do
 
           let!(:address) do

data/spec/mongoid/scopable_spec.rb

@@ -227,18 +227,6 @@ describe Mongoid::Scopable do
 
     context "when provided a criteria" do
 
-      context 'when a collation is defined on the criteria', if: collation_supported? do
-
-        before do
-          Band.scope(:tests, ->{ Band.where(name: 'TESTING').collation(locale: 'en_US', strength: 2) })
-          Band.create(name: 'testing')
-        end
-
-        it 'applies the collation' do
-          expect(Band.tests.first['name']).to eq('testing')
-        end
-      end
-
       context "when the lambda includes a geo_near query" do
 
         before do

data/spec/mongoid/serializable_spec.rb

@@ -829,54 +829,4 @@ describe Mongoid::Serializable do
       end
     end
   end
-
-  describe "#to_xml" do
-
-    context "BSON::ObjectId" do
-
-      let(:person) do
-        Person.new
-      end
-
-      it "serializes as string" do
-        expect(person.to_xml).to include("<_id>#{person.id}</_id>")
-      end
-    end
-
-    context "when an Array field is defined" do
-
-      let(:person) do
-        Person.new(
-          aliases: [ "Kelly", "Machine Gun" ]
-        )
-      end
-
-      it "properly types the array" do
-        expect(person.to_xml).to include("<aliases type=\"array\">")
-      end
-
-      it "serializes the array" do
-        expect(person.to_xml).to include("<alias>Kelly</alias>")
-        expect(person.to_xml).to include("<alias>Machine Gun</alias>")
-      end
-    end
-
-    context "when a Hash field is defined" do
-
-      let(:person) do
-        Person.new(
-          map: { lat: 24.5, long: 22.1 }
-        )
-      end
-
-      it "properly types the hash" do
-        expect(person.to_xml).to include("<map>")
-      end
-
-      it "serializes the hash" do
-        expect(person.to_xml).to include("<lat type=\"float\">24.5</lat>")
-        expect(person.to_xml).to include("<long type=\"float\">22.1</long>")
-      end
-    end
-  end
 end

data/spec/mongoid/validatable/presence_spec.rb

@@ -280,7 +280,7 @@ describe Mongoid::Validatable::PresenceValidator do
             end
 
             it "does not save the relation" do
-              expect { game.reload }.to raise_error
+              expect { game.reload }.to raise_error(Mongoid::Errors::DocumentNotFound)
             end
           end
         end

data/spec/mongoid/validatable/uniqueness_spec.rb

@@ -19,34 +19,41 @@ describe Mongoid::Validatable::UniquenessValidator do
         context "when persisting to another collection" do
 
           before do
-            Dictionary.with(collection: "dicts").create(name: "websters")
+            Dictionary.with(collection: "dicts") do |klass|
+              klass.create(name: "websters")
+            end
           end
 
           context "when the document is not valid" do
 
             let(:websters) do
-              Dictionary.with(collection: "dicts").new(name: "websters")
+              object = nil
+              valid = Dictionary.with(collection: "dicts") do |klass|
+                object = klass.new(name: "websters")
+                object.valid?
+              end
+              { :valid => valid, :object => object }
             end
 
             it "performs the validation on the correct collection" do
-              expect(websters).to_not be_valid
+              expect(websters[:valid]).to be(false)
             end
 
             it "adds the uniqueness error" do
-              websters.valid?
-              expect(websters.errors[:name]).to_not be_nil
+              expect(websters[:object].errors[:name]).to_not be_nil
             end
 
             it "clears the persistence options in the thread local" do
-              websters.valid?
-              expect(Dictionary.persistence_options).to be_nil
+              expect(Dictionary.persistence_context).to eq(Mongoid::PersistenceContext.new(Dictionary))
             end
           end
 
           context "when the document is valid" do
 
             let(:oxford) do
-              Dictionary.with(collection: "dicts").new(name: "oxford")
+              Dictionary.with(collection: "dicts") do |klass|
+                klass.new(name: "oxford")
+              end
             end
 
             it "performs the validation on the correct collection" do
@@ -2431,7 +2438,7 @@ describe Mongoid::Validatable::UniquenessValidator do
     it "transfers the options to the cloned client" do
       expect {
         Person.create!(ssn: "132-11-1111", username: "asdfsdfA")
-      }.to raise_error
+      }.to raise_error(Mongo::Error::OperationFailure)
     end
   end
 end