mongoid 9.0.11 → 9.1.1

data/spec/mongoid/atomic/modifiers_spec.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Atomic::Modifiers do
-
   let(:modifiers) do
     described_class.new
   end
 
-  describe "#push_conflict?" do
+  describe '#push_conflict?' do
     let(:result) { modifiers.send(:push_conflict?, field) }
 
     context 'for embeds many subdocument' do
@@ -29,42 +27,37 @@ describe Mongoid::Atomic::Modifiers do
     end
   end
 
-  describe "#add_to_set" do
-
-    context "when the unique adds are empty" do
-
+  describe '#add_to_set' do
+    context 'when the unique adds are empty' do
       before do
         modifiers.add_to_set({})
       end
 
-      it "does not contain any operations" do
+      it 'does not contain any operations' do
         expect(modifiers).to eq({})
       end
     end
 
-    context "when the adds are not empty" do
-
+    context 'when the adds are not empty' do
       let(:adds) do
-        { "preference_ids" => [ "one", "two" ] }
+        { 'preference_ids' => %w[one two] }
       end
 
-      context "when adding a single field" do
-
+      context 'when adding a single field' do
         before do
           modifiers.add_to_set(adds)
         end
 
-        it "adds the add to set with each modifiers" do
+        it 'adds the add to set with each modifiers' do
           expect(modifiers).to eq({
-            "$addToSet" => { "preference_ids" => { "$each" => [ "one", "two" ] }}
-          })
+                                    '$addToSet' => { 'preference_ids' => { '$each' => %w[one two] } }
+                                  })
         end
       end
 
-      context "when adding to an existing field" do
-
+      context 'when adding to an existing field' do
         let(:adds_two) do
-          { "preference_ids" => [ "three" ] }
+          { 'preference_ids' => [ 'three' ] }
         end
 
         before do
@@ -72,58 +65,52 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.add_to_set(adds_two)
         end
 
-        it "adds the add to set with each modifiers" do
+        it 'adds the add to set with each modifiers' do
           expect(modifiers).to eq({
-            "$addToSet" =>
-              { "preference_ids" =>
-                { "$each" => [ "one", "two", "three" ] }
-              }
-          })
+                                    '$addToSet' =>
+              { 'preference_ids' =>
+                { '$each' => %w[one two three] } }
+                                  })
         end
       end
     end
   end
 
-  describe "#pull" do
-
-    context "when the pulls are empty" do
-
+  describe '#pull' do
+    context 'when the pulls are empty' do
       before do
         modifiers.pull({})
       end
 
-      it "does not contain any pull operations" do
+      it 'does not contain any pull operations' do
         expect(modifiers).to eq({})
       end
     end
 
-    context "when no conflicting modifications are present" do
-
-      context "when adding a single pull" do
-
+    context 'when no conflicting modifications are present' do
+      context 'when adding a single pull' do
         let(:pulls) do
-          { "addresses" => { "_id" => { "$in" => [ "one" ]}} }
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
         end
 
         before do
           modifiers.pull(pulls)
         end
 
