mongoid 7.4.0 → 8.0.3

data/spec/mongoid/criteria/includable_spec_models.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class IncUser
+  include Mongoid::Document
+  has_many :posts, class_name: 'IncPost'
+  has_many :comments, class_name: 'IncComment'
+end
+
+class IncPost
+  include Mongoid::Document
+  belongs_to :user, class_name: 'IncUser'
+  has_many :comments, class_name: 'IncComment'
+end
+
+class IncComment
+  include Mongoid::Document
+  belongs_to :posts, class_name: 'IncPost'
+  belongs_to :user, class_name: 'IncUser'
+  belongs_to :thread, class_name: 'IncThread'
+end
+
+class IncThread
+  include Mongoid::Document
+  has_many :comments, class_name: 'IncComment'
+end
+
+class IncBlog
+  include Mongoid::Document
+
+  has_and_belongs_to_many :posts, class_name: "IncBlogPost"
+  belongs_to :highlighted_post, class_name: "IncBlogPost"
+  belongs_to :pinned_post, class_name: "IncBlogPost"
+end
+
+class IncBlogPost
+  include Mongoid::Document
+
+  belongs_to :author, class_name: "IncAuthor"
+end
+
+class IncAuthor
+  include Mongoid::Document
+end
+
+class IncPost
+  include Mongoid::Document
+  belongs_to :person, class_name: "IncPerson"
+end
+
+class IncPerson
+  include Mongoid::Document
+  has_many :posts, class_name: "IncPost"
+  field :name
+end

data/spec/mongoid/criteria/marshalable_spec.rb

@@ -3,7 +3,6 @@
 require "spec_helper"
 
 describe Mongoid::Criteria::Marshalable do
-
   describe "Marshal.dump" do
 
     let(:criteria) do
@@ -26,5 +25,23 @@ describe Mongoid::Criteria::Marshalable do
     it "loads the proper attributes" do
       expect(Marshal.load(Marshal.dump(criteria))).to eq(criteria)
     end
+
+    context "when it receives driver mongo1x" do
+      let(:dump) { Marshal.dump(criteria) }
+
+      before do
+        expect_any_instance_of(Mongoid::Criteria).to receive(:marshal_dump).and_wrap_original do |m, *args|
+          data = m.call(*args)
+          data[1] = :mongo1x
+          data
+        end
+      end
+
+      it "raises an error" do
+        expect do
+          Marshal.load(dump)
+        end.to raise_error(NotImplementedError, /Mongoid no longer supports marshalling with driver version 1.x./)
+      end
+    end
   end
 end

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

@@ -33,6 +33,13 @@ describe Array do
         expect(described_class.evolve("testing")).to eq("testing")
       end
     end
+
+    context "when providing a set" do
+
+      it "returns an array" do
+        expect(described_class.evolve([ 1, 2, 3 ].to_set)).to eq([ 1, 2, 3 ])
+      end
+    end
   end
 
   describe "#__add__" do
@@ -503,23 +510,4 @@ describe Array do
       end
     end
   end
-
-  describe "#update_values" do
-
-    let(:array) do
-      [ 1, 2, 3 ]
-    end
-
-    let(:updated) do
-      array.update_values(&:to_s)
-    end
-
-    it "replaces each of the values with the result of the block" do
-      expect(updated).to eq([ "1", "2", "3" ])
-    end
-
-    it "returns the same instance of the array" do
-      expect(updated).to equal(array)
-    end
-  end
 end

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

@@ -6,55 +6,163 @@ describe BigDecimal do
 
   describe ".evolve" do
 
-    context "when provided a big decimal" do
+    context 'when map_big_decimal_to_decimal128 is false' do
+      config_override :map_big_decimal_to_decimal128, false
 
-      let(:big_decimal) do
-        BigDecimal("123456.789")
+      context "when provided a big decimal" do
+
+        let(:big_decimal) do
+          BigDecimal("123456.789")
+        end
+
+        it "returns the decimal as a string" do
+          expect(described_class.evolve(big_decimal)).to eq(big_decimal.to_s)
+        end
       end
 
