mongoid 8.0.5 → 8.0.7

data/spec/mongoid/contextual/mongo_spec.rb

@@ -158,6 +158,16 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when for_js is present' do
+      let(:context) do
+        Band.for_js('this.name == "Depeche Mode"')
+      end
+
+      it 'counts the expected records' do
+        expect(context.count).to eq(1)
+      end
+    end
   end
 
   describe "#estimated_count" do
@@ -1179,33 +1189,49 @@ describe Mongoid::Contextual::Mongo do
       let!(:person2) { Person.create!(ssn: BSON::Decimal128.new("1")) }
       let(:tally) { Person.tally("ssn") }
 
+      let(:tallied_classes) do
+        tally.keys.map(&:class).sort do |a, b|
+          a.to_s.casecmp(b.to_s)
+        end
+      end
+
       context "< BSON 5" do
         max_bson_version '4.99.99'
 
         it "stores the correct types in the database" do
-          Person.find(person1.id).attributes["ssn"].should be_a BSON::Regexp::Raw
-          Person.find(person2.id).attributes["ssn"].should be_a BSON::Decimal128
+          expect(Person.find(person1.id).attributes["ssn"]).to be_a BSON::Regexp::Raw
+          expect(Person.find(person2.id).attributes["ssn"]).to be_a BSON::Decimal128
+        end
+
+        it "tallies the correct type" do
+          expect(tallied_classes).to be == [ BSON::Decimal128, BSON::Regexp::Raw ]
+        end
+      end
+
+      context '>= BSON 5' do
+        min_bson_version "5.0"
+
+        it "stores the correct types in the database" do
+          expect(Person.find(person1.id).ssn).to be_a BSON::Regexp::Raw
+          expect(Person.find(person2.id).ssn).to be_a BigDecimal
         end
 
         it "tallies the correct type" do
-          tally.keys.map(&:class).sort do |a,b|
-            a.to_s <=> b.to_s
-          end.should == [BSON::Decimal128, BSON::Regexp::Raw]
+          expect(tallied_classes).to be == [ BigDecimal, BSON::Regexp::Raw ]
         end
       end
 
-      context ">= BSON 5" do
+      context '>= BSON 5 with decimal128 allowed' do
         min_bson_version "5.0"
+        config_override :allow_bson5_decimal128, true
 
         it "stores the correct types in the database" do
-          Person.find(person1.id).ssn.should be_a BSON::Regexp::Raw
-          Person.find(person2.id).ssn.should be_a BigDeimal
+          expect(Person.find(person1.id).ssn).to be_a BSON::Regexp::Raw
+          expect(Person.find(person2.id).ssn).to be_a BSON::Decimal128
         end
 
         it "tallies the correct type" do
-          tally.keys.map(&:class).sort do |a,b|
-            a.to_s <=> b.to_s
-          end.should == [BigDecimal, BSON::Regexp::Raw]
+          expect(tallied_classes).to be == [ BSON::Decimal128, BSON::Regexp::Raw ]
         end
       end
     end
@@ -3547,16 +3573,65 @@ describe Mongoid::Contextual::Mongo do
 
         context "when the attributes are in the correct type" do
 
+          context "when operation is $set" do
+
+            before do
+              context.update_all("$set" => { name: "Smiths" })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.name).to eq("Smiths")
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.name).to eq("Smiths")
+            end
+          end
+
+          context "when operation is $push" do
+
+            before do
+              depeche_mode.update_attribute(:genres, ["electronic"])
+              new_order.update_attribute(:genres, ["electronic"])
+              context.update_all("$push" => { genres: "pop" })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.genres).to eq(["electronic", "pop"])
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.genres).to eq(["electronic", "pop"])
+            end
+          end
+
+          context "when operation is $addToSet" do
+
+            before do
+              context.update_all("$addToSet" => { genres: "electronic" })
+            end
+
+            it "updates the first matching document" do
+              expect(depeche_mode.reload.genres).to eq(["electronic"])
+            end
+
+            it "updates the last matching document" do
+              expect(new_order.reload.genres).to eq(["electronic"])
+            end
+          end
+        end
+
+        context 'when using aliased field names' do
           before do
