acts_as_list 0.9.17 → 1.0.2

data/lib/acts_as_list/active_record/acts/no_update.rb

@@ -89,20 +89,30 @@ module ActiveRecord
 
         class << self
           def apply_to(klasses)
-            extracted_klasses.push(*klasses)
+            klasses.map {|klass| add_klass(klass)}
             yield
           ensure
-            extracted_klasses.clear
+            klasses.map {|klass| remove_klass(klass)}
           end
 
           def applied_to?(klass)
-            !(klass.ancestors & extracted_klasses).empty?
+            !(klass.ancestors & extracted_klasses.keys).empty?
           end
 
           private
 
           def extracted_klasses
-            Thread.current[:act_as_list_no_update] ||= []
+            Thread.current[:act_as_list_no_update] ||= {}
+          end
+
+          def add_klass(klass)
+            extracted_klasses[klass] = 0 unless extracted_klasses.key?(klass)
+            extracted_klasses[klass] += 1
+          end
+
+          def remove_klass(klass)
+            extracted_klasses[klass] -= 1
+            extracted_klasses.delete(klass) if extracted_klasses[klass] <= 0
           end
         end
 

data/lib/acts_as_list/active_record/acts/position_column_method_definer.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Acts::List::PositionColumnMethodDefiner #:nodoc:
-  def self.call(caller_class, position_column)
-    define_class_methods(caller_class, position_column)
+  def self.call(caller_class, position_column, touch_on_update)
+    define_class_methods(caller_class, position_column, touch_on_update)
     define_instance_methods(caller_class, position_column)
 
     if mass_assignment_protection_was_used_by_user?(caller_class)
@@ -12,7 +12,7 @@ module ActiveRecord::Acts::List::PositionColumnMethodDefiner #:nodoc:
 
   private
 
-  def self.define_class_methods(caller_class, position_column)
+  def self.define_class_methods(caller_class, position_column, touch_on_update)
     caller_class.class_eval do
       define_singleton_method :quoted_position_column do
         @_quoted_position_column ||= connection.quote_column_name(position_column)
@@ -22,6 +22,18 @@ module ActiveRecord::Acts::List::PositionColumnMethodDefiner #:nodoc:
         @_quoted_position_column_with_table_name ||= "#{caller_class.quoted_table_name}.#{quoted_position_column}"
       end
 
+      define_singleton_method :decrement_sequentially do
+        pluck(primary_key).each do |id|
+          where(primary_key => id).decrement_all
+        end
+      end
+
+      define_singleton_method :increment_sequentially do
+        pluck(primary_key).each do |id|
+          where(primary_key => id).increment_all
+        end
+      end
+
       define_singleton_method :decrement_all do
         update_all_with_touch "#{quoted_position_column} = (#{quoted_position_column_with_table_name} - 1)"
       end
@@ -31,7 +43,8 @@ module ActiveRecord::Acts::List::PositionColumnMethodDefiner #:nodoc:
       end
 
       define_singleton_method :update_all_with_touch do |updates|
-        update_all(updates + touch_record_sql)
+        updates += touch_record_sql if touch_on_update
+        update_all(updates)
       end
 
       private
@@ -51,7 +64,7 @@ module ActiveRecord::Acts::List::PositionColumnMethodDefiner #:nodoc:
       end
 
       define_method :"#{position_column}=" do |position|
-        write_attribute(position_column, position)
+        self[position_column] = position
         @position_changed = true
       end
 

data/lib/acts_as_list/active_record/acts/scope_method_definer.rb

@@ -4,7 +4,7 @@ module ActiveRecord::Acts::List::ScopeMethodDefiner #:nodoc:
   extend ActiveSupport::Inflector
 
   def self.call(caller_class, scope)
-    scope = idify(scope) if scope.is_a?(Symbol)
+    scope = idify(caller_class, scope) if scope.is_a?(Symbol)
 
     caller_class.class_eval do
       define_method :scope_name do
@@ -21,7 +21,6 @@ module ActiveRecord::Acts::List::ScopeMethodDefiner #:nodoc:
         end
 
         define_method :destroyed_via_scope? do
