mongoid 9.0.11 → 9.1.0

data/spec/mongoid/contextual/atomic_spec.rb

@@ -1,26 +1,22 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Contextual::Atomic do
-
-  describe "#add_to_set" do
-
+  describe '#add_to_set' do
     let!(:depeche_mode) do
-      Band.create!(members: [ "Dave" ])
+      Band.create!(members: [ 'Dave' ])
     end
 
     let!(:new_order) do
-      Band.create!(members: [ "Peter" ])
+      Band.create!(members: [ 'Peter' ])
     end
 
     let!(:smiths) do
       Band.create!
     end
 
-    context "when the criteria has no sorting" do
-
+    context 'when the criteria has no sorting' do
       let(:criteria) do
         Band.all
       end
@@ -30,24 +26,23 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.add_to_set(members: "Dave")
+        context.add_to_set(members: 'Dave')
       end
 
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave" ])
+      it 'does not add duplicates' do
+        expect(depeche_mode.reload.members).to eq([ 'Dave' ])
       end
 
-      it "adds unique values" do
-        expect(new_order.reload.members).to eq([ "Peter", "Dave" ])
+      it 'adds unique values' do
+        expect(new_order.reload.members).to eq(%w[Peter Dave])
       end
 
-      it "adds to non initialized fields" do
-        expect(smiths.reload.members).to eq([ "Dave" ])
+      it 'adds to non initialized fields' do
+        expect(smiths.reload.members).to eq([ 'Dave' ])
       end
     end
 
-    context "when the criteria has sorting" do
-
+    context 'when the criteria has sorting' do
       let(:criteria) do
         Band.asc(:name)
       end
@@ -57,30 +52,29 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.add_to_set(members: "Dave", genres: "Electro")
+        context.add_to_set(members: 'Dave', genres: 'Electro')
       end
 
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave" ])
+      it 'does not add duplicates' do
+        expect(depeche_mode.reload.members).to eq([ 'Dave' ])
       end
 
-      it "adds multiple operations" do
-        expect(depeche_mode.reload.genres).to eq([ "Electro" ])
+      it 'adds multiple operations' do
+        expect(depeche_mode.reload.genres).to eq([ 'Electro' ])
       end
 
-      it "adds unique values" do
-        expect(new_order.reload.members).to eq([ "Peter", "Dave" ])
+      it 'adds unique values' do
+        expect(new_order.reload.members).to eq(%w[Peter Dave])
       end
 
-      it "adds to non initialized fields" do
-        expect(smiths.reload.members).to eq([ "Dave" ])
+      it 'adds to non initialized fields' do
+        expect(smiths.reload.members).to eq([ 'Dave' ])
       end
     end
 
     context 'when the criteria has a collation' do
-
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -88,35 +82,33 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.add_to_set(members: "Dave", genres: "Electro")
+        context.add_to_set(members: 'Dave', genres: 'Electro')
       end
 
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave" ])
+      it 'does not add duplicates' do
+        expect(depeche_mode.reload.members).to eq([ 'Dave' ])
       end
 
-      it "adds multiple operations" do
-        expect(depeche_mode.reload.genres).to eq([ "Electro" ])
+      it 'adds multiple operations' do
+        expect(depeche_mode.reload.genres).to eq([ 'Electro' ])
       end
     end
   end
 
-  describe "#add_each_to_set" do
-
+  describe '#add_each_to_set' do
     let!(:depeche_mode) do
-      Band.create!(members: [ "Dave" ])
+      Band.create!(members: [ 'Dave' ])
     end
 
     let!(:new_order) do
-      Band.create!(members: [ "Peter" ])
+      Band.create!(members: [ 'Peter' ])
     end
 
     let!(:smiths) do
       Band.create!
     end
 
-    context "when the criteria has no sorting" do
-
+    context 'when the criteria has no sorting' do
       let(:criteria) do
         Band.all
       end
@@ -126,24 +118,23 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.add_each_to_set(members: [ "Dave", "Joe" ])
+        context.add_each_to_set(members: %w[Dave Joe])
       end
 
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Joe" ])
+      it 'does not add duplicates' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Joe])
       end
 
-      it "adds unique values" do
-        expect(new_order.reload.members).to eq([ "Peter", "Dave", "Joe" ])
+      it 'adds unique values' do
+        expect(new_order.reload.members).to eq(%w[Peter Dave Joe])
       end
 
