summaryrefslogtreecommitdiffstats
path: root/test/unit/issue_nested_set_concurrency_test.rb
blob: 2692ce99fe48ba6c4e5a36a2d7f740baa3c82232 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
# frozen_string_literal: true

# Redmine - project management software
# Copyright (C) 2006-  Jean-Philippe Lang
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

require_relative '../test_helper'

class IssueNestedSetConcurrencyTest < ActiveSupport::TestCase
  self.use_transactional_tests = false

  def setup
    skip if sqlite?
    if mysql?
      connection = ActiveRecord::Base.connection_db_config.configuration_hash.deep_dup
      connection[:variables] = mysql8? ? { transaction_isolation: "READ-COMMITTED" } : { tx_isolation: "READ-COMMITTED" }
      ActiveRecord::Base.establish_connection connection
    end
    User.current = nil
    CustomField.destroy_all
  end

  def teardown
    Issue.delete_all
  end

  def test_concurrency
    # Generates an issue and destroys it in order
    # to load all needed classes before starting threads
    i = Issue.generate!
    i.destroy

    root = Issue.generate!
    assert_difference 'Issue.count', 60 do
      threaded(3) do
        10.times do
          i = Issue.generate! :parent_issue_id => root.id
          c1 = Issue.generate! :parent_issue_id => i.id
          c2 = Issue.generate! :parent_issue_id => i.id
          c3 = Issue.generate! :parent_issue_id => i.id
          c2.reload.destroy
          c1.reload.destroy
        end
      end
    end
  end

  def test_concurrent_subtasks_creation
    root = Issue.generate!
    assert_difference 'Issue.count', 30 do
      threaded(3) do
        10.times do
          Issue.generate! :parent_issue_id => root.id
        end
      end
    end
    root.reload
    assert_equal [1, 62], [root.lft, root.rgt]
    children_bounds = root.children.sort_by(&:lft).map {|c| [c.lft, c.rgt]}.flatten
    assert_equal (2..61).to_a, children_bounds
  end

  def test_concurrent_subtask_removal
    with_settings :notified_events => [] do
      root = Issue.generate!
      60.times do
        Issue.generate! :parent_issue_id => root.id
      end
      # pick 40 random subtask ids
      child_ids = Issue.where(root_id: root.id, parent_id: root.id).pluck(:id)
      ids_to_remove = child_ids.sample(40).shuffle
      ids_to_keep = child_ids - ids_to_remove
      # remove these from the set, using four parallel threads
      threads = []
      ids_to_remove.each_slice(10) do |ids|
        threads << Thread.new do
          ActiveRecord::Base.connection_pool.with_connection do
            begin
              ids.each do |id|
                Issue.find(id).update(parent_id: nil)
              end
            rescue => e
              Thread.current[:exception] = e.message
            end
          end
        end
      end
      threads.each do |thread|
        thread.join
        assert_nil thread[:exception]
      end
      assert_equal 20, Issue.where(parent_id: root.id).count
      Issue.where(id: ids_to_remove).each do |issue|
        assert_nil issue.parent_id
        assert_equal issue.id, issue.root_id
        assert_equal 1, issue.lft
        assert_equal 2, issue.rgt
      end
      root.reload
      assert_equal [1, 42], [root.lft, root.rgt]
      children_bounds = root.children.sort_by(&:lft).map {|c| [c.lft, c.rgt]}.flatten
      assert_equal (2..41).to_a, children_bounds
    end
  end

  private

  def threaded(count, &)
    with_settings :notified_events => [] do
      threads = []
      count.times do |i|
        threads << Thread.new(i) do
          ActiveRecord::Base.connection_pool.with_connection do
            begin
              yield
            rescue => e
              Thread.current[:exception] = e.message
            end
          end
        end
      end
      threads.each do |thread|
        thread.join
        assert_nil thread[:exception]
      end
    end
  end
end