mongoid 9.0.11 → 9.1.1

data/spec/mongoid/extensions/time_with_zone_spec.rb

@@ -1,94 +1,85 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Extensions::TimeWithZone do
-
-  describe ".demongoize" do
-
+  describe '.demongoize' do
     let!(:time) do
       Time.zone.local(2010, 11, 19)
     end
 
-    context "when the time zone is not defined" do
+    context 'when the time zone is not defined' do
       config_override :use_utc, false
 
-      context "when the local time is not observing daylight saving" do
-
+      context 'when the local time is not observing daylight saving' do
         let(:time) do
           Time.utc(2010, 11, 19)
         end
 
-        it "returns the local time" do
+        it 'returns the local time' do
           expect(ActiveSupport::TimeWithZone.demongoize(time).utc_offset).to eq(
             Time.zone.local(2010, 11, 19).utc_offset
           )
         end
       end
 
-      context "when the local time is observing daylight saving" do
-
+      context 'when the local time is observing daylight saving' do
         let(:time) do
           Time.utc(2010, 9, 19)
         end
 
-        it "returns the local time" do
+        it 'returns the local time' do
           expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(time.getlocal)
         end
       end
 
-      context "when we have a time close to midnight" do
-
+      context 'when we have a time close to midnight' do
         let(:time) do
           Time.zone.local(2010, 11, 19, 0, 30).utc
         end
 
-        it "changes it back to the equivalent local time" do
+        it 'changes it back to the equivalent local time' do
           expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(time)
         end
       end
 
-      context "when setting ActiveSupport time zone" do
-        time_zone_override "Stockholm"
+      context 'when setting ActiveSupport time zone' do
+        time_zone_override 'Stockholm'
 
-        it "returns an ActiveSupport::TimeWithZone" do
+        it 'returns an ActiveSupport::TimeWithZone' do
           expect(ActiveSupport::TimeWithZone.demongoize(time).class).to eq(ActiveSupport::TimeWithZone)
         end
 
-        context "when the local time is not observing daylight saving" do
-
+        context 'when the local time is not observing daylight saving' do
           let(:new_time) do
             Time.utc(2010, 11, 19, 12)
           end
 
-          it "returns the local time" do
+          it 'returns the local time' do
             expect(ActiveSupport::TimeWithZone.demongoize(new_time)).to eq(
               Time.zone.local(2010, 11, 19, 13)
             )
           end
         end
 
-        context "when the local time is observing daylight saving" do
-
+        context 'when the local time is observing daylight saving' do
           let(:new_time) do
             Time.utc(2010, 9, 19, 12)
           end
 
-          it "returns the local time" do
+          it 'returns the local time' do
             expect(ActiveSupport::TimeWithZone.demongoize(new_time)).to eq(
               Time.zone.local(2010, 9, 19, 14)
             )
           end
         end
 
-        context "when we have a time close to midnight" do
-
+        context 'when we have a time close to midnight' do
           let(:new_time) do
             Time.utc(2010, 11, 19, 0, 30)
           end
 
-          it "change it back to the equivalent local time" do
+          it 'change it back to the equivalent local time' do
             expect(ActiveSupport::TimeWithZone.demongoize(new_time)).to eq(
               Time.zone.local(2010, 11, 19, 1, 30)
             )
@@ -97,27 +88,27 @@ describe Mongoid::Extensions::TimeWithZone do
       end
     end
 
-    context "when the time zone is defined as UTC" do
+    context 'when the time zone is defined as UTC' do
       config_override :use_utc, true
 
-      it "returns utc" do
+      it 'returns utc' do
         expect(ActiveSupport::TimeWithZone.demongoize(time.dup.utc).utc_offset).to eq(0)
       end
 
-      context "when setting ActiveSupport time zone" do
-        time_zone_override "Stockholm"
+      context 'when setting ActiveSupport time zone' do
+        time_zone_override 'Stockholm'
 
         let(:time) do
           Time.utc(2010, 11, 19, 0, 30)
         end
 