-      it "adds to non initialized fields" do
-        expect(smiths.reload.members).to eq([ "Dave", "Joe" ])
+      it 'adds to non initialized fields' do
+        expect(smiths.reload.members).to eq(%w[Dave Joe])
       end
     end
 
-    context "when the criteria has sorting" do
-
+    context 'when the criteria has sorting' do
       let(:criteria) do
         Band.asc(:name)
       end
@@ -153,30 +144,29 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.add_each_to_set(members: [ "Dave", "Joe" ], genres: "Electro")
+        context.add_each_to_set(members: %w[Dave Joe], genres: 'Electro')
       end
 
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Joe" ])
+      it 'does not add duplicates' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Joe])
       end
 
-      it "adds multiple operations" do
-        expect(depeche_mode.reload.genres).to eq([ "Electro" ])
+      it 'adds multiple operations' do
+        expect(depeche_mode.reload.genres).to eq([ 'Electro' ])
       end
 
-      it "adds unique values" do
-        expect(new_order.reload.members).to eq([ "Peter", "Dave", "Joe" ])
+      it 'adds unique values' do
+        expect(new_order.reload.members).to eq(%w[Peter Dave Joe])
       end
 
-      it "adds to non initialized fields" do
-        expect(smiths.reload.members).to eq([ "Dave", "Joe" ])
+      it 'adds to non initialized fields' do
+        expect(smiths.reload.members).to eq(%w[Dave Joe])
       end
     end
 
     context 'when the criteria has a collation' do
-
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -184,21 +174,20 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.add_each_to_set(members: [ "Dave", "Joe" ], genres: "Electro")
+        context.add_each_to_set(members: %w[Dave Joe], genres: 'Electro')
       end
 
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Joe" ])
+      it 'does not add duplicates' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Joe])
       end
 
-      it "adds multiple operations" do
-        expect(depeche_mode.reload.genres).to eq([ "Electro" ])
+      it 'adds multiple operations' do
+        expect(depeche_mode.reload.genres).to eq([ 'Electro' ])
       end
     end
   end
 
-  describe "#bit" do
-
+  describe '#bit' do
     let!(:depeche_mode) do
       Band.create!(likes: 60)
     end
@@ -211,47 +200,43 @@ describe Mongoid::Contextual::Atomic do
       Mongoid::Contextual::Mongo.new(criteria)
     end
 
-    context "when performing a bitwise and" do
-
+    context 'when performing a bitwise and' do
       before do
         context.bit(likes: { and: 13 })
       end
 
-      it "performs the bitwise operation on initialized fields" do
+      it 'performs the bitwise operation on initialized fields' do
         expect(depeche_mode.reload.likes).to eq(12)
       end
     end
 
-    context "when performing a bitwise or" do
-
+    context 'when performing a bitwise or' do
       before do
         context.bit(likes: { or: 13 })
       end
 
-      it "performs the bitwise operation on initialized fields" do
+      it 'performs the bitwise operation on initialized fields' do
         expect(depeche_mode.reload.likes).to eq(61)
       end
     end
 
-    context "when chaining bitwise operations" do
-
+    context 'when chaining bitwise operations' do
       before do
         context.bit(likes: { and: 13, or: 10 })
       end
 
-      it "performs the bitwise operation on initialized fields" do
+      it 'performs the bitwise operation on initialized fields' do
         expect(depeche_mode.reload.likes).to eq(14)
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ], likes: 60)
+        Band.create!(members: [ 'Dave' ], likes: 60)
       end
 
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -262,14 +247,13 @@ describe Mongoid::Contextual::Atomic do
         context.bit(likes: { and: 13, or: 10 })
       end
 
-      it "performs the bitwise operation on initialized fields" do
+      it 'performs the bitwise operation on initialized fields' do
         expect(depeche_mode.reload.likes).to eq(14)
       end
     end
   end
 
-  describe "#inc" do
-
+  describe '#inc' do
     let!(:depeche_mode) do
       Band.create!(likes: 60)
     end
@@ -294,43 +278,39 @@ describe Mongoid::Contextual::Atomic do
       context.inc(likes: 10)
     end
 
-    context "when the field exists" do
-
-      it "incs the value" do
+    context 'when the field exists' do
+      it 'incs the value' do
         expect(depeche_mode.reload.likes).to eq(70)
       end
     end
 
