Redmine

---

reaction_001:

  id: 1

  reactable_type: Issue

  reactable_id: 1

  user_id: 1

reaction_002:

  id: 2

  reactable_type: Issue

  reactable_id: 1

  user_id: 2

reaction_003:

  id: 3

  reactable_type: Issue

  reactable_id: 1

  user_id: 3

reaction_004:

  id: 4

  reactable_type: Journal

  reactable_id: 1

  user_id: 2

reaction_005:

  id: 5

  reactable_type: Issue

  reactable_id: 6

  user_id: 2

reaction_006:

  id: 6

  reactable_type: Journal

  reactable_id: 4

  user_id: 2

reaction_007:

  id: 7

  reactable_type: News

  reactable_id: 1

  user_id: 1

reaction_008:

  id: 8

  reactable_type: Comment

  reactable_id: 1

  user_id: 2

reaction_009:

  id: 9

  reactable_type: Message

  reactable_id: 7

  user_id: 2

reaction_010:

  id: 10

  reactable_type: News

  reactable_id: 3

  user_id: 2

  def test_show_should_display_reactions

    @request.session[:user_id] = nil

    get :show, params: { id: 1 }

    assert_response :success

    assert_select 'span[data-reaction-button-id=reaction_issue_1] span.reaction-button' do

      assert_select 'span.icon-label', '3'

    end

    assert_select 'span[data-reaction-button-id=reaction_journal_1] span.reaction-button'

    assert_select 'span[data-reaction-button-id=reaction_journal_2] span.reaction-button'

    # Should not display reactions when reactions feature is disabled.

    Setting.reactions_enabled = false

    get :show, params: { id: 1 }

    assert_response :success

    assert_select 'span[data-reaction-button-id]', false

  end

  def test_show_should_display_reactions

    @request.session[:user_id] = 2

    get :show, params: { board_id: 1, id: 4 }

    assert_response :success

    assert_select 'span[data-reaction-button-id=reaction_message_4] a.reaction-button' do

      assert_select 'svg use[href*=thumb-up]'

    end

    assert_select 'span[data-reaction-button-id=reaction_message_5] a.reaction-button'

    assert_select 'span[data-reaction-button-id=reaction_message_6] a.reaction-button'

    # Should not display reactions when reactions feature is disabled.

    Setting.reactions_enabled = false

    get :show, params: { board_id: 1, id: 4 }

    assert_response :success

    assert_select 'span[data-reaction-button-id]', false

  end

  def test_show_should_display_reactions

    @request.session[:user_id] = 1

    get :show, params: { id: 1 }

    assert_response :success

    assert_select 'span[data-reaction-button-id=reaction_news_1] a.reaction-button.reacted'

    assert_select 'span[data-reaction-button-id=reaction_comment_1] a.reaction-button'

    # Should not display reactions when reactions feature is disabled.

    Setting.reactions_enabled = false

    get :show, params: { id: 1 }

    assert_response :success

    assert_select 'span[data-reaction-button-id]', false

  end