-        it "returns utc" do
+        it 'returns utc' do
           expect(ActiveSupport::TimeWithZone.demongoize(time)).to eq(
             ActiveSupport::TimeZone['UTC'].local(2010, 11, 19, 0, 30)
           )
         end
 
-        it "returns an ActiveSupport::TimeWithZone" do
+        it 'returns an ActiveSupport::TimeWithZone' do
           expect(ActiveSupport::TimeWithZone.demongoize(time).class).to eq(
             ActiveSupport::TimeWithZone
           )
@@ -125,82 +116,74 @@ describe Mongoid::Extensions::TimeWithZone do
       end
     end
 
-    context "when time is nil" do
-
-      it "returns nil" do
+    context 'when time is nil' do
+      it 'returns nil' do
         expect(ActiveSupport::TimeWithZone.demongoize(nil)).to be_nil
       end
     end
   end
 
-  describe ".mongoize" do
-
+  describe '.mongoize' do
     let!(:time) do
       Time.zone.local(2010, 11, 19)
     end
 
-    context "when given nil" do
-
-      it "returns nil" do
+    context 'when given nil' do
+      it 'returns nil' do
         expect(ActiveSupport::TimeWithZone.mongoize(nil)).to be_nil
       end
     end
 
-    context "when string is empty" do
-
+    context 'when string is empty' do
       let(:mongoized) do
-        ActiveSupport::TimeWithZone.mongoize("")
+        ActiveSupport::TimeWithZone.mongoize('')
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(mongoized).to be_nil
       end
     end
 
-    context "when given a string" do
-
-      context "when the string is a valid time" do
-
-        it "converts to a utc time" do
+    context 'when given a string' do
+      context 'when the string is a valid time' do
+        it 'converts to a utc time' do
           expect(ActiveSupport::TimeWithZone.mongoize(time.to_s).utc_offset).to eq(0)
         end
 
-        it "serializes with time parsing" do
+        it 'serializes with time parsing' do
           expect(ActiveSupport::TimeWithZone.mongoize(time.to_s)).to eq(Time.parse(time.to_s).utc)
         end
 
-        it "returns a local date from the string" do
+        it 'returns a local date from the string' do
           expect(ActiveSupport::TimeWithZone.mongoize(time.to_s)).to eq(
             Time.zone.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
           )
         end
       end
 
-      context "when the string is an invalid time" do
+      context 'when the string is an invalid time' do
         let(:mongoized) do
-          ActiveSupport::TimeWithZone.mongoize("time")
+          ActiveSupport::TimeWithZone.mongoize('time')
         end
 
-        it "returns nil" do
+        it 'returns nil' do
           expect(mongoized).to be_nil
         end
       end
 
-      context "when setting ActiveSupport time zone" do
-        time_zone_override "Stockholm"
-
-        context "when the local time is not observing daylight saving" do
+      context 'when setting ActiveSupport time zone' do
+        time_zone_override 'Stockholm'
 
-          it "returns the local time" do
+        context 'when the local time is not observing daylight saving' do
+          it 'returns the local time' do
             expect(ActiveSupport::TimeWithZone.mongoize('2010-11-19 5:00:00')).to eq(
               Time.utc(2010, 11, 19, 4)
             )
           end
         end
 
-        context "when the local time is observing daylight saving" do
-
-          it "returns the local time" do
+        context 'when the local time is observing daylight saving' do
+          it 'returns the local time' do
             expect(ActiveSupport::TimeWithZone.mongoize('2010-9-19 5:00:00')).to eq(
               Time.utc(2010, 9, 19, 3)
             )
@@ -209,8 +192,7 @@ describe Mongoid::Extensions::TimeWithZone do
       end
     end
 
-    context "when given a DateTime" do
-
+    context 'when given a DateTime' do
       let!(:time) do
         Time.now
       end