-    context "when the field does not exist" do
-
-      it "does not error on the inc" do
-        expect(smiths.reload.likes).to be == 10
+    context 'when the field does not exist' do
+      it 'does not error on the inc' do
+        expect(smiths.reload.likes).to eq 10
       end
     end
 
-    context "when using the alias" do
-
+    context 'when using the alias' do
       before do
         context.inc(years: 1)
       end
 
-      it "incs the value and read from alias" do
+      it 'incs the value and read from alias' do
         expect(beatles.reload.years).to eq(3)
       end
 
-      it "incs the value and read from field" do
+      it 'incs the value and read from field' do
         expect(beatles.reload.y).to eq(3)
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -341,14 +321,13 @@ describe Mongoid::Contextual::Atomic do
         context.inc(years: 1)
       end
 
-      it "incs the value and read from alias" do
+      it 'incs the value and read from alias' do
         expect(depeche_mode.reload.years).to eq(1)
       end
     end
   end
 
-  describe "#mul" do
-
+  describe '#mul' do
     let!(:depeche_mode) { Band.create!(likes: 60) }
     let!(:smiths) { Band.create! }
     let!(:beatles) { Band.create!(years: 2) }
@@ -358,56 +337,51 @@ describe Mongoid::Contextual::Atomic do
 
     before { context.mul(likes: 10) }
 
-    context "when the field exists" do
-
-      it "muls the value" do
+    context 'when the field exists' do
+      it 'muls the value' do
         expect(depeche_mode.reload.likes).to eq(600)
       end
     end
 
-    context "when the field does not exist" do
-
-      it "sets undefined fields to zero" do
-        expect(smiths.reload.likes).to be == 0
+    context 'when the field does not exist' do
+      it 'sets undefined fields to zero' do
+        expect(smiths.reload.likes).to eq 0
       end
     end
 
-    context "when using the alias" do
-
+    context 'when using the alias' do
       before do
         context.mul(years: 2)
       end
 
-      it "muls the value and read from alias" do
+      it 'muls the value and read from alias' do
         expect(beatles.reload.years).to eq(4)
       end
 
-      it "muls the value and read from field" do
+      it 'muls the value and read from field' do
         expect(beatles.reload.y).to eq(4)
       end
     end
 
     context 'when the criteria has a collation' do
-
-      let!(:depeche_mode) { Band.create!(members: [ "Dave" ], years: 3) }
+      let!(:depeche_mode) { Band.create!(members: [ 'Dave' ], years: 3) }
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) { Mongoid::Contextual::Mongo.new(criteria) }
 
       before { context.mul(years: 2) }
 
-      it "muls the value" do
+      it 'muls the value' do
         expect(depeche_mode.reload.years).to eq(6)
       end
     end
   end
 
-  describe "#pop" do
-
+  describe '#pop' do
     let!(:depeche_mode) do
-      Band.create!(members: [ "Dave", "Martin" ])
+      Band.create!(members: %w[Dave Martin])
     end
 
     let!(:smiths) do
@@ -422,44 +396,41 @@ describe Mongoid::Contextual::Atomic do
       Mongoid::Contextual::Mongo.new(criteria)
     end
 
-    context "when popping from the front" do
-
+    context 'when popping from the front' do
       before do
         context.pop(members: -1)
       end
 
-      it "pops the first element off the array" do
-        expect(depeche_mode.reload.members).to eq([ "Martin" ])
+      it 'pops the first element off the array' do
+        expect(depeche_mode.reload.members).to eq([ 'Martin' ])
       end
 
-      it "does not error on uninitialized fields" do
+      it 'does not error on uninitialized fields' do
         expect(smiths.reload.members).to be_nil
       end
     end
 
-    context "when popping from the rear" do
-
+    context 'when popping from the rear' do
       before do
         context.pop(members: 1)
       end
 
-      it "pops the last element off the array" do
-        expect(depeche_mode.reload.members).to eq([ "Dave" ])
+      it 'pops the last element off the array' do
+        expect(depeche_mode.reload.members).to eq([ 'Dave' ])
       end
 
-      it "does not error on uninitialized fields" do
+      it 'does not error on uninitialized fields' do
         expect(smiths.reload.members).to be_nil
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -470,16 +441,15 @@ describe Mongoid::Contextual::Atomic do
         context.pop(members: 1)
       end
 