-            context.update_all("$set" => { name: "Smiths" })
+            context.update_all('$set' => { years: 100 })
           end
 
           it "updates the first matching document" do
-            expect(depeche_mode.reload.name).to eq("Smiths")
+            expect(depeche_mode.reload.years).to eq(100)
           end
 
           it "updates the last matching document" do
-            expect(new_order.reload.name).to eq("Smiths")
+            expect(new_order.reload.years).to eq(100)
           end
         end
 

data/spec/mongoid/copyable_spec.rb

@@ -90,7 +90,7 @@ describe Mongoid::Copyable do
           end
 
           it 'calls constructor with explicitly declared attributes only' do
-            expect(Mongoid::Factory).to receive(:build).with(cls, 'name' => 'test').and_call_original
+            expect(Mongoid::Factory).to receive(:build).with(cls, { 'name' => 'test' }).and_call_original
             cloned
           end
         end

data/spec/mongoid/criteria/queryable/selector_spec.rb

@@ -44,7 +44,7 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
 
-    context "when selector contains a $nin" do
+    context "when selector contains a $nin string" do
 
       let(:initial) do
         { "$nin" => ["foo"] }
@@ -72,7 +72,35 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
 
-    context "when selector contains a $in" do
+    context "when selector contains a $nin symbol" do
+
+      let(:initial) do
+        { :$nin => ["foo"] }
+      end
+
+      before do
+        selector["field"] = initial
+      end
+
+      context "when merging in a new $nin" do
+
+        let(:other) do
+          { "field" => { :$nin => ["bar"] } }
+        end
+
+        before do
+          selector.merge!(other)
+        end
+
+        it "combines the two $nin queries into one" do
+          expect(selector).to eq({
+            "field" => { :$nin => ["foo", "bar"] }
+          })
+        end
+      end
+    end
+
+    context "when selector contains a $in string" do
 
       let(:initial) do
         { "$in" => [1, 2] }
@@ -117,6 +145,51 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
 
+    context "when selector contains a $in symbol" do
+
+      let(:initial) do
+        { :$in => [1, 2] }
+      end
+
+      before do
+        selector["field"] = initial
+      end
+
+      context "when merging in a new $in with an intersecting value" do
+
+        let(:other) do
+          { "field" => { :$in => [1] } }
+        end
+
+        before do
+          selector.merge!(other)
+        end
+
+        it "intersects the $in values" do
+          expect(selector).to eq({
+                                     "field" => { :$in => [1] }
+                                 })
+        end
+      end
+
+      context "when merging in a new $in with no intersecting values" do
+
+        let(:other) do
+          { "field" => { :$in => [3] } }
+        end
+
+        before do
+          selector.merge!(other)
+        end
+
+        it "intersects the $in values" do
+          expect(selector).to eq({
+                                     "field" => { :$in => [] }
+                                 })
+        end
+      end
+    end
+
     context "when selector is not nested" do
 
       before do

data/spec/mongoid/criteria/queryable/storable_spec.rb

@@ -210,7 +210,79 @@ describe Mongoid::Criteria::Queryable::Storable do
         }
       end
     end
