mongoid 6.4.8 → 7.0.0.beta

data/lib/mongoid/relations/touchable.rb

@@ -1,97 +0,0 @@
-# encoding: utf-8
-module Mongoid
-  module Relations
-    module Touchable
-      extend ActiveSupport::Concern
-
-      # Touch the document, in effect updating its updated_at timestamp and
-      # optionally the provided field to the current time. If any belongs_to
-      # relations exist with a touch option, they will be updated as well.
-      #
-      # @example Update the updated_at timestamp.
-      #   document.touch
-      #
-      # @example Update the updated_at and provided timestamps.
-      #   document.touch(:audited)
-      #
-      # @note This will not autobuild relations if those options are set.
-      #
-      # @param [ Symbol ] field The name of an additional field to update.
-      #
-      # @return [ true/false ] false if record is new_record otherwise true.
-      #
-      # @since 3.0.0
-      def touch(field = nil)
-        return false if _root.new_record?
-        current = Time.now
-        field = database_field_name(field)
-        write_attribute(:updated_at, current) if respond_to?("updated_at=")
-        write_attribute(field, current) if field
-
-        touches = touch_atomic_updates(field)
-        unless touches["$set"].blank?
-          selector = atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, touches), session: _session)
-        end
-        run_callbacks(:touch)
-        true
-      end
-
-      module ClassMethods
-
-        # Add the metadata to the touchable relations if the touch option was
-        # provided.
-        #
-        # @example Add the touchable.
-        #   Model.touchable(meta)
-        #
-        # @param [ Metadata ] metadata The relation metadata.
-        #
-        # @return [ Class ] The model class.
-        #
-        # @since 3.0.0
-        def touchable(metadata)
-          if metadata.touchable?
-            name = metadata.name
-            field = metadata[:touch].is_a?(Symbol) ? metadata[:touch] : nil
-            method_name = define_relation_touch_method(name, field)
-            after_save method_name
-            after_destroy method_name
-            after_touch method_name
-          end
-          self
-        end
-
-        private
-
-        # Define the method that will get called for touching belongs_to
-        # relations.
-        #
-        # @api private
-        #
-        # @example Define the touch relation.
-        #   Model.define_relation_touch_method(:band)
-        #   Model.define_relation_touch_method(:band, :band_updated_at)
-        #
-        # @param [ Symbol ] name The name of the relation.
-        # @param [ Symbol ] extra_field Additional timestamp field to update.
-        #
-        # @since 3.1.0
-        #
-        # @return [ Symbol ] The method name.
-        def define_relation_touch_method(name, extra_field = nil)
-          method_name = "touch_#{name}_after_create_or_destroy"
-          class_eval <<-TOUCH, __FILE__, __LINE__ + 1
-            def #{method_name}
-              without_autobuild do
-                relation = __send__(:#{name})
-                relation.touch #{":#{extra_field}" if extra_field} if relation
-              end
-            end
-          TOUCH
-          method_name.to_sym
-        end
-      end
-    end
-  end
-end

data/spec/app/models/array_field.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class ArrayField
-  include Mongoid::Document
-
-  field :af, type: Array
-end

data/spec/app/models/delegating_patient.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-class DelegatingPatient
-  include Mongoid::Document
-
-  embeds_one :email
-
-  # Instance level delegation
-  delegate :address, to: :email
-
-  class << self
-    # Class level delegation
-    delegate :default_client, to: ::Mongoid
-  end
-end

data/spec/integration/document_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mongoid::Document do
-  context 'when including class uses delegate' do
-    let(:patient) do
-      DelegatingPatient.new(
-        email: Email.new(address: 'test@example.com'),
-      )
-    end
-
-    it 'works for instance level delegation' do
-      patient.address.should == 'test@example.com'
-    end
-
-    it 'works for class level delegation' do
-      DelegatingPatient.default_client.should be Mongoid.default_client
-    end
-  end
-end

data/spec/mongoid/clients/sessions_spec.rb

@@ -1,334 +0,0 @@
-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
-    client = Mongoid::Clients.with_name(:other)
-    monitoring = if client.respond_to?(:monitoring, true)
-      client.send(:monitoring)
-    else
-      # driver 2.5
-      client.instance_variable_get('@monitoring')
-    end
-    monitoring.subscribers['Command'].find do |s|
-      s.is_a?(EventSubscriber)
-    end
-  end
-
-  let(:insert_events) do
-    # Driver 2.5 sends command_name as a symbol
-    subscriber.started_events.select { |event| event.command_name.to_s == 'insert' }
-  end
-
-  let(:update_events) do
-    # Driver 2.5 sends command_name as a symbol
-    subscriber.started_events.select { |event| event.command_name.to_s == '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