mongoid_orderable 6.0.1 → 6.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 517614edc30dd44ac15d5eafcfcc9103bced1dd7ddd4cb0f3624edfe6adb6af2
-  data.tar.gz: 914eff039882840a25b888fe534a5adf3198c762a2944d141d425daff558baf5
+  metadata.gz: b3a80c8eb058adeffe1ead4c0fa20ce10660ea49a2df1405d46048419f2af965
+  data.tar.gz: d68f6f64f52f132295e588dfcd59ad27d22a68237e5b29ab7682a37e3c940ca5
 SHA512:
-  metadata.gz: 67ef0079e9c442579b08d6043fd80215e7678f705fea24b4581131b39880d1b0b33cc9fee4d8eb9ec1905e0b8b8ad2b4c79706ff170e0d49ec5c91130b91737a
-  data.tar.gz: c7c9befe3900fa468e6149fa0562de121525428b294981c6990d50e862f42912fa8a2b59a09e54e63328975b303af51de7c556a4b9a9632f0bbb9e4ed7d876b4
+  metadata.gz: 6c2d9da294dda836b17047aaf3ebc6329b3c382fb793c83fe57dd63a07512d2e1da65af3559b12e75ce3924b1edfaaefad8317f4acaa488cb94ad2392d84b474
+  data.tar.gz: 58e8c15554183674cef20639c2cb888cb6e793471ecf7f55ea76360f2ca7de351d218f417e34db220d2daa32c6ab5dc11da23bce7acec0f77a1f99718e713705

data/CHANGELOG.md

@@ -1,7 +1,13 @@
-### 6.0.2 (Next)
+### 6.0.3 (Next)
 
 * Your contribution here.
 