-      it "pops the last element off the array" do
+      it 'pops the last element off the array' do
         expect(depeche_mode.reload.members).to be_empty
       end
     end
   end
 
-  describe "#pull" do
-
+  describe '#pull' do
     let!(:depeche_mode) do
-      Band.create!(members: [ "Dave", "Alan" ])
+      Band.create!(members: %w[Dave Alan])
     end
 
     let!(:smiths) do
@@ -495,25 +465,24 @@ describe Mongoid::Contextual::Atomic do
     end
 
     before do
-      context.pull(members: "Alan")
+      context.pull(members: 'Alan')
     end
 
-    it "pulls when the value is found" do
-      expect(depeche_mode.reload.members).to eq([ "Dave" ])
+    it 'pulls when the value is found' do
+      expect(depeche_mode.reload.members).to eq([ 'Dave' ])
     end
 
-    it "does not error on non existent fields" do
+    it 'does not error on non existent fields' do
       expect(smiths.reload.members).to be_nil
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -521,21 +490,19 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.pull(members: "DAVE")
+        context.pull(members: 'DAVE')
       end
 
-      it "pulls when the value is found" do
+      it 'pulls when the value is found' do
         expect(depeche_mode.reload.members).to be_empty
       end
     end
   end
 
-  describe "#pull_all" do
-
+  describe '#pull_all' do
     context 'when the criteria does not have a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave", "Alan", "Fletch" ])
+        Band.create!(members: %w[Dave Alan Fletch])
       end
 
       let!(:smiths) do
@@ -551,22 +518,21 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.pull_all(members: [ "Alan", "Dave" ])
+        context.pull_all(members: %w[Alan Dave])
       end
 
-      it "pulls when the values are found" do
-        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+      it 'pulls when the values are found' do
+        expect(depeche_mode.reload.members).to eq([ 'Fletch' ])
       end
 
-      it "does not error on non existent fields" do
+      it 'does not error on non existent fields' do
         expect(smiths.reload.members).to be_nil
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave", "Alan", "Fletch" ])
+        Band.create!(members: %w[Dave Alan Fletch])
       end
 
       let(:criteria) do
@@ -578,21 +544,19 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.pull_all(members: [ "ALAN", "DAVE" ])
+        context.pull_all(members: %w[ALAN DAVE])
       end
 
-      it "pulls when the value is found" do
-        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+      it 'pulls when the value is found' do
+        expect(depeche_mode.reload.members).to eq([ 'Fletch' ])
       end
     end
   end
 
-  describe "#push" do
-
+  describe '#push' do
     context 'when the criteria does not have a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let!(:smiths) do
@@ -608,22 +572,21 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.push(members: "Alan")
+        context.push(members: 'Alan')
       end
 
-      it "pushes the value to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+      it 'pushes the value to existing arrays' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Alan])
       end
 
-      it "pushes to non existent fields" do
-        expect(smiths.reload.members).to eq([ "Alan" ])
+      it 'pushes to non existent fields' do
+        expect(smiths.reload.members).to eq([ 'Alan' ])
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let!(:smiths) do
@@ -631,7 +594,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       let(:criteria) do
-        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -639,25 +602,23 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.push(members: "Alan")
+        context.push(members: 'Alan')
       end
 
-      it "pushes the value to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+      it 'pushes the value to existing arrays' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Alan])
       end
 
-      it "pushes to non existent fields" do
+      it 'pushes to non existent fields' do
         expect(smiths.reload.members).to be_nil
       end
     end
   end
 
-  describe "#push_all" do
-
+  describe '#push_all' do
     context 'when the criteria does not have a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let!(:smiths) do
@@ -673,22 +634,21 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.push_all(members: [ "Alan", "Fletch" ])
+        context.push_all(members: %w[Alan Fletch])
       end
 
-      it "pushes the values to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+      it 'pushes the values to existing arrays' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Alan Fletch])
       end
 
-      it "pushes to non existent fields" do
-        expect(smiths.reload.members).to eq([ "Alan", "Fletch" ])
+      it 'pushes to non existent fields' do
+        expect(smiths.reload.members).to eq(%w[Alan Fletch])
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let!(:smiths) do
@@ -696,7 +656,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       let(:criteria) do
-        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -704,21 +664,19 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.push_all(members: [ "Alan", "Fletch" ])
+        context.push_all(members: %w[Alan Fletch])
       end
 