-          return false if ActiveRecord::VERSION::MAJOR < 4
           scope == (destroyed_by_association && destroyed_by_association.foreign_key.to_sym)
         end
       elsif scope.is_a?(Array)
@@ -45,7 +44,6 @@ module ActiveRecord::Acts::List::ScopeMethodDefiner #:nodoc:
         end
 
         define_method :destroyed_via_scope? do
-          return false if ActiveRecord::VERSION::MAJOR < 4
           scope_condition.keys.include? (destroyed_by_association && destroyed_by_association.foreign_key.to_sym)
         end
       else
@@ -66,9 +64,13 @@ module ActiveRecord::Acts::List::ScopeMethodDefiner #:nodoc:
     end
   end
 
-  def self.idify(name)
+  def self.idify(caller_class, name)
     return name if name.to_s =~ /_id$/
 
-    foreign_key(name).to_sym
+    if caller_class.reflections.key?(name.to_s)
+      caller_class.reflections[name.to_s].foreign_key.to_sym
+    else
+      foreign_key(name).to_sym
+    end
   end
 end

data/lib/acts_as_list/active_record/acts/sequential_updates_method_definer.rb

@@ -7,7 +7,7 @@ module ActiveRecord::Acts::List::SequentialUpdatesMethodDefiner #:nodoc:
         if !defined?(@sequential_updates)
           if sequential_updates_option.nil?
             table_exists =
-              if ActiveRecord::VERSION::MAJOR >= 5
+              if active_record_version_is?('>= 5')
                 caller_class.connection.data_source_exists?(caller_class.table_name)
               else
                 caller_class.connection.table_exists?(caller_class.table_name)

data/lib/acts_as_list/version.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Acts
     module List
-      VERSION = '0.9.17'
+      VERSION = '1.0.2'
     end
   end
 end

data/test/helper.rb

@@ -13,7 +13,7 @@ rescue Bundler::BundlerError => e
 end
 require "active_record"
 require "minitest/autorun"
-require "mocha/mini_test"
+require "mocha/minitest"
 require "#{File.dirname(__FILE__)}/../init"
 
 if defined?(ActiveRecord::VERSION) &&
@@ -27,15 +27,6 @@ db_config = YAML.load_file(File.expand_path("../database.yml", __FILE__)).fetch(
 ActiveRecord::Base.establish_connection(db_config)
 ActiveRecord::Schema.verbose = false
 
-# Returns true if ActiveRecord is rails 3, 4 version
-def rails_3
-  defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
-end
-
-def rails_4
-  defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 4
-end
-
 def teardown_db
   if ActiveRecord::VERSION::MAJOR >= 5
     tables = ActiveRecord::Base.connection.data_sources

data/test/shared_list.rb

@@ -10,6 +10,13 @@ module Shared
       end
     end
 
+    def test_current_position
+      first_item = ListMixin.where(parent_id: 5).first
+      assert_equal 1, first_item.current_position
+      first_item.remove_from_list
+      assert_nil first_item.current_position
+    end
+
     def test_reordering
       assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
 
@@ -230,12 +237,9 @@ module Shared
       # We need to trigger all the before_destroy callbacks without actually
       # destroying the record so we can see the affect the callbacks have on
       # the record.
-      # NOTE: Hotfix for rails3 ActiveRecord
       list = ListMixin.where(id: 2).first
       if list.respond_to?(:run_callbacks)
-        # Refactored to work according to Rails3 ActiveRSupport Callbacks <http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html>
-        list.run_callbacks(:destroy) if rails_3
-        list.run_callbacks(:before_destroy) if !rails_3
+        list.run_callbacks(:destroy)
       else
         list.send(:callback, :before_destroy)
       end

data/test/shared_list_sub.rb

@@ -47,7 +47,7 @@ module Shared
 
     def test_next_prev_not_regular_sequence
       ListMixin.all.each do |item|
-        item.update_attributes(pos: item.pos * 5)
+        item.update pos: item.pos * 5
       end
 
       assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5000).order('pos').map(&:id)

