mirror of
https://github.com/discourse/discourse.git
synced 2024-12-19 05:23:53 +08:00
0be0bcfc7d
* DEV: Use list controller and action It used an empty action handler which just returned the app and it required another request to get the topic list. By using the correct controller and action we can preload the topic list.
1027 lines
33 KiB
Ruby
1027 lines
33 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
RSpec.describe ListController do
|
|
fab!(:user) { Fabricate(:user) }
|
|
fab!(:topic) { Fabricate(:topic, user: user) }
|
|
fab!(:group) { Fabricate(:group, name: "AwesomeGroup") }
|
|
fab!(:admin) { Fabricate(:admin) }
|
|
|
|
before do
|
|
admin # to skip welcome wizard at home page `/`
|
|
SiteSetting.top_menu = 'latest|new|unread|categories'
|
|
end
|
|
|
|
describe '#index' do
|
|
it "does not return a 500 for invalid input" do
|
|
get "/latest?min_posts=bob"
|
|
expect(response.status).to eq(400)
|
|
|
|
get "/latest?max_posts=bob"
|
|
expect(response.status).to eq(400)
|
|
|
|
get "/latest?max_posts=1111111111111111111111111111111111111111"
|
|
expect(response.status).to eq(400)
|
|
|
|
get "/latest?page=-1"
|
|
expect(response.status).to eq(400)
|
|
|
|
get "/latest?page=2147483648"
|
|
expect(response.status).to eq(400)
|
|
|
|
get "/latest?page=1111111111111111111111111111111111111111"
|
|
expect(response.status).to eq(400)
|
|
end
|
|
|
|
it "returns 200 for legit requests" do
|
|
get "/latest.json?no_definitions=true&no_subcategories=false&page=1&_=1534296100767"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest.json?max_posts=12"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest.json?min_posts=0"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest?page=0"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest?page=1"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest.json?page=2147483647"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest?search="
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest.json?topic_ids%5B%5D=14583&topic_ids%5B%5D=14584"
|
|
expect(response.status).to eq(200)
|
|
|
|
get "/latest.json?topic_ids=14583%2C14584"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
(Discourse.anonymous_filters - [:categories]).each do |filter|
|
|
context "#{filter}" do
|
|
it "succeeds" do
|
|
get "/#{filter}"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
end
|
|
|
|
it 'allows users to filter on a set of topic ids' do
|
|
p = create_post
|
|
|
|
get "/latest.json", params: { topic_ids: "#{p.topic_id}" }
|
|
expect(response.status).to eq(200)
|
|
parsed = response.parsed_body
|
|
expect(parsed["topic_list"]["topics"].length).to eq(1)
|
|
end
|
|
|
|
it "shows correct title if topic list is set for homepage" do
|
|
get "/latest"
|
|
|
|
expect(response.body).to have_tag "title", text: "Discourse"
|
|
|
|
SiteSetting.short_site_description = "Best community"
|
|
get "/latest"
|
|
|
|
expect(response.body).to have_tag "title", text: "Discourse - Best community"
|
|
end
|
|
end
|
|
|
|
describe "categories and X" do
|
|
let(:category) { Fabricate(:category_with_definition) }
|
|
let(:sub_category) { Fabricate(:category_with_definition, parent_category: category) }
|
|
|
|
it "returns top topics" do
|
|
Fabricate(:topic, like_count: 1000, posts_count: 100)
|
|
TopTopic.refresh!
|
|
|
|
get "/categories_and_top.json"
|
|
data = response.parsed_body
|
|
expect(data["topic_list"]["topics"].length).to eq(1)
|
|
|
|
get "/categories_and_latest.json"
|
|
data = response.parsed_body
|
|
expect(data["topic_list"]["topics"].length).to eq(2)
|
|
end
|
|
|
|
it "returns topics from subcategories when no_subcategories=false" do
|
|
Fabricate(:topic, category: sub_category)
|
|
get "/c/#{category.slug}/#{category.id}/l/latest.json?no_subcategories=false"
|
|
expect(response.parsed_body["topic_list"]["topics"].length).to eq(2)
|
|
end
|
|
end
|
|
|
|
describe 'titles for crawler layout' do
|
|
it 'has no title for the default URL' do
|
|
topic
|
|
filter = Discourse.anonymous_filters[0]
|
|
get "/#{filter}", params: { _escaped_fragment_: 'true' }
|
|
|
|
expect(response.body).to include(I18n.t("rss_description.posts"))
|
|
|
|
expect(response.body).to_not include(
|
|
I18n.t('js.filters.with_topics', filter: filter)
|
|
)
|
|
end
|
|
|
|
it 'has a title for non-default URLs' do
|
|
topic
|
|
filter = Discourse.anonymous_filters[1]
|
|
get "/#{filter}", params: { _escaped_fragment_: 'true' }
|
|
|
|
expect(response.body).to include(
|
|
I18n.t('js.filters.with_topics', filter: filter)
|
|
)
|
|
end
|
|
end
|
|
|
|
describe "filter private messages by tag" do
|
|
fab!(:user) { Fabricate(:user) }
|
|
fab!(:moderator) { Fabricate(:moderator) }
|
|
fab!(:admin) { Fabricate(:admin) }
|
|
let(:tag) { Fabricate(:tag) }
|
|
let(:private_message) { Fabricate(:private_message_topic, user: admin) }
|
|
|
|
before do
|
|
SiteSetting.tagging_enabled = true
|
|
SiteSetting.pm_tags_allowed_for_groups = "1|2|3"
|
|
Fabricate(:topic_tag, tag: tag, topic: private_message)
|
|
end
|
|
|
|
it 'should fail for non-staff users' do
|
|
sign_in(user)
|
|
get "/topics/private-messages-tags/#{user.username}/#{tag.name}.json"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
it 'should fail for staff users if empty' do
|
|
SiteSetting.pm_tags_allowed_for_groups = ""
|
|
|
|
[moderator, admin].each do |user|
|
|
sign_in(user)
|
|
get "/topics/private-messages-tags/#{user.username}/#{tag.name}.json"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
end
|
|
|
|
it 'should be success for staff users' do
|
|
[moderator, admin].each do |user|
|
|
sign_in(user)
|
|
get "/topics/private-messages-tags/#{user.username}/#{tag.name}.json"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
it 'should work for tag with unicode name' do
|
|
unicode_tag = Fabricate(:tag, name: 'hello-🇺🇸')
|
|
Fabricate(:topic_tag, tag: unicode_tag, topic: private_message)
|
|
|
|
sign_in(admin)
|
|
get "/topics/private-messages-tags/#{admin.username}/#{UrlHelper.encode_component(unicode_tag.name)}.json"
|
|
expect(response.status).to eq(200)
|
|
expect(response.parsed_body["topic_list"]["topics"].first["id"])
|
|
.to eq(private_message.id)
|
|
end
|
|
|
|
it 'should work for users who are allowed and direct links' do
|
|
SiteSetting.pm_tags_allowed_for_groups = group.name
|
|
group.add(user)
|
|
sign_in(user)
|
|
|
|
get "/u/#{user.username}/messages/tags/#{tag.name}"
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
describe '#private_messages_group' do
|
|
fab!(:user) { Fabricate(:user) }
|
|
|
|
describe 'when user not in personal_message_enabled_groups group' do
|
|
let!(:topic) { Fabricate(:private_message_topic, allowed_groups: [group]) }
|
|
|
|
before do
|
|
group.add(user)
|
|
SiteSetting.personal_message_enabled_groups = Group::AUTO_GROUPS[:staff]
|
|
Group.refresh_automatic_groups!
|
|
end
|
|
|
|
it 'should display group private messages for an admin' do
|
|
sign_in(Fabricate(:admin))
|
|
|
|
get "/topics/private-messages-group/#{user.username}/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
|
|
expect(response.parsed_body["topic_list"]["topics"].first["id"])
|
|
.to eq(topic.id)
|
|
end
|
|
|
|
it 'should display moderator group private messages for a moderator' do
|
|
moderator = Fabricate(:moderator)
|
|
group = Group.find(Group::AUTO_GROUPS[:moderators])
|
|
topic = Fabricate(:private_message_topic, allowed_groups: [group])
|
|
|
|
sign_in(moderator)
|
|
|
|
get "/topics/private-messages-group/#{moderator.username}/#{group.name}.json"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
it "should not display group private messages for a moderator's group" do
|
|
moderator = Fabricate(:moderator)
|
|
sign_in(moderator)
|
|
group.add(moderator)
|
|
|
|
get "/topics/private-messages-group/#{user.username}/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(404)
|
|
end
|
|
end
|
|
|
|
describe 'with unicode_usernames' do
|
|
before do
|
|
group.add(user)
|
|
sign_in(user)
|
|
SiteSetting.unicode_usernames = false
|
|
Group.refresh_automatic_groups!
|
|
end
|
|
|
|
it 'should return the right response when user does not belong to group' do
|
|
Fabricate(:private_message_topic, allowed_groups: [group])
|
|
|
|
group.remove(user)
|
|
|
|
get "/topics/private-messages-group/#{user.username}/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
it 'should return the right response' do
|
|
topic = Fabricate(:private_message_topic, allowed_groups: [group])
|
|
get "/topics/private-messages-group/#{user.username}/awesomegroup.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
|
|
expect(response.parsed_body["topic_list"]["topics"].first["id"])
|
|
.to eq(topic.id)
|
|
end
|
|
end
|
|
|
|
describe 'with unicode_usernames' do
|
|
before do
|
|
sign_in(user)
|
|
SiteSetting.unicode_usernames = true
|
|
Group.refresh_automatic_groups!
|
|
end
|
|
|
|
it 'Returns a 200 with unicode group name' do
|
|
unicode_group = Fabricate(:group, name: '群群组')
|
|
unicode_group.add(user)
|
|
topic = Fabricate(:private_message_topic, allowed_groups: [unicode_group])
|
|
get "/topics/private-messages-group/#{user.username}/#{UrlHelper.encode_component(unicode_group.name)}.json"
|
|
expect(response.status).to eq(200)
|
|
|
|
expect(response.parsed_body["topic_list"]["topics"].first["id"])
|
|
.to eq(topic.id)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#group_topics' do
|
|
%i{user user2}.each do |user|
|
|
let(user) do
|
|
user = Fabricate(:user)
|
|
group.add(user)
|
|
user
|
|
end
|
|
end
|
|
|
|
let!(:topic) { Fabricate(:topic, user: user) }
|
|
let!(:topic2) { Fabricate(:topic, user: user2) }
|
|
let!(:another_topic) { Fabricate(:topic) }
|
|
|
|
describe 'when an invalid group name is given' do
|
|
it 'should return the right response' do
|
|
get "/topics/groups/something.json"
|
|
|
|
expect(response.status).to eq(404)
|
|
end
|
|
end
|
|
|
|
describe 'for an anon user' do
|
|
describe 'public visible group' do
|
|
it 'should return the right response' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
expect(response.parsed_body["topic_list"]).to be_present
|
|
end
|
|
end
|
|
|
|
describe 'group restricted to logged-on-users' do
|
|
before { group.update!(visibility_level: Group.visibility_levels[:logged_on_users]) }
|
|
|
|
it 'should return the right response' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
|
|
describe 'restricted group' do
|
|
before { group.update!(visibility_level: Group.visibility_levels[:staff]) }
|
|
|
|
it 'should return the right response' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
|
|
describe 'group members visibility restricted to logged-on-users' do
|
|
before { group.update!(members_visibility_level: Group.visibility_levels[:logged_on_users]) }
|
|
|
|
it 'should return the right response' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'for a normal user' do
|
|
before { sign_in(Fabricate(:user)) }
|
|
|
|
describe 'restricted group' do
|
|
before { group.update!(visibility_level: Group.visibility_levels[:staff]) }
|
|
|
|
it 'should return the right response' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
|
|
describe 'group restricted to logged-on-users' do
|
|
before { group.update!(visibility_level: Group.visibility_levels[:logged_on_users]) }
|
|
|
|
it 'should return the right response' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'for a group user' do
|
|
before do
|
|
sign_in(user)
|
|
end
|
|
|
|
it 'should be able to view the topics started by group users' do
|
|
get "/topics/groups/#{group.name}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
|
|
topics = response.parsed_body["topic_list"]["topics"]
|
|
|
|
expect(topics.map { |topic| topic["id"] }).to contain_exactly(
|
|
topic.id, topic2.id
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'RSS feeds' do
|
|
it 'renders latest RSS' do
|
|
get "/latest.rss"
|
|
expect(response.status).to eq(200)
|
|
expect(response.media_type).to eq('application/rss+xml')
|
|
expect(response.headers['X-Robots-Tag']).to eq('noindex')
|
|
end
|
|
|
|
it 'renders latest RSS with query params' do
|
|
get "/latest.rss?status=closed"
|
|
expect(response.status).to eq(200)
|
|
expect(response.media_type).to eq('application/rss+xml')
|
|
expect(response.body).to_not include("<item>")
|
|
end
|
|
|
|
it 'renders links correctly with subfolder' do
|
|
set_subfolder "/forum"
|
|
_post = Fabricate(:post, topic: topic, user: user)
|
|
get "/latest.rss"
|
|
expect(response.status).to eq(200)
|
|
expect(response.body).to_not include("/forum/forum")
|
|
expect(response.body).to include("http://test.localhost/forum/t/#{topic.slug}")
|
|
end
|
|
|
|
it 'renders top RSS' do
|
|
get "/top.rss"
|
|
expect(response.status).to eq(200)
|
|
expect(response.media_type).to eq('application/rss+xml')
|
|
end
|
|
|
|
it 'errors for invalid periods on top RSS' do
|
|
get "/top.rss?period=decadely"
|
|
expect(response.status).to eq(400)
|
|
end
|
|
|
|
TopTopic.periods.each do |period|
|
|
it "renders #{period} top RSS" do
|
|
get "/top.rss?period=#{period}"
|
|
expect(response.status).to eq(200)
|
|
expect(response.media_type).to eq('application/rss+xml')
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'Top' do
|
|
it 'renders top' do
|
|
get "/top"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
it 'renders top with a period' do
|
|
get "/top?period=weekly"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
it 'errors for invalid periods on top' do
|
|
get "/top?period=decadely"
|
|
expect(response.status).to eq(400)
|
|
end
|
|
end
|
|
|
|
describe 'category' do
|
|
context 'when in a category' do
|
|
let(:category) { Fabricate(:category_with_definition) }
|
|
let(:group) { Fabricate(:group) }
|
|
let(:private_category) { Fabricate(:private_category, group: group) }
|
|
|
|
context 'without access to see the category' do
|
|
it "responds with a 404 error" do
|
|
get "/c/#{private_category.slug}/l/latest"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
end
|
|
|
|
context 'with access to see the category' do
|
|
it "succeeds" do
|
|
get "/c/#{category.slug}/#{category.id}/l/latest"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
context 'with encoded slug in the category' do
|
|
let(:category) { Fabricate(:category, slug: "தமிழ்") }
|
|
|
|
before do
|
|
SiteSetting.slug_generation_method = "encoded"
|
|
end
|
|
|
|
it "succeeds" do
|
|
get "/c/#{category.slug}/#{category.id}/l/latest"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
context 'with a link that has a parent slug, slug and id in its path' do
|
|
let(:child_category) { Fabricate(:category_with_definition, parent_category: category) }
|
|
|
|
context "with valid slug" do
|
|
it "succeeds" do
|
|
get "/c/#{category.slug}/#{child_category.slug}/#{child_category.id}/l/latest"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
context "with invalid slug" do
|
|
it "redirects" do
|
|
get "/c/random_slug/another_random_slug/#{child_category.id}/l/latest"
|
|
expect(response).to redirect_to("#{child_category.url}/l/latest")
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when another category exists with a number at the beginning of its name' do
|
|
# One category has another category's id at the beginning of its name
|
|
let!(:other_category) {
|
|
# Our validations don't allow this to happen now, but did historically
|
|
Fabricate(:category_with_definition, name: "#{category.id} name", slug: 'will-be-changed').tap do |category|
|
|
category.update_column(:slug, "#{category.id}-name")
|
|
end
|
|
}
|
|
|
|
it 'uses the correct category' do
|
|
get "/c/#{other_category.slug}/#{other_category.id}/l/latest.json"
|
|
expect(response.status).to eq(200)
|
|
body = response.parsed_body
|
|
expect(body["topic_list"]["topics"].first["category_id"])
|
|
.to eq(other_category.id)
|
|
end
|
|
end
|
|
|
|
context 'with a child category' do
|
|
let(:sub_category) { Fabricate(:category_with_definition, parent_category_id: category.id) }
|
|
|
|
context 'when parent and child are requested' do
|
|
it "succeeds" do
|
|
get "/c/#{category.slug}/#{sub_category.slug}/#{sub_category.id}/l/latest"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
context 'when child is requested with the wrong parent' do
|
|
it "responds with a 404 error" do
|
|
get "/c/not-the-right-slug/#{sub_category.slug}/l/latest"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'feed' do
|
|
it 'renders RSS' do
|
|
get "/c/#{category.slug}/#{category.id}.rss"
|
|
expect(response.status).to eq(200)
|
|
expect(response.media_type).to eq('application/rss+xml')
|
|
end
|
|
|
|
it "renders RSS in subfolder correctly" do
|
|
set_subfolder "/forum"
|
|
get "/c/#{category.slug}/#{category.id}.rss"
|
|
expect(response.status).to eq(200)
|
|
expect(response.body).to_not include("/forum/forum")
|
|
expect(response.body).to include("http://test.localhost/forum/c/#{category.slug}")
|
|
end
|
|
end
|
|
|
|
describe "category default views" do
|
|
it "has a top default view" do
|
|
category.update!(default_view: 'top', default_top_period: 'monthly')
|
|
get "/c/#{category.slug}/#{category.id}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["for_period"]).to eq("monthly")
|
|
end
|
|
|
|
it "has a default view of nil" do
|
|
category.update!(default_view: nil)
|
|
get "/c/#{category.slug}/#{category.id}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["for_period"]).to be_blank
|
|
end
|
|
|
|
it "has a default view of ''" do
|
|
category.update!(default_view: '')
|
|
get "/c/#{category.slug}/#{category.id}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["for_period"]).to be_blank
|
|
end
|
|
|
|
it "has a default view of latest" do
|
|
category.update!(default_view: 'latest')
|
|
get "/c/#{category.slug}/#{category.id}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["for_period"]).to be_blank
|
|
end
|
|
end
|
|
|
|
describe "renders canonical tag" do
|
|
it 'for category default view' do
|
|
get "/c/#{category.slug}/#{category.id}"
|
|
expect(response.status).to eq(200)
|
|
expect(css_select("link[rel=canonical]").length).to eq(1)
|
|
end
|
|
|
|
it 'for category latest view' do
|
|
get "/c/#{category.slug}/#{category.id}/l/latest"
|
|
expect(response.status).to eq(200)
|
|
expect(css_select("link[rel=canonical]").length).to eq(1)
|
|
end
|
|
end
|
|
|
|
context "for category default view" do
|
|
let!(:amazing_category) { Fabricate(:category_with_definition, name: "Amazing Category") }
|
|
|
|
it "renders correct title" do
|
|
get "/c/#{amazing_category.slug}/#{amazing_category.id}"
|
|
|
|
expect(response.body).to have_tag "title", text: "Amazing Category - Discourse"
|
|
end
|
|
end
|
|
|
|
context "for category latest view" do
|
|
let!(:amazing_category) { Fabricate(:category_with_definition, name: "Amazing Category") }
|
|
|
|
it 'renders correct title' do
|
|
SiteSetting.short_site_description = "Best community"
|
|
get "/c/#{amazing_category.slug}/#{amazing_category.id}/l/latest"
|
|
|
|
expect(response.body).to have_tag "title", text: "Amazing Category - Discourse"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "topics_by" do
|
|
fab!(:topic2) { Fabricate(:topic, user: user) }
|
|
fab!(:user2) { Fabricate(:user) }
|
|
|
|
before do
|
|
sign_in(user2)
|
|
end
|
|
|
|
it "should respond with a list" do
|
|
get "/topics/created-by/#{user.username}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(2)
|
|
end
|
|
|
|
it "should work with period in username" do
|
|
user.update!(username: "myname.test")
|
|
get "/topics/created-by/#{user.username}", xhr: true
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(2)
|
|
end
|
|
|
|
context "with unicode usernames" do
|
|
before do
|
|
SiteSetting.unicode_usernames = true
|
|
end
|
|
|
|
it "should return the more_topics_url in the encoded form" do
|
|
stub_const(TopicQuery, "DEFAULT_PER_PAGE_COUNT", 1) do
|
|
user.update!(username: "快快快")
|
|
|
|
get "/topics/created-by/#{UrlHelper.encode(user.username)}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
|
|
json = response.parsed_body
|
|
|
|
expect(json["topic_list"]["more_topics_url"]).to eq("/topics/created-by/%E5%BF%AB%E5%BF%AB%E5%BF%AB?page=1")
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when `hide_profile_and_presence` is true' do
|
|
before do
|
|
user.user_option.update_columns(hide_profile_and_presence: true)
|
|
end
|
|
|
|
it "returns 404" do
|
|
get "/topics/created-by/#{user.username}.json"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
it "should respond with a list when `allow_users_to_hide_profile` is false" do
|
|
SiteSetting.allow_users_to_hide_profile = false
|
|
get "/topics/created-by/#{user.username}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(2)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "private_messages" do
|
|
it "returns 403 error when the user can't see private message" do
|
|
sign_in(Fabricate(:user))
|
|
get "/topics/private-messages/#{user.username}.json"
|
|
expect(response).to be_forbidden
|
|
end
|
|
|
|
it "succeeds when the user can see private messages" do
|
|
pm = Fabricate(:private_message_topic, user: Fabricate(:user))
|
|
pm.topic_allowed_users.create!(user: user)
|
|
sign_in(user)
|
|
get "/topics/private-messages/#{user.username}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(1)
|
|
end
|
|
end
|
|
|
|
describe "private_messages_sent" do
|
|
before do
|
|
pm = Fabricate(:private_message_topic, user: user)
|
|
Fabricate(:post, user: user, topic: pm, post_number: 1)
|
|
end
|
|
|
|
it "returns 403 error when the user can't see private message" do
|
|
sign_in(Fabricate(:user))
|
|
get "/topics/private-messages-sent/#{user.username}.json"
|
|
expect(response).to be_forbidden
|
|
end
|
|
|
|
it "succeeds when the user can see private messages" do
|
|
sign_in(user)
|
|
get "/topics/private-messages-sent/#{user.username}.json"
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(1)
|
|
end
|
|
end
|
|
|
|
describe "#private_messages_unread" do
|
|
fab!(:pm_user) { Fabricate(:user) }
|
|
|
|
fab!(:pm) do
|
|
Fabricate(:private_message_topic).tap do |t|
|
|
t.allowed_users << pm_user
|
|
create_post(user: pm_user, topic_id: t.id)
|
|
end
|
|
end
|
|
|
|
it "returns 404 when the user can't see private message" do
|
|
sign_in(Fabricate(:user))
|
|
get "/topics/private-messages-unread/#{pm_user.username}.json"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
it "succeeds when the user can see private messages" do
|
|
TopicUser.find_by(topic: pm, user: pm_user).update!(
|
|
notification_level: TopicUser.notification_levels[:tracking],
|
|
last_read_post_number: 0,
|
|
)
|
|
|
|
sign_in(pm_user)
|
|
get "/topics/private-messages-unread/#{pm_user.username}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(1)
|
|
expect(json["topic_list"]["topics"][0]["id"]).to eq(pm.id)
|
|
end
|
|
end
|
|
|
|
describe "#private_messages_warnings" do
|
|
fab!(:target_user) { Fabricate(:user) }
|
|
fab!(:admin) { Fabricate(:admin) }
|
|
fab!(:moderator1) { Fabricate(:moderator) }
|
|
fab!(:moderator2) { Fabricate(:moderator) }
|
|
|
|
let(:create_args) do
|
|
{ title: 'you need a warning buddy!',
|
|
raw: "you did something bad and I'm telling you about it!",
|
|
is_warning: true,
|
|
target_usernames: target_user.username,
|
|
archetype: Archetype.private_message }
|
|
end
|
|
|
|
let(:warning_post) do
|
|
creator = PostCreator.new(moderator1, create_args)
|
|
creator.create
|
|
end
|
|
let(:warning_topic) { warning_post.topic }
|
|
|
|
before do
|
|
warning_topic
|
|
end
|
|
|
|
it "returns 403 error for unrelated users" do
|
|
sign_in(Fabricate(:user))
|
|
get "/topics/private-messages-warnings/#{target_user.username}.json"
|
|
expect(response.status).to eq(403)
|
|
end
|
|
|
|
it "shows the warning to moderators and admins" do
|
|
[moderator1, moderator2, admin].each do |viewer|
|
|
sign_in(viewer)
|
|
get "/topics/private-messages-warnings/#{target_user.username}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(1)
|
|
expect(json["topic_list"]["topics"][0]["id"]).to eq(warning_topic.id)
|
|
end
|
|
end
|
|
|
|
it "does not show the warning as applying to the authoring moderator" do
|
|
sign_in(admin)
|
|
get "/topics/private-messages-warnings/#{moderator1.username}.json"
|
|
|
|
expect(response.status).to eq(200)
|
|
json = response.parsed_body
|
|
expect(json["topic_list"]["topics"].size).to eq(0)
|
|
end
|
|
end
|
|
|
|
describe 'read' do
|
|
it 'raises an error when not logged in' do
|
|
get "/read"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
|
|
context 'when logged in' do
|
|
it "succeeds" do
|
|
sign_in(user)
|
|
get "/read"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "best_periods_for" do
|
|
it "works" do
|
|
expect(ListController.best_periods_for(nil)).to eq([:all])
|
|
expect(ListController.best_periods_for(5.years.ago)).to eq([:all])
|
|
expect(ListController.best_periods_for(2.years.ago)).to eq([:yearly, :all])
|
|
expect(ListController.best_periods_for(6.months.ago)).to eq([:quarterly, :yearly, :all])
|
|
expect(ListController.best_periods_for(2.months.ago)).to eq([:monthly, :quarterly, :yearly, :all])
|
|
expect(ListController.best_periods_for(2.weeks.ago)).to eq([:weekly, :monthly, :quarterly, :yearly, :all])
|
|
expect(ListController.best_periods_for(2.days.ago)).to eq([:daily, :weekly, :monthly, :quarterly, :yearly, :all])
|
|
end
|
|
|
|
it "supports default period" do
|
|
expect(ListController.best_periods_for(nil, :yearly)).to eq([:yearly, :all])
|
|
expect(ListController.best_periods_for(nil, :quarterly)).to eq([:quarterly, :all])
|
|
expect(ListController.best_periods_for(nil, :monthly)).to eq([:monthly, :all])
|
|
expect(ListController.best_periods_for(nil, :weekly)).to eq([:weekly, :all])
|
|
expect(ListController.best_periods_for(nil, :daily)).to eq([:daily, :all])
|
|
end
|
|
end
|
|
|
|
describe "user_topics_feed" do
|
|
it "returns 404 if `hide_profile_and_presence` user option is checked" do
|
|
user.user_option.update_columns(hide_profile_and_presence: true)
|
|
get "/u/#{user.username}/activity/topics.rss"
|
|
expect(response.status).to eq(404)
|
|
end
|
|
end
|
|
|
|
describe "set_category" do
|
|
let(:category) { Fabricate(:category_with_definition) }
|
|
let(:subcategory) { Fabricate(:category_with_definition, parent_category_id: category.id) }
|
|
let(:subsubcategory) { Fabricate(:category_with_definition, parent_category_id: subcategory.id) }
|
|
|
|
before do
|
|
SiteSetting.max_category_nesting = 3
|
|
end
|
|
|
|
it "redirects to URL with the updated slug" do
|
|
get "/c/hello/world/bye/#{subsubcategory.id}"
|
|
expect(response.status).to eq(301)
|
|
expect(response).to redirect_to("/c/#{category.slug}/#{subcategory.slug}/#{subsubcategory.slug}/#{subsubcategory.id}")
|
|
|
|
get "/c/#{category.slug}/#{subcategory.slug}/#{subsubcategory.slug}/#{subsubcategory.id}"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
it "redirects to URL with correct case slug" do
|
|
category.update!(slug: "hello")
|
|
|
|
get "/c/Hello/#{category.id}"
|
|
expect(response).to redirect_to("/c/hello/#{category.id}")
|
|
|
|
get "/c/hello/#{category.id}"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
|
|
context "with encoded slugs" do
|
|
it "does not create a redirect loop" do
|
|
category = Fabricate(:category)
|
|
category.update_columns(slug: CGI.escape("systèmes"))
|
|
|
|
get "/c/syst%C3%A8mes/#{category.id}"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
context "with lowercase encoded slugs" do
|
|
it "does not create a redirect loop" do
|
|
category = Fabricate(:category)
|
|
category.update_columns(slug: CGI.escape("systèmes").downcase)
|
|
|
|
get "/c/syst%C3%A8mes/#{category.id}"
|
|
expect(response.status).to eq(200)
|
|
end
|
|
end
|
|
|
|
context "with subfolder" do
|
|
it "main category redirects to URL containing the updated slug" do
|
|
set_subfolder "/forum"
|
|
get "/c/#{category.slug}"
|
|
|
|
expect(response.status).to eq(301)
|
|
expect(response).to redirect_to("/forum/c/#{category.slug}/#{category.id}")
|
|
end
|
|
|
|
it "sub-sub-category redirects to URL containing the updated slug" do
|
|
set_subfolder "/forum"
|
|
get "/c/hello/world/bye/#{subsubcategory.id}"
|
|
|
|
expect(response.status).to eq(301)
|
|
expect(response).to redirect_to("/forum/c/#{category.slug}/#{subcategory.slug}/#{subsubcategory.slug}/#{subsubcategory.id}")
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "shared drafts" do
|
|
fab!(:category1) { Fabricate(:category) }
|
|
fab!(:category2) { Fabricate(:category) }
|
|
|
|
fab!(:topic1) { Fabricate(:topic, category: category1) }
|
|
fab!(:topic2) { Fabricate(:topic, category: category2) }
|
|
|
|
fab!(:shared_draft_topic) { Fabricate(:topic, category: category1) }
|
|
fab!(:shared_draft) { Fabricate(:shared_draft, topic: shared_draft_topic, category: category2) }
|
|
|
|
it "are not displayed if they are disabled" do
|
|
SiteSetting.shared_drafts_category = ""
|
|
sign_in(admin)
|
|
|
|
get "/c/#{category1.slug}/#{category1.id}.json"
|
|
expect(response.parsed_body['topic_list']['shared_drafts']).to eq(nil)
|
|
expect(response.parsed_body['topic_list']['topics'].map { |t| t['id'] }).to contain_exactly(topic1.id, shared_draft_topic.id)
|
|
end
|
|
|
|
it "are displayed in both shared drafts category and target category" do
|
|
SiteSetting.shared_drafts_category = category1.id
|
|
sign_in(admin)
|
|
|
|
get "/c/#{category1.slug}/#{category1.id}.json"
|
|
expect(response.parsed_body['topic_list']['shared_drafts']).to be_nil
|
|
expect(response.parsed_body['topic_list']['topics'].map { |t| t['id'] }).to contain_exactly(topic1.id, shared_draft_topic.id)
|
|
|
|
get "/c/#{category2.slug}/#{category2.id}.json"
|
|
expect(response.parsed_body['topic_list']['shared_drafts'].map { |t| t['id'] }).to contain_exactly(shared_draft_topic.id)
|
|
expect(response.parsed_body['topic_list']['topics'].map { |t| t['id'] }).to contain_exactly(topic2.id)
|
|
end
|
|
end
|
|
|
|
describe "body class" do
|
|
it "pre-renders the correct body class for categories" do
|
|
c = Fabricate(:category, slug: 'myparentslug')
|
|
sub_c = Fabricate(:category, parent_category: c, slug: 'mychildslug')
|
|
|
|
get "/c/#{c.slug}/#{sub_c.slug}/#{sub_c.id}"
|
|
|
|
expect(response.body).to have_tag "body", with: { class: "category-myparentslug-mychildslug" }
|
|
end
|
|
end
|
|
|
|
describe "welcome topic" do
|
|
fab!(:welcome_topic) { Fabricate(:topic) }
|
|
fab!(:post) { Fabricate(:post, topic: welcome_topic) }
|
|
|
|
before do
|
|
SiteSetting.welcome_topic_id = welcome_topic.id
|
|
SiteSetting.editing_grace_period = 1.minute.to_i
|
|
SiteSetting.bootstrap_mode_enabled = true
|
|
end
|
|
|
|
it "is hidden for non-admins" do
|
|
|
|
get "/latest.json"
|
|
expect(response.status).to eq(200)
|
|
parsed = response.parsed_body
|
|
expect(parsed["topic_list"]["topics"].length).to eq(1)
|
|
expect(parsed["topic_list"]["topics"].first["id"]).not_to eq(welcome_topic.id)
|
|
end
|
|
|
|
it "is shown to non-admins when there is an edit" do
|
|
post.revise(post.user, { raw: "#{post.raw}2" }, revised_at: post.updated_at + 2.minutes)
|
|
post.reload
|
|
expect(post.version).to eq(2)
|
|
|
|
get "/latest.json"
|
|
expect(response.status).to eq(200)
|
|
parsed = response.parsed_body
|
|
expect(parsed["topic_list"]["topics"].length).to eq(2)
|
|
expect(parsed["topic_list"]["topics"].first["id"]).to eq(welcome_topic.id)
|
|
end
|
|
|
|
it "is shown to admins" do
|
|
sign_in(admin)
|
|
|
|
get "/latest.json"
|
|
expect(response.status).to eq(200)
|
|
parsed = response.parsed_body
|
|
expect(parsed["topic_list"]["topics"].length).to eq(2)
|
|
expect(parsed["topic_list"]["topics"].first["id"]).to eq(welcome_topic.id)
|
|
end
|
|
|
|
it "is shown to users when bootstrap mode is disabled" do
|
|
SiteSetting.bootstrap_mode_enabled = false
|
|
|
|
get "/latest.json"
|
|
expect(response.status).to eq(200)
|
|
parsed = response.parsed_body
|
|
expect(parsed["topic_list"]["topics"].length).to eq(2)
|
|
expect(parsed["topic_list"]["topics"].first["id"]).to eq(welcome_topic.id)
|
|
end
|
|
end
|
|
end
|