-      it "pushes the values to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+      it 'pushes the values to existing arrays' do
+        expect(depeche_mode.reload.members).to eq(%w[Dave Alan Fletch])
       end
     end
   end
 
-  describe "#rename" do
-
+  describe '#rename' do
     context 'when the criteria does not have a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let!(:smiths) do
@@ -737,19 +695,18 @@ describe Mongoid::Contextual::Atomic do
         context.rename(members: :musicians)
       end
 
-      it "renames existing fields" do
-        expect(depeche_mode.reload.musicians).to eq([ "Dave" ])
+      it 'renames existing fields' do
+        expect(depeche_mode.reload.musicians).to eq([ 'Dave' ])
       end
 
-      it "does not rename non existent fields" do
-        expect(smiths.reload).to_not respond_to(:musicians)
+      it 'does not rename non existent fields' do
+        expect(smiths.reload).not_to respond_to(:musicians)
       end
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(members: [ "Dave" ])
+        Band.create!(members: [ 'Dave' ])
       end
 
       let!(:smiths) do
@@ -757,7 +714,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       let(:criteria) do
-        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
+        Band.where(members: [ 'DAVE' ]).collation(locale: 'en_US', strength: 2)
       end
 
       let(:context) do
@@ -768,20 +725,19 @@ describe Mongoid::Contextual::Atomic do
         context.rename(members: :musicians)
       end
 
-      it "renames existing fields" do
-        expect(depeche_mode.reload.musicians).to eq([ "Dave" ])
+      it 'renames existing fields' do
+        expect(depeche_mode.reload.musicians).to eq([ 'Dave' ])
       end
 
-      it "does not rename non existent fields" do
-        expect(smiths.reload).to_not respond_to(:musicians)
+      it 'does not rename non existent fields' do
+        expect(smiths.reload).not_to respond_to(:musicians)
       end
     end
   end
 
-  describe "#set" do
-
+  describe '#set' do
     let!(:depeche_mode) do
-      Band.create!(name: "Depeche Mode")
+      Band.create!(name: 'Depeche Mode')
     end
 
     let!(:smiths) do
@@ -797,23 +753,22 @@ describe Mongoid::Contextual::Atomic do
     end
 
     before do
-      context.set(name: "Recoil")
+      context.set(name: 'Recoil')
     end
 
     shared_examples 'writes as expected' do
-      it "sets existing fields" do
-        expect(depeche_mode.reload.name).to eq("Recoil")
+      it 'sets existing fields' do
+        expect(depeche_mode.reload.name).to eq('Recoil')
       end
 
-      it "sets non existent fields" do
-        expect(smiths.reload.name).to eq("Recoil")
+      it 'sets non existent fields' do
+        expect(smiths.reload.name).to eq('Recoil')
       end
     end
 
     include_examples 'writes as expected'
 
     context 'when fields being set have been projected out' do
-
       let(:criteria) do
         Band.only(:genres)
       end
@@ -822,16 +777,14 @@ describe Mongoid::Contextual::Atomic do
     end
   end
 
-  describe "#unset" do
-
-    context "when unsetting a single field" do
-
+  describe '#unset' do
+    context 'when unsetting a single field' do
       let!(:depeche_mode) do
-        Band.create!(name: "Depeche Mode", years: 10)
+        Band.create!(name: 'Depeche Mode', years: 10)
       end
 
       let!(:new_order) do
-        Band.create!(name: "New Order", years: 10)
+        Band.create!(name: 'New Order', years: 10)
       end
 
       let(:criteria) do
@@ -842,43 +795,41 @@ describe Mongoid::Contextual::Atomic do
         Mongoid::Contextual::Mongo.new(criteria)
       end
 
-      context "when the field is not aliased" do
-
+      context 'when the field is not aliased' do
         before do
           context.unset(:name)
         end
 
-        it "unsets the fields from all documents" do
+        it 'unsets the fields from all documents' do
           depeche_mode.reload
           new_order.reload
           expect(depeche_mode.name).to be_nil
-          expect(depeche_mode.years).to_not be_nil
+          expect(depeche_mode.years).not_to be_nil
           expect(new_order.name).to be_nil
