mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/nested/many_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Nested::Many do
-
   let(:association) do
     Person.relations['addresses']
   end
@@ -13,61 +11,55 @@ describe Mongoid::Association::Nested::Many do
     Person.new
   end
 
-  describe "#allow_destroy?" do
-
-    context "when the option is provided" do
-
+  describe '#allow_destroy?' do
+    context 'when the option is provided' do
       let(:builder) do
         described_class.new(association, {}, allow_destroy: true)
       end
 
-      it "returns the option" do
+      it 'returns the option' do
         expect(builder.allow_destroy?).to be true
       end
     end
 
-    context "when the option is not provided" do
-
+    context 'when the option is not provided' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(builder.allow_destroy?).to be false
       end
     end
   end
 
-  describe "#build" do
-
+  describe '#build' do
     let(:attributes) do
       {
-        "foo" => { "street" => "Maybachufer" },
-        "bar" => { "street" => "Alexander Platz" },
-        "baz" => { "street" => "Unter den Linden" }
+        'foo' => { 'street' => 'Maybachufer' },
+        'bar' => { 'street' => 'Alexander Platz' },
+        'baz' => { 'street' => 'Unter den Linden' }
       }
     end
 
-    context "when attributes are over limit" do
-
+    context 'when attributes are over limit' do
       let(:builder) do
         described_class.new(association, attributes, limit: 2)
       end
 
-      it "raises an error" do
-        expect {
+      it 'raises an error' do
+        expect do
           builder.build(person)
-        }.to raise_error(Mongoid::Errors::TooManyNestedAttributeRecords)
+        end.to raise_error(Mongoid::Errors::TooManyNestedAttributeRecords)
       end
     end
 
-    context "when rejectable using a proc" do
-
+    context 'when rejectable using a proc' do
       let(:builder) do
         described_class.new(
           association,
           attributes,
-          reject_if: ->(attrs){ attrs[:city].blank? }
+          reject_if: ->(attrs) { attrs[:city].blank? }
         )
       end
 
@@ -75,14 +67,12 @@ describe Mongoid::Association::Nested::Many do
         builder.build(person)
       end
 
-      it "rejects the matching attributes" do
+      it 'rejects the matching attributes' do
         expect(person.addresses).to be_empty
       end
-
     end
 
