mongoid 8.1.4 → 9.0.0

data/spec/mongoid/extensions/time_with_zone_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -7,7 +8,7 @@ describe Mongoid::Extensions::TimeWithZone do
   describe ".demongoize" do
 
     let!(:time) do
-      Time.local(2010, 11, 19)
+      Time.zone.local(2010, 11, 19)
     end
 
     context "when the time zone is not defined" do
@@ -21,7 +22,7 @@ describe Mongoid::Extensions::TimeWithZone do
 
         it "returns the local time" do
           expect(ActiveSupport::TimeWithZone.demongoize(time).utc_offset).to eq(
-            Time.local(2010, 11, 19).utc_offset
+            Time.zone.local(2010, 11, 19).utc_offset
           )
         end
       end
@@ -40,7 +41,7 @@ describe Mongoid::Extensions::TimeWithZone do
       context "when we have a time close to midnight" do
 
         let(:time) do
-          Time.local(2010, 11, 19, 0, 30).utc
+          Time.zone.local(2010, 11, 19, 0, 30).utc
         end
 
         it "changes it back to the equivalent local time" do
@@ -48,8 +49,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
       end
 
-      context "when using the ActiveSupport time zone" do
-        config_override :use_activesupport_time_zone, true
+      context "when setting ActiveSupport time zone" do
         time_zone_override "Stockholm"
 
         it "returns an ActiveSupport::TimeWithZone" do
@@ -104,8 +104,7 @@ describe Mongoid::Extensions::TimeWithZone do
         expect(ActiveSupport::TimeWithZone.demongoize(time.dup.utc).utc_offset).to eq(0)
       end
 
-      context "when using the ActiveSupport time zone" do
-        config_override :use_activesupport_time_zone, true
+      context "when setting ActiveSupport time zone" do
         time_zone_override "Stockholm"
 
         let(:time) do
@@ -137,7 +136,7 @@ describe Mongoid::Extensions::TimeWithZone do
   describe ".mongoize" do
 
     let!(:time) do
-      Time.local(2010, 11, 19)
+      Time.zone.local(2010, 11, 19)
     end
 
     context "when given nil" do
@@ -172,7 +171,7 @@ describe Mongoid::Extensions::TimeWithZone do
 
         it "returns a local date from the string" do
           expect(ActiveSupport::TimeWithZone.mongoize(time.to_s)).to eq(
-            Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
+            Time.zone.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
           )
         end
       end
@@ -187,9 +186,7 @@ describe Mongoid::Extensions::TimeWithZone do
         end
       end
 
-      context "when using the ActiveSupport time zone" do
-        config_override :use_activesupport_time_zone, true
-        # if this is actually your time zone, the following tests are useless
+      context "when setting ActiveSupport time zone" do
         time_zone_override "Stockholm"
 
         context "when the local time is not observing daylight saving" do
@@ -224,8 +221,7 @@ describe Mongoid::Extensions::TimeWithZone do
         )
       end
 
-      context "when using the ActiveSupport time zone" do
-        config_override :use_activesupport_time_zone, true
+      context "when setting ActiveSupport time zone" do
         time_zone_override "Stockholm"
 
         let(:datetime) do
@@ -279,15 +275,14 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "converts to a utc time" do
-        expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.local(date.year, date.month, date.day))
+        expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.zone.local(date.year, date.month, date.day))
       end
 
       it "has a zero utc offset" do
         expect(ActiveSupport::TimeWithZone.mongoize(date).utc_offset).to eq(0)
       end
 
-      context "when using the ActiveSupport time zone" do
-        config_override :use_activesupport_time_zone, true
+      context "when setting ActiveSupport time zone" do
         time_zone_override "Stockholm"
 
         let(:date) do
@@ -307,11 +302,10 @@ describe Mongoid::Extensions::TimeWithZone do
       end
 
       it "returns a time" do
-        expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(Time.local(*array))
+        expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(Time.zone.local(*array))
       end
 