-          expect(new_order.years).to_not be_nil
+          expect(new_order.years).not_to be_nil
         end
       end
 
-      context "when the field is aliased" do
+      context 'when the field is aliased' do
         before do
           context.unset(:years)
         end
 
-        it "unsets the fields from all documents" do
+        it 'unsets the fields from all documents' do
           depeche_mode.reload
           new_order.reload
-          expect(depeche_mode.name).to_not be_nil
+          expect(depeche_mode.name).not_to be_nil
           expect(depeche_mode.years).to be_nil
-          expect(new_order.name).to_not be_nil
+          expect(new_order.name).not_to be_nil
           expect(new_order.years).to be_nil
         end
       end
     end
 
-    context "when unsetting multiple fields" do
-
+    context 'when unsetting multiple fields' do
       let!(:new_order) do
-        Band.create!(name: "New Order", genres: %w[electro dub], years: 10,
-          likes: 200, rating: 4.3, origin: 'Space')
+        Band.create!(name: 'New Order', genres: %w[electro dub], years: 10,
+                     likes: 200, rating: 4.3, origin: 'Space')
       end
 
       let(:criteria) do
@@ -889,48 +840,45 @@ describe Mongoid::Contextual::Atomic do
         Mongoid::Contextual::Mongo.new(criteria)
       end
 
-      context "when the field is not aliased" do
-
+      context 'when the field is not aliased' do
         before do
           context.unset(:name, :genres)
         end
 
-        it "unsets the specified fields" do
+        it 'unsets the specified fields' do
           new_order.reload
           expect(new_order.name).to be_nil
           expect(new_order.genres).to be_nil
-          expect(new_order.years).to_not be_nil
-          expect(new_order.likes).to_not be_nil
-          expect(new_order.rating).to_not be_nil
+          expect(new_order.years).not_to be_nil
+          expect(new_order.likes).not_to be_nil
+          expect(new_order.rating).not_to be_nil
         end
       end
 
-      context "when the field is aliased" do
-
+      context 'when the field is aliased' do
         before do
           context.unset(:name, :years)
         end
 
-        it "unsets the specified fields" do
+        it 'unsets the specified fields' do
           new_order.reload
           expect(new_order.name).to be_nil
-          expect(new_order.genres).to_not be_nil
+          expect(new_order.genres).not_to be_nil
           expect(new_order.years).to be_nil
-          expect(new_order.likes).to_not be_nil
-          expect(new_order.rating).to_not be_nil
+          expect(new_order.likes).not_to be_nil
+          expect(new_order.rating).not_to be_nil
         end
       end
 
-      context "when using Hash arguments" do
-
+      context 'when using Hash arguments' do
         before do
-          context.unset({ years: true, likes: "" }, { rating: false, origin: nil })
+          context.unset({ years: true, likes: '' }, { rating: false, origin: nil })
         end
 
-        it "unsets the specified fields" do
+        it 'unsets the specified fields' do
           new_order.reload
-          expect(new_order.name).to_not be_nil
-          expect(new_order.genres).to_not be_nil
+          expect(new_order.name).not_to be_nil
+          expect(new_order.genres).not_to be_nil
           expect(new_order.years).to be_nil
           expect(new_order.likes).to be_nil
           expect(new_order.rating).to be_nil
@@ -938,16 +886,15 @@ describe Mongoid::Contextual::Atomic do
         end
       end
 
-      context "when mixing argument types" do
-
+      context 'when mixing argument types' do
         before do
-          context.unset(:name, [:years], { likes: "" }, { rating: false })
+          context.unset(:name, [ :years ], { likes: '' }, { rating: false })
         end
 
-        it "unsets the specified fields" do
+        it 'unsets the specified fields' do
           new_order.reload
           expect(new_order.name).to be_nil
-          expect(new_order.genres).to_not be_nil
+          expect(new_order.genres).not_to be_nil
           expect(new_order.years).to be_nil
           expect(new_order.likes).to be_nil
           expect(new_order.rating).to be_nil
@@ -956,13 +903,12 @@ describe Mongoid::Contextual::Atomic do
     end
 
     context 'when the criteria has a collation' do
-
       let!(:depeche_mode) do
-        Band.create!(name: "Depeche Mode", years: 10)
+        Band.create!(name: 'Depeche Mode', years: 10)
       end
 
       let!(:new_order) do
