mongoid 7.0.0.beta → 7.0.0

data/spec/mongoid/attributes_spec.rb

@@ -42,7 +42,7 @@ describe Mongoid::Attributes do
             context "accessing via []" do
 
               it "does not raise an error" do
-                expect(from_db["desc"]).to eq("en" => "test")
+                expect(from_db["desc"]).to eq("test")
               end
             end
 
@@ -150,6 +150,17 @@ describe Mongoid::Attributes do
 
   describe "#[]" do
 
+    context 'when the document has a custom attribute type' do
+
+      let(:bar) do
+        Bar.create(lat_lng: LatLng.new(52.30, 13.25))
+      end
+
+      it 'returns the demongoized version of the attribute' do
+        expect(bar.reload[:lat_lng]).to be_a(LatLng)
+      end
+    end
+
     context "when the document is a new record" do
 
       let(:person) do
@@ -165,7 +176,7 @@ describe Mongoid::Attributes do
         context "when passing just the name" do
 
           it "returns the full value" do
-            expect(person[:desc]).to eq("en" => "testing")
+            expect(person[:desc]).to eq("testing")
           end
         end
 
@@ -268,6 +279,20 @@ describe Mongoid::Attributes do
 
   describe "#[]=" do
 
+    context 'when the document has a custom attribute type' do
+
+      let(:bar) do
+        Bar.new.tap do |b|
+          b[:lat_lng] = LatLng.new(52.30, 13.25)
+          b.save
+        end
+      end
+
+      it 'sets the demongoized version of the attribute' do
+        expect(bar.reload.lat_lng).to be_a(LatLng)
+      end
+    end
+
     let(:person) do
       Person.new
     end
@@ -768,6 +793,17 @@ describe Mongoid::Attributes do
 
   describe "#read_attribute" do
 
+    context 'when the document has a custom attribute type' do
+
+      let(:bar) do
+        Bar.create(lat_lng: LatLng.new(52.30, 13.25))
+      end
+
+      it 'returns the demongoized version of the attribute' do
+        expect(bar.reload.read_attribute(:lat_lng)).to be_a(LatLng)
+      end
+    end
+
     context "when the document is a new record" do
 
       let(:person) do

data/spec/mongoid/clients/sessions_spec.rb