-    context "when rejectable using a symbol" do
-
+    context 'when rejectable using a symbol' do
       let(:builder) do
         described_class.new(
           association,
@@ -95,20 +85,18 @@ describe Mongoid::Association::Nested::Many do
         builder.build(person)
       end
 
-      it "rejects the matching attributes" do
+      it 'rejects the matching attributes' do
         expect(person.addresses).to be_empty
       end
-
     end
 
-    context "when ids are present" do
-
+    context 'when ids are present' do
       let!(:address) do
-        person.addresses.build(street: "Alexander Platz")
+        person.addresses.build(street: 'Alexander Platz')
       end
 
       let(:attributes) do
-        { "foo" => { "id" => address.id, "street" => "Maybachufer" } }
+        { 'foo' => { 'id' => address.id, 'street' => 'Maybachufer' } }
       end
 
       let(:builder) do
@@ -119,15 +107,14 @@ describe Mongoid::Association::Nested::Many do
         builder.build(person)
       end
 
-      it "updates existing documents" do
-        expect(person.addresses.first.street).to eq("Maybachufer")
+      it 'updates existing documents' do
+        expect(person.addresses.first.street).to eq('Maybachufer')
       end
     end
 
-    context "when ids are not present" do
-
+    context 'when ids are not present' do
       let(:attributes) do
-        { "foo" => { "street" => "Maybachufer" } }
+        { 'foo' => { 'street' => 'Maybachufer' } }
       end
 
       let(:builder) do
@@ -138,19 +125,18 @@ describe Mongoid::Association::Nested::Many do
         builder.build(person)
       end
 
-      it "adds new documents" do
-        expect(person.addresses.first.street).to eq("Maybachufer")
+      it 'adds new documents' do
+        expect(person.addresses.first.street).to eq('Maybachufer')
       end
     end
   end
 
-  describe "#initialize" do
-
+  describe '#initialize' do
     let(:attributes) do
       {
-        "4" => { "street" => "Maybachufer" },
-        "1" => { "street" => "Frederichstrasse" },
-        "2" => { "street" => "Alexander Platz" }
+        '4' => { 'street' => 'Maybachufer' },
+        '1' => { 'street' => 'Frederichstrasse' },
+        '2' => { 'street' => 'Alexander Platz' }
       }
     end
 
@@ -158,74 +144,66 @@ describe Mongoid::Association::Nested::Many do
       described_class.new(association, attributes, {})
     end
 
-    it "sorts the attributes" do
-      expect(builder.attributes.map { |e| e[0] }).to eq([ "1", "2", "4" ])
+    it 'sorts the attributes' do
+      expect(builder.attributes.map { |e| e[0] }).to eq(%w[1 2 4])
     end
   end
 
-  describe "#reject?" do
-
-    context "when the proc is provided" do
-
+  describe '#reject?' do
+    context 'when the proc is provided' do
       let(:options) do
-        { reject_if: ->(attrs){ attrs[:first_name].blank? } }
+        { reject_if: ->(attrs) { attrs[:first_name].blank? } }
       end
 
-      context "when the proc matches" do
-
+      context 'when the proc matches' do
         let(:builder) do
           described_class.new(association, {}, options)
         end
 
-        it "returns true" do
-          expect(builder.reject?(builder, { last_name: "Lang" })).to be true
+        it 'returns true' do
+          expect(builder.reject?(builder, { last_name: 'Lang' })).to be true
         end
       end
 
-      context "when the proc does not match" do
-
+      context 'when the proc does not match' do
         let(:builder) do
           described_class.new(association, {}, options)
         end
 
-        it "returns false" do
-          expect(builder.reject?(builder, { first_name: "Lang" })).to be false
+        it 'returns false' do
+          expect(builder.reject?(builder, { first_name: 'Lang' })).to be false
         end
       end
     end
 
-    context "when the proc is not provided" do
-
+    context 'when the proc is not provided' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns false" do
-        expect(builder.reject?(builder,{ first_name: "Lang" })).to be false
+      it 'returns false' do
+        expect(builder.reject?(builder, { first_name: 'Lang' })).to be false
       end
     end
   end
 
-  describe "#update_only?" do
-
-    context "when the option is provided" do
-
+  describe '#update_only?' do
+    context 'when the option is provided' do
       let(:builder) do
         described_class.new(association, {}, update_only: true)
       end
 
-      it "returns the option" do
+      it 'returns the option' do
         expect(builder.update_only?).to be true
       end
     end
 
-    context "when the option is not provided" do
-
+    context 'when the option is not provided' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(builder.update_only?).to be false
       end
     end

data/spec/mongoid/association/nested/one_spec.rb

@@ -1,89 +1,78 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Nested::One do
-
   let(:association) do
     Person.relations['name']
   end
 
-  describe "#allow_destroy?" do
-
-    context "when the option is provided" do
-
+  describe '#allow_destroy?' do
+    context 'when the option is provided' do
       let(:builder) do
         described_class.new(association, {}, allow_destroy: true)
       end
 
-      it "returns the option" do
+      it 'returns the option' do
         expect(builder.allow_destroy?).to be true
       end
     end
 
-    context "when the option is not provided" do
-
+    context 'when the option is not provided' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(builder.allow_destroy?).to be false
       end
     end
   end
 
-  describe "#build" do
-
+  describe '#build' do
     let(:person) do
       Person.new
     end
 
-    context "when attributes are rejectable using a proc" do
-
+    context 'when attributes are rejectable using a proc' do
       let(:options) do
-        { reject_if: ->(attrs){ attrs[:first_name].blank? } }
+        { reject_if: ->(attrs) { attrs[:first_name].blank? } }
       end
 
       let(:builder) do
-        described_class.new(association, { last_name: "Lang" }, options)
+        described_class.new(association, { last_name: 'Lang' }, options)
       end
 
       before do
         builder.build(person)
       end
 
-      it "does not change the relation" do
+      it 'does not change the relation' do
         expect(person.name).to be_nil
       end
     end
 
-    context "when attributes are rejectable using a symbol" do
-
+    context 'when attributes are rejectable using a symbol' do
       let(:options) do
         { reject_if: :reject_if_name_is_blank }
       end
 
       let(:builder) do
-        described_class.new(association, { last_name: "Lang" }, options)
+        described_class.new(association, { last_name: 'Lang' }, options)
       end
 
       before do
         builder.build(person)
       end
 
-      it "does not change the relation" do
+      it 'does not change the relation' do
         expect(person.name).to be_nil
       end
     end
 
-
-
-    context "when attributes are updatable" do
-
+    context 'when attributes are updatable' do
       let(:name) do
-        person.build_name(last_name: "Ling")
+        person.build_name(last_name: 'Ling')
       end
 
       let(:options) do
@@ -92,66 +81,64 @@ describe Mongoid::Association::Nested::One do
 
       let(:builder) do
         described_class.new(association, {
-          _id: name.id,
-          last_name: "Lang"
-        }, options)
+                              _id: name.id,
+                              last_name: 'Lang'
+                            }, options)
       end
 
       before do
         builder.build(person)
       end
 