data/test/test_list.rb

@@ -39,11 +39,18 @@ def setup_db(position_options = {})
     t.column :order, :integer
   end
 
-  mixins = [ Mixin, ListMixin, ListMixinSub1, ListMixinSub2, ListWithStringScopeMixin,
-    ArrayScopeListMixin, ZeroBasedMixin, DefaultScopedMixin,
-    DefaultScopedWhereMixin, TopAdditionMixin, NoAdditionMixin, QuotedList ]
+  # This table is used to test table names with different primary_key columns
+  ActiveRecord::Base.connection.create_table 'altid-table', primary_key: 'altid' do |t|
+    t.column :pos, :integer
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
 
-  mixins << EnumArrayScopeListMixin if rails_4
+  ActiveRecord::Base.connection.add_index 'altid-table', :pos, unique: true
+
+  mixins = [ Mixin, ListMixin, ListMixinSub1, ListMixinSub2, ListWithStringScopeMixin,
+    ArrayScopeListMixin, ZeroBasedMixin, DefaultScopedMixin, EnumArrayScopeListMixin,
+    DefaultScopedWhereMixin, TopAdditionMixin, NoAdditionMixin, QuotedList, TouchDisabledMixin ]
 
   ActiveRecord::Base.connection.schema_cache.clear!
   mixins.each do |klass|
@@ -63,23 +70,19 @@ class ListMixin < Mixin
   acts_as_list column: "pos", scope: :parent
 end
 
+class TouchDisabledMixin < Mixin
+  acts_as_list column: "pos", touch_on_update: false
+end
+
 class ListMixinSub1 < ListMixin
 end
 
 class ListMixinSub2 < ListMixin
-  if rails_3
-    validates :pos, presence: true
-  else
-    validates_presence_of :pos
-  end
+  validates :pos, presence: true
 end
 
 class ListMixinError < ListMixin
-  if rails_3
-    validates :state, presence: true
-  else
-    validates_presence_of :state
-  end
+  validates :state, presence: true
 end
 
 class ListWithStringScopeMixin < Mixin
@@ -94,13 +97,11 @@ class ArrayScopeListWithHashMixin < Mixin
   acts_as_list column: "pos", scope: [:parent_id, state: nil]
 end
 
-if rails_4
-  class EnumArrayScopeListMixin < Mixin
-    STATE_VALUES = %w(active archived)
-    enum state: STATE_VALUES
+class EnumArrayScopeListMixin < Mixin
+  STATE_VALUES = %w(active archived)
+  enum state: STATE_VALUES
 
-    acts_as_list column: "pos", scope: [:parent_id, :state]
-  end
+  acts_as_list column: "pos", scope: [:parent_id, :state]
 end
 
 class ZeroBasedMixin < Mixin
@@ -117,13 +118,7 @@ class DefaultScopedWhereMixin < Mixin
   default_scope { order('pos ASC').where(active: true) }
 
   def self.for_active_false_tests
-    if ActiveRecord::VERSION::MAJOR < 4
-      unscoped do
-        order('pos ASC').where(active: false)
-      end
-    else
-      unscope(:where).where(active: false)
-    end
+    unscope(:where).where(active: false)
   end
 end
 
@@ -131,6 +126,17 @@ class SequentialUpdatesDefault < Mixin
   acts_as_list column: "pos"
 end
 
+class SequentialUpdatesAltId < ActiveRecord::Base
+  self.table_name = "altid-table"
+  self.primary_key = "altid"
+
+  acts_as_list column: "pos"
+end
+
+class SequentialUpdatesAltIdTouchDisabled < SequentialUpdatesAltId
+  acts_as_list column: "pos", touch_on_update: false
+end
+
 class SequentialUpdatesFalseMixin < Mixin
   acts_as_list column: "pos", sequential_updates: false
 end
@@ -146,7 +152,7 @@ end
 ##
 # The way we track changes to
 # scope and position can get tripped up