@@ -0,0 +1,325 @@
+require "spec_helper"
+
+describe Mongoid::Clients::Sessions do
+
+  before(:all) do
+    CONFIG[:clients][:other] = CONFIG[:clients][:default].dup
+    CONFIG[:clients][:other][:database] = 'other'
+    Mongoid::Clients.clients.values.each(&:close)
+    Mongoid::Config.send(:clients=, CONFIG[:clients])
+    Mongoid::Clients.with_name(:other).subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.new)
+  end
+
+  after(:all) do
+    Mongoid::Clients.with_name(:other).close
+    Mongoid::Clients.clients.delete(:other)
+  end
+
+  let(:subscriber) do
+    Mongoid::Clients.with_name(:other).instance_variable_get(:@monitoring).subscribers['Command'].find do |s|
+      s.is_a?(EventSubscriber)
+    end
+  end
+
+  let(:insert_events) do
+    subscriber.started_events.select { |event| event.command_name == :insert }
+  end
+
+  let(:update_events) do
+    subscriber.started_events.select { |event| event.command_name == :update }
+  end
+
+  context 'when a session is used on a model class' do
+
+    context 'when sessions are supported', if: sessions_supported? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        subscriber.clear_events!
+        Person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      context 'when another thread is started' do
+
+        let!(:last_use_diff) do
+          Person.with_session do |session|
+            Person.create
+            Person.create
+            last_use = session.instance_variable_get(:@server_session).last_use
+            Thread.new { Person.create }.value
+            session.instance_variable_get(:@server_session).last_use - last_use
+          end
+        end
+
+        it 'does not use the session for that thread' do
+          expect(Person.count).to be(2)
+          expect(Person.with(client: :default) { Person.count }).to be(1)
+          lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+          expect(last_use_diff).to eq(0)
+        end
+      end
+
+      context 'when the operations in the session block are all on the class' do
+
+        before do
+          Person.with_session do
+            Person.create
+            Person.create
+          end
+        end
+
+        it 'uses a single session id for all operations on the class' do
+          expect(Person.count).to be(2)
+          lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the session block are also on another class' do
+
+        context 'when the other class uses the same client' do
+
+          before do
+            Post.with(client: :other) do
+              Person.with_session do
+                Person.create
+                Person.create
+                Post.create
+              end
+            end
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(Post.with(client: :other) { |klass| klass.count }).to be(1)
+            lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(lsids_sent.size).to eq(3)
+            expect(lsids_sent.uniq.size).to eq(1)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do
+                Person.create
+                Person.create
+                Post.create
+              end
+            rescue => ex
+                e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(Person.count).to be(2)
+            lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(lsids_sent.size).to eq(2)
+            expect(lsids_sent.uniq.size).to eq(1)
+          end
+        end
+
+        context 'when sessions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do
+                Person.with_session do
+                  Person.create
+                  Post.create
+                end
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'does not execute any operations' do
+            expect(Person.count).to be(0)
+            expect(insert_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_supported? do
+
+      let!(:error) do
+        e = nil
+        begin
+          Person.with_session {}
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+        expect(error.message).to include('not supported')
+      end
+    end
+  end
+
+  context 'when a session is used on a model instance' do
+
+    let!(:person) do
+      Person.with(client: :other) do |klass|
+        klass.create
+      end
+    end
+
+    context 'when sessions are supported', if: sessions_supported? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        subscriber.clear_events!
+        person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      context 'when the operations in the session block are all on the instance' do
+
+        before do
+          person.with_session do
+            person.username = 'Emily'
+            person.save
+            person.age = 80
+            person.save
+          end
+        end
+
+        it 'uses a single session id for all operations on the class' do
+          expect(person.reload.username).to eq('Emily')
+          expect(person.reload.age).to eq(80)
+          lsids_sent = update_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the session block are also on another class' do
+
+        context 'when the other class uses the same client' do
+
+          before do
+            Post.with(client: :other) do
+              person.with_session do
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+              end
+            end
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.with(client: :other) { Post.count }).to be(1)
+            update_lsids_sent = update_events.collect { |event| event.command['lsid'] }
+            expect(update_lsids_sent.size).to eq(3) # person update, counter cache, post assignment
+            expect(update_lsids_sent.uniq.size).to eq(1) # person update, counter cache, post assignment
+            insert_lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(insert_lsids_sent.size).to eq(2)
+            expect(insert_lsids_sent.uniq.size).to eq(1)
+            expect(update_lsids_sent.uniq).to eq(insert_lsids_sent.uniq)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.count).to be(0)
+            update_lsids_sent = update_events.collect { |event| event.command['lsid'] }
+            expect(update_lsids_sent.size).to eq(1)
+          end
+        end
+
+        context 'when sessions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do
+                person.with_session do
+                  person.username = 'Emily'
+                  person.save
+                  person.posts << Post.create
+                end
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'does not execute any operations' do
+            expect(person.reload.username).not_to eq('Emily')
+            expect(Post.count).to be(0)
+            expect(update_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_supported? do
+
+      let!(:error) do
+        e = nil
+        begin
+          person.with_session {}
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+        expect(error.message).to include('not supported')
+      end
+    end
+  end
+end

data/spec/mongoid/contextual/memory_spec.rb

@@ -987,6 +987,25 @@ describe Mongoid::Contextual::Memory do
     end
   end
 
+  describe '#inc' do
+
+    let(:criteria) do
+      Address.all.tap do |crit|
+        crit.documents = [ Address.new(number: 1),
+                           Address.new(number: 2),
+                           Address.new(number: 3) ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it 'increases each member' do
+      expect(context.inc(number: 10).collect(&:number)).to eql([11, 12, 13])
+    end
+  end
+
   describe "#skip" do
 
     let(:hobrecht) do

data/spec/mongoid/contextual/mongo_spec.rb

@@ -275,6 +275,23 @@ describe Mongoid::Contextual::Mongo do
           expect(Band.count).to eq(0)
         end
       end
+
+      context 'when the write concern is unacknowledged' do
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let!(:deleted) do
+          criteria.with(write: { w: 0 }) do |crit|
+            crit.send(method)
+          end
+        end
+
+        it 'returns 0' do
+          expect(deleted).to eq(0)
+        end
+      end
     end
   end
 
@@ -363,6 +380,27 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when the write concern is unacknowledged' do
+
+      before do
+        2.times { Band.create }
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let!(:deleted) do
+        criteria.with(write: { w: 0 }) do |crit|
+          crit.send(method)
+        end
+      end
+
+      it 'returns 0' do
+        expect(deleted).to eq(0)
+      end
+    end
   end
 
   describe "#distinct" do
@@ -539,6 +577,31 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when the criteria has a parent document' do
+
+      before do
+        Post.create(person: person)
+        Post.create(person: person)
+        Post.create(person: person)
+      end
+
+      let(:person) do
+        Person.new
+      end
+
+      let(:criteria) do
+        person.posts.all
+      end
+
+      let(:persons) do
+        criteria.collect(&:person)
+      end
+
+      it 'sets the same parent object on each related object' do
+        expect(persons.uniq.size).to eq(1)
+      end
+    end
   end
 
   describe "#eager_load" do
@@ -2094,6 +2157,41 @@ describe Mongoid::Contextual::Mongo do
         expect(context.update).to be false
       end
     end
+
+    context 'when provided array filters', if: array_filters_supported? do
+
+      before do
+        Band.delete_all
+        b = Band.new(name: 'Depeche Mode')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Sony')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+
+        b = Band.new(name: 'FKA Twigs')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+      end
+
+
+      let(:criteria) do
+        Band.where(name: 'Depeche Mode')
+      end
+
+      let!(:update) do
+        context.update({ '$set' => { 'labels.$[i].name' => 'Sony' } },
+                       array_filters: [{ 'i.name' => 'Cbs' }])
+      end
+
+      it 'applies the array filters' do
+        expect(Band.where(name: 'Depeche Mode').first.labels.collect(&:name)).to match_array(['Warner', 'Sony', 'Sony'])
+      end
+
+      it 'does not affect other documents' do
+        expect(Band.where(name: 'FKA Twigs').first.labels.collect(&:name)).to match_array(['Warner', 'Cbs'])
+      end
+    end
   end
 
   describe "#update_all" do
@@ -2231,6 +2329,41 @@ describe Mongoid::Contextual::Mongo do
         expect(context.update_all).to be false
       end
     end
+
+    context 'when provided array filters', if: array_filters_supported? do
+
+      before do
+        Band.delete_all
+        b = Band.new(name: 'Depeche Mode')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Sony')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+
+        b = Band.new(name: 'FKA Twigs')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+      end
+
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let!(:update) do
+        context.update_all({ '$set' => { 'labels.$[i].name' => 'Sony' } },
+                       array_filters: [{ 'i.name' => 'Cbs' }])
+      end
+
+      it 'applies the array filters' do
+        expect(Band.where(name: 'Depeche Mode').first.labels.collect(&:name)).to match_array(['Warner', 'Sony', 'Sony'])
+      end
+
+      it 'updates all documents' do
+        expect(Band.where(name: 'FKA Twigs').first.labels.collect(&:name)).to match_array(['Warner', 'Sony'])
+      end
+    end
   end
 
   describe '#pipeline' do