-      it "updates the relation" do
-        expect(person.name.last_name).to eq("Lang")
+      it 'updates the relation' do
+        expect(person.name.last_name).to eq('Lang')
       end
     end
 
-    context "when attributes are replacable" do
-
+    context 'when attributes are replaceable' do
       let(:options) do
         {}
       end
 
       let(:builder) do
         described_class.new(association, {
-          last_name: "Lang"
-        }, options)
+                              last_name: 'Lang'
+                            }, options)
       end
 
       before do
         builder.build(person)
       end
 
-      it "updates the relation" do
-        expect(person.name.last_name).to eq("Lang")
+      it 'updates the relation' do
+        expect(person.name.last_name).to eq('Lang')
       end
     end
 
-    context "when attributes are deletable" do
-
+    context 'when attributes are deletable' do
       let(:name) do
-        person.build_name(last_name: "Ling")
+        person.build_name(last_name: 'Ling')
       end
 
       let(:options) do
         { allow_destroy: true }
       end
 
-      %i(id _id).each do |id_field|
+      %i[id _id].each do |id_field|
         context "#{id_field}" do
           let(:builder) do
             described_class.new(association, {
-              id_field => name.id,
-              last_name: "Lang",
-              _destroy: true
-            }, options)
+                                  id_field => name.id,
+                                  last_name: 'Lang',
+                                  _destroy: true
+                                }, options)
           end
 
           before do
             builder.build(person)
           end
 
-          it "deletes the relation" do
+          it 'deletes the relation' do
             expect(person.name).to be_nil
           end
         end
@@ -159,94 +146,83 @@ describe Mongoid::Association::Nested::One do
     end
   end
 
-  describe "#destroy" do
-
-    context "when the attribute exists" do
-
+  describe '#destroy' do
+    context 'when the attribute exists' do
       let(:builder) do
         described_class.new(association, { _destroy: true }, {})
       end
 
-      it "returns the value" do
+      it 'returns the value' do
         expect(builder.destroy).to be true
       end
     end
 
-    context "when the attribute does not exist" do
-
+    context 'when the attribute does not exist' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(builder.destroy).to be_nil
       end
     end
   end
 
-  describe "#reject?" do
-
-    context "when the proc is provided" do
-
+  describe '#reject?' do
+    context 'when the proc is provided' do
       let(:options) do
-        { reject_if: ->(attrs){ attrs[:first_name].blank? } }
+        { reject_if: ->(attrs) { attrs[:first_name].blank? } }
       end
 
-      context "when the proc matches" do
-
+      context 'when the proc matches' do
         let(:builder) do
           described_class.new(association, {}, options)
         end
 
-        it "returns true" do
-          expect(builder.reject?(builder, { last_name: "Lang" })).to be true
+        it 'returns true' do
+          expect(builder.reject?(builder, { last_name: 'Lang' })).to be true
         end
       end
 
-      context "when the proc does not match" do
-
+      context 'when the proc does not match' do
         let(:builder) do
           described_class.new(association, {}, options)
         end
 
-        it "returns false" do
-          expect(builder.reject?(builder, { first_name: "Lang" })).to be false
+        it 'returns false' do
+          expect(builder.reject?(builder, { first_name: 'Lang' })).to be false
         end
       end
     end
 
-    context "when the proc is not provided" do
-
+    context 'when the proc is not provided' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns false" do
-        expect(builder.reject?(builder, { first_name: "Lang" })).to be false
+      it 'returns false' do
+        expect(builder.reject?(builder, { first_name: 'Lang' })).to be false
       end
     end
   end
 
-  describe "#update_only?" do
-
-    context "when the option is provided" do
-
+  describe '#update_only?' do
+    context 'when the option is provided' do
       let(:builder) do
         described_class.new(association, {}, update_only: true)
       end
 
-      it "returns the option" do
+      it 'returns the option' do
         expect(builder.update_only?).to be true
       end
     end
 
-    context "when the option is not provided" do
-
+    context 'when the option is not provided' do
       let(:builder) do
         described_class.new(association, {}, {})
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(builder.update_only?).to be false
       end
     end