acts_as_list 1.1.0 → 1.2.0

data/test/shared_list.rb

@@ -2,103 +2,108 @@
 
 module Shared
   module List
-    def setup
+    def setup(mixin = ListMixin, mixinError = ListMixinError, id = :id)
+      @mixin = mixin
+      @id = id
+      @mixinError = mixinError
       (1..4).each do |counter|
-        node = ListMixin.new parent_id: 5
+        node = @mixin.new parent_id: 5
+        node.first_id = counter if @id == :first_id
+        node.second_id = counter if @id == :first_id
         node.pos = counter
         node.save!
       end
     end
 
     def test_current_position
-      first_item = ListMixin.where(parent_id: 5).first
+      first_item = @mixin.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)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 2).first.move_lower
-      assert_equal [1, 3, 2, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 2).first.move_lower
+      assert_equal [1, 3, 2, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 2).first.move_higher
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 2).first.move_higher
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 1).first.move_to_bottom
-      assert_equal [2, 3, 4, 1], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 1).first.move_to_bottom
+      assert_equal [2, 3, 4, 1], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 1).first.move_to_top
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 1).first.move_to_top
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 2).first.move_to_bottom
-      assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 2).first.move_to_bottom
+      assert_equal [1, 3, 4, 2], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 4).first.move_to_top
-      assert_equal [4, 1, 3, 2], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 4).first.move_to_top
+      assert_equal [4, 1, 3, 2], @mixin.where(parent_id: 5).order('pos').map(&@id)
     end
 
     def test_move_to_bottom_with_next_to_last_item
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-      ListMixin.where(id: 3).first.move_to_bottom
-      assert_equal [1, 2, 4, 3], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
+      @mixin.where(@id => 3).first.move_to_bottom
+      assert_equal [1, 2, 4, 3], @mixin.where(parent_id: 5).order('pos').map(&@id)
     end
 
     def test_next_prev
-      assert_equal ListMixin.where(id: 2).first, ListMixin.where(id: 1).first.lower_item
-      assert_nil ListMixin.where(id: 1).first.higher_item
-      assert_equal ListMixin.where(id: 3).first, ListMixin.where(id: 4).first.higher_item
-      assert_nil ListMixin.where(id: 4).first.lower_item
+      assert_equal @mixin.where(@id => 2).first, @mixin.where(@id => 1).first.lower_item
+      assert_nil @mixin.where(@id => 1).first.higher_item
+      assert_equal @mixin.where(@id => 3).first, @mixin.where(@id => 4).first.higher_item
+      assert_nil @mixin.where(@id => 4).first.lower_item
     end
 
     def test_injection
-      item = ListMixin.new(parent_id: 1)
+      item = @mixin.new(parent_id: 1)
       assert_equal({ parent_id: 1 }, item.scope_condition)
       assert_equal "pos", item.position_column
     end
 
     def test_insert
-      new = ListMixin.create(parent_id: 20)
+      new = create_record(id: 5, parent_id: 20)
       assert_equal 1, new.pos
       assert new.first?
       assert new.last?
 
-      new = ListMixin.create(parent_id: 20)
+      new = create_record(id: 6, parent_id: 20)
       assert_equal 2, new.pos
       assert !new.first?
       assert new.last?
 
-      new = ListMixin.acts_as_list_no_update { ListMixin.create(parent_id: 20) }
+      new = @mixin.acts_as_list_no_update { create_record(id: 7, parent_id: 20) }
       assert_equal_or_nil $default_position, new.pos
       assert_equal $default_position.is_a?(Integer), new.first?
       assert !new.last?
 
-      new = ListMixin.create(parent_id: 20)
+      new = create_record(id: 8, parent_id: 20)
       assert_equal 3, new.pos
       assert !new.first?
       assert new.last?
 
-      new = ListMixin.create(parent_id: 0)
+      new = create_record(id: 9, parent_id: 0)
       assert_equal 1, new.pos
       assert new.first?
       assert new.last?
     end
 
     def test_insert_at
-      new = ListMixin.create(parent_id: 20)
+      new = create_record(id: 5, parent_id: 20)
       assert_equal 1, new.pos
 