# 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 ReactionsControllerTest < Redmine::ControllerTest

  def setup

    Setting.reactions_enabled = '1'

    # jsmith

    @request.session[:user_id] = users(:users_002).id

  end

  test 'create for issue' do

    issue = issues(:issues_002)

    assert_difference(

      ->{ Reaction.count } => 1,

      ->{ issue.reactions.by(users(:users_002)).count } => 1

    ) do

      post :create, params: {

        object_type: 'Issue',

        object_id: issue.id

      }, xhr: true

    end

    assert_response :success

  end

  test 'create for journal' do

    journal = journals(:journals_005)

    assert_difference(

      ->{ Reaction.count } => 1,

      ->{ journal.reactions.by(users(:users_002)).count } => 1

    ) do

      post :create, params: {

        object_type: 'Journal',

        object_id: journal.id

      }, xhr: true

    end

    assert_response :success

  end

  test 'create for news' do

    news = news(:news_002)

    assert_difference(

      ->{ Reaction.count } => 1,

      ->{ news.reactions.by(users(:users_002)).count } => 1

    ) do

      post :create, params: {

        object_type: 'News',

        object_id: news.id

      }, xhr: true

    end

    assert_response :success

  end

  test 'create reaction for comment' do

    comment = comments(:comments_002)

    assert_difference(

      ->{ Reaction.count } => 1,

      ->{ comment.reactions.by(users(:users_002)).count } => 1

    ) do

      post :create, params: {

        object_type: 'Comment',

        object_id: comment.id

      }, xhr: true

    end

    assert_response :success

  end

  test 'create for message' do

    message = messages(:messages_001)

    assert_difference(

      ->{ Reaction.count } => 1,

      ->{ message.reactions.by(users(:users_002)).count } => 1

    ) do

      post :create, params: {

        object_type: 'Message',

        object_id: message.id

      }, xhr: true

    end

    assert_response :success

  end

  test 'destroy for issue' do

    reaction = reactions(:reaction_005)

    assert_difference 'Reaction.count', -1 do

      delete :destroy, params: {

        id: reaction.id,

        # Issue (id=6)

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

    assert_not Reaction.exists?(reaction.id)

  end

  test 'destroy for journal' do

    reaction = reactions(:reaction_006)

    assert_difference 'Reaction.count', -1 do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

    assert_not Reaction.exists?(reaction.id)

  end

  test 'destroy for news' do

    # For News(id=3)

    reaction = reactions(:reaction_010)

    assert_difference 'Reaction.count', -1 do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

    assert_not Reaction.exists?(reaction.id)

  end

  test 'destroy for comment' do

    # For Comment(id=1)

    reaction = reactions(:reaction_008)

    assert_difference 'Reaction.count', -1 do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

    assert_not Reaction.exists?(reaction.id)

  end

  test 'destroy for message' do

    reaction = reactions(:reaction_009)

    assert_difference 'Reaction.count', -1 do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

    assert_not Reaction.exists?(reaction.id)

  end

  test 'create should respond with 403 when feature is disabled' do

    Setting.reactions_enabled = '0'

    # admin

    @request.session[:user_id] = users(:users_001).id

    assert_no_difference 'Reaction.count' do

      post :create, params: {

        object_type: 'Issue',

        object_id: issues(:issues_002).id

      }, xhr: true

    end

    assert_response :forbidden

  end

  test 'destroy should respond with 403 when feature is disabled' do

    Setting.reactions_enabled = '0'

    # admin

    @request.session[:user_id] = users(:users_001).id

    reaction = reactions(:reaction_001)

    assert_no_difference 'Reaction.count' do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :forbidden

  end

  test 'create by anonymous user should respond with 403' do

    @request.session[:user_id] = nil

    assert_no_difference 'Reaction.count' do

      post :create, params: {

        object_type: 'Issue',

        # Issue(id=1) is an issue in a public project

        object_id: issues(:issues_001).id

      }, xhr: true

    end

    assert_response :unauthorized

  end

  test 'destroy by anonymous user should respond with 401' do

    @request.session[:user_id] = nil

    reaction = reactions(:reaction_002)

    assert_no_difference 'Reaction.count' do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :unauthorized

  end

  test 'create when reaction already exists should not create a new reaction and succeed' do

    assert_no_difference 'Reaction.count' do

      post :create, params: {

        object_type: 'Comment',

        # user(jsmith) has already reacted to Comment(id=1)

        object_id: comments(:comments_001).id

      }, xhr: true

    end

    assert_response :success

  end

  test 'destroy another user reaction should not destroy the reaction and succeed' do

    # admin user's reaction

    reaction = reactions(:reaction_001)

    assert_no_difference 'Reaction.count' do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

  end

  test 'destroy nonexistent reaction' do

    # For Journal(id=4)

    reaction = reactions(:reaction_006)

    reaction.destroy!

    assert_not Reaction.exists?(reaction.id)

    assert_no_difference 'Reaction.count' do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :success

  end

  test 'create with invalid object type should respond with 403' do

    # admin

    @request.session[:user_id] = users(:users_001).id

    post :create, params: {

      object_type: 'InvalidType',

      object_id: 1

    }, xhr: true

    assert_response :forbidden

  end

  test 'create without permission to view should respond with 403' do

    # dlopper

    @request.session[:user_id] = users(:users_003).id

    assert_no_difference 'Reaction.count' do

      post :create, params: {

        object_type: 'Issue',

        # dlopper is not a member of the project where the issue (id=4) belongs.

        object_id: issues(:issues_004).id

      }, xhr: true

    end

    assert_response :forbidden

  end

  test 'destroy without permission to view should respond with 403' do

    # dlopper

    @request.session[:user_id] = users(:users_003).id

    # For Issue(id=6)

    reaction = reactions(:reaction_005)

    assert_no_difference 'Reaction.count' do

      delete :destroy, params: {

        id: reaction.id,

        object_type: reaction.reactable_type,

        object_id: reaction.reactable_id

      }, xhr: true

    end

    assert_response :forbidden

  end

end

# 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 ReactionsHelperTest < ActionView::TestCase

  include ReactionsHelper

  setup do

    User.current = users(:users_002)

    Setting.reactions_enabled = '1'

  end

  test 'reaction_id_for generates a DOM id' do

    assert_equal "reaction_issue_1", reaction_id_for(issues(:issues_001))

  end

  test 'reaction_button returns nil when feature is disabled' do

    Setting.reactions_enabled = '0'

    assert_nil reaction_button(issues(:issues_004))

  end

  test 'reaction_button returns nil when object not visible' do

    User.current = users(:users_003)

    assert_nil reaction_button(issues(:issues_004))

  end

  test 'reaction_button for anonymous users shows static icon' do

    User.current = nil

    result = reaction_button(journals(:journals_001))

    assert_select_in result, 'span.reaction-button[title=?]', 'John Smith'

    assert_select_in result, 'a.reaction-button', false

  end

  test 'reaction_button includes no tooltip when the object has no reactions' do

    issue = issues(:issues_002) # Issue without reactions

    result = reaction_button(issue)

    assert_select_in result, 'span.reaction-button[title]', false

  end

  test 'reaction_button includes tooltip with all usernames when reactions are 10 or fewer' do

    issue = issues(:issues_002)

    reactions = build_reactions(10)

    issue.reactions += reactions

    result = with_locale 'en' do

      reaction_button(issue)

    end

    # The tooltip should display usernames in order of newest reactions.

    expected_tooltip = 'Bob9 Doe, Bob8 Doe, Bob7 Doe, Bob6 Doe, Bob5 Doe, ' \

                       'Bob4 Doe, Bob3 Doe, Bob2 Doe, Bob1 Doe, and Bob0 Doe'

    assert_select_in result, 'a.reaction-button[title=?]', expected_tooltip

  end

  test 'reaction_button includes tooltip with 10 usernames and others count when reactions exceed 10' do

    issue = issues(:issues_002)

    reactions = build_reactions(11)

    issue.reactions += reactions

    result = with_locale 'en' do

      reaction_button(issue)

    end

    expected_tooltip = 'Bob10 Doe, Bob9 Doe, Bob8 Doe, Bob7 Doe, Bob6 Doe, ' \

                       'Bob5 Doe, Bob4 Doe, Bob3 Doe, Bob2 Doe, Bob1 Doe, and 1 other'

    assert_select_in result, 'a.reaction-button[title=?]', expected_tooltip

  end

  test 'reaction_button for reacted object' do

    issue = issues(:issues_001)

    reaction = issue.reactions.find_by(user: User.current)

    result = with_locale('en') do

      reaction_button(issue, reaction)

    end

    tooltip = 'Dave Lopper, John Smith, and Redmine Admin'

    assert_select_in result, 'span[data-reaction-button-id=?]', 'reaction_issue_1' do

      href = reaction_path(reaction, object_type: 'Issue', object_id: 1)

      assert_select 'a.icon.reaction-button.reacted[href=?]', href do

        assert_select 'use[href*=?]', 'thumb-up-filled'

        assert_select 'span.icon-label', '3'

      end

      assert_select 'span.reaction-button', false

    end

  end

  test 'reaction_button for non-reacted object' do

    User.current = users(:users_004)

    issue = issues(:issues_001)

    reaction = issue.reactions.find_by(user: User.current)

    result = with_locale('en') do

      reaction_button(issue, reaction)

    end

    tooltip = 'Dave Lopper, John Smith, and Redmine Admin'

    assert_select_in result, 'span[data-reaction-button-id=?]', 'reaction_issue_1' do

      href = reactions_path(object_type: 'Issue', object_id: 1)

      assert_select 'a.icon.reaction-button[href=?]', href do

        assert_select 'use[href*=?]', 'thumb-up'

        assert_select 'span.icon-label', '3'

      end

      assert_select 'span.reaction-button', false

    end

  end

  private

  def build_reactions(count)

    Array.new(count) do |i|

      Reaction.new(user: User.generate!(firstname: "Bob#{i}"))

    end

  end

end

# 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 '../application_system_test_case'

class ReactionsSystemTest < ApplicationSystemTestCase

  def test_react_to_issue

    log_user('jsmith', 'jsmith')

    issue = issues(:issues_002)

    with_settings(reactions_enabled: '1') do

      visit '/issues/2'

      reaction_button = find("div.issue.details [data-reaction-button-id=\"reaction_issue_#{issue.id}\"]")

      assert_reaction_add_and_remove(reaction_button, issue)

    end

  end

  def test_react_to_journal

    log_user('jsmith', 'jsmith')

    journal = journals(:journals_002)

    with_settings(reactions_enabled: '1') do

      visit '/issues/1'

      reaction_button = find("[data-reaction-button-id=\"reaction_journal_#{journal.id}\"]")

      assert_reaction_add_and_remove(reaction_button, journal.reload)

    end

  end

  def test_react_to_forum_reply

    log_user('jsmith', 'jsmith')

    reply_message = messages(:messages_002) # reply to message_001

    with_settings(reactions_enabled: '1') do

      visit 'boards/1/topics/1'

      reaction_button = find("[data-reaction-button-id=\"reaction_message_#{reply_message.id}\"]")

      assert_reaction_add_and_remove(reaction_button, reply_message)

    end

  end

  def test_react_to_forum_message

    log_user('jsmith', 'jsmith')

    message = messages(:messages_001)

    with_settings(reactions_enabled: '1') do

      visit 'boards/1/topics/1'

      reaction_button = find("[data-reaction-button-id=\"reaction_message_#{message.id}\"]")

      assert_reaction_add_and_remove(reaction_button, message)

    end

  end

  def test_react_to_news

    log_user('jsmith', 'jsmith')

    with_settings(reactions_enabled: '1') do

      visit '/news/2'

      reaction_button = find("[data-reaction-button-id=\"reaction_news_2\"]")

      assert_reaction_add_and_remove(reaction_button, news(:news_002))

    end

  end

  def test_react_to_comment

    log_user('jsmith', 'jsmith')

    comment = comments(:comments_002)

    with_settings(reactions_enabled: '1') do

      visit '/news/1'

      reaction_button = find("[data-reaction-button-id=\"reaction_comment_#{comment.id}\"]")

      assert_reaction_add_and_remove(reaction_button, comment)

    end

  end

  def test_reactions_disabled

    log_user('jsmith', 'jsmith')

    with_settings(reactions_enabled: '0') do

      visit '/issues/1'

      assert_no_selector('[data-reaction-button-id="reaction_issue_1"]')

    end

  end

  def test_reaction_button_is_visible_but_not_clickable_for_not_logged_in_user

    with_settings(reactions_enabled: '1') do

      visit '/issues/1'

      # visible

      reaction_button = find('div.issue.details [data-reaction-button-id="reaction_issue_1"]')

      within(reaction_button) { assert_selector('span.reaction-button') }

      assert_equal "3", reaction_button.text

      # not clickable

      within(reaction_button) { assert_no_selector('a.reaction-button') }

    end

  end

  private

  def assert_reaction_add_and_remove(reaction_button, expected_subject)

    # Add a reaction

    within(reaction_button) { find('a.reaction-button').click }

    find('body').hover # Hide tooltip

    within(reaction_button) { assert_selector('a.reaction-button.reacted[title="John Smith"]') }

    assert_equal "1", reaction_button.text

    assert_equal 1, expected_subject.reactions.count

    # Remove the reaction

    within(reaction_button) { find('a.reacted').click }

    within(reaction_button) { assert_selector('a.reaction-button:not(.reacted)') }

    assert_equal "0", reaction_button.text

    assert_equal 0, expected_subject.reactions.count

  end

end

# 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 Redmine::ReactionTest < ActiveSupport::TestCase

  setup do

    @user = users(:users_002)

    @issue = issues(:issues_007)

    Setting.reactions_enabled = '1'

  end

  test 'reaction_by returns reaction for specific user' do

    reaction = Reaction.create(reactable: @issue, user: @user)

    assert_equal reaction, @issue.reaction_by(@user)

    assert_nil @issue.reaction_by(users(:users_003)) # Another user

  end

  test 'reaction_by finds reaction when reactions are preloaded' do

    reaction = Reaction.create(reactable: @issue, user: @user)

    issue_with_reactions = Issue.preload(:reactions).find(@issue.id)

    assert_no_queries do

      assert_equal reaction.id, issue_with_reactions.reaction_by(@user).id

    end

  end

  test 'load_with_reactions returns an array and preloads reaction_user_names' do

    issues = Issue.where(id: [1, 6]).order(:id).load_with_reactions

    assert_equal [issues(:issues_001), issues(:issues_006)], issues

    assert_no_queries do

      assert_equal ['Dave Lopper', 'John Smith', 'Redmine Admin'], issues.first.reaction_user_names

      assert_equal ['John Smith'], issues.second.reaction_user_names

    end

  end

  test 'load_with_reactions returns an array and does not preload reaction_user_names' do

    Setting.reactions_enabled = '0'

    journals = Journal.where(id: 1).load_with_reactions

    assert_equal [journals(:journals_001)], journals

    assert_nil journals.first.instance_variable_get(:@reaction_user_names)

  end

  test 'reaction_user_names returns an array of user names' do

    assert_equal ['John Smith'], comments(:comments_001).reaction_user_names

    # When user names are preloaded by load_with_reactions

    comment = Comment.where(id: [1]).load_with_reactions.first

    assert_no_queries do

      assert_equal ['John Smith'], comment.reaction_user_names

    end

  end

  test 'reaction_users returns users ordered by their newest reactions' do

    Reaction.create(reactable: @issue, user: users(:users_001))

    Reaction.create(reactable: @issue, user: users(:users_002))

    Reaction.create(reactable: @issue, user: users(:users_003))

    assert_equal [

      users(:users_003),

      users(:users_002),

      users(:users_001)

    ], @issue.reaction_users

  end

  test 'destroy should delete associated reactions' do

    @issue.reactions.create!(

      [

        {user: users(:users_001)},

        {user: users(:users_002)}

      ]

    )

    assert_difference 'Reaction.count', -2 do

      @issue.destroy

    end

  end

end

# 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 ReactionTest < ActiveSupport::TestCase

  test 'validates :inclusion of reactable_type' do

    %w(Issue Journal News Comment Message).each do |type|

      reaction = Reaction.new(reactable_type: type, user: User.new)

      assert reaction.valid?

    end

    assert_not Reaction.new(reactable_type: 'InvalidType', user: User.new).valid?

  end

  test 'scope: by' do

    user2_reactions = issues(:issues_001).reactions.by(users(:users_002))

    assert_equal [reactions(:reaction_002)], user2_reactions

  end

  test 'users_map_for_reactables returns correct mapping for given reactable_type and reactable_ids' do

    issue1 = issues(:issues_001)

    issue6 = issues(:issues_006)

    result = Reaction.users_map_for_reactables('Issue', [issue1.id, issue6.id])

    expected_result = {

      issue1.id => ['Dave Lopper', 'John Smith', 'Redmine Admin'],

      issue6.id => ['John Smith']

    }

    assert_equal expected_result, result

  end

  test 'users_map_for_reactables returns empty hash when no reactions exist' do

    result = Reaction.users_map_for_reactables('Issue', [3, 4, 5])

    assert_equal({}, result)

  end

  test "should prevent duplicate reactions with unique constraint under concurrent creation" do

    user = users(:users_001)

    issue = issues(:issues_004)

    threads = []

    results = []

    # Ensure both threads start at the same time

    barrier = Concurrent::CyclicBarrier.new(2)

    # Create two threads to simulate concurrent creation

    2.times do

      threads << Thread.new do

        barrier.wait # Wait for both threads to be ready

        begin

          reaction = Reaction.create(

            reactable: issue,

            user: user

          )

          results << reaction.persisted?

        rescue ActiveRecord::RecordNotUnique

          results << false

        end

      end

    end

    # Wait for both threads to finish

    threads.each(&:join)

    # Ensure only one reaction was created

    assert_equal 1, Reaction.where(reactable: issue, user: user).count

    assert_includes results, true

    assert_equal 1, results.count(true)

  end

end

  def test_destroy_should_delete_associated_reactions

    users(:users_004).reactions.create!(

      [

        {reactable: issues(:issues_001)},

        {reactable: issues(:issues_002)}

      ]

    )

    assert_difference 'Reaction.count', -2 do

      users(:users_004).destroy

    end

  end