mongoid 7.0.0.beta → 7.0.0

data/spec/mongoid/copyable_spec.rb

@@ -144,6 +144,40 @@ describe Mongoid::Copyable do
         end
       end
 
+      context "when cloning a document with polymorphic embedded documents with multiple language field" do
+
+        let!(:shipment_address) do
+          person.addresses.build({ shipping_name: "Title" }, ShipmentAddress)
+        end
+
+        before do
+          I18n.enforce_available_locales = false
+          I18n.locale = 'pt_BR'
+          person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
+          person.save
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it 'sets embedded translations' do
+          I18n.locale = 'pt_BR'
+          copy.addresses.type(ShipmentAddress).each do |address|
+            expect(address.shipping_name).to eq("Título")
+          end
+        end
+
+      end
+
       context "when cloning a loaded document" do
 
         before do

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

@@ -66,6 +66,49 @@ describe String do
         expect(evolved).to eq(Time.new(2010, 1, 1, 11, 0, 0, 0).utc)
       end
     end
+
+    context "when the string without timezone" do
+
+      context "when using active support's time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          ::Time.zone = "Tokyo"
+        end
+
+        let(:date) do
+          "2010-01-01 5:00:00"
+        end
+
+        let(:evolved) do
+          date.__evolve_time__
+        end
+
+        it "parses string using active support's time zone" do
+          expect(evolved).to eq(Time.zone.parse(date).utc)
+        end
+      end
+
+      context "when not using active support's time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = false
+          ::Time.zone = nil
+        end
+
+        let(:date) do
+          "2010-01-01 5:00:00"
+        end
+
+        let(:evolved) do
+          date.__evolve_time__
+        end
+
+        it "parses string using system time zone" do
+          expect(evolved).to eq(Time.parse(date).utc)
+        end
+      end
+    end
   end
 
   describe "#__sort_option__" do

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

@@ -1449,7 +1449,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
       context "when the criterion are on the same field" do
 
-        context "when the stretegy is the default (intersection)" do
+        context "when the strategy is the default (intersection)" do
 
           let(:selection) do
             query.in(first: [ 1, 2 ].freeze).in(first: [ 2, 3 ])
@@ -1466,6 +1466,35 @@ describe Mongoid::Criteria::Queryable::Selectable do
           end
         end
 
+        context 'when the field is aliased' do
+
+          before(:all) do
+            class TestModel
+              include Mongoid::Document
+            end
+          end
+
+          after(:all) do
+            Object.send(:remove_const, :TestModel)
+          end
+
+          let(:bson_object_id) do
+            BSON::ObjectId.new
+          end
+
+          let(:selection) do
+            TestModel.in(id: [bson_object_id.to_s]).in(id: [bson_object_id.to_s])
+          end
+
+          it "intersects the $in selectors" do
+            expect(selection.selector).to eq("_id" =>  { "$in" => [ bson_object_id ] })
+          end
+
+          it "returns a cloned query" do
+            expect(selection).to_not equal(query)
+          end
+        end
+
         context "when the stretegy is intersect" do
 
           let(:selection) do
@@ -1483,7 +1512,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
           end
         end
 
-        context "when the stretegy is override" do
+        context "when the strategy is override" do
 
           let(:selection) do
             query.in(first: [ 1, 2 ]).override.in(first: [ 3, 4 ])
@@ -1500,7 +1529,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
           end
         end
 
-        context "when the stretegy is union" do
+        context "when the strategy is union" do
 
           let(:selection) do
             query.in(first: [ 1, 2 ]).union.in(first: [ 3, 4 ])

data/spec/mongoid/extensions/hash_spec.rb

@@ -230,10 +230,27 @@ describe Mongoid::Extensions::Hash do
     it "should retrieve a nested value under the provided key" do
       expect(nested).to eq "hundred"
     end
+
+    context 'and the value is falsey' do
+      let(:hash) do
+        { "100" => { "name" => false } }
+      end
+      it "should retrieve the falsey nested value under the provided key" do
+        expect(nested).to eq false
+      end
+    end
+
+    context 'and the value is nil' do
+      let(:hash) do
+        { "100" => { 0 => "Please don't return this value!" } }
+      end
+      it "should retrieve the nil nested value under the provided key" do
+        expect(nested).to eq nil
+      end
+    end
   end
 
   context "when the hash key is an integer" do
-
     let(:hash) do
       { 100 => { "name" => "hundred" } }
     end

data/spec/mongoid/factory_spec.rb

@@ -88,6 +88,17 @@ describe Mongoid::Factory do
         expect(person.title).to eq("Sir")
       end
     end
+
+    context "when the type is a symbol" do
+
+      let(:person) do
+        described_class.build(Person, { :_type => "Doctor" })
+      end
+
+      it "instantiates the subclass" do
+        expect(person.class).to eq(Doctor)
+      end
+    end
   end
 
   describe ".from_db" do

data/spec/mongoid/interceptable_spec.rb

@@ -526,7 +526,9 @@ describe Mongoid::Interceptable do
           end
 
           after(:all) do
-            Band.reset_callbacks(:rearrange)
+            # ActiveSupport may raise an error when trying to reset callbacks on all of Band's
+            # descendants, regardless of whether they have a particular callback defined.
+            begin; Band.reset_callbacks(:rearrange); rescue; end
           end
 
           let(:attributes) do

data/spec/mongoid/matchable/elem_match_spec.rb