-# by someone using update_attributes within
+# by someone using update within
 # a callback because it causes multiple passes
 # through the callback chain
 module CallbackMixin
@@ -161,7 +167,7 @@ module CallbackMixin
       # doesn't matter what column changes, just
       # need to change something
 
-      self.update_attributes(active: !self.active)
+      self.update active: !self.active
     end
   end
 end
@@ -625,7 +631,7 @@ class MultipleListsTest < ActsAsListTestCase
   def test_check_scope_order
     assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).order('pos').map(&:id)
     assert_equal [5, 6, 7, 8], ListMixin.where(:parent_id => 2).order('pos').map(&:id)
-    ListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2)
+    ListMixin.find(4).update :parent_id => 2, :pos => 2
     assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order('pos').map(&:id)
     assert_equal [5, 4, 6, 7, 8], ListMixin.where(:parent_id => 2).order('pos').map(&:id)
   end
@@ -633,34 +639,32 @@ class MultipleListsTest < ActsAsListTestCase
   def test_check_scope_position
     assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 1).map(&:pos)
     assert_equal [1, 2, 3, 4], ListMixin.where(:parent_id => 2).map(&:pos)
-    ListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2)
+    ListMixin.find(4).update :parent_id => 2, :pos => 2
     assert_equal [1, 2, 3], ListMixin.where(:parent_id => 1).order('pos').map(&:pos)
     assert_equal [1, 2, 3, 4, 5], ListMixin.where(:parent_id => 2).order('pos').map(&:pos)
   end
 end
 
-if rails_4
-  class EnumArrayScopeListMixinTest < ActsAsListTestCase
-    def setup
-      setup_db
-      EnumArrayScopeListMixin.create! :parent_id => 1, :state => EnumArrayScopeListMixin.states['active']
-      EnumArrayScopeListMixin.create! :parent_id => 1, :state => EnumArrayScopeListMixin.states['archived']
-      EnumArrayScopeListMixin.create! :parent_id => 2, :state => EnumArrayScopeListMixin.states["active"]
-      EnumArrayScopeListMixin.create! :parent_id => 2, :state => EnumArrayScopeListMixin.states["archived"]
-    end
+class EnumArrayScopeListMixinTest < ActsAsListTestCase
+  def setup
+    setup_db
+    EnumArrayScopeListMixin.create! :parent_id => 1, :state => EnumArrayScopeListMixin.states['active']
+    EnumArrayScopeListMixin.create! :parent_id => 1, :state => EnumArrayScopeListMixin.states['archived']
+    EnumArrayScopeListMixin.create! :parent_id => 2, :state => EnumArrayScopeListMixin.states["active"]
+    EnumArrayScopeListMixin.create! :parent_id => 2, :state => EnumArrayScopeListMixin.states["archived"]
+  end
 
-    def test_positions
-      assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 1, :state => EnumArrayScopeListMixin.states['active']).map(&:pos)
-      assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 1, :state => EnumArrayScopeListMixin.states['archived']).map(&:pos)
-      assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 2, :state => EnumArrayScopeListMixin.states['active']).map(&:pos)
-      assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 2, :state => EnumArrayScopeListMixin.states['archived']).map(&:pos)
-    end
+  def test_positions
+    assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 1, :state => EnumArrayScopeListMixin.states['active']).map(&:pos)
+    assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 1, :state => EnumArrayScopeListMixin.states['archived']).map(&:pos)
+    assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 2, :state => EnumArrayScopeListMixin.states['active']).map(&:pos)
+    assert_equal [1], EnumArrayScopeListMixin.where(:parent_id => 2, :state => EnumArrayScopeListMixin.states['archived']).map(&:pos)
+  end
 