@@ -221,14 +203,14 @@ describe Mongoid::Extensions::TimeWithZone do
         )
       end
 
-      context "when setting ActiveSupport time zone" do
-        time_zone_override "Stockholm"
+      context 'when setting ActiveSupport time zone' do
+        time_zone_override 'Stockholm'
 
         let(:datetime) do
           DateTime.new(2010, 11, 19)
         end
 
-        it "assumes the given time is local" do
+        it 'assumes the given time is local' do
           expect(ActiveSupport::TimeWithZone.mongoize(datetime)).to eq(
             Time.utc(2010, 11, 19)
           )
@@ -236,17 +218,16 @@ describe Mongoid::Extensions::TimeWithZone do
       end
     end
 
-    context "when given a Time" do
-
-      it "converts to a utc time" do
+    context 'when given a Time' do
+      it 'converts to a utc time' do
         expect(ActiveSupport::TimeWithZone.mongoize(time).utc_offset).to eq(0)
       end
 
-      it "returns utc times unchanged" do
+      it 'returns utc times unchanged' do
         expect(ActiveSupport::TimeWithZone.mongoize(time.utc)).to eq(time.utc)
       end
 
-      it "returns the time as utc" do
+      it 'returns the time as utc' do
         expect(ActiveSupport::TimeWithZone.mongoize(time)).to eq(time.utc)
       end
 
@@ -255,60 +236,57 @@ describe Mongoid::Extensions::TimeWithZone do
       end
     end
 
-    context "when given an ActiveSupport::TimeWithZone" do
-
+    context 'when given an ActiveSupport::TimeWithZone' do
       before do
         1.hour.ago
       end
 
-      it "converts it to utc" do
-        expect(ActiveSupport::TimeWithZone.mongoize(time.in_time_zone("Alaska"))).to eq(
+      it 'converts it to utc' do
+        expect(ActiveSupport::TimeWithZone.mongoize(time.in_time_zone('Alaska'))).to eq(
           Time.at(time.to_i).utc
         )
       end
     end
 
-    context "when given a Date" do
-
+    context 'when given a Date' do
       let(:date) do
         Date.today
       end
 
-      it "converts to a utc time" do
+      it 'converts to a utc time' do
         expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.zone.local(date.year, date.month, date.day))
       end
 
-      it "has a zero utc offset" do
+      it 'has a zero utc offset' do
         expect(ActiveSupport::TimeWithZone.mongoize(date).utc_offset).to eq(0)
       end
 
-      context "when setting ActiveSupport time zone" do
-        time_zone_override "Stockholm"
+      context 'when setting ActiveSupport time zone' do
+        time_zone_override 'Stockholm'
 
         let(:date) do
           Date.new(2010, 11, 19)
         end
 
-        it "assumes the given time is local" do
+        it 'assumes the given time is local' do
           expect(ActiveSupport::TimeWithZone.mongoize(date)).to eq(Time.utc(2010, 11, 18, 23))
         end
       end
     end
 
-    context "when given an array" do
-
+    context 'when given an array' do
       let(:array) do
-        [ 2010, 11, 19, 00, 24, 49 ]
+        [ 2010, 11, 19, 0o0, 24, 49 ]
       end
 
-      it "returns a time" do
+      it 'returns a time' do
         expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(Time.zone.local(*array))
       end
 
-      context "when setting ActiveSupport time zone" do
-        time_zone_override "Stockholm"
+      context 'when setting ActiveSupport time zone' do
+        time_zone_override 'Stockholm'
 
-        it "assumes the given time is local" do
+        it 'assumes the given time is local' do
           expect(ActiveSupport::TimeWithZone.mongoize(array)).to eq(
             Time.utc(2010, 11, 18, 23, 24, 49)
           )
@@ -317,17 +295,16 @@ describe Mongoid::Extensions::TimeWithZone do
     end
   end
 
-  describe "#mongoize" do
-
+  describe '#mongoize' do
     let!(:time) do
       Time.zone.local(2010, 11, 19)
     end
 