@@ -53,6 +53,19 @@ describe Mongoid::Matchable::ElemMatch do
           expect(matcher._matches?("$elemMatch" => {"a" => {"$in" => [1]}, "b" => {"$gt" => 1}})).to be true
         end
       end
+
+      context "when using a $not operator that matches" do
+
+        it "returns true" do
+          expect(matcher._matches?("$elemMatch" => {"a" => {"$not" => 4}})).to be true
+        end
+      end
+    end
+
+    context "when using symbols and a :$not operator that matches" do
+      it "returns true" do
+        expect(matcher._matches?(:$elemMatch => {"a" => {:$not => 4}})).to be true
+      end
     end
 
     context "when there is not a sub document that matches the criteria" do
@@ -74,6 +87,13 @@ describe Mongoid::Matchable::ElemMatch do
           expect(matcher._matches?("$elemMatch" => {"a" => {"$in" => [1]}, "b" => {"$gt" => 10}})).to be false
         end
       end
+
+      context "when using a $not operator that does not match" do
+
+        it "returns true" do
+          expect(matcher._matches?("$elemMatch" => {"a" => {"$not" => 1}})).to be true
+        end
+      end
     end
 
     context "when using a criteria that matches partially but not a single sub document" do

data/spec/mongoid/persistable/deletable_spec.rb

@@ -228,6 +228,25 @@ describe Mongoid::Persistable::Deletable do
           expect(removed).to eq(1)
         end
       end
+
+      context 'when the write concern is unacknowledged' do
+
+        before do
+          Person.create(title: 'miss')
+        end
+
+        let!(:deleted) do
+          Person.with(write: { w: 0 }) { |klass| klass.delete_all(title: "sir") }
+        end
+
+        it "removes the matching documents" do
+          expect(Person.where(title: 'miss').count).to eq(1)
+        end
+
+        it "returns 0" do
+          expect(deleted).to eq(0)
+        end
+      end
     end
   end
 end

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -222,6 +222,25 @@ describe Mongoid::Persistable::Destroyable do
       end
     end
 
+    context 'when the write concern is unacknowledged' do
+
+      before do
+        Person.create(title: 'miss')
+      end
+
+      let!(:removed) do
+        Person.with(write: { w: 0 }) { |klass| klass.destroy_all(title: "sir") }
+      end
+
+      it "removes the matching documents" do
+        expect(Person.where(title: 'miss').count).to eq(1)
+      end
+
+      it "returns 0" do
+        expect(removed).to eq(0)
+      end
+    end
+
     context 'when removing a list of embedded documents' do
 
       context 'when the embedded documents list is reversed in memory' do

data/spec/mongoid/persistable/savable_spec.rb

@@ -189,8 +189,8 @@ describe Mongoid::Persistable::Savable do
               "title" => "King",
               "name.first_name" => "Ryan"
             },
-            "$pushAll"=> {
-              "addresses" => [ { "_id" => address.id, "street" => "Bond St" } ]
+            "$push"=> {
+              "addresses" => { '$each' => [ { "_id" => address.id, "street" => "Bond St" } ] }
             }
           })
         end

data/spec/mongoid/persistable/updatable_spec.rb

@@ -462,7 +462,7 @@ describe Mongoid::Persistable::Updatable do
 
         it "raises an error" do
           expect {
-            person.update_attributes(map: { "bad.key" => "value" })
+            person.update_attributes(map: { "$bad.key" => "value" })
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
@@ -498,7 +498,7 @@ describe Mongoid::Persistable::Updatable do
 
         it "raises an error" do
           expect {
-            person.send(method, map: { "bad.key" => "value" })
+            person.send(method, map: { "$bad.key" => "value" })
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end

data/spec/mongoid/persistable_spec.rb

@@ -52,16 +52,16 @@ describe Mongoid::Persistable do
       context "when not chaining the operations" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+            { :session => nil } ]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -79,16 +79,16 @@ describe Mongoid::Persistable do
       context "when chaining the operations" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true } },
+            { :session => nil } ]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -107,16 +107,16 @@ describe Mongoid::Persistable do
       context "when given multiple operations of the same type" do
 
         let(:operations) do
-          {
+         [{
             "$inc" => { "member_count" => 10, "other_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+            { :session => nil } ]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -144,16 +144,16 @@ describe Mongoid::Persistable do
       context "when expecting the document to be yielded" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+            { :session => nil } ]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -200,6 +200,21 @@ describe Mongoid::Persistable do
         expect(document.atomically).to be true
       end
     end
+
+    context "when the block has no operations" do
+        before do
+          expect_any_instance_of(Mongo::Collection::View).to_not receive(:update_one)
+        end
+
+        let!(:update) do
+          document.atomically do
+          end
+        end
+
+        it "doesn't update the document" do
+          expect(document.reload.origin).to eq("London")
+        end
+    end
   end
 
   describe "#fail_due_to_valiation!" do

data/spec/mongoid/persistence_context_spec.rb

@@ -70,6 +70,20 @@ describe Mongoid::PersistenceContext do
       { collection: :other }
     end
 
+    context 'when the method throws an error' do
+
+      let!(:persistence_context) do
+        described_class.set(object, options).tap do |cxt|
+          allow(cxt).to receive(:client).and_raise(Mongoid::Errors::NoClientConfig.new('default'))
+        end
+      end
+
+      it 'clears the context anyway' do
+        begin; described_class.clear(object); rescue; end
+        expect(described_class.get(object)).to be(nil)
+      end
+    end
+
     context 'when there has been a persistence context set on the current thread' do
 
       let!(:persistence_context) do