+
+    context 'when value is a hash combine values with different operator keys' do
+      let(:base) do
+        query.add_field_expression('foo', {'$in' => ['bar']})
+      end
+
+      let(:modified) do
+        base.add_field_expression('foo', {'$nin' => ['zoom']})
+      end
+
+      it 'combines the conditions using $and' do
+        modified.selector.should == {
+          'foo' => {
+            '$in' => ['bar'],
+            '$nin' => ['zoom']
+          }
+        }
+      end
+    end
+
+    context 'when value is a hash with symbol operator key combine values with different operator keys' do
+      let(:base) do
+        query.add_field_expression('foo', {:$in => ['bar']})
+      end
+
+      let(:modified) do
+        base.add_field_expression('foo', {:$nin => ['zoom']})
+      end
+
+      it 'combines the conditions using $and' do
+        modified.selector.should == {
+          'foo' => {
+            :$in => ['bar'],
+            :$nin => ['zoom']
+          }
+        }
+      end
+    end
+
+    context 'when value is a hash add values with same operator keys using $and' do
+      let(:base) do
+        query.add_field_expression('foo', {'$in' => ['bar']})
+      end
+
+      let(:modified) do
+        base.add_field_expression('foo', {'$in' => ['zoom']})
+      end
+
+      it 'adds the new condition using $and' do
+        modified.selector.should == {
+          'foo' => {'$in' => ['bar']},
+          '$and' => ['foo' => {'$in' => ['zoom']}]
+        }
+      end
+    end
+
+  context 'when value is a hash with symbol operator key add values with same operator keys using $and' do
+    let(:base) do
+      query.add_field_expression('foo', {:$in => ['bar']})
+    end
+
+    let(:modified) do
+      base.add_field_expression('foo', {:$in => ['zoom']})
+    end
+
+    it 'adds the new condition using $and' do
+      modified.selector.should == {
+        'foo' => {:$in => ['bar']},
+        '$and' => ['foo' => {:$in => ['zoom']}]
+      }
+    end
   end
+end
 
   describe '#add_operator_expression' do
     let(:query_method) { :add_operator_expression }

data/spec/mongoid/extensions/hash_spec.rb

@@ -178,7 +178,7 @@ describe Mongoid::Extensions::Hash do
 
         it "moves the non hash values under the provided key" do
           expect(consolidated).to eq({
-            "$set" => { name: "Tool", likes: 10 }, "$inc" => { plays: 1 }
+            "$set" => { 'name' => "Tool", likes: 10 }, "$inc" => { 'plays' => 1 }
           })
         end
       end
@@ -195,7 +195,7 @@ describe Mongoid::Extensions::Hash do
 
         it "moves the non hash values under the provided key" do
           expect(consolidated).to eq({
-            "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
+            "$set" => { likes: 10, 'name' => "Tool" }, "$inc" => { 'plays' => 1 }
           })
         end
       end
@@ -213,7 +213,7 @@ describe Mongoid::Extensions::Hash do
 
       it "moves the non hash values under the provided key" do
         expect(consolidated).to eq({
-          "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
+          "$set" => { likes: 10, name: "Tool" }, "$inc" => { 'plays' => 1 }
         })
       end
     end

data/spec/mongoid/fields_spec.rb

@@ -567,6 +567,49 @@ describe Mongoid::Fields do
         end
       end
     end
+
+    context 'when the field is declared as BSON::Decimal128' do
+      let(:document) { Mop.create!(decimal128_field: BSON::Decimal128.new(Math::PI.to_s)).reload }
+
+      shared_context 'BSON::Decimal128 is BigDecimal' do
+        it 'should return a BigDecimal' do
+          expect(document.decimal128_field).to be_a BigDecimal
+        end
+      end
+
+      shared_context 'BSON::Decimal128 is BSON::Decimal128' do
+        it 'should return a BSON::Decimal128' do
+          expect(document.decimal128_field).to be_a BSON::Decimal128
+        end
+      end
+
+      it 'is declared as BSON::Decimal128' do
+        expect(Mop.fields['decimal128_field'].type).to be == BSON::Decimal128
+      end
+
+      context 'when BSON version <= 4' do
+        max_bson_version '4.99.99'
+        it_behaves_like 'BSON::Decimal128 is BSON::Decimal128'
+      end
+
+      context 'when BSON version >= 5' do
+        min_bson_version '5.0.0'
+
+        context 'when allow_bson5_decimal128 is false' do
+          config_override :allow_bson5_decimal128, false
+          it_behaves_like 'BSON::Decimal128 is BigDecimal'
+        end
+
+        context 'when allow_bson5_decimal128 is true' do
+          config_override :allow_bson5_decimal128, true
+          it_behaves_like 'BSON::Decimal128 is BSON::Decimal128'
+        end
+
+        context 'when allow_bson5_decimal128 is default' do
+          it_behaves_like 'BSON::Decimal128 is BigDecimal'
+        end
+      end
+    end
   end
 
   describe "#getter_before_type_cast" do