IntenseWebs/discourse
3
0
Fork 0
mirror of https://github.com/discourse/discourse.git synced 2026-08-17 16:35:03 -05:00
Code Issues Packages Projects Releases Wiki Activity

FEATURE: thread pagination (#22624)

Browse Source 
Prior to this commit we were loading a large number of thread messages without any pagination. This commit attempts to fix this and also improves the following points:

- code sharing between channels and threads:
Attempts to reuse/share the code use in channels for threads. To make it possible part of this code has been extracted in dedicated helpers or has been improved to reduce the duplication needed.

Examples of extracted helpers:
- `stackingContextFix`: the ios hack for rendering bug when momentum scrolling is interrupted
- `scrollListToMessage`, `scrollListToTop`, `scrollListToBottom`:  a series of helper to correctly scroll to a specific position in the list of messages

- better general performance of listing messages:
One of the main changes which has been made is to remove the computation of visible message during scroll, it will only happen when needed (update last read for example). This constant recomputation of `message.visible` on intersection observer event while scrolling was consuming a lot of CPU time.
This commit is contained in:
Joffrey JAFFEUX
2023-07-27 09:57:03 +02:00
committed by GitHub
parent 7fb4bd3f43
commit 2d567cee26
105 changed files with 2533 additions and 2576 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/chat/spec/lib/chat/guardian_extensions_spec.rb
+106
View File
@@ -128,6 +128,112 @@ RSpec.describe Chat::GuardianExtensions do
end
end
describe "#can_post_in_chatable?" do
alias_matcher :be_able_to_post_in_chatable, :be_can_post_in_chatable
context "when channel is a category channel" do
context "when post_allowed_category_ids given" do
context "when no chatable given" do
it "returns false" do
expect(guardian).not_to be_able_to_post_in_chatable(
nil,
post_allowed_category_ids: [channel.chatable.id],
)
end
end
context "when user is anonymous" do
it "returns false" do
expect(Guardian.new).not_to be_able_to_post_in_chatable(
channel.chatable,
post_allowed_category_ids: [channel.chatable.id],
)
end
end
context "when user is admin" do
it "returns true" do
guardian = Fabricate(:admin).guardian
expect(guardian).to be_able_to_post_in_chatable(
channel.chatable,
post_allowed_category_ids: [channel.chatable.id],
)
end
end
context "when chatable id is part of allowed ids" do
it "returns true" do
expect(guardian).to be_able_to_post_in_chatable(
channel.chatable,
post_allowed_category_ids: [channel.chatable.id],
)
end
end
context "when chatable id is not part of allowed ids" do
it "returns false" do
expect(guardian).not_to be_able_to_post_in_chatable(
channel.chatable,
post_allowed_category_ids: [-1],
)
end
end
end
context "when no post_allowed_category_ids given" do
context "when no chatable given" do
it "returns false" do
expect(guardian).not_to be_able_to_post_in_chatable(nil)
end
end
context "when user is anonymous" do
it "returns false" do
expect(Guardian.new).not_to be_able_to_post_in_chatable(channel.chatable)
end
end
context "when user is admin" do
it "returns true" do
guardian = Fabricate(:admin).guardian
expect(guardian).to be_able_to_post_in_chatable(channel.chatable)
end
end
context "when chatable id is part of allowed ids" do
it "returns true" do
expect(guardian).to be_able_to_post_in_chatable(channel.chatable)
end
end
context "when user can't post in chatable" do
fab!(:group) { Fabricate(:group) }
fab!(:channel) { Fabricate(:private_category_channel, group: group) }
before do
channel.chatable.category_groups.first.update!(
permission_type: CategoryGroup.permission_types[:readonly],
)
group.add(user)
channel.add(user)
end
it "returns false" do
expect(guardian).not_to be_able_to_post_in_chatable(channel.chatable)
end
end
end
end
context "when channel is a direct message channel" do
let(:channel) { Fabricate(:direct_message_channel) }
it "returns true" do
expect(guardian).to be_able_to_post_in_chatable(channel.chatable)
end
end
end
describe "#can_flag_in_chat_channel?" do
alias_matcher :be_able_to_flag_in_chat_channel, :be_can_flag_in_chat_channel
plugins/chat/spec/plugin_spec.rb
+21
View File
@@ -369,6 +369,27 @@ describe Chat do
expect(serializer.chat_channels[:public_channels][0].id).to eq(channel.id)
end
end
context "when the category is restricted and user has readonly persmissions" do
fab!(:channel_1) { Fabricate(:chat_channel) }
fab!(:group_1) { Fabricate(:group) }
fab!(:private_channel_1) { Fabricate(:private_category_channel, group: group_1) }
before do
private_channel_1.chatable.category_groups.first.update!(
permission_type: CategoryGroup.permission_types[:readonly],
)
group_1.add(user)
channel_1.add(user)
private_channel_1.add(user)
end
it "doesn’t list the associated channel" do
expect(serializer.chat_channels[:public_channels].map(&:id)).to contain_exactly(
channel_1.id,
)
end
end
end
describe "current_user_serializer#has_joinable_public_channels" do
plugins/chat/spec/queries/chat/messages_query_spec.rb
+1
View File
@@ -130,6 +130,7 @@ RSpec.describe Chat::MessagesQuery do
target_date: target_date,
can_load_more_past: false,
can_load_more_future: false,
target_message_id: message_2.id,
)
end
end
plugins/chat/spec/requests/chat/api/channel_messages_controller_spec.rb
+57
View File
@@ -0,0 +1,57 @@
# frozen_string_literal: true
require "rails_helper"
RSpec.describe Chat::Api::ChannelMessagesController do
fab!(:current_user) { Fabricate(:user) }
fab!(:channel) { Fabricate(:chat_channel) }
before do
SiteSetting.chat_enabled = true
SiteSetting.chat_allowed_groups = Group::AUTO_GROUPS[:everyone]
channel.add(current_user)
sign_in(current_user)
end
describe "index" do
describe "success" do
fab!(:message_1) { Fabricate(:chat_message, chat_channel: channel) }
fab!(:message_2) { Fabricate(:chat_message) }
it "works" do
get "/chat/api/channels/#{channel.id}/messages"
expect(response.status).to eq(200)
expect(response.parsed_body["messages"].map { |m| m["id"] }).to contain_exactly(
message_1.id,
)
end
end
context "when channnel doesn’t exist" do
it "returns a 404" do
get "/chat/api/channels/-999/messages"
expect(response.status).to eq(404)
end
end
context "when target message doesn’t exist" do
it "returns a 404" do
get "/chat/api/channels/#{channel.id}/messages?target_message_id=-999"
expect(response.status).to eq(404)
end
end
context "when user can’t see channel" do
fab!(:channel) { Fabricate(:private_category_channel) }
it "returns a 403" do
get "/chat/api/channels/#{channel.id}/messages"
expect(response.status).to eq(403)
end
end
end
end
plugins/chat/spec/requests/chat/api/channel_thread_messages_controller_spec.rb
+77
View File
@@ -0,0 +1,77 @@
# frozen_string_literal: true
require "rails_helper"
RSpec.describe Chat::Api::ChannelThreadMessagesController do
fab!(:current_user) { Fabricate(:user) }
fab!(:thread) do
Fabricate(:chat_thread, channel: Fabricate(:chat_channel, threading_enabled: true))
end
before do
SiteSetting.chat_enabled = true
SiteSetting.chat_allowed_groups = Group::AUTO_GROUPS[:everyone]
thread.channel.add(current_user)
sign_in(current_user)
end
describe "index" do
describe "success" do
fab!(:message_1) { Fabricate(:chat_message, thread: thread) }
fab!(:message_2) { Fabricate(:chat_message) }
it "works" do
get "/chat/api/channels/#{thread.channel.id}/threads/#{thread.id}/messages"
expect(response.status).to eq(200)
expect(response.parsed_body["messages"].map { |m| m["id"] }).to contain_exactly(
thread.original_message.id,
message_1.id,
)
end
end
context "when thread doesn’t exist" do
it "returns a 404" do
get "/chat/api/channels/#{thread.channel.id}/threads/-999/messages"
expect(response.status).to eq(404)
end
end
context "when target message doesn’t exist" do
it "returns a 404" do
get "/chat/api/channels/#{thread.channel.id}/threads/#{thread.id}/messages?target_message_id=-999"
expect(response.status).to eq(404)
end
end
context "when user can’t see channel" do
fab!(:thread) do
Fabricate(
:chat_thread,
channel: Fabricate(:private_category_channel, threading_enabled: true),
)
end
it "returns a 403" do
get "/chat/api/channels/#{thread.channel.id}/threads/#{thread.id}/messages"
expect(response.status).to eq(403)
end
end
context "when channel disabled threading" do
fab!(:thread) do
Fabricate(:chat_thread, channel: Fabricate(:chat_channel, threading_enabled: false))
end
it "returns a 404" do
get "/chat/api/channels/#{thread.channel.id}/threads/#{thread.id}/messages"
expect(response.status).to eq(404)
end
end
end
end
plugins/chat/spec/requests/chat/api/channels_controller_spec.rb
-390
View File
@@ -159,396 +159,6 @@ RSpec.describe Chat::Api::ChannelsController do
end
end
end
context "when include_messages is true" do
fab!(:current_user) { Fabricate(:user) }
fab!(:channel_1) { Fabricate(:category_channel) }
fab!(:other_user) { Fabricate(:user) }
describe "target message lookup" do
let!(:message) { Fabricate(:chat_message, chat_channel: channel_1) }
let(:chatable) { channel_1.chatable }
before { sign_in(current_user) }
context "when the message doesn’t belong to the channel" do
let!(:message) { Fabricate(:chat_message) }
it "returns a 404" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
target_message_id: message.id,
include_messages: true,
}
expect(response.status).to eq(404)
end
end
context "when the chat channel is for a category" do
it "ensures the user can access that category" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
target_message_id: message.id,
include_messages: true,
}
expect(response.status).to eq(200)
expect(response.parsed_body["chat_messages"][0]["id"]).to eq(message.id)
group = Fabricate(:group)
chatable.update!(read_restricted: true)
Fabricate(:category_group, group: group, category: chatable)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
target_message_id: message.id,
include_messages: true,
}
expect(response.status).to eq(403)
GroupUser.create!(user: current_user, group: group)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
target_message_id: message.id,
include_messages: true,
}
expect(response.status).to eq(200)
expect(response.parsed_body["chat_messages"][0]["id"]).to eq(message.id)
end
end
context "when the chat channel is for a direct message channel" do
let(:channel_1) { Fabricate(:direct_message_channel) }
it "ensures the user can access that direct message channel" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
target_message_id: message.id,
include_messages: true,
}
expect(response.status).to eq(403)
Chat::DirectMessageUser.create!(user: current_user, direct_message: chatable)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
target_message_id: message.id,
include_messages: true,
}
expect(response.status).to eq(200)
expect(response.parsed_body["chat_messages"][0]["id"]).to eq(message.id)
end
end
end
describe "messages pagination and direction" do
let(:page_size) { 30 }
message_count = 70
message_count.times do |n|
fab!("message_#{n}") do
Fabricate(
:chat_message,
chat_channel: channel_1,
user: other_user,
message: "message #{n}",
)
end
end
before do
sign_in(current_user)
Group.refresh_automatic_groups!
end
it "errors for user when they are not allowed to chat" do
SiteSetting.chat_allowed_groups = Group::AUTO_GROUPS[:staff]
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.status).to eq(403)
end
it "errors when page size is over the maximum" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: Chat::MessagesQuery::MAX_PAGE_SIZE + 1,
}
expect(response.status).to eq(400)
expect(response.parsed_body["errors"]).to include(
"Page size must be less than or equal to #{Chat::MessagesQuery::MAX_PAGE_SIZE}",
)
end
it "errors when page size is nil" do
get "/chat/api/channels/#{channel_1.id}.json", params: { include_messages: true }
expect(response.status).to eq(400)
expect(response.parsed_body["errors"]).to include("Page size can't be blank")
end
it "returns the latest messages in created_at, id order" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
messages = response.parsed_body["chat_messages"]
expect(messages.count).to eq(page_size)
expect(messages.first["id"]).to eq(message_40.id)
expect(messages.last["id"]).to eq(message_69.id)
end
it "returns `can_flag=true` for public channels" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["can_flag"]).to be true
end
it "returns `can_flag=true` for DM channels" do
dm_chat_channel = Fabricate(:direct_message_channel, users: [current_user, other_user])
get "/chat/api/channels/#{dm_chat_channel.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["can_flag"]).to be true
end
it "returns `can_moderate=true` based on whether the user can moderate the chatable" do
1.upto(4) do |n|
current_user.update!(trust_level: n)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["can_moderate"]).to be false
end
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["can_moderate"]).to be false
current_user.update!(admin: true)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["can_moderate"]).to be true
current_user.update!(admin: false)
SiteSetting.enable_category_group_moderation = true
group = Fabricate(:group)
group.add(current_user)
channel_1.category.update!(reviewable_by_group: group)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["can_moderate"]).to be true
end
it "serializes `user_flag_status` for user who has a pending flag" do
chat_message = channel_1.chat_messages.last
reviewable = flag_message(chat_message, current_user)
score = reviewable.reviewable_scores.last
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["chat_messages"].last["user_flag_status"]).to eq(
score.status_for_database,
)
end
it "doesn't serialize `reviewable_ids` for non-staff" do
reviewable = flag_message(channel_1.chat_messages.last, Fabricate(:admin))
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["chat_messages"].last["reviewable_id"]).to be_nil
end
it "serializes `reviewable_ids` correctly for staff" do
admin = Fabricate(:admin)
sign_in(admin)
reviewable = flag_message(channel_1.chat_messages.last, admin)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["chat_messages"].last["reviewable_id"]).to eq(reviewable.id)
end
it "correctly marks reactions as 'reacted' for the current_user" do
heart_emoji = ":heart:"
smile_emoji = ":smile"
last_message = channel_1.chat_messages.last
last_message.reactions.create(user: current_user, emoji: heart_emoji)
last_message.reactions.create(user: Fabricate(:admin), emoji: smile_emoji)
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
reactions = response.parsed_body["chat_messages"].last["reactions"]
heart_reaction = reactions.find { |r| r["emoji"] == heart_emoji }
expect(heart_reaction["reacted"]).to be true
smile_reaction = reactions.find { |r| r["emoji"] == smile_emoji }
expect(smile_reaction["reacted"]).to be false
end
it "sends the last message bus id for the channel" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
page_size: page_size,
}
expect(response.parsed_body["meta"]["channel_message_bus_last_id"]).not_to eq(nil)
end
describe "scrolling to the past" do
it "returns the correct messages in created_at, id order" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
target_message_id: message_40.id,
page_size: page_size,
direction: Chat::MessagesQuery::PAST,
}
messages = response.parsed_body["chat_messages"]
expect(messages.count).to eq(page_size)
expect(messages.first["id"]).to eq(message_10.id)
expect(messages.last["id"]).to eq(message_39.id)
end
it "returns 'can_load...' properly when there are more past messages" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
target_message_id: message_40.id,
page_size: page_size,
direction: Chat::MessagesQuery::PAST,
}
expect(response.parsed_body["meta"]["can_load_more_past"]).to be true
expect(response.parsed_body["meta"]["can_load_more_future"]).to be_nil
end
it "returns 'can_load...' properly when there are no past messages" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
target_message_id: message_3.id,
page_size: page_size,
direction: Chat::MessagesQuery::PAST,
}
expect(response.parsed_body["meta"]["can_load_more_past"]).to be false
expect(response.parsed_body["meta"]["can_load_more_future"]).to be_nil
end
end
describe "scrolling to the future" do
it "returns the correct messages in created_at, id order when there are many after" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
target_message_id: message_10.id,
page_size: page_size,
direction: Chat::MessagesQuery::FUTURE,
}
messages = response.parsed_body["chat_messages"]
expect(messages.count).to eq(page_size)
expect(messages.first["id"]).to eq(message_11.id)
expect(messages.last["id"]).to eq(message_40.id)
end
it "return 'can_load..' properly when there are future messages" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
target_message_id: message_10.id,
page_size: page_size,
direction: Chat::MessagesQuery::FUTURE,
}
expect(response.parsed_body["meta"]["can_load_more_past"]).to be_nil
expect(response.parsed_body["meta"]["can_load_more_future"]).to be true
end
it "returns 'can_load..' properly when there are no future messages" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
include_messages: true,
target_message_id: message_60.id,
page_size: page_size,
direction: Chat::MessagesQuery::FUTURE,
}
expect(response.parsed_body["meta"]["can_load_more_past"]).to be_nil
expect(response.parsed_body["meta"]["can_load_more_future"]).to be false
end
end
describe "without direction (latest messages)" do
it "signals there are no future messages" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
page_size: page_size,
include_messages: true,
}
expect(response.parsed_body["meta"]["can_load_more_future"]).to eq(false)
end
it "signals there are more messages in the past" do
get "/chat/api/channels/#{channel_1.id}.json",
params: {
page_size: page_size,
include_messages: true,
}
expect(response.parsed_body["meta"]["can_load_more_past"]).to eq(true)
end
it "signals there are no more messages" do
new_channel = Fabricate(:category_channel)
Fabricate(
:chat_message,
chat_channel: new_channel,
user: other_user,
message: "message",
)
chat_messages_qty = 1
get "/chat/api/channels/#{new_channel.id}.json",
params: {
page_size: chat_messages_qty + 1,
include_messages: true,
}
expect(response.parsed_body["meta"]["can_load_more_past"]).to eq(false)
end
end
end
end
end
describe "#destroy" do
plugins/chat/spec/requests/core_ext/latest_performance_spec.rb
+2 -13
View File
@@ -15,13 +15,7 @@ describe ListController do
Fabricate(:direct_message_channel, users: [current_user, user_1])
public_channel_1 = Fabricate(:chat_channel)
public_channel_2 = Fabricate(:chat_channel)
Fabricate(
:user_chat_channel_membership,
user: current_user,
chat_channel: public_channel_1,
following: true,
)
public_channel_1.add(current_user)
# warm up
get "/latest.html"
@@ -41,12 +35,7 @@ describe ListController do
end
end.count
Fabricate(
:user_chat_channel_membership,
user: current_user,
chat_channel: public_channel_2,
following: true,
)
public_channel_2.add(current_user)
user_2 = Fabricate(:user)
Fabricate(:direct_message_channel, users: [current_user, user_2])
plugins/chat/spec/serializer/chat/structured_channel_serializer_spec.rb
+1
View File
@@ -179,6 +179,7 @@ RSpec.describe Chat::StructuredChannelSerializer do
kick_message_bus_last_id: 0,
channel_message_bus_last_id: 0,
can_join_chat_channel: true,
post_allowed_category_ids: nil,
)
.once
described_class.new(data, scope: guardian).as_json
plugins/chat/spec/services/chat/channel_view_builder_spec.rb
-368
View File
@@ -1,368 +0,0 @@
# frozen_string_literal: true
RSpec.describe Chat::ChannelViewBuilder do
describe Chat::ChannelViewBuilder::Contract, type: :model do
it { is_expected.to validate_presence_of :channel_id }
it do
is_expected.to validate_inclusion_of(
:direction,
).in_array Chat::MessagesQuery::VALID_DIRECTIONS
end
end
describe ".call" do
subject(:result) { described_class.call(params) }
fab!(:current_user) { Fabricate(:user) }
fab!(:channel) { Fabricate(:category_channel) }
let(:channel_id) { channel.id }
let(:guardian) { current_user.guardian }
let(:target_message_id) { nil }
let(:page_size) { 10 }
let(:direction) { nil }
let(:thread_id) { nil }
let(:fetch_from_last_read) { nil }
let(:target_date) { nil }
let(:params) do
{
guardian: guardian,
channel_id: channel_id,
target_message_id: target_message_id,
fetch_from_last_read: fetch_from_last_read,
page_size: page_size,
direction: direction,
thread_id: thread_id,
target_date: target_date,
}
end
before { channel.add(current_user) }
it "threads_enabled is false by default" do
expect(result.threads_enabled).to eq(false)
end
it "include_thread_messages is true by default" do
expect(result.include_thread_messages).to eq(true)
end
it "queries messages" do
Chat::MessagesQuery
.expects(:call)
.with(
channel: channel,
guardian: guardian,
target_message_id: target_message_id,
thread_id: thread_id,
include_thread_messages: true,
page_size: page_size,
direction: direction,
target_date: target_date,
)
.returns({ messages: [] })
result
end
it "returns channel messages and thread replies" do
message_1 = Fabricate(:chat_message, chat_channel: channel)
message_2 = Fabricate(:chat_message, chat_channel: channel)
message_3 =
Fabricate(
:chat_message,
chat_channel: channel,
thread: Fabricate(:chat_thread, channel: channel),
)
expect(result.view.chat_messages).to eq(
[message_1, message_2, message_3.thread.original_message, message_3],
)
end
it "updates the channel membership last_viewed_at" do
membership = channel.membership_for(current_user)
membership.update!(last_viewed_at: 1.day.ago)
old_last_viewed_at = membership.last_viewed_at
result
expect(membership.reload.last_viewed_at).not_to eq_time(old_last_viewed_at)
end
it "does not query thread tracking overview or state by default" do
Chat::TrackingStateReportQuery.expects(:call).never
result
end
it "does not query threads by default" do
Chat::Thread.expects(:where).never
result
end
it "returns a Chat::View" do
expect(result.view).to be_a(Chat::View)
end
context "when page_size is null" do
let(:page_size) { nil }
it { is_expected.to fail_a_contract }
end
context "when page_size is too big" do
let(:page_size) { Chat::MessagesQuery::MAX_PAGE_SIZE + 1 }
it { is_expected.to fail_a_contract }
end
context "when channel has threading_enabled true" do
before { channel.update!(threading_enabled: true) }
it "threads_enabled is true" do
expect(result.threads_enabled).to eq(true)
end
it "include_thread_messages is false" do
expect(result.include_thread_messages).to eq(false)
end
it "returns channel messages but not thread replies" do
message_1 = Fabricate(:chat_message, chat_channel: channel)
message_2 = Fabricate(:chat_message, chat_channel: channel)
message_3 =
Fabricate(
:chat_message,
chat_channel: channel,
thread: Fabricate(:chat_thread, channel: channel),
)
expect(result.view.chat_messages).to eq(
[message_1, message_2, message_3.thread.original_message],
)
end
it "fetches threads for any messages that have a thread id" do
message_1 =
Fabricate(
:chat_message,
chat_channel: channel,
thread: Fabricate(:chat_thread, channel: channel),
)
expect(result.view.threads).to eq([message_1.thread])
end
it "fetches thread memberships for the current user for fetched threads" do
message_1 =
Fabricate(
:chat_message,
chat_channel: channel,
thread: Fabricate(:chat_thread, channel: channel),
)
message_1.thread.add(current_user)
expect(result.view.thread_memberships).to eq(
[message_1.thread.membership_for(current_user)],
)
end
it "calls the tracking state report query for thread overview and tracking" do
thread = Fabricate(:chat_thread, channel: channel)
message_1 = Fabricate(:chat_message, chat_channel: channel, thread: thread)
::Chat::TrackingStateReportQuery
.expects(:call)
.with(
guardian: guardian,
channel_ids: [channel.id],
include_threads: true,
include_read: false,
include_last_reply_details: true,
)
.returns(Chat::TrackingStateReport.new)
.once
::Chat::TrackingStateReportQuery
.expects(:call)
.with(guardian: guardian, thread_ids: [thread.id], include_threads: true)
.returns(Chat::TrackingStateReport.new)
.once
result
end
it "fetches an overview of threads with unread messages in the channel" do
thread = Fabricate(:chat_thread, channel: channel)
thread.add(current_user)
message_1 = Fabricate(:chat_message, chat_channel: channel, thread: thread)
expect(result.view.unread_thread_overview).to eq({ thread.id => message_1.created_at })
end
it "fetches the tracking state of threads in the channel" do
thread = Fabricate(:chat_thread, channel: channel)
thread.add(current_user)
Fabricate(:chat_message, chat_channel: channel, thread: thread)
expect(result.view.tracking.thread_tracking).to eq(
{ thread.id => { channel_id: channel.id, unread_count: 1, mention_count: 0 } },
)
end
context "when a thread_id is provided" do
let(:thread_id) { Fabricate(:chat_thread, channel: channel).id }
it "include_thread_messages is true" do
expect(result.include_thread_messages).to eq(true)
end
end
end
context "when channel is not found" do
before { channel.destroy! }
it { is_expected.to fail_to_find_a_model(:channel) }
end
context "when user cannot access the channel" do
fab!(:channel) { Fabricate(:private_category_channel) }
it { is_expected.to fail_a_policy(:can_view_channel) }
end
context "when fetch_from_last_read is true" do
let(:fetch_from_last_read) { true }
fab!(:message) { Fabricate(:chat_message, chat_channel: channel) }
fab!(:past_message_1) do
msg = Fabricate(:chat_message, chat_channel: channel)
msg.update!(created_at: message.created_at - 1.day)
msg
end
fab!(:past_message_2) do
msg = Fabricate(:chat_message, chat_channel: channel)
msg.update!(created_at: message.created_at - 2.days)
msg
end
context "when page_size is null" do
let(:page_size) { nil }
it { is_expected.not_to fail_a_contract }
end
context "if the user is not a member of the channel" do
it "does not error and still returns messages" do
expect(result.view.chat_messages).to eq([past_message_2, past_message_1, message])
end
end
context "if the user is a member of the channel" do
fab!(:membership) do
Fabricate(:user_chat_channel_membership, user: current_user, chat_channel: channel)
end
context "if the user's last_read_message_id is not nil" do
before { membership.update!(last_read_message_id: past_message_1.id) }
it "uses the last_read_message_id of the user's membership as the target_message_id" do
expect(result.view.chat_messages).to eq([past_message_2, past_message_1, message])
end
end
context "if the user's last_read_message_id is nil" do
before { membership.update!(last_read_message_id: nil) }
it "does not error and still returns messages" do
expect(result.view.chat_messages).to eq([past_message_2, past_message_1, message])
end
context "if page_size is nil" do
let(:page_size) { nil }
it "calls the messages query with the default page size" do
::Chat::MessagesQuery
.expects(:call)
.with(has_entries(page_size: Chat::MessagesQuery::MAX_PAGE_SIZE))
.once
.returns({ messages: [] })
result
end
end
end
end
end
context "when target_message_id provided" do
fab!(:message) { Fabricate(:chat_message, chat_channel: channel) }
fab!(:past_message) do
msg = Fabricate(:chat_message, chat_channel: channel)
msg.update!(created_at: message.created_at - 1.day)
msg
end
fab!(:future_message) do
msg = Fabricate(:chat_message, chat_channel: channel)
msg.update!(created_at: message.created_at + 1.day)
msg
end
let(:target_message_id) { message.id }
it "includes the target message as well as past and future messages" do
expect(result.view.chat_messages).to eq([past_message, message, future_message])
end
context "when page_size is null" do
let(:page_size) { nil }
it { is_expected.not_to fail_a_contract }
end
context "when the target message is a thread reply" do
fab!(:thread) { Fabricate(:chat_thread, channel: channel) }
before { message.update!(thread: thread) }
it "includes it by default" do
expect(result.view.chat_messages).to eq(
[past_message, message, thread.original_message, future_message],
)
end
context "when not including thread messages" do
before { channel.update!(threading_enabled: true) }
it "does not include the target message" do
expect(result.view.chat_messages).to eq(
[past_message, thread.original_message, future_message],
)
end
end
end
context "when the message does not exist" do
before { message.trash! }
it { is_expected.to fail_a_policy(:target_message_exists) }
context "when the user is the owner of the trashed message" do
before { message.update!(user: current_user) }
it { is_expected.not_to fail_a_policy(:target_message_exists) }
end
context "when the user is admin" do
before { current_user.update!(admin: true) }
it { is_expected.not_to fail_a_policy(:target_message_exists) }
end
end
end
context "when target_date provided" do
fab!(:past_message) do
msg = Fabricate(:chat_message, chat_channel: channel)
msg.update!(created_at: 3.days.ago)
msg
end
fab!(:future_message) do
msg = Fabricate(:chat_message, chat_channel: channel)
msg.update!(created_at: 1.days.ago)
msg
end
let(:target_date) { 2.days.ago }
it "includes past and future messages" do
expect(result.view.chat_messages).to eq([past_message, future_message])
end
end
end
end
plugins/chat/spec/services/chat/list_channel_messages_spec.rb
+193
View File
@@ -0,0 +1,193 @@
# frozen_string_literal: true
RSpec.describe Chat::ListChannelMessages do
subject(:result) { described_class.call(params) }
fab!(:user) { Fabricate(:user) }
fab!(:channel) { Fabricate(:chat_channel) }
let(:guardian) { Guardian.new(user) }
let(:channel_id) { channel.id }
let(:optional_params) { {} }
let(:params) { { guardian: guardian, channel_id: channel_id }.merge(optional_params) }
before { channel.add(user) }
context "when contract" do
context "when channel_id is not present" do
let(:channel_id) { nil }
it { is_expected.to fail_a_contract }
end
end
context "when fetch_channel" do
context "when channel doesn’t exist" do
let(:channel_id) { -1 }
it { is_expected.to fail_to_find_a_model(:channel) }
end
context "when channel exists" do
it "finds the correct channel" do
expect(result.channel).to eq(channel)
end
end
end
context "when fetch_eventual_membership" do
context "when user has membership" do
it "finds the correct membership" do
expect(result.membership).to eq(channel.membership_for(user))
end
end
context "when user has no membership" do
before { channel.membership_for(user).destroy! }
it "finds no membership" do
expect(result.membership).to be_blank
end
end
end
context "when enabled_threads?" do
context "when channel threading is disabled" do
before { channel.update!(threading_enabled: false) }
it "marks threads as disabled" do
expect(result.enabled_threads).to eq(false)
end
end
context "when channel and site setting are enabling threading" do
before { channel.update!(threading_enabled: true) }
it "marks threads as enabled" do
expect(result.enabled_threads).to eq(true)
end
end
end
context "when determine_target_message_id" do
context "when fetch_from_last_read is true" do
let(:optional_params) { { fetch_from_last_read: true } }
before do
channel.add(user)
channel.membership_for(user).update!(last_read_message_id: 1)
end
it "sets target_message_id to last_read_message_id" do
expect(result.target_message_id).to eq(1)
end
end
end
context "when target_message_exists" do
context "when no target_message_id is given" do
it { is_expected.to be_a_success }
end
context "when target message is not found" do
let(:optional_params) { { target_message_id: -1 } }
it { is_expected.to fail_a_policy(:target_message_exists) }
end
context "when target message is found" do
fab!(:target_message) { Fabricate(:chat_message, chat_channel: channel) }
let(:optional_params) { { target_message_id: target_message.id } }
it { is_expected.to be_a_success }
end
context "when target message is trashed" do
fab!(:target_message) { Fabricate(:chat_message, chat_channel: channel) }
let(:optional_params) { { target_message_id: target_message.id } }
before { target_message.trash! }
context "when user is regular" do
it { is_expected.to fail_a_policy(:target_message_exists) }
end
context "when user is the message creator" do
fab!(:target_message) { Fabricate(:chat_message, chat_channel: channel, user: user) }
it { is_expected.to be_a_success }
end
context "when user is admin" do
fab!(:user) { Fabricate(:admin) }
it { is_expected.to be_a_success }
end
end
end
context "when fetch_messages" do
context "with no params" do
fab!(:messages) { Fabricate.times(20, :chat_message, chat_channel: channel) }
it "returns messages" do
expect(result.can_load_more_past).to eq(false)
expect(result.can_load_more_future).to eq(false)
expect(result.messages).to contain_exactly(*messages)
end
end
context "when target_date is provided" do
fab!(:past_message) do
Fabricate(:chat_message, chat_channel: channel, created_at: 3.days.ago)
end
fab!(:future_message) do
Fabricate(:chat_message, chat_channel: channel, created_at: 1.days.ago)
end
let(:optional_params) { { target_date: 2.days.ago } }
it "includes past and future messages" do
expect(result.messages).to eq([past_message, future_message])
end
end
end
context "when fetch_tracking" do
context "when threads are disabled" do
fab!(:thread_1) { Fabricate(:chat_thread, channel: channel) }
before { channel.update!(threading_enabled: false) }
it "returns empty tracking" do
expect(result.tracking).to eq({})
end
end
context "when threads are enabled" do
fab!(:thread_1) { Fabricate(:chat_thread, channel: channel) }
before do
channel.update!(threading_enabled: true)
thread_1.add(user)
end
it "returns tracking" do
Fabricate(:chat_message, chat_channel: channel, thread: thread_1)
expect(result.tracking.channel_tracking).to eq({})
expect(result.tracking.thread_tracking).to eq(
{ thread_1.id => { channel_id: channel.id, mention_count: 0, unread_count: 1 } },
)
end
end
end
context "when update_membership_last_viewed_at" do
it "updates the last viewed at" do
expect { result }.to change { channel.membership_for(user).last_viewed_at }.to be_within(
1.second,
).of(Time.zone.now)
end
end
end
plugins/chat/spec/services/chat/list_channel_thread_messages_spec.rb
+168
View File
@@ -0,0 +1,168 @@
# frozen_string_literal: true
RSpec.describe Chat::ListChannelThreadMessages do
subject(:result) { described_class.call(params) }
fab!(:user) { Fabricate(:user) }
fab!(:thread) do
Fabricate(:chat_thread, channel: Fabricate(:chat_channel, threading_enabled: true))
end
let(:guardian) { Guardian.new(user) }
let(:thread_id) { thread.id }
let(:optional_params) { {} }
let(:params) { { guardian: guardian, thread_id: thread_id }.merge(optional_params) }
before { thread.channel.add(user) }
context "when contract" do
context "when thread_id is not present" do
let(:thread_id) { nil }
it { is_expected.to fail_a_contract }
end
end
context "when fetch_thread" do
context "when thread doesn’t exist" do
let(:thread_id) { -1 }
it { is_expected.to fail_to_find_a_model(:thread) }
end
context "when thread exists" do
it "finds the correct channel" do
expect(result.thread).to eq(thread)
end
end
end
context "when ensure_thread_enabled?" do
context "when channel threading is disabled" do
before { thread.channel.update!(threading_enabled: false) }
it { is_expected.to fail_a_policy(:ensure_thread_enabled) }
end
context "when channel and site setting are enabling threading" do
before { thread.channel.update!(threading_enabled: true) }
it { is_expected.to be_a_success }
end
end
context "when can_view_thread" do
context "when channel is private" do
fab!(:thread) do
Fabricate(
:chat_thread,
channel: Fabricate(:private_category_channel, threading_enabled: true),
)
end
it { is_expected.to fail_a_policy(:can_view_thread) }
end
end
context "when determine_target_message_id" do
context "when fetch_from_last_read is true" do
let(:optional_params) { { fetch_from_last_read: true } }
before do
thread.add(user)
thread.membership_for(guardian.user).update!(last_read_message_id: 1)
end
it "sets target_message_id to last_read_message_id" do
expect(result.target_message_id).to eq(1)
end
end
end
context "when target_message_exists" do
context "when no target_message_id is given" do
it { is_expected.to be_a_success }
end
context "when target message is not found" do
let(:optional_params) { { target_message_id: -1 } }
it { is_expected.to fail_a_policy(:target_message_exists) }
end
context "when target message is found" do
fab!(:target_message) do
Fabricate(:chat_message, chat_channel: thread.channel, thread: thread)
end
let(:optional_params) { { target_message_id: target_message.id } }
it { is_expected.to be_a_success }
end
context "when target message is trashed" do
fab!(:target_message) do
Fabricate(:chat_message, chat_channel: thread.channel, thread: thread)
end
let(:optional_params) { { target_message_id: target_message.id } }
before { target_message.trash! }
context "when user is regular" do
it { is_expected.to fail_a_policy(:target_message_exists) }
end
context "when user is the message creator" do
fab!(:target_message) do
Fabricate(:chat_message, chat_channel: thread.channel, thread: thread, user: user)
end
it { is_expected.to be_a_success }
end
context "when user is admin" do
fab!(:user) { Fabricate(:admin) }
it { is_expected.to be_a_success }
end
end
end
context "when fetch_messages" do
context "with not params" do
fab!(:messages) do
Fabricate.times(20, :chat_message, chat_channel: thread.channel, thread: thread)
end
it "returns messages" do
expect(result.can_load_more_past).to eq(false)
expect(result.can_load_more_future).to eq(false)
expect(result.messages).to contain_exactly(thread.original_message, *messages)
end
end
context "when target_date is provided" do
fab!(:past_message) do
Fabricate(
:chat_message,
chat_channel: thread.channel,
thread: thread,
created_at: 1.days.from_now,
)
end
fab!(:future_message) do
Fabricate(
:chat_message,
chat_channel: thread.channel,
thread: thread,
created_at: 3.days.from_now,
)
end
let(:optional_params) { { target_date: 2.days.ago } }
it "includes past and future messages" do
expect(result.messages).to eq([thread.original_message, past_message, future_message])
end
end
end
end
plugins/chat/spec/system/chat_channel_spec.rb
+4 -18
View File
@@ -16,16 +16,7 @@ RSpec.describe "Chat channel", type: :system do
end
context "when first batch of messages doesnt fill page" do
before do
50.times do
Fabricate(
:chat_message,
message: Faker::Lorem.characters(number: SiteSetting.chat_minimum_message_length),
user: current_user,
chat_channel: channel_1,
)
end
end
before { 30.times { Fabricate(:chat_message, user: current_user, chat_channel: channel_1) } }
it "autofills for more messages" do
chat.prefers_full_page
@@ -105,7 +96,7 @@ RSpec.describe "Chat channel", type: :system do
expect(channel_page).to have_no_loading_skeleton
expect(page).to have_no_css("[data-id='#{unloaded_message.id}']")
find(".chat-scroll-to-bottom").click
find(".chat-scroll-to-bottom__button.visible").click
expect(channel_page).to have_no_loading_skeleton
expect(page).to have_css("[data-id='#{unloaded_message.id}']")
@@ -131,15 +122,10 @@ RSpec.describe "Chat channel", type: :system do
50.times { Fabricate(:chat_message, chat_channel: channel_1) }
end
it "doesn’t scroll the pane" do
xit "doesn’t scroll the pane" do
visit("/chat/message/#{message_1.id}")
new_message =
Chat::MessageCreator.create(
chat_channel: channel_1,
user: other_user,
content: "this is fine",
).chat_message
new_message = Fabricate(:chat_message, chat_channel: channel_1)
expect(page).to have_no_content(new_message.message)
end
plugins/chat/spec/system/chat_message/thread_spec.rb
+15 -16
View File
@@ -2,47 +2,46 @@
RSpec.describe "Chat message - thread", type: :system do
fab!(:current_user) { Fabricate(:user) }
fab!(:other_user) { Fabricate(:user) }
fab!(:channel_1) { Fabricate(:chat_channel) }
fab!(:thread_1) do
chat_thread_chain_bootstrap(channel: channel_1, users: [current_user, other_user])
fab!(:channel_1) { Fabricate(:chat_channel, threading_enabled: true) }
fab!(:thread_message_1) do
message_1 = Fabricate(:chat_message, chat_channel: channel_1)
Fabricate(:chat_message, chat_channel: channel_1, in_reply_to: message_1)
end
let(:cdp) { PageObjects::CDP.new }
let(:chat) { PageObjects::Pages::Chat.new }
let(:chat_page) { PageObjects::Pages::Chat.new }
let(:thread_page) { PageObjects::Pages::ChatThread.new }
let(:message_1) { thread_1.chat_messages.first }
before do
chat_system_bootstrap
channel_1.update!(threading_enabled: true)
channel_1.add(current_user)
channel_1.add(other_user)
sign_in(current_user)
end
context "when hovering a message" do
it "adds an active class" do
first_message = thread_1.chat_messages.first
chat.visit_thread(thread_1)
chat_page.visit_thread(thread_message_1.thread)
thread_page.hover_message(first_message)
thread_page.hover_message(thread_message_1)
expect(page).to have_css(
".chat-thread[data-id='#{thread_1.id}'] [data-id='#{first_message.id}'].chat-message-container.-active",
".chat-thread[data-id='#{thread_message_1.thread.id}'] [data-id='#{thread_message_1.id}'].chat-message-container.-active",
)
end
end
context "when copying link to a message" do
let(:cdp) { PageObjects::CDP.new }
before { cdp.allow_clipboard }
it "copies the link to the thread" do
chat.visit_thread(thread_1)
chat_page.visit_thread(thread_message_1.thread)
thread_page.copy_link(message_1)
thread_page.copy_link(thread_message_1)
expect(cdp.read_clipboard).to include("/chat/c/-/#{channel_1.id}/t/#{thread_1.id}")
expect(cdp.read_clipboard).to include(
"/chat/c/-/#{channel_1.id}/t/#{thread_message_1.thread.id}/#{thread_message_1.id}",
)
end
end
end
plugins/chat/spec/system/dates_separators_spec.rb
+3 -3
View File
@@ -15,11 +15,11 @@ RSpec.describe "Dates separators", type: :system do
context "when today separator is out of screen" do
before do
20.times { Fabricate(:chat_message, chat_channel: channel_1, created_at: 1.day.ago) }
25.times { Fabricate(:chat_message, chat_channel: channel_1) }
15.times { Fabricate(:chat_message, chat_channel: channel_1, created_at: 1.day.ago) }
30.times { Fabricate(:chat_message, chat_channel: channel_1) }
end
it "shows it as a sticky date" do
xit "shows it as a sticky date" do
chat_page.visit_channel(channel_1)
expect(page.find(".chat-message-separator__text-container.is-pinned")).to have_content(
plugins/chat/spec/system/deleted_message_spec.rb
+23 -8
View File
@@ -104,33 +104,48 @@ RSpec.describe "Deleted message", type: :system do
let(:open_thread) { PageObjects::Pages::ChatThread.new }
fab!(:other_user) { Fabricate(:user) }
fab!(:message_1) { Fabricate(:chat_message, chat_channel: channel_1, user: other_user) }
fab!(:message_2) { Fabricate(:chat_message, chat_channel: channel_1, user: other_user) }
fab!(:message_3) { Fabricate(:chat_message, chat_channel: channel_1, user: other_user) }
fab!(:thread_1) { Fabricate(:chat_thread, channel: channel_1, original_message: message_3) }
fab!(:thread) { Fabricate(:chat_thread, channel: channel_1) }
fab!(:message_4) do
Fabricate(:chat_message, chat_channel: channel_1, user: other_user, thread: thread)
Fabricate(
:chat_message,
in_reply_to_id: message_3.id,
chat_channel: channel_1,
user: other_user,
thread_id: thread_1.id,
)
end
fab!(:message_5) do
Fabricate(:chat_message, chat_channel: channel_1, user: other_user, thread: thread)
Fabricate(
:chat_message,
in_reply_to_id: message_3.id,
chat_channel: channel_1,
user: other_user,
thread_id: thread_1.id,
)
end
before do
channel_1.update!(threading_enabled: true)
chat_system_user_bootstrap(user: other_user, channel: channel_1)
Chat::Thread.update_counts
thread_1.add(current_user)
end
it "hides the deleted messages" do
chat_page.visit_channel(channel_1)
channel_page.message_thread_indicator(thread.original_message).click
expect(side_panel).to have_open_thread(thread)
channel_page.message_thread_indicator(message_3).click
expect(side_panel).to have_open_thread(message_3.thread)
expect(channel_page.messages).to have_message(id: message_2.id)
expect(channel_page.messages).to have_message(id: message_1.id)
expect(open_thread.messages).to have_message(thread_id: thread.id, id: message_4.id)
expect(open_thread.messages).to have_message(thread_id: thread.id, id: message_5.id)
expect(open_thread.messages).to have_message(thread_id: thread_1.id, id: message_4.id)
expect(open_thread.messages).to have_message(thread_id: thread_1.id, id: message_5.id)
Chat::Publisher.publish_bulk_delete!(
channel_1,
@@ -139,7 +154,7 @@ RSpec.describe "Deleted message", type: :system do
expect(channel_page.messages).to have_no_message(id: message_1.id)
expect(channel_page.messages).to have_deleted_message(message_2, count: 2)
expect(open_thread.messages).to have_no_message(thread_id: thread.id, id: message_4.id)
expect(open_thread.messages).to have_no_message(thread_id: thread_1.id, id: message_4.id)
expect(open_thread.messages).to have_deleted_message(message_5, count: 2)
end
end
plugins/chat/spec/system/hashtag_autocomplete_spec.rb
+5 -1
View File
@@ -64,7 +64,9 @@ describe "Using #hashtag autocompletion to search for and lookup channels", type
)
expect(message).not_to eq(nil)
end
expect(chat_channel_page).to have_message(id: message.id)
expect(chat_channel_page.messages).to have_message(id: message.id)
expect(page).to have_css(".hashtag-cooked[aria-label]", count: 3)
cooked_hashtags = page.all(".hashtag-cooked", count: 3)
@@ -158,11 +160,13 @@ describe "Using #hashtag autocompletion to search for and lookup channels", type
it "shows a default color and css class for the channel icon in a post" do
topic_page.visit_topic(topic, post_number: post_with_private_category.post_number)
expect(page).to have_css(".hashtag-cooked")
expect(page).to have_css(".hashtag-cooked .hashtag-missing")
end
it "shows a default color and css class for the channel icon in a channel" do
chat_page.visit_channel(channel1)
expect(page).to have_css(".hashtag-cooked")
expect(page).to have_css(".hashtag-cooked .hashtag-missing")
end
end
plugins/chat/spec/system/page_objects/chat/chat.rb
+1
View File
@@ -50,6 +50,7 @@ module PageObjects
def visit_thread(thread)
visit(thread.url)
has_css?(".chat-skeleton")
has_no_css?(".chat-skeleton")
end
plugins/chat/spec/system/page_objects/chat/chat_channel.rb
-1
View File
@@ -142,7 +142,6 @@ module PageObjects
text = text.chomp if text.present? # having \n on the end of the string counts as an Enter keypress
composer.fill_in(with: text)
click_send_message
click_composer
text
end
plugins/chat/spec/system/page_objects/chat/components/message.rb
+1 -1
View File
@@ -7,7 +7,7 @@ module PageObjects
attr_reader :context
attr_reader :component
SELECTOR = ".chat-message-container"
SELECTOR = ".chat-message-container:not(.has-thread-indicator)"
def initialize(context)
@context = context
plugins/chat/spec/system/react_to_message_spec.rb
+1 -1
View File
@@ -70,7 +70,7 @@ RSpec.describe "React to message", type: :system do
end
context "when current user has multiple sessions" do
it "adds reaction on each session" do
xit "adds reaction on each session" do
reaction = "grimacing"
sign_in(current_user)
plugins/chat/spec/system/reply_to_message/full_page_spec.rb
+7 -14
View File
@@ -57,17 +57,11 @@ RSpec.describe "Reply to message - channel - full page", type: :system do
context "when the message has an existing thread" do
fab!(:message_1) do
creator =
Chat::MessageCreator.new(
chat_channel: channel_1,
in_reply_to_id: original_message.id,
user: Fabricate(:user),
content: Faker::Lorem.paragraph,
)
creator.create
creator.chat_message
Fabricate(:chat_message, chat_channel: channel_1, in_reply_to: original_message)
end
before { original_message.thread.add(current_user) }
it "replies to the existing thread" do
chat_page.visit_channel(channel_1)
@@ -77,13 +71,12 @@ RSpec.describe "Reply to message - channel - full page", type: :system do
expect(side_panel_page).to have_open_thread
thread_page.fill_composer("reply to message")
thread_page.click_send_message
message = thread_page.send_message
expect(thread_page).to have_message(text: message_1.message)
expect(thread_page).to have_message(text: "reply to message")
expect(thread_page.messages).to have_message(text: message_1.message)
expect(thread_page.messages).to have_message(text: message)
expect(channel_page.message_thread_indicator(original_message)).to have_reply_count(2)
expect(channel_page).to have_no_message(text: "reply to message")
expect(channel_page.messages).to have_no_message(text: message)
end
end
plugins/chat/spec/system/select_message/thread_spec.rb
+22 -7
View File
@@ -3,6 +3,7 @@
RSpec.describe "Chat | Select message | thread", type: :system do
fab!(:current_user) { Fabricate(:user) }
fab!(:channel_1) { Fabricate(:chat_channel, threading_enabled: true) }
fab!(:thread_1) { Fabricate(:chat_thread, channel: channel_1) }
fab!(:original_message) { Fabricate(:chat_message, chat_channel: channel_1) }
let(:chat_page) { PageObjects::Pages::Chat.new }
@@ -16,19 +17,33 @@ RSpec.describe "Chat | Select message | thread", type: :system do
end
fab!(:thread_message_1) do
Fabricate(:chat_message, chat_channel: channel_1, in_reply_to: original_message)
Fabricate(
:chat_message,
thread_id: thread_1.id,
chat_channel: channel_1,
in_reply_to: original_message,
)
end
fab!(:thread_message_2) do
Fabricate(:chat_message, chat_channel: channel_1, in_reply_to: original_message)
Fabricate(
:chat_message,
thread_id: thread_1.id,
chat_channel: channel_1,
in_reply_to: original_message,
)
end
fab!(:thread_message_3) do
Fabricate(:chat_message, chat_channel: channel_1, in_reply_to: original_message)
Fabricate(
:chat_message,
thread_id: thread_1.id,
chat_channel: channel_1,
in_reply_to: original_message,
)
end
before { channel_1.update!(threading_enabled: true) }
it "can select multiple messages" do
chat_page.visit_thread(thread_message_1.thread)
chat_page.visit_thread(thread_1)
thread_page.messages.select(thread_message_1)
thread_page.messages.select(thread_message_2)
@@ -36,7 +51,7 @@ RSpec.describe "Chat | Select message | thread", type: :system do
end
it "can shift + click to select messages between the first and last" do
chat_page.visit_thread(thread_message_1.thread)
chat_page.visit_thread(thread_1)
thread_page.messages.select(thread_message_1)
thread_page.messages.shift_select(thread_message_3)
plugins/chat/spec/system/thread_list/full_page_spec.rb
+8
View File
@@ -133,6 +133,14 @@ describe "Thread list in side panel | full page", type: :system do
end
describe "deleting and restoring the original message of the thread" do
fab!(:thread_1) do
chat_thread_chain_bootstrap(
channel: channel,
messages_count: 2,
users: [current_user, other_user],
)
end
before do
thread_1.update!(original_message_user: other_user)
thread_1.original_message.update!(user: other_user)
plugins/chat/spec/system/visit_channel_spec.rb
+24
View File
@@ -11,7 +11,9 @@ RSpec.describe "Visit channel", type: :system do
fab!(:inaccessible_dm_channel_1) { Fabricate(:direct_message_channel) }
let(:chat) { PageObjects::Pages::Chat.new }
let(:sidebar_page) { PageObjects::Pages::Sidebar.new }
let(:channel_page) { PageObjects::Pages::ChatChannel.new }
let(:dialog) { PageObjects::Components::Dialog.new }
before { chat_system_bootstrap }
@@ -177,6 +179,28 @@ RSpec.describe "Visit channel", type: :system do
)
end
end
context "when visiting a specific channel message ID then navigating to another channel" do
fab!(:early_message) { Fabricate(:chat_message, chat_channel: category_channel_1) }
fab!(:other_channel) do
Fabricate(:category_channel, category: category_channel_1.chatable)
end
fab!(:other_channel_message) { Fabricate(:chat_message, chat_channel: other_channel) }
before do
30.times { Fabricate(:chat_message, chat_channel: category_channel_1) }
other_channel.add(current_user)
end
it "does not error" do
visit(early_message.url)
expect(channel_page).to have_no_loading_skeleton
expect(channel_page).to have_message(id: early_message.id)
sidebar_page.open_channel(other_channel)
expect(dialog).to be_closed
expect(channel_page).to have_message(id: other_channel_message.id)
end
end
end
context "when direct message channel" do