-    def test_update_state
-      active_item = EnumArrayScopeListMixin.find_by(:parent_id => 2, :state => EnumArrayScopeListMixin.states['active'])
-      active_item.update(state: EnumArrayScopeListMixin.states['archived'])
-      assert_equal [1, 2], EnumArrayScopeListMixin.where(:parent_id => 2, :state => EnumArrayScopeListMixin.states['archived']).map(&:pos).sort
-    end
+  def test_update_state
+    active_item = EnumArrayScopeListMixin.find_by(:parent_id => 2, :state => EnumArrayScopeListMixin.states['active'])
+    active_item.update(state: EnumArrayScopeListMixin.states['archived'])
+    assert_equal [1, 2], EnumArrayScopeListMixin.where(:parent_id => 2, :state => EnumArrayScopeListMixin.states['archived']).map(&:pos).sort
   end
 end
 
@@ -675,7 +679,7 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   def test_order_after_all_scope_properties_are_changed
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:id)
     assert_equal [5, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order('pos').map(&:id)
-    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 2, :pos => 2,:parent_type => 'something')
+    ArrayScopeListMixin.find(2).update :parent_id => 2, :pos => 2,:parent_type => 'something'
     assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order('pos').map(&:id)
     assert_equal [5, 2, 6, 7, 8], ArrayScopeListMixin.where(:parent_id => 2,:parent_type => 'something').order('pos').map(&:id)
   end
@@ -683,7 +687,7 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   def test_position_after_all_scope_properties_are_changed
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').map(&:pos)
-    ArrayScopeListMixin.find(4).update_attributes(:parent_id => 2, :pos => 2, :parent_type => 'something')
+    ArrayScopeListMixin.find(4).update :parent_id => 2, :pos => 2, :parent_type => 'something'
     assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:pos)
     assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 2, :parent_type => 'something').order('pos').map(&:pos)
   end
@@ -691,7 +695,7 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   def test_order_after_one_scope_property_is_changed
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:id)
     assert_equal [9, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order('pos').map(&:id)
-    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 3, :pos => 2)
+    ArrayScopeListMixin.find(2).update :parent_id => 3, :pos => 2
     assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order('pos').map(&:id)
     assert_equal [9, 2, 10, 11, 12], ArrayScopeListMixin.where(:parent_id => 3,:parent_type => 'anything').order('pos').map(&:id)
   end
@@ -699,7 +703,7 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   def test_position_after_one_scope_property_is_changed
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').map(&:pos)
-    ArrayScopeListMixin.find(4).update_attributes(:parent_id => 3, :pos => 2)
+    ArrayScopeListMixin.find(4).update :parent_id => 3, :pos => 2
     assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:pos)
     assert_equal [1, 2, 3, 4, 5], ArrayScopeListMixin.where(:parent_id => 3, :parent_type => 'anything').order('pos').map(&:pos)
   end
@@ -707,7 +711,7 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   def test_order_after_moving_to_empty_list
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:id)
     assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order('pos').map(&:id)
-    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 4, :pos => 1)
+    ArrayScopeListMixin.find(2).update :parent_id => 4, :pos => 1
     assert_equal [1, 3, 4], ArrayScopeListMixin.where(:parent_id => 1,:parent_type => 'anything').order('pos').map(&:id)
     assert_equal [2], ArrayScopeListMixin.where(:parent_id => 4,:parent_type => 'anything').order('pos').map(&:id)
   end
@@ -715,7 +719,7 @@ class MultipleListsArrayScopeTest < ActsAsListTestCase
   def test_position_after_moving_to_empty_list
     assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').map(&:pos)
     assert_equal [], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').map(&:pos)
-    ArrayScopeListMixin.find(2).update_attributes(:parent_id => 4, :pos => 1)
+    ArrayScopeListMixin.find(2).update :parent_id => 4, :pos => 1
     assert_equal [1, 2, 3], ArrayScopeListMixin.where(:parent_id => 1, :parent_type => 'anything').order('pos').map(&:pos)
     assert_equal [1], ArrayScopeListMixin.where(:parent_id => 4, :parent_type => 'anything').order('pos').map(&:pos)
   end
@@ -812,6 +816,41 @@ class TouchTest < ActsAsListTestCase
   end
 end
 