-      context "when using the ActiveSupport time zone" do
-        config_override :use_activesupport_time_zone, true
+      context "when setting ActiveSupport time zone" do
         time_zone_override "Stockholm"
 
         it "assumes the given time is local" do
@@ -326,7 +320,7 @@ describe Mongoid::Extensions::TimeWithZone do
   describe "#mongoize" do
 
     let!(:time) do
-      Time.local(2010, 11, 19)
+      Time.zone.local(2010, 11, 19)
     end
 
     it "converts to a utc time" do
@@ -358,15 +352,8 @@ describe Mongoid::Extensions::TimeWithZone do
 
     let(:expected_time) { time.in_time_zone }
 
-    context "when using active support's time zone" do
-      include_context 'using AS time zone'
-
-      it_behaves_like 'mongoizes to AS::TimeWithZone'
-      it_behaves_like 'maintains precision when mongoized'
-    end
-
-    context "when not using active support's time zone" do
-      include_context 'not using AS time zone'
+    context "when setting ActiveSupport time zone" do
+      include_context 'setting ActiveSupport time zone'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'
       it_behaves_like 'maintains precision when mongoized'

data/spec/mongoid/extensions/true_class_spec.rb

@@ -1,16 +1,10 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
 describe Mongoid::Extensions::TrueClass do
 
-  describe "#__sortable__" do
-
-    it "returns 1" do
-      expect(true.__sortable__).to eq(1)
-    end
-  end
-
   describe "#is_a?" do
 
     context "when provided a Boolean" do

data/spec/mongoid/factory_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/fields/foreign_key_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -496,181 +497,343 @@ describe Mongoid::Fields::ForeignKey do
     end
   end
 
-  describe "#mongoize" do
+  describe '#mongoize' do
+    let(:field) do
+      described_class.new(
+        :vals,
+        type: type,
+        default: [],
+        identity: true,
+        association: association,
+        overwrite: true
+      )
+    end
+    let(:association) { Game.relations['person'] }
+    subject(:mongoized) { field.mongoize(object) }
+
+    context 'type is Array' do
+      let(:type) { Array }
+
+      context 'when the object is a BSON::ObjectId' do
+        let(:object) { BSON::ObjectId.new }
+
+        it 'returns the object id as an array' do
+          expect(mongoized).to eq([object])
+        end
+      end
+
+      context 'when the object is an Array of BSON::ObjectId' do
+        let(:object) { [BSON::ObjectId.new] }
+
+        it 'returns the object ids' do
+          expect(mongoized).to eq(object)
+        end
+      end
+
+      context 'when the object is a String which is a legal object id' do
+        let(:object) { BSON::ObjectId.new.to_s }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq([BSON::ObjectId.from_string(object)])
+        end
+      end
+
+      context 'when the object is a String which is not a legal object id' do
+        let(:object) { 'blah' }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq(%w[blah])
+        end
+      end
+
+      context 'when the object is a blank String' do
+        let(:object) { '' }
+
+        it 'returns an empty array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is nil' do
+        let(:object) { nil }
+
+        it 'returns an empty array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is Array of Strings which are legal object ids' do
+        let(:object) { [BSON::ObjectId.new.to_s] }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq([BSON::ObjectId.from_string(object.first)])
+        end
+      end
+
+      context 'when the object is Array of Strings which are not legal object ids' do
+        let(:object) { %w[blah] }
+
+        it 'returns the Array' do
+          expect(mongoized).to eq(%w[blah])
+        end
+      end
+
+      context 'when the object is Array of Strings which are blank' do
+        let(:object) { ['', ''] }
+
+        it 'returns an empty Array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is Array of nils' do
+        let(:object) { [nil, nil, nil] }
+
+        it 'returns an empty Array' do
+          expect(mongoized).to eq([])
+        end
+      end
+
+      context 'when the object is an empty Array' do
+        let(:object) { [] }
+
+        it 'returns an empty Array' do
+          expect(mongoized).to eq([])
+        end
 
-    context "when the type is array" do
+        it 'returns the same instance' do
+          expect(mongoized).to equal(object)
+        end
+      end
 