-      it "returns the decimal as a string" do
-        expect(described_class.evolve(big_decimal)).to eq(big_decimal.to_s)
+      context "when provided a non big decimal" do
+
+        it "returns the object as a string" do
+          expect(described_class.evolve("testing")).to eq("testing")
+        end
+      end
+
+      context "when provided an array of big decimals" do
+
+        let(:bd_one) do
+          BigDecimal("123456.789")
+        end
+
+        let(:bd_two) do
+          BigDecimal("123333.789")
+        end
+
+        let(:array) do
+          [ bd_one, bd_two ]
+        end
+
+        let(:evolved) do
+          described_class.evolve(array)
+        end
+
+        it "returns the array as strings" do
+          expect(evolved).to eq([ bd_one.to_s, bd_two.to_s ])
+        end
+
+        it "does not evolve in place" do
+          expect(evolved).to_not equal(array)
+        end
+      end
+
+      context "when provided nil" do
+
+        it "returns nil" do
+          expect(described_class.evolve(nil)).to be_nil
+        end
+      end
+
+      context "when provided a numeric" do
+        it "returns a string" do
+          expect(described_class.evolve(1)).to eq('1')
+        end
+      end
+
+      context "when provided a bogus value" do
+        it "returns the value" do
+          expect(described_class.evolve(:bogus)).to eq(:bogus)
+        end
       end
-    end
 
-    context "when provided a non big decimal" do
+      context "when provided a bogus string" do
+        it "returns the string" do
+          expect(described_class.evolve("bogus")).to eq("bogus")
+        end
+      end
 
-      it "returns the object as a string" do
-        expect(described_class.evolve("testing")).to eq("testing")
+      context "when provided a valid string" do
+        it "returns the string" do
+          expect(described_class.evolve("1")).to eq("1")
+        end
       end
     end
 
-    context "when provided an array of big decimals" do
+    context 'when map_big_decimal_to_decimal128 is true' do
+      config_override :map_big_decimal_to_decimal128, true
 
-      let(:bd_one) do
-        BigDecimal("123456.789")
+      context "when provided a big decimal" do
+
+        let(:big_decimal) do
+          BigDecimal("123456.789")
+        end
+
+        it "returns the decimal as a BSON::Decimal128 object" do
+          expect(described_class.evolve(big_decimal)).to eq(BSON::Decimal128.new(big_decimal))
+        end
       end
 
-      let(:bd_two) do
-        BigDecimal("123333.789")
+      context "when provided a non big decimal" do
+
+        it "returns the object as a string" do
+          expect(described_class.evolve("testing")).to eq("testing")
+        end
       end
 
-      let(:array) do
-        [ bd_one, bd_two ]
+      context "when provided an array of big decimals" do
+
+        let(:bd_one) do
+          BigDecimal("123456.789")
+        end
+
+        let(:bd_two) do
+          BigDecimal("123333.789")
+        end
+
+        let(:array) do
+          [ bd_one, bd_two ]
+        end
+
+        let(:evolved) do
+          described_class.evolve(array)
+        end
+
+        it "returns the array as BSON::Decimal128s" do
+          expect(evolved).to eq([ BSON::Decimal128.new(bd_one), BSON::Decimal128.new(bd_two) ])
+        end
+
+        it "does not evolve in place" do
+          expect(evolved).to_not equal(array)
+        end
       end
 
-      let(:evolved) do
-        described_class.evolve(array)
+      context "when provided nil" do
+
+        it "returns nil" do
+          expect(described_class.evolve(nil)).to be_nil
+        end
       end
 
-      it "returns the array as strings" do
-        expect(evolved).to eq([ bd_one.to_s, bd_two.to_s ])
+      context "when provided a numeric" do
+        it "returns a string" do
+          expect(described_class.evolve(1)).to eq(BSON::Decimal128.new('1'))
+        end
       end
 
-      it "does not evolve in place" do
-        expect(evolved).to_not equal(array)
+      context "when provided a bogus value" do
+        it "returns the value" do
+          expect(described_class.evolve(:bogus)).to eq(:bogus)
+        end
       end
-    end
 
-    context "when provided nil" do
+      context "when provided a bogus string" do
+        it "returns the string" do
+          expect(described_class.evolve("bogus")).to eq("bogus")
+        end
+      end
 
-      it "returns nil" do
-        expect(described_class.evolve(nil)).to be_nil
+      context "when provided a valid string" do
+        it "returns the string" do
+          expect(described_class.evolve("1")).to eq("1")
+        end
       end
     end
   end

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

@@ -322,6 +322,17 @@ describe Date do
       end
     end
 