-        it "adds the push all modifiers" do
+        it 'adds the push all modifiers' do
           expect(modifiers).to eq(
-            { "$pull" => { "addresses" => { "_id" => { "$in" => [ "one" ]}}}}
+            { '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } } }
           )
         end
       end
 
-      context "when adding to an existing pull" do
-
+      context 'when adding to an existing pull' do
         let(:pull_one) do
-          { "addresses" => { "_id" => { "$in" => [ "one" ]}} }
+          { 'addresses' => { '_id' => { '$in' => [ 'one' ] } } }
         end
 
         let(:pull_two) do
-          { "addresses" => { "_id" => { "$in" => [ "two" ]}} }
+          { 'addresses' => { '_id' => { '$in' => [ 'two' ] } } }
         end
 
         before do
@@ -131,60 +118,53 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.pull(pull_two)
         end
 
-        it "overwrites the previous pulls" do
+        it 'overwrites the previous pulls' do
           expect(modifiers).to eq(
-            { "$pull" => { "addresses" => { "_id" => { "$in" => [ "two" ]}}}}
+            { '$pull' => { 'addresses' => { '_id' => { '$in' => [ 'two' ] } } } }
           )
         end
       end
     end
   end
 
-  describe "#pull_all" do
-
-    context "when the pulls are empty" do
-
+  describe '#pull_all' do
+    context 'when the pulls are empty' do
       before do
         modifiers.pull_all({})
       end
 
-      it "does not contain any pull operations" do
+      it 'does not contain any pull operations' do
         expect(modifiers).to eq({})
       end
     end
 
-    context "when no conflicting modifications are present" do
-
-      context "when adding a single pull" do
-
+    context 'when no conflicting modifications are present' do
+      context 'when adding a single pull' do
         let(:pulls) do
-          { "addresses" => [{ "_id" => "one" }] }
+          { 'addresses' => [ { '_id' => 'one' } ] }
         end
 
         before do
           modifiers.pull_all(pulls)
         end
 
-        it "adds the push all modifiers" do
+        it 'adds the push all modifiers' do
           expect(modifiers).to eq(
-            { "$pullAll" =>
-              { "addresses" => [
-                  { "_id" => "one" }
-                ]
-              }
-            }
+            { '$pullAll' =>
+              { 'addresses' => [
+                { '_id' => 'one' }
+              ] } }
           )
         end
       end
 
-      context "when adding to an existing pull" do
-
+      context 'when adding to an existing pull' do
         let(:pull_one) do
-          { "addresses" => [{ "street" => "Hobrechtstr." }] }
+          { 'addresses' => [ { 'street' => 'Hobrechtstr.' } ] }
         end
 
         let(:pull_two) do
-          { "addresses" => [{ "street" => "Pflugerstr." }] }
+          { 'addresses' => [ { 'street' => 'Pflugerstr.' } ] }
         end
 
         before do
@@ -192,66 +172,57 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.pull_all(pull_two)
         end
 
-        it "adds the pull all modifiers" do
+        it 'adds the pull all modifiers' do
           expect(modifiers).to eq(
-            { "$pullAll" =>
-              { "addresses" => [
-                  { "street" => "Hobrechtstr." },
-                  { "street" => "Pflugerstr." }
-                ]
-              }
-            }
+            { '$pullAll' =>
+              { 'addresses' => [
+                { 'street' => 'Hobrechtstr.' },
+                { 'street' => 'Pflugerstr.' }
+              ] } }
           )
         end
       end
     end
   end
 
-  describe "#push" do
-
-    context "when the pushes are empty" do
-
+  describe '#push' do
+    context 'when the pushes are empty' do
       before do
         modifiers.push({})
       end
 
-      it "does not contain any push operations" do
+      it 'does not contain any push operations' do
         expect(modifiers).to eq({})
       end
     end
 
-    context "when no conflicting modification is present" do
-
-      context "when adding a single push" do
-
+    context 'when no conflicting modification is present' do
+      context 'when adding a single push' do
         let(:pushes) do
-          { "addresses" => { "street" => "Oxford St" } }
+          { 'addresses' => { 'street' => 'Oxford St' } }
         end
 
         before do
           modifiers.push(pushes)
         end
 
-        it "adds the push all modifiers" do
+        it 'adds the push all modifiers' do
           expect(modifiers).to eq(
-            { "$push" =>
-              { "addresses" => { '$each' => [
-                  { "street" => "Oxford St" }
-                ] }
-              }
-            }
+            { '$push' =>
+              { 'addresses' => { '$each' => [
+                { 'street' => 'Oxford St' }
+              ] } } }
           )
         end
       end
 
-      context "when adding to an existing push" do
-
+      context 'when adding to an existing push' do
         let(:push_one) do
-          { "addresses" => { "street" => "Hobrechtstr." } }
+          { 'addresses' => { 'street' => 'Hobrechtstr.' } }
         end
 
         let(:push_two) do
-          { "addresses" => { "street" => "Pflugerstr." } }
+          { 'addresses' => { 'street' => 'Pflugerstr.' } }
         end
 
         before do
@@ -259,30 +230,26 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.push(push_two)
         end
 
-        it "adds the push all modifiers" do
+        it 'adds the push all modifiers' do
           expect(modifiers).to eq(
-            { "$push" =>
-              { "addresses" => { '$each' => [
-                  { "street" => "Hobrechtstr." },
-                  { "street" => "Pflugerstr." }
-                ] }
-              }
-            }
+            { '$push' =>
+              { 'addresses' => { '$each' => [
+                { 'street' => 'Hobrechtstr.' },
+                { 'street' => 'Pflugerstr.' }
+              ] } } }
           )
         end
       end
     end
 
-    context "when a conflicting modification exists" do
-
-      context "when the conflicting modification is a set" do
-
+    context 'when a conflicting modification exists' do
+      context 'when the conflicting modification is a set' do
         let(:sets) do
-          { "addresses.0.street" => "Bond" }
+          { 'addresses.0.street' => 'Bond' }
         end
 
         let(:pushes) do
-          { "addresses" => { "street" => "Oxford St" } }
+          { 'addresses' => { 'street' => 'Oxford St' } }
         end
 
         before do
@@ -290,28 +257,24 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.push(pushes)
         end
 
-        it "adds the push all modifiers to the conflicts hash" do
+        it 'adds the push all modifiers to the conflicts hash' do
           expect(modifiers).to eq(
-            { "$set" => { "addresses.0.street" => "Bond" },
-              conflicts: { "$push" =>
-                { "addresses" => { '$each' => [
-                    { "street" => "Oxford St" }
-                  ] }
-                }
-              }
-            }
+            { '$set' => { 'addresses.0.street' => 'Bond' },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
           )
         end
       end
 
-      context "when the conflicting modification is a pull" do
-
+      context 'when the conflicting modification is a pull' do
         let(:pulls) do
-          { "addresses" => { "street" => "Bond St" } }
+          { 'addresses' => { 'street' => 'Bond St' } }
         end
 
         let(:pushes) do
-          { "addresses" => { "street" => "Oxford St" } }
+          { 'addresses' => { 'street' => 'Oxford St' } }
         end
 
         before do
@@ -319,29 +282,26 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.push(pushes)
         end
 
-        it "adds the push all modifiers to the conflicts hash" do
+        it 'adds the push all modifiers to the conflicts hash' do
           expect(modifiers).to eq(
-            { "$pullAll" => {
-              "addresses" => { "street" => "Bond St" }},
-              conflicts: { "$push" =>
-                { "addresses" => { '$each' => [
-                    { "street" => "Oxford St" }
-                  ]}
-                }
-              }
-            }
+            { '$pullAll' => {
+                'addresses' => { 'street' => 'Bond St' }
+              },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
           )
         end
       end
 
-      context "when the conflicting modification is a push" do
-
+      context 'when the conflicting modification is a push' do
         let(:nested) do
-          { "addresses.0.locations" => { "street" => "Bond St" } }
+          { 'addresses.0.locations' => { 'street' => 'Bond St' } }
         end
 
         let(:pushes) do
-          { "addresses" => { "street" => "Oxford St" } }
+          { 'addresses' => { 'street' => 'Oxford St' } }
         end
 
         before do
@@ -349,30 +309,27 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.push(pushes)
         end
 
-        it "adds the push all modifiers to the conflicts hash" do
+        it 'adds the push all modifiers to the conflicts hash' do
           expect(modifiers).to eq(
-            { "$push" => {
-              "addresses.0.locations" => { '$each' => [{ "street" => "Bond St" }] } },
-              conflicts: { "$push" =>
-                { "addresses" => { '$each' => [
-                    { "street" => "Oxford St" }
-                  ] }
-                }
-              }
-            }
+            { '$push' => {
+                'addresses.0.locations' => { '$each' => [ { 'street' => 'Bond St' } ] }
+              },
+              conflicts: { '$push' =>
+                { 'addresses' => { '$each' => [
+                  { 'street' => 'Oxford St' }
+                ] } } } }
           )
         end
       end
     end
 
     context 'when there is another operation on a sibling of a key which is nested' do
-
       let(:first_op) do
-        { "addresses.0.name" => 'test' }
+        { 'addresses.0.name' => 'test' }
       end
 
       let(:push_op) do
-        { "addresses.0.locations" => { "street" => "Oxford St" } }
+        { 'addresses.0.locations' => { 'street' => 'Oxford St' } }
       end
 
       before do
@@ -380,75 +337,70 @@ describe Mongoid::Atomic::Modifiers do
         modifiers.push(push_op)
       end
 
-      it "does not conflict and adds push to top level" do
+      it 'does not conflict and adds push to top level' do
         pending 'https://jira.mongodb.org/browse/MONGOID-4982'
 
-        modifiers.should == {
-          '$set' => { "addresses.0.name" => 'test' },
-          '$push' => {"addresses.0.locations" => {'$each' => [
-            { "street" => "Oxford St" },
-          ]}},
-        }
+        modifiers.should eq(
+          {
+            '$set' => { 'addresses.0.name' => 'test' },
+            '$push' => { 'addresses.0.locations' => { '$each' => [
+              { 'street' => 'Oxford St' }
+            ] } }
+          }
+        )
       end
     end
   end
 
-  describe "#set" do
-
-    describe "when adding to the root level" do
-
-      context "when no conflicting mods exist" do
-
-        context "when the sets have values" do
-
+  describe '#set' do
+    describe 'when adding to the root level' do
+      context 'when no conflicting mods exist' do
+        context 'when the sets have values' do
           let(:sets) do
-            { "title" => "Sir" }
+            { 'title' => 'Sir' }
           end
 
           before do
             modifiers.set(sets)
           end
 
-          it "adds the sets to the modifiers" do
-            expect(modifiers).to eq({ "$set" => { "title" => "Sir" } })
+          it 'adds the sets to the modifiers' do
+            expect(modifiers).to eq({ '$set' => { 'title' => 'Sir' } })
           end
         end
 
-        context "when the sets contain an id" do
-
+        context 'when the sets contain an id' do
           let(:sets) do
-            { "_id" => BSON::ObjectId.new }
+            { '_id' => BSON::ObjectId.new }
           end
 
           before do
             modifiers.set(sets)
           end
 
-          it "does not include the id sets" do
+          it 'does not include the id sets' do
             expect(modifiers).to eq({})
           end
         end
 
-        context "when the sets are empty" do
-
+        context 'when the sets are empty' do
           before do
             modifiers.set({})
           end
 
-          it "does not contain set operations" do
+          it 'does not contain set operations' do
             expect(modifiers).to eq({})
           end
         end
       end
 
-      context "when a conflicting modification exists" do
-
+      context 'when a conflicting modification exists' do
         let(:pulls) do
-          { "addresses" => [{ "_id" => "one" }] }
+          { 'addresses' => [ { '_id' => 'one' } ] }
         end
 
         let(:sets) do
-          { "addresses.0.title" => "Sir" }
+          { 'addresses.0.title' => 'Sir' }
         end
 
         before do
@@ -456,51 +408,86 @@ describe Mongoid::Atomic::Modifiers do
           modifiers.set(sets)
         end
 
-        it "adds the set modifiers to the conflicts hash" do
+        it 'adds the set modifiers to the conflicts hash' do
           expect(modifiers).to eq(
-            { "$pullAll" =>
-              { "addresses" => [
-                  { "_id" => "one" }
-                ]
-              },
+            { '$pullAll' =>
+              { 'addresses' => [
+                { '_id' => 'one' }
+              ] },
               conflicts:
-                { "$set" => { "addresses.0.title" => "Sir" }}
-            }
+                { '$set' => { 'addresses.0.title' => 'Sir' } } }
           )
         end
       end
     end
   end
 
-  describe "#unset" do
-
-    describe "when adding to the root level" do
-
-      context "when the unsets have values" do
-
+  describe '#unset' do
+    describe 'when adding to the root level' do
+      context 'when the unsets have values' do
         let(:unsets) do
-          [ "addresses" ]
+          [ 'addresses' ]
         end
 
         before do
           modifiers.unset(unsets)
         end
 
-        it "adds the unsets to the modifiers" do
-          expect(modifiers).to eq({ "$unset" => { "addresses" => true } })
+        it 'adds the unsets to the modifiers' do
+          expect(modifiers).to eq({ '$unset' => { 'addresses' => true } })
         end
       end
 
-      context "when the unsets are empty" do
-
+      context 'when the unsets are empty' do
         before do
           modifiers.unset([])
         end
 
-        it "does not contain unset operations" do
+        it 'does not contain unset operations' do
           expect(modifiers).to eq({})
         end
       end
+
+      context 'when the unsets conflict with a prior set' do
+        before do
+          # `generate_atomic_updates` always calls `unset` before `set`, but in the case
+          # of nested documents, `generate_atomic_updates` is always called for the
+          # child documents after the parent.
+          #
+          # The following initialization assumes that `sets` is what is set on the parent,
+          # and `unsets` is what is set on the children.
+          modifiers.set(sets)
+          modifiers.unset(unsets)
+        end
+
+        context 'when the child is a new document' do
+          let(:sets) { { 'books' => [ { 'title' => '1984' } ] } }
+
+          # if the child is a new document, its path will not be set correctly,
+          # effectively giving it a `nil` index.
+          let(:unsets) { [ 'books.title' ] }
+
+          it 'conflicts' do
+            expect(modifiers).to eq(
+              { '$set' => { 'books' => [ { 'title' => '1984' } ] } }
+            )
+          end
+        end
+
+        context 'when the child is a persisted document' do
+          let(:sets) { { 'books' => [ { 'title' => '1984' } ] } }
+
+          # if the child is a persisted document, its path will be set correctly,
+          # referencing the child by index.
+          let(:unsets) { [ 'books.0.title' ] }
+
+          it 'conflicts' do
+            expect(modifiers).to eq(
+              { '$set' => { 'books' => [ { 'title' => '1984' } ] } }
+            )
+          end
+        end
+      end
     end
   end
 end