-        Band.create!(name: "New Order", years: 10)
+        Band.create!(name: 'New Order', years: 10)
       end
 
       let(:criteria) do
@@ -977,10 +923,10 @@ describe Mongoid::Contextual::Atomic do
         context.unset(:name)
       end
 
-      it "unsets the unaliased field" do
+      it 'unsets the unaliased field' do
         depeche_mode.reload
         expect(depeche_mode.name).to be_nil
-        expect(depeche_mode.years).to_not be_nil
+        expect(depeche_mode.years).not_to be_nil
       end
     end
   end
@@ -995,7 +941,8 @@ describe Mongoid::Contextual::Atomic do
       Band.create!(
         member_count: member_count,
         founded: founded,
-        views: views)
+        views: views
+      )
     end
 
     let(:criteria) { Band.all }
@@ -1004,12 +951,12 @@ describe Mongoid::Contextual::Atomic do
     shared_examples_for 'min-able comparisons' do
       shared_examples_for 'a min-able context' do
         it 'chooses the smaller value' do
-          context.send(min_method, "member_count" => given_members, views: given_views)
-          expect(band.reload.member_count).to be == [ member_count, given_members ].min
-          expect(band.views).to be == [ views, given_views ].min
+          context.send(min_method, 'member_count' => given_members, views: given_views)
+          expect(band.reload.member_count).to eq [ member_count, given_members ].min
+          expect(band.views).to eq [ views, given_views ].min
         end
       end
-  
+
       context 'when given value < existing value' do
         let(:given_views) { views - 1 }
         let(:given_members) { member_count - 1 }
@@ -1034,25 +981,27 @@ describe Mongoid::Contextual::Atomic do
       context 'when the named field does not yet exist on the document' do
         it 'sets the field to the argument' do
           context.send(min_method, new_field: 100)
-          expect(band.reload.new_field).to be == 100
+          expect(band.reload.new_field).to eq 100
         end
       end
 
       context 'when arguments are dates/times' do
         it 'picks the earliest date' do
           context.send(min_method, founded: founded - 1)
-          expect(band.reload.founded).to be == founded - 1
+          expect(band.reload.founded).to eq founded - 1
         end
       end
     end
 
     context 'as itself' do
       let(:min_method) { :set_min }
+
       include_examples 'min-able comparisons'
     end
 
     context 'as #clamp_upper_bound' do
       let(:min_method) { :clamp_upper_bound }
+
       include_examples 'min-able comparisons'
     end
   end
@@ -1067,7 +1016,8 @@ describe Mongoid::Contextual::Atomic do
       Band.create!(
         member_count: member_count,
         founded: founded,
-        views: views)
+        views: views
+      )
     end
 
     let(:criteria) { Band.all }
@@ -1076,9 +1026,9 @@ describe Mongoid::Contextual::Atomic do
     shared_examples_for 'max-able comparisons' do
       shared_examples_for 'a max-able context' do
         it 'chooses the larger value' do
-          context.send(max_method, "member_count" => given_members, views: given_views)
-          expect(band.reload.member_count).to be == [ member_count, given_members ].max
-          expect(band.views).to be == [ views, given_views ].max
+          context.send(max_method, 'member_count' => given_members, views: given_views)
+          expect(band.reload.member_count).to eq [ member_count, given_members ].max
+          expect(band.views).to eq [ views, given_views ].max
         end
       end
 
@@ -1106,25 +1056,27 @@ describe Mongoid::Contextual::Atomic do
       context 'when the named field does not yet exist on the document' do
         it 'sets the field to the argument' do
           context.send(max_method, new_field: 100)
-          expect(band.reload.new_field).to be == 100
+          expect(band.reload.new_field).to eq 100
         end
       end
 
       context 'when arguments are dates/times' do
         it 'picks the earliest date' do
           context.send(max_method, founded: founded + 1)
-          expect(band.reload.founded).to be == founded + 1
+          expect(band.reload.founded).to eq founded + 1
         end
       end
     end
 
     context 'as itself' do
       let(:max_method) { :set_max }
+
       include_examples 'max-able comparisons'
     end
 
     context 'as #clamp_lower_bound' do
       let(:max_method) { :clamp_lower_bound }
+
       include_examples 'max-able comparisons'
     end
   end