+    context "when provided an invalid string" do
+
+      let(:evolved) do
+        described_class.evolve("bogus")
+      end
+
+      it "returns that string" do
+        expect(evolved).to eq("bogus")
+      end
+    end
+
     context "when provided nil" do
 
       it "returns nil" do

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

@@ -413,6 +413,17 @@ describe DateTime do
       end
     end
 
+    context "when provided an invalid string" do
+
+      let(:evolved) do
+        described_class.evolve("bogus")
+      end
+
+      it "returns that string" do
+        expect(evolved).to eq("bogus")
+      end
+    end
+
     context "when provided nil" do
 
       it "returns nil" do

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

@@ -311,19 +311,4 @@ describe Hash do
       end
     end
   end
-
-  describe "#update_values" do
-
-    let(:hash) do
-      { field: "1" }
-    end
-
-    before do
-      hash.update_values(&:to_i)
-    end
-
-    it "updates each value in the hash" do
-      expect(hash).to eq({ field: 1 })
-    end
-  end
 end

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

@@ -11,42 +11,108 @@ describe Mongoid::Criteria::Queryable::Extensions::Numeric::ClassMethods do
   end
 
   describe "#__numeric__" do
-
     let(:actual) { host.__numeric__(str) }
 
     context "when the string is a whole number" do
-
       let(:str) { '123' }
 
-      it "returns the value as integer" do
+      it "returns the value as an integer" do
         expect(actual).to eq(123)
+        expect(actual).to be_a Integer
       end
     end
 
     context "when the string is a floating point number" do
-
       let(:str) { '123.45' }
 
       it "returns the value as a float" do
         expect(actual).to eq(123.45)
+        expect(actual).to be_a Float
       end
     end
 
-    context "when the string is a dot only" do
+    context "when the string is a floating point number with a leading dot" do
+      let(:str) { '.45' }
 
+      it "returns the value as a float" do
+        expect(actual).to eq(0.45)
+        expect(actual).to be_a Float
+      end
+    end
+
+    context "when the string is a dot only" do
       let(:str) { '.' }
 
       it "returns zero" do
         expect(actual).to eq(0)
+        expect(actual).to be_a Integer
       end
     end
 
-    context "when the string is a number with fractional part consisting of zeros" do
+    context "when the string is a number with a trailing dot" do
+      let(:str) { '123.' }
 
+      it "returns zero" do
+        expect(actual).to eq(123)
+        expect(actual).to be_a Integer
+      end
+    end
+
+    context "when the string is a number with fractional part consisting of zeros" do
       let(:str) { '12.000' }
 
-      it "returns the value as integer" do
+      it "returns the value as an integer" do
         expect(actual).to eq(12)
+        expect(actual).to be_a Integer
+      end
+    end
+
+    context "when the string is a number with leading dot then zeros" do
+      let(:str) { '.000' }
+
+      it "returns the value as an integer" do
+        expect(actual).to eq(0)
+        expect(actual).to be_a Integer
+      end
+    end
+
+    context "when the string is non-numeric" do
+      let(:str) { 'foo' }
+
+      it "raises ArgumentError" do
+        expect { actual }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when the string is non-numeric with leading dot" do
+      let(:str) { '.foo' }
+
+      it "raises ArgumentError" do
+        expect { actual }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when the string is non-numeric with trailing dot" do
+      let(:str) { 'foo.' }
+
+      it "raises ArgumentError" do
+        expect { actual }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when the string is non-numeric with trailing dot and zeroes" do
+      let(:str) { 'foo.000' }
+
+      it "raises ArgumentError" do
+        expect { actual }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when the string is empty" do
+      let(:str) { '' }
+
+      it "raises ArgumentError" do
+        expect { actual }.to raise_error(ArgumentError)
       end
     end
   end

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

@@ -343,6 +343,17 @@ describe Time do
       end
     end
 
+    context "when provided an invalid string" do
+
+      let(:evolved) do
+        described_class.evolve("bogus")
+      end
+
+      it "returns that string" do
+        expect(evolved).to eq("bogus")
+      end
+    end
+
     context "when provided nil" do
 
       it "returns nil" do

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

@@ -316,6 +316,17 @@ describe ActiveSupport::TimeWithZone do
       end
     end
 
+    context "when provided an invalid string" do
+
+      let(:evolved) do
+        described_class.evolve("bogus")
+      end
+
+      it "returns that string" do
+        expect(evolved).to eq("bogus")
+      end
+    end
+
     context "when provided nil" do
 
       it "returns nil" do