-      new = ListMixin.create(parent_id: 20)
+      new = create_record(id: 6, parent_id: 20)
       assert_equal 2, new.pos
 
-      new = ListMixin.create(parent_id: 20)
+      new = create_record(id: 7, parent_id: 20)
       assert_equal 3, new.pos
 
-      new_noup = ListMixin.acts_as_list_no_update { ListMixin.create(parent_id: 20) }
+      new_noup = @mixin.acts_as_list_no_update { create_record(id: 8, parent_id: 20) }
       assert_equal_or_nil $default_position, new_noup.pos
 
-      new4 = ListMixin.create(parent_id: 20)
+      new4 = create_record(id: 9, parent_id: 20)
       assert_equal 4, new4.pos
 
       new4.insert_at(3)
@@ -113,7 +118,7 @@ module Shared
       new4.reload
       assert_equal 4, new4.pos
 
-      new5 = ListMixin.create(parent_id: 20)
+      new5 = create_record(id: 10, parent_id: 20)
       assert_equal 5, new5.pos
 
       new5.insert_at(1)
@@ -125,49 +130,50 @@ module Shared
       new_noup.reload
       assert_equal_or_nil $default_position, new_noup.pos
 
-      last1 = ListMixin.where('pos IS NOT NULL').order('pos').last
-      last2 = ListMixin.where('pos IS NOT NULL').order('pos').last
+      last1 = @mixin.where('pos IS NOT NULL').order('pos').last
+      last2 = @mixin.where('pos IS NOT NULL').order('pos').last
       last1.insert_at(1)
       last2.insert_at(1)
-      pos_list = ListMixin.where(parent_id: 20).order("pos ASC#{' NULLS FIRST' if ENV['DB'] == 'postgresql'}").map(&:pos)
+      pos_list = @mixin.where(parent_id: 20).order("pos ASC#{' NULLS FIRST' if ENV['DB'] == 'postgresql'}").map(&:pos)
       assert_equal [$default_position, 1, 2, 3, 4, 5], pos_list
     end
 
     def test_insert_at_after_dup
-      new1 = ListMixin.create(parent_id: 20)
-      new2 = ListMixin.create(parent_id: 20)
-      new3 = ListMixin.create(parent_id: 20)
+      new1 = create_record(id: 5, parent_id: 20)
+      new2 = create_record(id: 6, parent_id: 20)
+      new3 = create_record(id: 7, parent_id: 20)
 
       duped = new1.dup
