mirror of
https://github.com/discourse/discourse.git
synced 2024-12-15 21:53:44 +08:00
464 lines
13 KiB
Ruby
464 lines
13 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'rails_helper'
|
|
|
|
describe ::Presence::PresencesController do
|
|
describe '#handle_message' do
|
|
context 'when not logged in' do
|
|
it 'should raise the right error' do
|
|
post '/presence/publish.json'
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
|
|
context 'when logged in' do
|
|
fab!(:user) { Fabricate(:user) }
|
|
fab!(:user2) { Fabricate(:user) }
|
|
fab!(:admin) { Fabricate(:admin) }
|
|
|
|
fab!(:group) do
|
|
group = Fabricate(:group)
|
|
group.add(user)
|
|
group
|
|
end
|
|
|
|
fab!(:category) { Fabricate(:private_category, group: group) }
|
|
fab!(:private_topic) { Fabricate(:topic, category: category) }
|
|
fab!(:public_topic) { Fabricate(:topic, first_post: Fabricate(:post)) }
|
|
|
|
fab!(:private_message) do
|
|
Fabricate(:private_message_topic,
|
|
allowed_groups: [group]
|
|
)
|
|
end
|
|
|
|
before do
|
|
sign_in(user)
|
|
end
|
|
|
|
it 'returns the right response when user disables the presence feature' do
|
|
user.user_option.update_column(:hide_profile_and_presence, true)
|
|
|
|
post '/presence/publish.json'
|
|
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
it 'returns the right response when the presence site settings is disabled' do
|
|
SiteSetting.presence_enabled = false
|
|
|
|
post '/presence/publish.json'
|
|
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
it 'returns the right response if required params are missing' do
|
|
post '/presence/publish.json'
|
|
|
|
expect(response.status).to eq(400)
|
|
end
|
|
|
|
it 'returns the right response if topic_id is invalid' do
|
|
post '/presence/publish.json', params: { topic_id: -999, state: 'replying' }
|
|
|
|
expect(response.status).to eq(400)
|
|
end
|
|
|
|
it 'returns the right response when user does not have access to the topic' do
|
|
group.remove(user)
|
|
|
|
post '/presence/publish.json', params: { topic_id: private_topic.id, state: 'replying' }
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
|
|
it 'returns the right response when an invalid state is provided with a post_id' do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: public_topic.first_post.id,
|
|
state: 'some state'
|
|
}
|
|
|
|
expect(response.status).to eq(400)
|
|
end
|
|
|
|
it 'returns the right response when user can not edit a post' do
|
|
Fabricate(:post, topic: private_topic, user: private_topic.user)
|
|
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_topic.id,
|
|
post_id: private_topic.first_post.id,
|
|
state: 'editing'
|
|
}
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
|
|
it 'returns the right response when an invalid post_id is given' do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: -9,
|
|
state: 'editing'
|
|
}
|
|
|
|
expect(response.status).to eq(400)
|
|
end
|
|
|
|
it 'publishes the right message for a public topic' do
|
|
freeze_time
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: { topic_id: public_topic.id, state: 'replying' }
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.channel).to eq("/presence/#{public_topic.id}")
|
|
expect(message.data.dig(:user, :id)).to eq(user.id)
|
|
expect(message.data[:published_at]).to eq(Time.zone.now.to_i)
|
|
expect(message.group_ids).to eq(nil)
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publishes the right message for a restricted topic' do
|
|
freeze_time
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_topic.id,
|
|
state: 'replying'
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.channel).to eq("/presence/#{private_topic.id}")
|
|
expect(message.data.dig(:user, :id)).to eq(user.id)
|
|
expect(message.data[:published_at]).to eq(Time.zone.now.to_i)
|
|
expect(message.group_ids).to contain_exactly(group.id)
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publishes the right message for a private message' do
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_message.id,
|
|
state: 'replying'
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(
|
|
group.id,
|
|
Group::AUTO_GROUPS[:staff]
|
|
)
|
|
|
|
expect(message.user_ids).to contain_exactly(
|
|
*private_message.topic_allowed_users.pluck(:user_id)
|
|
)
|
|
end
|
|
|
|
it 'publishes the message to staff group when user is whispering' do
|
|
SiteSetting.enable_whispers = true
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
state: 'replying',
|
|
is_whisper: true
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(Group::AUTO_GROUPS[:staff])
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publishes the message to staff group when staff_only param override is present' do
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
state: 'replying',
|
|
staff_only: true
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(Group::AUTO_GROUPS[:staff])
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publishes the message to staff group when a staff is editing a whisper' do
|
|
SiteSetting.enable_whispers = true
|
|
sign_in(admin)
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: public_topic.first_post.id,
|
|
state: 'editing',
|
|
is_whisper: true
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(Group::AUTO_GROUPS[:staff])
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publishes the message to staff group when a staff is editing a locked post' do
|
|
SiteSetting.enable_whispers = true
|
|
sign_in(admin)
|
|
locked_post = Fabricate(:post, topic: public_topic, locked_by_id: admin.id)
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: locked_post.id,
|
|
state: 'editing',
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(Group::AUTO_GROUPS[:staff])
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publishes the message to author, staff group and TL4 group when editing a public post' do
|
|
post = Fabricate(:post, topic: public_topic, user: user)
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: post.id,
|
|
state: 'editing',
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(
|
|
Group::AUTO_GROUPS[:trust_level_4],
|
|
Group::AUTO_GROUPS[:staff]
|
|
)
|
|
|
|
expect(message.user_ids).to contain_exactly(user.id)
|
|
end
|
|
|
|
it 'publishes the message to author and staff group when editing a public post ' \
|
|
'if SiteSettings.trusted_users_can_edit_others is set to false' do
|
|
|
|
post = Fabricate(:post, topic: public_topic, user: user)
|
|
SiteSetting.trusted_users_can_edit_others = false
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: post.id,
|
|
state: 'editing',
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(Group::AUTO_GROUPS[:staff])
|
|
expect(message.user_ids).to contain_exactly(user.id)
|
|
end
|
|
|
|
it 'publishes the message to SiteSetting.min_trust_to_edit_wiki_post group ' \
|
|
'and staff group when editing a wiki in a public topic' do
|
|
|
|
post = Fabricate(:post, topic: public_topic, user: user, wiki: true)
|
|
SiteSetting.min_trust_to_edit_wiki_post = TrustLevel.levels[:basic]
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
post_id: post.id,
|
|
state: 'editing',
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(
|
|
Group::AUTO_GROUPS[:trust_level_1],
|
|
Group::AUTO_GROUPS[:staff]
|
|
)
|
|
|
|
expect(message.user_ids).to contain_exactly(user.id)
|
|
end
|
|
|
|
it 'publishes the message to author and staff group when editing a private message' do
|
|
post = Fabricate(:post, topic: private_message, user: user)
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_message.id,
|
|
post_id: post.id,
|
|
state: 'editing',
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(
|
|
Group::AUTO_GROUPS[:staff],
|
|
)
|
|
|
|
expect(message.user_ids).to contain_exactly(user.id)
|
|
end
|
|
|
|
it 'publishes the message to users with trust levels of SiteSetting.min_trust_to_edit_wiki_post ' \
|
|
'and staff group when editing a wiki in a private message' do
|
|
|
|
post = Fabricate(:post,
|
|
topic: private_message,
|
|
user: private_message.user,
|
|
wiki: true
|
|
)
|
|
|
|
user2.update!(trust_level: TrustLevel.levels[:newuser])
|
|
group.add(user2)
|
|
|
|
SiteSetting.min_trust_to_edit_wiki_post = TrustLevel.levels[:basic]
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_message.id,
|
|
post_id: post.id,
|
|
state: 'editing',
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(
|
|
Group::AUTO_GROUPS[:staff],
|
|
group.id
|
|
)
|
|
|
|
expect(message.user_ids).to contain_exactly(
|
|
*private_message.allowed_users.pluck(:id)
|
|
)
|
|
end
|
|
|
|
it 'publises the right message when closing composer in public topic' do
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: public_topic.id,
|
|
state: described_class::CLOSED_STATE,
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to eq(nil)
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publises the right message when closing composer in private topic' do
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_topic.id,
|
|
state: described_class::CLOSED_STATE,
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(group.id)
|
|
expect(message.user_ids).to eq(nil)
|
|
end
|
|
|
|
it 'publises the right message when closing composer in private message' do
|
|
post = Fabricate(:post, topic: private_message, user: user)
|
|
|
|
messages = MessageBus.track_publish do
|
|
post '/presence/publish.json', params: {
|
|
topic_id: private_message.id,
|
|
state: described_class::CLOSED_STATE,
|
|
}
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
expect(messages.length).to eq(1)
|
|
|
|
message = messages.first
|
|
|
|
expect(message.group_ids).to contain_exactly(
|
|
Group::AUTO_GROUPS[:staff],
|
|
group.id
|
|
)
|
|
|
|
expect(message.user_ids).to contain_exactly(
|
|
*private_message.allowed_users.pluck(:id)
|
|
)
|
|
end
|
|
end
|
|
end
|
|
end
|