-      context "when the array is object ids" do
+      context 'when the object is a Set' do
+        let(:object) { Set['blah'] }
 
-        let(:association) do
-          Game.relations["person"]
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq(%w[blah])
         end
+      end
 
-        let(:field) do
-          described_class.new(
-            :vals,
-            type: Array,
-            default: [],
-            identity: true,
-            association: association,
+      context 'when foreign key is a String' do
+        before do
+          Person.field(:_id, type: String, overwrite: true)
+        end
+
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
             overwrite: true
           )
         end
 
-        context "when provided nil" do
+        context 'when the object is a String' do
+          let(:object) { %w[1] }
 
-          it "returns an empty array" do
-            expect(field.mongoize(nil)).to be_empty
+          it 'returns String' do
+            expect(mongoized).to eq(object)
           end
         end
 
-        context "when provided an empty array" do
+        context 'when the object is a BSON::ObjectId' do
+          let(:object) { [BSON::ObjectId.new] }
 
-          let(:array) do
-            []
+          it 'converts to String' do
+            expect(mongoized).to eq([object.first.to_s])
           end
+        end
 
-          it "returns an empty array" do
-            expect(field.mongoize(array)).to eq(array)
-          end
+        context 'when the object is an Integer' do
+          let(:object) { [1] }
 
-          it "returns the same instance" do
-            expect(field.mongoize(array)).to equal(array)
+          it 'converts to String' do
+            expect(mongoized).to eq(%w[1])
           end
         end
+      end
 
-        context "when using object ids" do
+      context 'when foreign key is an Integer' do
+        before do
+          Person.field(:_id, type: Integer, overwrite: true)
+        end
 
-          let(:object_id) do
-            BSON::ObjectId.new
-          end
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
+            overwrite: true
+          )
+        end
 
-          it "performs conversion on the ids if strings" do
-            expect(field.mongoize([object_id.to_s])).to eq([object_id])
+        context 'when the object is a String' do
+          let(:object) { %w[1] }
+
+          it 'converts to Integer' do
+            expect(mongoized).to eq([1])
           end
         end
 
-        context "when not using object ids" do
+        context 'when the object is an Integer' do
+          let(:object) { [1] }
 
-          let(:object_id) do
-            BSON::ObjectId.new
+          it 'returns Integer' do
+            expect(mongoized).to eq([1])
           end
+        end
+      end
+    end
 
-          before do
-            Person.field(
-              :_id,
-              type: String,
-              pre_processed: true,
-              default: ->{ BSON::ObjectId.new.to_s },
-              overwrite: true
-            )
-          end
+    context 'type is Set' do
+      let(:type) { Set }
 
-          after do
-            Person.field(
-              :_id,
-              type: BSON::ObjectId,
-              pre_processed: true,
-              default: ->{ BSON::ObjectId.new },
-              overwrite: true
-            )
-          end
+      context 'when the object is an Array of BSON::ObjectId' do
+        let(:object) { [BSON::ObjectId.new] }
 
-          it "does not convert" do
-            expect(field.mongoize([object_id.to_s])).to eq([object_id.to_s])
-          end
+        it 'returns the object ids' do
+          expect(mongoized).to eq(object)
+        end
+      end
+
+      context 'when the object is a Set of BSON::ObjectId' do
+        let(:object) { Set[BSON::ObjectId.new] }
+
+        it 'returns the object id in an array' do
+          expect(mongoized).to eq([object.first])
         end
       end
     end
 
-    context "when the type is object" do
+    context 'type is Object' do
+      let(:type) { Object }
 
-      context "when the array is object ids" do
+      context 'when the object is a BSON::ObjectId' do
+        let(:object) { BSON::ObjectId.new }
 
-        let(:association) do
-          Game.relations['person']
+        it 'returns the object id' do
+          expect(mongoized).to eq(object)
         end
+      end
 
-        let(:field) do
-          described_class.new(
-            :vals,
-            type: Object,
-            default: nil,
-            identity: true,
-            association: association,
-            overwrite: true
-          )
+      context 'when the object is a String which is a legal object id' do
+        let(:object) { BSON::ObjectId.new.to_s }
+
+        it 'returns the object id' do
+          expect(mongoized).to eq(BSON::ObjectId.from_string(object))
         end