+class TouchDisabledTest < ActsAsListTestCase
+  def setup
+    setup_db
+    Timecop.freeze(yesterday) do
+      4.times { TouchDisabledMixin.create! }
+    end
+  end
+
+  def now
+    @now ||= Time.current.change(usec: 0)
+  end
+
+  def yesterday
+    @yesterday ||= 1.day.ago
+  end
+
+  def updated_ats
+    TouchDisabledMixin.order(:id).pluck(:updated_at)
+  end
+
+  def positions
+    ListMixin.order(:id).pluck(:pos)
+  end
+
+  def test_deleting_item_does_not_touch_higher_items
+    Timecop.freeze(now) do
+      TouchDisabledMixin.first.destroy
+      updated_ats.each do |updated_at|
+        assert_equal updated_at.to_i, yesterday.to_i
+      end
+      assert_equal positions, [1, 2, 3]
+    end
+  end
+end
+
 class ActsAsListTopTest < ActsAsListTestCase
   def setup
     setup_db
@@ -930,4 +969,100 @@ class SequentialUpdatesMixinNotNullUniquePositiveConstraintsTest < ActsAsListTes
       new_item.insert_at(0)
     end
   end
+
+
+  class SequentialUpdatesMixinNotNullUniquePositiveConstraintsTest < ActsAsListTestCase
+    def setup
+      setup_db null: false, unique: true, positive: true
+      (1..4).each { |counter| SequentialUpdatesAltId.create!({pos: counter}) }
+    end
+
+    def test_sequential_updates_default_to_true_with_unique_index
+      assert_equal true, SequentialUpdatesAltId.new.send(:sequential_updates?)
+    end
+
+    def test_insert_at
+      new = SequentialUpdatesAltId.create
+      assert_equal 5, new.pos
+
+      new.insert_at(1)
+      assert_equal 1, new.pos
+
+      new.insert_at(5)
+      assert_equal 5, new.pos
+
+      new.insert_at(3)
+      assert_equal 3, new.pos
+    end
+
+    def test_create_at_top
+      new = SequentialUpdatesAltId.create!(pos: 1)
+      assert_equal 1, new.pos
+    end
+
+    def test_move_to_bottom
+      item = SequentialUpdatesAltId.order(:pos).first
+      item.move_to_bottom
+      assert_equal 4, item.pos
+    end
+
+    def test_move_to_top
+      new_item = SequentialUpdatesAltId.create!
+      assert_equal 5, new_item.pos
+
+      new_item.move_to_top
+      assert_equal 1, new_item.pos
+    end
+
+    def test_destroy
+      new_item = SequentialUpdatesAltId.create
+      assert_equal 5, new_item.pos
+
+      new_item.insert_at(2)
+      assert_equal 2, new_item.pos
+
+      new_item.destroy
+      assert_equal [1,2,3,4], SequentialUpdatesAltId.all.map(&:pos).sort
+
+    end
+  end
+
+  class SequentialUpdatesAltIdTouchDisabledTest < ActsAsListTestCase
+    def setup
+      setup_db
+      Timecop.freeze(yesterday) do
+        4.times { SequentialUpdatesAltIdTouchDisabled.create! }
+      end
+    end
+
+    def now
+      @now ||= Time.current.change(usec: 0)
+    end
+
+    def yesterday
+      @yesterday ||= 1.day.ago
+    end
+
+    def updated_ats
+      SequentialUpdatesAltIdTouchDisabled.order(:altid).pluck(:updated_at)
+    end
+
+    def positions
+      SequentialUpdatesAltIdTouchDisabled.order(:altid).pluck(:pos)
+    end
+
+    def test_sequential_updates_default_to_true_with_unique_index
+      assert_equal true, SequentialUpdatesAltIdTouchDisabled.new.send(:sequential_updates?)
+    end
+
+    def test_deleting_item_does_not_touch_higher_items
+      Timecop.freeze(now) do
+        SequentialUpdatesAltIdTouchDisabled.first.destroy
+        updated_ats.each do |updated_at|
+          assert_equal updated_at.to_i, yesterday.to_i
+        end
+        assert_equal positions, [1, 2, 3]
+      end
+    end
+  end
 end