-    it "converts to a utc time" do
+    it 'converts to a utc time' do
       expect(time.mongoize.utc_offset).to eq(0)
     end
 
-    it "returns the time as utc" do
+    it 'returns the time as utc' do
       expect(time.mongoize).to eq(time.utc)
     end
 
@@ -336,23 +313,20 @@ describe Mongoid::Extensions::TimeWithZone do
     end
   end
 
-  describe "__mongoize_time__" do
-
+  describe '__mongoize_time__' do
     let(:time) do
-      ActiveSupport::TimeZone['Magadan'].at(1543331265.123457)
-    end
-
-    before do
-      expect(time).to be_a(ActiveSupport::TimeWithZone)
+      ActiveSupport::TimeZone['Magadan'].at(1_543_331_265.123457)
     end
-
     let(:mongoized) do
       time.__mongoize_time__
     end
-
     let(:expected_time) { time.in_time_zone }
 
-    context "when setting ActiveSupport time zone" do
+    before do
+      expect(time).to be_a(ActiveSupport::TimeWithZone)
+    end
+
+    context 'when setting ActiveSupport time zone' do
       include_context 'setting ActiveSupport time zone'
 
       it_behaves_like 'mongoizes to AS::TimeWithZone'

data/spec/mongoid/extensions/true_class_spec.rb

@@ -1,36 +1,29 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Extensions::TrueClass do
-
-  describe "#is_a?" do
-
-    context "when provided a Boolean" do
-
-      it "returns true" do
+  describe '#is_a?' do
+    context 'when provided a Boolean' do
+      it 'returns true' do
         expect(true.is_a?(Mongoid::Boolean)).to be true
       end
     end
 
-    context "when provided a FalseClass" do
-
-      it "returns false" do
+    context 'when provided a FalseClass' do
+      it 'returns false' do
         expect(true.is_a?(FalseClass)).to be false
       end
     end
 
-    context "when provided a TrueClass" do
-
-      it "returns true" do
+    context 'when provided a TrueClass' do
+      it 'returns true' do
         expect(true.is_a?(TrueClass)).to be true
       end
     end
 
-    context "when provided an invalid class" do
-
-      it "returns false" do
+    context 'when provided an invalid class' do
+      it 'returns false' do
         expect(false.is_a?(String)).to be false
       end
     end