+      end
 
-        context "when using object ids" do
+      context 'when the object is a String which is not a legal object id' do
+        let(:object) { 'blah' }
 
-          let(:object_id) do
-            BSON::ObjectId.new
-          end
+        it 'returns the string' do
+          expect(mongoized).to eq('blah')
+        end
+      end
 
-          it "performs conversion on the ids if strings" do
-            expect(field.mongoize(object_id.to_s)).to eq(object_id)
-          end
+      context 'when the String is blank' do
+        let(:object) { '' }
+
+        it 'returns nil' do
+          expect(mongoized).to be_nil
+        end
+      end
+
+      context 'when the object is nil' do
+        let(:object) { '' }
+
+        it 'returns nil' do
+          expect(mongoized).to be_nil
         end
+      end
 
-        context "when not using object ids" do
+      context 'when object is an empty Array' do
+        let(:object) { [] }
 
-          context "when using strings" do
+        it 'returns an empty array' do
+          expect(mongoized).to eq([])
+        end
+      end
 
-            context "when provided a string" do
+      context 'when the object is a Set' do
+        let(:object) { Set['blah'] }
 
-              let(:object_id) do
-                BSON::ObjectId.new
-              end
+        it 'returns the set' do
+          expect(mongoized).to eq(Set['blah'])
+        end
+      end
 
-              before do
-                Person.field(
-                  :_id,
-                  type: String,
-                  pre_processed: true,
-                  default: ->{ BSON::ObjectId.new.to_s },
-                  overwrite: true
-                )
-              end
+      context 'when foreign key is a String' do
+        before do
+          Person.field(:_id, type: String, overwrite: true)
+        end
 
-              after do
-                Person.field(
-                  :_id,
-                  type: BSON::ObjectId,
-                  pre_processed: true,
-                  default: ->{ BSON::ObjectId.new },
-                  overwrite: true
-                )
-              end
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
+            overwrite: true
+          )
+        end
 
-              it "does not convert" do
-                expect(field.mongoize(object_id.to_s)).to eq(object_id.to_s)
-              end
-            end
+        context 'when the object is a String' do
+          let(:object) { '1' }
+
+          it 'returns String' do
+            expect(mongoized).to eq(object)
+          end
+        end
+
+        context 'when the object is a BSON::ObjectId' do
+          let(:object) { BSON::ObjectId.new }
+
+          it 'converts to String' do
+            expect(mongoized).to eq(object.to_s)
           end
+        end
 
-          context "when using integers" do
+        context 'when the object is an Integer' do
+          let(:object) { 1 }
 
-            context "when provided a string" do
+          it 'converts to String' do
+            expect(mongoized).to eq('1')
+          end
+        end
+      end
 
-              before do
-                Person.field(:_id, type: Integer, overwrite: true)
-              end
+      context 'when foreign key is an Integer' do
+        before do
+          Person.field(:_id, type: Integer, overwrite: true)
+        end
 
-              after do
-                Person.field(
-                  :_id,
-                  type: BSON::ObjectId,
-                  pre_processed: true,
-                  default: ->{ BSON::ObjectId.new },
-                  overwrite: true
-                )
-              end
+        after do
+          Person.field(
+            :_id,
+            type: BSON::ObjectId,
+            pre_processed: true,
+            default: ->{ BSON::ObjectId.new },
+            overwrite: true
+          )
+        end
 
-              it "converts the string to an integer" do
-                expect(field.mongoize("1")).to eq(1)
-              end
-            end
+        context 'when the object is a String' do
+          let(:object) { '1' }
+
+          it 'converts to Integer' do
+            expect(mongoized).to eq(1)
+          end
+        end
+
+        context 'when the object is an Integer' do
+          let(:object) { 1 }
+
+          it 'returns Integer' do
+            expect(mongoized).to eq(object)
           end
         end
       end

data/spec/mongoid/fields/localized_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/fields/standard_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"