mongoid_orderable 6.0.4 → 6.0.5

data/spec/integration/concurrency_spec.rb

@@ -1,232 +0,0 @@
-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

data/spec/integration/conditional_spec.rb

@@ -1,36 +0,0 @@
-require_relative '../spec_helper'
-
-describe ConditionalOrderable do
-
-  shared_examples_for 'conditional_orderable' do
-
-    before :each do
-      ConditionalOrderable.create!(cond_a: false, cond_b: nil)
-      ConditionalOrderable.create!(cond_a: false, cond_b: 1)
-      ConditionalOrderable.create!(cond_a: true, cond_b: 2)
-      ConditionalOrderable.create!(cond_a: false, cond_b: 3)
-      ConditionalOrderable.create!(cond_a: true, cond_b: 4)
-      ConditionalOrderable.create!(cond_a: true, cond_b: 5)
-    end
-
-    it 'should have proper position field' do
-      orderables = ConditionalOrderable.all.sort_by {|x| x.cond_b || 0 }
-
-      expect(orderables.map(&:pos_a)).to eq [nil, nil, 1, nil, 2, 3]
-      expect(orderables.map(&:pos_b)).to eq [nil, 1, 2, 3, 4, nil]
-      expect(orderables.map(&:pos_c)).to eq [1, 2, 3, 4, 5, 6]
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'conditional_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'conditional_orderable'
-  end
-end

data/spec/integration/customized_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe CustomizedOrderable do
-
-  shared_examples_for 'customized_orderable' do
-
-    it 'does not have default position field' do
-      expect(CustomizedOrderable.fields).not_to have_key('position')
-    end
-
-    it 'should have custom pos field' do
-      expect(CustomizedOrderable.fields).to have_key('pos')
-    end
-
-    it 'should have an alias my_position which points to pos field on Mongoid 3+' do
-      expect(CustomizedOrderable.database_field_name('my_position')).to eq('pos')
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'customized_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'customized_orderable'
-  end
-end

data/spec/integration/embedded_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe EmbeddedOrderable do
-
-  shared_examples_for 'embedded_orderable' do
-
-    before :each do
-      eo = EmbedsOrderable.create!
-      2.times { eo.embedded_orderables.create! }
-      eo = EmbedsOrderable.create!
-      3.times { eo.embedded_orderables.create! }
-    end
-
-    def positions
-      EmbedsOrderable.order_by(position: 1).all.map { |eo| eo.embedded_orderables.map(&:position).sort }
-    end
-
-    it 'sets proper position while creation' do
-      expect(positions).to eq([[1, 2], [1, 2, 3]])
-    end
-
-    it 'move_to! moves an item returned by a query to position' do
-      parent = EmbedsOrderable.first
-      child1 = parent.embedded_orderables.where(position: 1).first
-      child2 = parent.embedded_orderables.where(position: 2).first
-      child1.move_to!(2)
-      expect(child1.reload.position).to eq(2)
-      expect(child2.reload.position).to eq(1)
-    end
-
-    it 'move_to moves an item returned by a query to position when saving the parent' do
-      parent = EmbedsOrderable.first
-      child1 = parent.embedded_orderables.where(position: 1).first
-      child2 = parent.embedded_orderables.where(position: 2).first
-      child1.move_to(2)
-      parent.save!
-      expect(child1.reload.position).to eq(2)
-      expect(child2.reload.position).to eq(1)
-    end
-
-    it 'move_to= moves an item returned by a query to position when saving the parent' do
-      parent = EmbedsOrderable.first
-      child1 = parent.embedded_orderables.where(position: 1).first
-      child2 = parent.embedded_orderables.where(position: 2).first
-      child1.move_to = 2
-      parent.save!
-      expect(child1.reload.position).to eq(2)
-      expect(child2.reload.position).to eq(1)
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'embedded_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'embedded_orderable'
-  end
-end

data/spec/integration/foreign_key_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe ForeignKeyDiffersOrderable do
-
-  shared_examples_for 'foreign_key_orderable' do
-
-    it 'uses the foreign key of the relationship as scope' do
-      orderable1, orderable2, orderable3 = nil
-      parent_scope1 = ForeignKeyDiffersOrderable.create
-      parent_scope2 = ForeignKeyDiffersOrderable.create
-      expect do
-        orderable1 = ForeignKeyDiffersOrderable.create!(different_scope: parent_scope1)
-        orderable2 = ForeignKeyDiffersOrderable.create!(different_scope: parent_scope1)
-        orderable3 = ForeignKeyDiffersOrderable.create!(different_scope: parent_scope2)
-      end.to_not raise_error
-      expect(orderable1.position).to eq 1
-      expect(orderable2.position).to eq 2
-      expect(orderable3.position).to eq 1
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'foreign_key_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'foreign_key_orderable'
-  end
-end

data/spec/integration/inherited_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe InheritedOrderable do
-
-  shared_examples_for 'inherited_orderable' do
-
-    it 'should set proper position' do
-      fruit1 = Apple.create
-      fruit2 = Orange.create
-      expect(fruit1.position).to eq(1)
-      expect(fruit2.position).to eq(2)
-    end
-
-    describe 'movement' do
-      before :each do
-        5.times { Apple.create! }
-      end
-
-      it 'with symbol position' do
-        first_apple = Apple.asc(:_id).first
-        top_pos = first_apple.position
-        bottom_pos = Apple.asc(:_id).last.position
-        expect { first_apple.move_to!(:bottom) }.to change(first_apple, :position).from(top_pos).to bottom_pos
-      end
-
-      it 'with point position' do
-        first_apple = Apple.asc(:_id).first
-        top_pos = first_apple.position
-        bottom_pos = Apple.asc(:_id).last.position
-        expect { first_apple.move_to!(bottom_pos) }.to change(first_apple, :position).from(top_pos).to bottom_pos
-      end
-    end
-
-    describe 'add orderable configs in inherited class' do
-      it 'does not affect the orderable configs of parent class and sibling class' do
-        expect(InheritedOrderable.orderable_configs).not_to eq Apple.orderable_configs
-        expect(Orange.orderable_configs).not_to eq Apple.orderable_configs
-        expect(InheritedOrderable.orderable_configs).to eq Orange.orderable_configs
-      end
-    end
-  end
-
-  context 'with transactions' do
-    enable_transactions!
-
-    it_behaves_like 'inherited_orderable'
-  end
-
-  context 'without transactions' do
-    disable_transactions!
-
-    it_behaves_like 'inherited_orderable'
-  end
-end