-      duped.save
+      duped.first_id = 8 if @id == :first_id
+      duped.second_id = 8 if @id == :first_id
+      duped.insert_at(1)
       [new1, new2, new3, duped].map(&:reload)
 
       assert_equal [1, 2, 3, 4], [duped.pos, new1.pos, new2.pos, new3.pos]
     end
 
     def test_delete_middle
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 2).first.destroy
+      @mixin.where(@id => 2).first.destroy
+      assert_equal [1, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal 1, @mixin.where(@id => 1).first.pos
+      assert_equal 2, @mixin.where(@id => 3).first.pos
+      assert_equal 3, @mixin.where(@id => 4).first.pos
 
-      assert_equal 1, ListMixin.where(id: 1).first.pos
-      assert_equal 2, ListMixin.where(id: 3).first.pos
-      assert_equal 3, ListMixin.where(id: 4).first.pos
+      @mixin.where(@id => 1).first.destroy
 
-      ListMixin.where(id: 1).first.destroy
+      assert_equal [3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      assert_equal [3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal 1, @mixin.where(@id => 3).first.pos
+      assert_equal 2, @mixin.where(@id => 4).first.pos
 
-      assert_equal 1, ListMixin.where(id: 3).first.pos
-      assert_equal 2, ListMixin.where(id: 4).first.pos
+      @mixin.acts_as_list_no_update { @mixin.where(@id => 3).first.destroy }
 
-      ListMixin.acts_as_list_no_update { ListMixin.where(id: 3).first.destroy }
+      assert_equal [4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      assert_equal [4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-
-      assert_equal 2, ListMixin.where(id: 4).first.pos
+      assert_equal 2, @mixin.where(@id => 4).first.pos
     end
 
     def test_with_string_based_scope
@@ -178,137 +184,142 @@ module Shared
     end
 
     def test_nil_scope
-      new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
+      new1, new2, new3 = create_record(id: 5), create_record(id: 6), create_record(id: 7)
       new2.move_higher
-      assert_equal [new2, new1, new3].map(&:id), ListMixin.where(parent_id: nil).order('pos').map(&:id)
+      assert_equal [new2, new1, new3].map(&@id), @mixin.where(parent_id: nil).order('pos').map(&@id)
     end
 
     def test_update_position_when_scope_changes
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-      ListMixin.create(parent_id: 6)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
+      create_record(id: 5, parent_id: 6)
 
-      ListMixin.where(id: 2).first.move_within_scope(6)
+      @mixin.where(@id => 2).first.move_within_scope(6)
 
-      assert_equal 2, ListMixin.where(id: 2).first.pos
+      assert_equal 2, @mixin.where(@id => 2).first.pos
 
-      assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      assert_equal 1, ListMixin.where(id: 1).first.pos
-      assert_equal 2, ListMixin.where(id: 3).first.pos
-      assert_equal 3, ListMixin.where(id: 4).first.pos
+      assert_equal 1, @mixin.where(@id => 1).first.pos
+      assert_equal 2, @mixin.where(@id => 3).first.pos
+      assert_equal 3, @mixin.where(@id => 4).first.pos
 
-      ListMixin.where(id: 2).first.move_within_scope(5)
-      assert_equal [1, 3, 4, 2], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      @mixin.where(@id => 2).first.move_within_scope(5)
+      assert_equal [1, 3, 4, 2], @mixin.where(parent_id: 5).order('pos').map(&@id)
     end
 
     def test_remove_from_list_should_then_fail_in_list?
-      assert_equal true, ListMixin.where(id: 1).first.in_list?
-      ListMixin.where(id: 1).first.remove_from_list
-      assert_equal false, ListMixin.where(id: 1).first.in_list?
+      assert_equal true, @mixin.where(@id => 1).first.in_list?
+      @mixin.where(@id => 1).first.remove_from_list
+      assert_equal false, @mixin.where(@id => 1).first.in_list?
     end
 
     def test_remove_from_list_should_set_position_to_nil
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 2).first.remove_from_list
+      @mixin.where(@id => 2).first.remove_from_list
 
-      assert_equal 1,   ListMixin.where(id: 1).first.pos
-      assert_nil        ListMixin.where(id: 2).first.pos
-      assert_equal 2,   ListMixin.where(id: 3).first.pos
-      assert_equal 3,   ListMixin.where(id: 4).first.pos
+      assert_equal 1,   @mixin.where(@id => 1).first.pos
+      assert_nil        @mixin.where(@id => 2).first.pos
+      assert_equal 2,   @mixin.where(@id => 3).first.pos
+      assert_equal 3,   @mixin.where(@id => 4).first.pos
     end
 
     def test_remove_before_destroy_does_not_shift_lower_items_twice
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      ListMixin.where(id: 2).first.remove_from_list
-      ListMixin.where(id: 2).first.destroy
+      @mixin.where(@id => 2).first.remove_from_list
+      @mixin.where(@id => 2).first.destroy
 
-      assert_equal [1, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      assert_equal 1, ListMixin.where(id: 1).first.pos
-      assert_equal 2, ListMixin.where(id: 3).first.pos
-      assert_equal 3, ListMixin.where(id: 4).first.pos
+      assert_equal 1, @mixin.where(@id => 1).first.pos
+      assert_equal 2, @mixin.where(@id => 3).first.pos
+      assert_equal 3, @mixin.where(@id => 4).first.pos
     end
 
     def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
       # We need to trigger all the before_destroy callbacks without actually
-      # destroying the record so we can see the affect the callbacks have on
+      # destroying the record so we can see the effect the callbacks have on
       # the record.
-      list = ListMixin.where(id: 2).first
+      list = @mixin.where(@id => 2).first
       if list.respond_to?(:run_callbacks)
         list.run_callbacks(:destroy)
       else
         list.send(:callback, :before_destroy)
       end
 
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      assert_equal 1, ListMixin.where(id: 1).first.pos
-      assert_equal 2, ListMixin.where(id: 2).first.pos
-      assert_equal 2, ListMixin.where(id: 3).first.pos
-      assert_equal 3, ListMixin.where(id: 4).first.pos
+      assert_equal 1, @mixin.where(@id => 1).first.pos
+      assert_equal 2, @mixin.where(@id => 2).first.pos
+      assert_equal 2, @mixin.where(@id => 3).first.pos
+      assert_equal 3, @mixin.where(@id => 4).first.pos
     end
 
     def test_before_create_callback_adds_to_bottom
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      new = ListMixin.create(parent_id: 5)
+      new = create_record(id: 5, parent_id: 5)
       assert_equal 5, new.pos
       assert !new.first?
       assert new.last?
 
-      assert_equal [1, 2, 3, 4, 5], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [1, 2, 3, 4, 5], @mixin.where(parent_id: 5).order('pos').map(&@id)
     end
 
     def test_before_create_callback_adds_to_given_position
-      assert_equal [1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
-
-      new = ListMixin.new(parent_id: 5)
+      assert_equal [1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
+      new = @mixin.new(@id => 5, parent_id: 5)
+      new.second_id = 5 if @id == :first_id
       new.pos = 1
       new.save!
       assert_equal 1, new.pos
       assert new.first?
       assert !new.last?
 
-      assert_equal [5, 1, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [5, 1, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      new6 = ListMixin.new(parent_id: 5)
+      new6 = @mixin.new(@id => 6, parent_id: 5)
+      new6.second_id = 6 if @id == :first_id
       new6.pos = 3
       new6.save!
       assert_equal 3, new6.pos
       assert !new6.first?
       assert !new6.last?
 
-      assert_equal [5, 1, 6, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos').map(&:id)
+      assert_equal [5, 1, 6, 2, 3, 4], @mixin.where(parent_id: 5).order('pos').map(&@id)
 
-      new = ListMixin.new(parent_id: 5)
+      new = @mixin.new(@id => 7, parent_id: 5)
+      new.second_id = 7 if @id == :first_id
       new.pos = 3
-      ListMixin.acts_as_list_no_update { new.save! }
+      @mixin.acts_as_list_no_update { new.save! }
       assert_equal 3, new.pos
       assert_equal 3, new6.pos
       assert !new.first?
       assert !new.last?
 
-      assert_equal [5, 1, 6, 7, 2, 3, 4], ListMixin.where(parent_id: 5).order('pos, id').map(&:id)
+      assert_equal [5, 1, 6, 7, 2, 3, 4], @mixin.where(parent_id: 5).order("pos, #{@id}").map(&@id)
     end
 
     def test_non_persisted_records_dont_get_lock_called
-      new = ListMixin.new(parent_id: 5)
+      new = @mixin.new(@id => 5, parent_id: 5)
+      new.second_id = 6 if @id == :first_id
       new.destroy
     end
 
     def test_invalid_records_dont_get_inserted
-      new = ListMixinError.new(parent_id: 5, state: nil)
+      new = @mixinError.new(@id => 5, parent_id: 5, state: nil)
+      new.second_id = 6 if @id == :first_id
       assert !new.valid?
       new.insert_at(1)
       assert !new.persisted?
     end
 
     def test_invalid_records_raise_error_with_insert_at!
-      new = ListMixinError.new(parent_id: 5, state: nil)
+      new = @mixinError.new(@id => 5, parent_id: 5, state: nil)
+      new.second_id = 5 if @id == :first_id
       assert !new.valid?
       assert_raises ActiveRecord::RecordInvalid do
         new.insert_at!(1)
@@ -317,8 +328,20 @@ module Shared
 
     def test_find_or_create_doesnt_raise_deprecation_warning
       assert_no_deprecation_warning_raised_by('ActiveRecord deprecation warning raised when using `find_or_create_by` when we didn\'t expect it') do
-        ListMixin.where(parent_id: 5).find_or_create_by(pos: 5)
+        @mixin.where(parent_id: 5).find_or_create_by(pos: 5) do |new|
+          new.first_id = 5 if @id == :first_id
+          new.second_id = 5 if @id == :first_id
+        end
       end
     end
+
+    private
+
+    def create_record(opts)
+      attrs = { parent_id: opts[:parent_id] }
+      attrs[:first_id] = opts[:id] if @id == :first_id
+      attrs[:second_id] = opts[:id] if @id == :first_id
+      @mixin.create(attrs)
+    end
   end
 end

data/test/support/ci_database.yml

@@ -0,0 +1,20 @@
+sqlite:
+  adapter: sqlite3
+  database: file::memory:?cache=shared
+
+mysql:
+  adapter: mysql2
+  database: runner
+  pool: 5
+  timeout: 5000
+  username: root
+  password: root
+
+postgresql:
+  adapter: postgresql
+  database: runner
+  pool: 5
+  timeout: 5000
+  username: runner
+  password:
+  min_messages: ERROR

data/test/{database.yml → support/database.yml}

@@ -1,6 +1,6 @@
 sqlite:
   adapter: sqlite3
-  database: "file:memdb1?mode=memory&cache=shared"
+  database: file::memory:?cache=shared
 
 mysql:
   adapter: mysql2

data/test/test_list.rb

@@ -7,11 +7,13 @@ def setup_db(position_options = {})
   $default_position = position_options[:default]
 
   # sqlite cannot drop/rename/alter columns and add constraints after table creation
-  sqlite = ENV.fetch("DB", "sqlite") == "sqlite"
+  sqlite = ENV.fetch("DB") == "sqlite"
+  unique = position_options.delete(:unique)
+  positive = position_options.delete(:positive)
 
   # AR caches columns options like defaults etc. Clear them!
   ActiveRecord::Base.connection.create_table :mixins do |t|
-    t.column :pos, :integer, **position_options unless position_options[:positive] && sqlite
+    t.column :pos, :integer, **position_options unless positive && sqlite
     t.column :active, :boolean, default: true
     t.column :parent_id, :integer
     t.column :parent_type, :string
@@ -20,11 +22,11 @@ def setup_db(position_options = {})
     t.column :state, :integer
   end
 
-  if position_options[:unique] && !(sqlite && position_options[:positive])
+  if unique && !(sqlite && positive)
     ActiveRecord::Base.connection.add_index :mixins, :pos, unique: true
   end
 
-  if position_options[:positive]
+  if positive
     if sqlite
       # SQLite cannot add constraint after table creation, also cannot add unique inside ADD COLUMN
       ActiveRecord::Base.connection.execute('ALTER TABLE mixins ADD COLUMN pos integer8 NOT NULL CHECK (pos > 0) DEFAULT 1')
@@ -48,9 +50,21 @@ def setup_db(position_options = {})
 
   ActiveRecord::Base.connection.add_index 'altid-table', :pos, unique: true
 
+  # This table is used to test table names with a composite primary_key
+  ActiveRecord::Base.connection.create_table 'composite-primary-key-table', primary_key: [:first_id, :second_id] do |t|
+    t.integer :first_id, null: false
+    t.integer :second_id, null: false
+    t.column :parent_id, :integer
+    t.column :parent_type, :string
+    t.column :pos, :integer
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+    t.column :state, :integer
+  end
+
   mixins = [ Mixin, ListMixin, ListMixinSub1, ListMixinSub2, ListWithStringScopeMixin,
     ArrayScopeListMixin, ZeroBasedMixin, DefaultScopedMixin, EnumArrayScopeListMixin,
-    DefaultScopedWhereMixin, TopAdditionMixin, NoAdditionMixin, QuotedList, TouchDisabledMixin ]
+    DefaultScopedWhereMixin, TopAdditionMixin, NoAdditionMixin, QuotedList, TouchDisabledMixin, CompositePrimaryKeyList, CompositePrimaryKeyListScoped ]
 
   ActiveRecord::Base.connection.schema_cache.clear!
   mixins.each do |klass|
@@ -194,6 +208,21 @@ class QuotedList < ActiveRecord::Base
   acts_as_list column: :order
 end
 
+class CompositePrimaryKeyList < ActiveRecord::Base
+  self.table_name = "composite-primary-key-table"
+  self.primary_key = [:first_id, :second_id] 
+
+  acts_as_list column: "pos"
+end
+
+class CompositePrimaryKeyListScoped < CompositePrimaryKeyList
+  acts_as_list column: "pos", scope: :parent_id
+end
+
+class CompositePrimaryKeyListScopedError < CompositePrimaryKeyListScoped
+  validates :state, presence: true
+end
+
 class ActsAsListTestCase < Minitest::Test
   # No default test required as this class is abstract.
   # Need for test/unit.
@@ -1120,3 +1149,105 @@ class SequentialUpdatesMixinNotNullUniquePositiveConstraintsTest < ActsAsListTes
     end
   end
 end
+
+if ActiveRecord::VERSION::MAJOR == 7 && ActiveRecord::VERSION::MINOR >= 1 || ActiveRecord::VERSION::MAJOR > 7
+  class CompositePrimaryKeyListTest < ActsAsListTestCase
+    def setup
+      setup_db
+      (1..4).each { |counter| CompositePrimaryKeyList.create!({first_id: counter, second_id: counter, pos: counter}) }
+    end
+
+    def test_insert_at
+      new = CompositePrimaryKeyList.create({first_id: 5, second_id: 5})
+      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_move_lower
+      item = CompositePrimaryKeyList.order(:pos).first
+      item.move_lower
+      assert_equal 2, item.pos
+    end
+
+    def test_move_higher
+      item = CompositePrimaryKeyList.order(:pos).second
+      item.move_higher
+      assert_equal 1, item.pos
+    end
+
+    def test_move_to_bottom
+      item = CompositePrimaryKeyList.order(:pos).first
+      item.move_to_bottom
+      assert_equal 4, item.pos
+    end
+
+    def test_move_to_top
+      new_item = CompositePrimaryKeyList.create!({first_id: 5, second_id: 5})
+      assert_equal 5, new_item.pos
+
+      new_item.move_to_top
+      assert_equal 1, new_item.pos
+    end
+
+    def test_remove_from_list
+      assert_equal true, CompositePrimaryKeyList.find([1, 1]).in_list?
+      CompositePrimaryKeyList.find([1,1]).remove_from_list
+      assert_equal false, CompositePrimaryKeyList.find([1, 1]).in_list?
+    end
+
+    def test_increment_position
+      item = CompositePrimaryKeyList.order(:pos).first
+      item.increment_position
+      assert_equal 2, item.pos
+    end
+
+    def test_decrement_position
+      item = CompositePrimaryKeyList.order(:pos).second
+      item.decrement_position
+      assert_equal 1, item.pos
+    end
+
+    def test_set_list_position
+      item = CompositePrimaryKeyList.order(:pos).first
+      item.set_list_position(4)
+      assert_equal 4, item.pos
+    end
+
+    def test_create_at_top
+      new = CompositePrimaryKeyList.create({first_id: 5, second_id: 5, pos: 1})
+      assert_equal 1, new.pos
+    end
+
+    def test_destroy
+      new_item = CompositePrimaryKeyList.create({first_id: 5, second_id: 5})
+      assert_equal 5, new_item.pos
+      assert_equal true, new_item.last?
+
+      new_item.insert_at(1)
+      assert_equal 1, new_item.pos
+      assert_equal true, new_item.first?
+
+      new_item.destroy
+      assert_equal [1,2,3,4], CompositePrimaryKeyList.all.map(&:pos).sort
+    end
+  end
+
+  class CompositePrimaryKeyListScopedTest < ActsAsListTestCase
+    include Shared::List
+
+    def setup
+      setup_db
+
+      super(CompositePrimaryKeyListScoped, CompositePrimaryKeyListScopedError, :first_id)
+    end
+  end
+end
+