data/spec/mongoid/extensions/vector_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# BSON::Vector only exists in bson-ruby >= 5.1, so the model and all examples
+# are guarded by min_bson_version. The describe argument is a string (not the
+# constant) so this file loads cleanly on older bson versions.
+if defined?(BSON::Vector)
+  class VectorEmbedding
+    include Mongoid::Document
+
+    field :embedding, type: BSON::Vector
+  end
+end
+
+describe 'BSON::Vector field type' do
+  min_bson_version '5.1'
+
+  shared_examples 'a vector round-trip' do
+    let(:vector) do
+      BSON::Vector.new(values, dtype, padding)
+    end
+
+    let(:binary) do
+      BSON::Binary.from_vector(vector)
+    end
+
+    describe '.mongoize' do
+      it 'returns the matching vector binary' do
+        expect(BSON::Vector.mongoize(vector)).to eq(binary)
+        expect(BSON::Vector.mongoize(vector).type).to eq(:vector)
+      end
+    end
+
+    describe '.demongoize' do
+      let(:demongoized) do
+        BSON::Vector.demongoize(binary)
+      end
+
+      it 'preserves the values, dtype and padding' do
+        expect(demongoized).to be_a(BSON::Vector)
+        expect(demongoized.to_a).to eq(values)
+        expect(demongoized.dtype).to eq(dtype)
+        expect(demongoized.padding).to eq(padding)
+      end
+    end
+
+    context 'when used as a field type' do
+      let!(:model) do
+        VectorEmbedding.create!(embedding: vector)
+      end
+
+      let(:reloaded) do
+        VectorEmbedding.find(model._id)
+      end
+
+      it 'stores the value as a vector binary' do
+        stored = VectorEmbedding.collection.find(_id: model._id).first['embedding']
+        expect(stored).to be_a(BSON::Binary)
+        expect(stored.type).to eq(:vector)
+      end
+
+      it 'reads the value back as an equivalent BSON::Vector' do
+        expect(reloaded.embedding).to be_a(BSON::Vector)
+        expect(reloaded.embedding.to_a).to eq(values)
+        expect(reloaded.embedding.dtype).to eq(dtype)
+        expect(reloaded.embedding.padding).to eq(padding)
+      end
+    end
+  end
+
+  context 'with an int8 vector' do
+    let(:values) { [ 1, 2, 3 ] }
+    let(:dtype) { :int8 }
+    let(:padding) { 0 }
+
+    it_behaves_like 'a vector round-trip'
+  end
+
+  context 'with a float32 vector' do
+    let(:values) { [ 1.5, -2.0, 0.25 ] }
+    let(:dtype) { :float32 }
+    let(:padding) { 0 }
+
+    it_behaves_like 'a vector round-trip'
+  end
+
+  context 'with a packed_bit vector' do
+    let(:values) { [ 255, 0, 128 ] }
+    let(:dtype) { :packed_bit }
+    let(:padding) { 3 }
+
+    it_behaves_like 'a vector round-trip'
+  end
+
+  describe '#mongoize' do
+    let(:vector) do
+      BSON::Vector.new([ 1, 2, 3 ], :int8)
+    end
+
+    it 'delegates to the class method and returns a vector binary' do
+      expect(vector.mongoize).to eq(BSON::Binary.from_vector(vector))
+      expect(vector.mongoize.type).to eq(:vector)
+    end
+
+    # Regression guard: BSON::Vector < ::Array, and Array has its own Mongoid
+    # extension. Without our override the value would be mongoized as a plain
+    # array, losing the vector subtype.
+    it 'does not mongoize via the Array extension' do
+      expect(vector.mongoize).to be_a(BSON::Binary)
+      expect(vector.mongoize).not_to be_a(Array)
+    end
+  end
+
+  describe '.mongoize' do
+    let(:vector) do
+      BSON::Vector.new([ 1, 2, 3 ], :int8)
+    end
+
+    context 'when given a vector BSON::Binary' do
+      it 'returns it unchanged' do
+        binary = BSON::Binary.from_vector(vector)
+        expect(BSON::Vector.mongoize(binary)).to eq(binary)
+      end
+    end
+
+    context 'when given nil' do
+      it 'returns nil' do
+        expect(BSON::Vector.mongoize(nil)).to be_nil
+      end
+    end
+
+    context 'when given a plain array' do
+      it 'returns nil' do
+        expect(BSON::Vector.mongoize([ 1, 2, 3 ])).to be_nil
+      end
+    end
+
+    context 'when given an uncastable type' do
+      it 'returns nil' do
+        expect(BSON::Vector.mongoize(true)).to be_nil
+      end
+    end
+  end
+
+  describe '.demongoize' do
+    let(:vector) do
+      BSON::Vector.new([ 1, 2, 3 ], :int8)
+    end
+
+    context 'when given a BSON::Vector' do
+      it 'returns it unchanged' do
+        expect(BSON::Vector.demongoize(vector)).to eq(vector)
+      end
+    end
+
+    context 'when given a non-vector BSON::Binary' do
+      it 'returns nil' do
+        expect(BSON::Vector.demongoize(BSON::Binary.new('x', :generic))).to be_nil
+      end
+    end
+
+    context 'when given nil' do
+      it 'returns nil' do
+        expect(BSON::Vector.demongoize(nil)).to be_nil
+      end
+    end
+
+    context 'when given an uncastable type' do
+      it 'returns nil' do
+        expect(BSON::Vector.demongoize(true)).to be_nil
+      end
+    end
+  end
+end