+### 6.0.2 (2021/01/26)
+
+* [#70](https://github.com/mongoid/mongoid_orderable/pull/70): Fix: Transactions should not use around callbacks - [@johnnyshields](https://github.com/johnnyshields).
+* [#70](https://github.com/mongoid/mongoid_orderable/pull/70): Refactor: Partially reduce code complexity of handler classes - [@johnnyshields](https://github.com/johnnyshields).
+* [#70](https://github.com/mongoid/mongoid_orderable/pull/70): Tests: Run all tests both with and without transactions - [@johnnyshields](https://github.com/johnnyshields).
+
 ### 6.0.1 (2021/01/26)
 
 * [#69](https://github.com/mongoid/mongoid_orderable/pull/69): Fix: Transactions should force read from primary - [@johnnyshields](https://github.com/johnnyshields).

data/lib/mongoid/orderable/{engine.rb → handlers/base.rb}

@@ -2,46 +2,53 @@
 
 module Mongoid
 module Orderable
-  class Engine
-    ORDERABLE_TRANSACTION_KEY = :__mongoid_orderable_in_txn
-
-    attr_accessor :doc
+module Handlers
+  class Base
+    attr_reader :doc
 
     def initialize(doc)
       @doc = doc
     end
 
-    # For new records, or if the orderable scope changes,
-    # we must yield the save action inside the transaction.
-    def update_positions(&_block)
-      yield and return unless orderable_keys.any? {|field| changed?(field) }
+    protected
 
-      new_record = new_record?
-      with_transaction do
-        orderable_keys.map {|field| apply_one_position(field, move_all[field]) }
-        yield if new_record
-      end
+    delegate :orderable_keys,
+             :orderable_field,
+             :orderable_position,
+             :orderable_scope,
+             :orderable_scope_changed?,
+             :orderable_top,
+             :orderable_bottom,
+             :_id,
+             :new_record?,
+             :persisted?,
+             :embedded?,
+             :collection_name,
+             to: :doc
 
-      yield unless new_record
+    def use_transactions
+      false
     end
 
-    def remove_positions
-      orderable_keys.each do |field|
-        remove_one_position(field)
-      end
+    def any_field_changed?
+      orderable_keys.any? {|field| changed?(field) }
+    end
+
+    def apply_all_positions
+      orderable_keys.map {|field| apply_one_position(field, move_all[field]) }
     end
 
     def apply_one_position(field, target_position)
       return unless changed?(field)
 
-      set_lock(field) if use_transactions && !embedded?
+      set_lock(field) if use_transactions
 
       f = orderable_field(field)
       scope = orderable_scope(field)
       scope_changed = orderable_scope_changed?(field)
 
       # Set scope-level lock if scope changed
-      if use_transactions && persisted? && !embedded? && scope_changed
+      if use_transactions && persisted? && scope_changed
         set_lock(field, true)
         scope_changed = orderable_scope_changed?(field)
       end
@@ -58,7 +65,7 @@ module Orderable
       # If scope changed, remove the position from the old scope
       if persisted? && !embedded? && scope_changed
         existing_doc = doc.class.unscoped.find(_id)
-        self.class.new(existing_doc).remove_one_position(field)
+        self.class.new(existing_doc).send(:remove_one_position, field)
       end
 
       # Return if there is no instruction to change the position
@@ -76,33 +83,23 @@ module Orderable
       end
 
       # If persisted, update the field in the database atomically
-      doc.set({ f => target }.merge(changed_scope_hash(field))) if use_transactions && persisted? && !embedded?
+      doc.set({ f => target }.merge(changed_scope_hash(field))) if use_transactions && persisted?
       doc.send("orderable_#{field}_position=", target)
     end
 
+    def remove_all_positions
+      orderable_keys.each do |field|
+        remove_one_position(field)
+      end
+    end
+
     def remove_one_position(field)
       f = orderable_field(field)
       current = orderable_position(field)
-      set_lock(field) if use_transactions && !embedded?
+      set_lock(field) if use_transactions
       orderable_scope(field).gt(f => current).inc(f => -1)
     end
 
-    protected
-
-    delegate :orderable_keys,
-             :orderable_field,
-             :orderable_position,
-             :orderable_scope,
-             :orderable_scope_changed?,
-             :orderable_top,
-             :orderable_bottom,
-             :_id,
-             :new_record?,
-             :persisted?,
-             :embedded?,
-             :collection_name,
-             to: :doc
-
     def move_all
       doc.send(:move_all)
     end
@@ -151,56 +148,20 @@ module Orderable
       end
     end
 
-    def set_lock(field, scope_changed = false)
-      return unless use_transactions && !embedded?
+    def set_lock(field, generic = false)
+      return unless use_transactions
       model_name = doc.class.orderable_configs[field][:lock_collection].to_s.singularize.classify
       model = Mongoid::Orderable::Models.const_get(model_name)
-      attrs = lock_scope(field, scope_changed)
+      attrs = lock_scope(field, generic)
       model.where(attrs).find_one_and_update(attrs, { upsert: true })
     end
 
-    def lock_scope(field, scope_changed = false)
+    def lock_scope(field, generic = false)
       sel = orderable_scope(field).selector
-      scope = ([collection_name] + (scope_changed ? sel.keys : sel.to_a.flatten)).map(&:to_s).join('|')
+      scope = ([collection_name] + (generic ? [field] : sel.to_a.flatten)).map(&:to_s).join('|')
       { scope: scope }
     end
-
-    def use_transactions
-      orderable_keys.any? {|k| doc.class.orderable_configs[k][:use_transactions] }
-    end
-
-    def transaction_max_retries
-      orderable_keys.map {|k| doc.class.orderable_configs[k][:transaction_max_retries] }.compact.max
-    end
-
-    def with_transaction(&_block)
-      Mongoid::QueryCache.uncached do
-        if use_transactions && !embedded? && !Thread.current[ORDERABLE_TRANSACTION_KEY]
-          Thread.current[ORDERABLE_TRANSACTION_KEY] = true
-          retries = transaction_max_retries
-          begin
-            doc.class.with_session(causal_consistency: true) do |session|
-              doc.class.with(read: { mode: :primary }) do
-                session.start_transaction(read: { mode: :primary },
-                                          read_concern: { level: 'majority' },
-                                          write_concern: { w: 'majority' })
-                yield
-                session.commit_transaction
-              end
-            end
-          rescue Mongo::Error::OperationFailure => e
-            sleep(0.001)
-            retries -= 1
-            retry if retries >= 0
-            raise Mongoid::Orderable::Errors::TransactionFailed.new(e)
-          ensure
-            Thread.current[ORDERABLE_TRANSACTION_KEY] = nil
-          end
-        else
-          yield
-        end
-      end
-    end
   end
 end
 end
+end

data/lib/mongoid/orderable/handlers/document.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class Document < Base
+    def before_create
+      apply_all_positions
+    end
+
+    def after_create; end
+
+    def before_update
+      return unless any_field_changed?
+      apply_all_positions
+    end
+
+    def after_destroy
+      remove_all_positions
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/document_embedded.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class DocumentEmbedded < Document
+    def after_destroy
+      return if doc._root.destroyed?
+      super
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/document_transactional.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  class DocumentTransactional < Document
+    def before_create
+      clear_all_positions
+    end
+
+    def after_create
+      apply_all_positions
+    end
+
+    protected
+
+    def apply_all_positions
+      with_transaction { super }
+    end
+
+    def clear_all_positions
+      orderable_keys.each {|field| doc.send("orderable_#{field}_position=", nil) }
+    end
+
+    def use_transactions
+      true
+    end
+
+    def with_transaction(&block)
+      Mongoid::Orderable::Handlers::Transaction.new(doc).with_transaction(&block)
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/handlers/transaction.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Mongoid
+module Orderable
+module Handlers
+  # Executes a block within the context of a MongoDB transaction.
+  class Transaction
+    THREAD_KEY = :__mongoid_orderable_in_txn
+    RETRY_SLEEP = 0.001
+
+    attr_reader :doc
+
+    def initialize(doc)
+      @doc = doc
+    end
+
+    def with_transaction(&block)
+      Mongoid::QueryCache.uncached do
+        if Thread.current[THREAD_KEY]
+          yield
+        else
+          Thread.current[THREAD_KEY] = true
+          retries = transaction_max_retries
+          begin
+            do_transaction(&block)
+          rescue Mongo::Error::OperationFailure => e
+            sleep(RETRY_SLEEP)
+            retries -= 1
+            retry if retries >= 0
+            raise Mongoid::Orderable::Errors::TransactionFailed.new(e)
+          ensure
+            Thread.current[THREAD_KEY] = nil
+          end
+        end
+      end
+    end
+
+    protected
+
+    def do_transaction(&_block)
+      doc.class.with_session(session_opts) do |session|
+        doc.class.with(persistence_opts) do
+          session.start_transaction(transaction_opts)
+          yield
+          session.commit_transaction
+        end
+      end
+    end
+
+    def session_opts
+      { read: { mode: :primary },
+        causal_consistency: true }
+    end
+
+    def persistence_opts
+      { read: { mode: :primary } }
+    end
+
+    def transaction_opts
+      { read: { mode: :primary },
+        read_concern: { level: 'majority' },
+        write_concern: { w: 'majority' } }
+    end
+
+    def transaction_max_retries
+      doc.orderable_keys.map {|k| doc.class.orderable_configs.dig(k, :transaction_max_retries) }.compact.max
+    end
+  end
+end
+end
+end

data/lib/mongoid/orderable/mixins/callbacks.rb

@@ -9,18 +9,32 @@ module Mixins
     ORDERABLE_TRANSACTION_KEY = :__mongoid_orderable_in_txn
 
     included do
-      around_save :orderable_update_positions
-      after_destroy :orderable_remove_positions, unless: -> { embedded? && _root.destroyed? }
+      before_create :orderable_before_create
+      after_create :orderable_after_create, prepend: true
+      before_update :orderable_before_update
+      after_destroy :orderable_after_destroy, prepend: true
 
-      delegate :update_positions,
-               :remove_positions,
-               to: :orderable_engine,
+      delegate :before_create,
+               :after_create,
+               :before_update,
+               :after_destroy,
+               to: :orderable_handler,
                prefix: :orderable
 
       protected
 
-      def orderable_engine
-        @orderable_engine ||= Mongoid::Orderable::Engine.new(self)
+      def orderable_handler
+        @orderable_handler ||= self.class.orderable_handler_class.new(self)
+      end
+
+      def self.orderable_handler_class
+        if embedded?
+          Mongoid::Orderable::Handlers::DocumentEmbedded
+        elsif orderable_configs.values.any? {|c| c[:use_transactions] }
+          Mongoid::Orderable::Handlers::DocumentTransactional
+        else
+          Mongoid::Orderable::Handlers::Document
+        end
       end
     end
   end

data/lib/mongoid/orderable/version.rb

@@ -2,6 +2,6 @@
 
 module Mongoid
   module Orderable
-    VERSION = '6.0.1'
+    VERSION = '6.0.2'
   end
 end

data/lib/mongoid_orderable.rb

@@ -25,5 +25,9 @@ require 'mongoid/orderable/generators/movable'
 require 'mongoid/orderable/generators/position'
 require 'mongoid/orderable/generators/scope'
 require 'mongoid/orderable/generators/helpers'
-require 'mongoid/orderable/engine'
+require 'mongoid/orderable/handlers/base'
+require 'mongoid/orderable/handlers/document'
+require 'mongoid/orderable/handlers/document_embedded'
+require 'mongoid/orderable/handlers/document_transactional'
+require 'mongoid/orderable/handlers/transaction'
 require 'mongoid/orderable/installer'

data/spec/integration/concurrency_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+describe 'concurrency' do
+  enable_transactions!
+
+  describe 'simple create' do
+
+    it 'should correctly insert at the top' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: :top)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..20).to_a)
+    end
+
+    it 'should correctly insert at the bottom' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..20).to_a)
+    end
+
+    it 'should correctly insert at a random position' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: (1..10).to_a.sample)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..20).to_a)
+    end
+  end
+
+  describe 'simple update' do
+    before :each do
+      5.times { SimpleOrderable.create! }
+    end
+
+    it 'should correctly move items to top' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :top
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly move items to bottom' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :bottom
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly move items higher' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :higher
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly move items lower' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: :lower
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+
+    it 'should correctly insert at the top' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: :top)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..25).to_a)
+    end
+
+    it 'should correctly insert at the bottom' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..25).to_a)
+    end
+
+    it 'should correctly insert at a random position' do
+      20.times.map do
+        Thread.new do
+          SimpleOrderable.create!(move_to: (1..10).to_a.sample)
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq((1..25).to_a)
+    end
+
+    it 'should correctly move items to a random position' do
+      20.times.map do
+        Thread.new do
+          record = SimpleOrderable.all.sample
+          record.update_attributes move_to: (1..5).to_a.sample
+        end
+      end.each(&:join)
+
+      expect(SimpleOrderable.pluck(:position).sort).to eq([1, 2, 3, 4, 5])
+    end
+  end
+
+  describe 'scoped update' do
+
+    before :each do
+      2.times { ScopedOrderable.create! group_id: 1 }
+      3.times { ScopedOrderable.create! group_id: 2 }
+    end
+
+    it 'should correctly move items to top' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :top
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items to bottom' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :bottom
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items higher' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :higher
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items lower' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: :lower
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    it 'should correctly move items to a random position' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          record.update_attributes move_to: (1..5).to_a.sample
+        end
+      end.each(&:join)
+
+      expect(ScopedOrderable.pluck(:position).sort).to eq([1, 1, 2, 2, 3])
+    end
+
+    # This spec fails randomly
+    it 'should correctly move items to a random scope', retry: 5 do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          group_id = ([1, 2, 3] - [record.group_id]).sample
+          record.update_attributes group_id: group_id
+        end
+      end.each(&:join)
+
+      result = ScopedOrderable.all.to_a.each_with_object({}) do |obj, hash|
+        hash[obj.group_id] ||= []
+        hash[obj.group_id] << obj.position
+      end
+
+      result.values.each do |ary|
+        expect(ary.sort).to eq((1..(ary.size)).to_a)
+      end
+    end
+
+    it 'should correctly move items to a random position and scope' do
+      20.times.map do
+        Thread.new do
+          record = ScopedOrderable.all.sample
+          group_id = ([1, 2, 3] - [record.group_id]).sample
+          position = (1..5).to_a.sample
+          record.update_attributes group_id: group_id, move_to: position
+        end
+      end.each(&:join)
+
+      result = ScopedOrderable.all.to_a.each_with_object({}) do |obj, hash|
+        hash[obj.group_id] ||= []
+        hash[obj.group_id] << obj.position
+      end
+
+      result.values.each do |ary|
+        expect(ary.sort).to eq((1..(ary.size)).to_a)
+      end
+    end
+  end
+end