A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
describe DiscoursePolicy::PolicyController do
fab!(:group)
fab!(:moderator)
fab!(:user1, :user)
fab!(:user2, :user)
before do
enable_current_plugin
Jobs.run_immediately!
group.add(user1)
group.add(user2)
end
let(:raw) { <<~MD }
[policy group=#{group.name}]
I always open **doors**!
[/policy]
MD
it "allows users to accept/reject policy" do
post = create_post(raw: raw, user: moderator)
sign_in(user1)
put "/policy/accept.json", params: { post_id: post.id }
expect(response.status).to eq(200)
expect(post.reload.post_policy.accepted_by.map(&:id)).to eq([user1.id])
sign_in(user2)
put "/policy/accept.json", params: { post_id: post.id }
expect(response.status).to eq(200)
expect(post.reload.post_policy.accepted_by.map(&:id).sort).to eq([user1.id, user2.id])
put "/policy/unaccept.json", params: { post_id: post.id }
expect(response.status).to eq(200)
expect(post.reload.post_policy.accepted_by.map(&:id)).to eq([user1.id])
end
context "when add_users_to_group is present" do
fab!(:group2, :group)
fab!(:post) { Fabricate(:post, user: moderator) }
fab!(:policy666) do
policy = Fabricate(:post_policy, post: post, add_users_to_group: group2.id)
PostPolicyGroup.create!(post_policy_id: policy.id, group_id: group.id)
policy
end
before { group2.add_owner(moderator) }
it "adds/removes users to the group when they accept the policy" do
sign_in(user1)
put "/policy/accept.json", params: { post_id: post.id }
expect(response.status).to eq(200)
expect(post.reload.post_policy.accepted_by.map(&:id)).to eq([user1.id])
expect(group2.users.pluck(:id)).to contain_exactly(moderator.id, user1.id)
put "/policy/unaccept.json", params: { post_id: post.id }
expect(response.status).to eq(200)
expect(post.reload.post_policy.accepted_by.map(&:id)).to eq([])
expect(group2.users.pluck(:id)).to contain_exactly(moderator.id)
end
end
context "when an add-users-to-group assignment is removed" do
it "does not grant accepters access to topics restricted to the former group" do
group_to_add = Fabricate(:group)
group_to_add.add_owner(moderator)
private_category = Fabricate(:private_category, group: group_to_add)
private_topic = Fabricate(:topic, category: private_category, user: moderator)
private_post = Fabricate(:post, topic: private_topic, user: moderator, raw: "Restricted post")
policy_post = create_post(raw: <<~MD, user: moderator)
[policy group=#{group.name} add-users-to-group=#{group_to_add.name}]
I always open **doors**!
[/policy]
MD
sign_in(moderator)
put "/posts/#{policy_post.id}.json", params: { post: { raw: <<~MD } }
[policy group=#{group.name}]
I always open **doors**!
[/policy]
MD
expect(response.status).to eq(200)
expect(response.parsed_body["post"]["raw"]).not_to include("add-users-to-group")
sign_in(user1)
get "/t/#{private_topic.id}.json"
expect(response.status).to eq(404)
expect(response.body).not_to include(private_post.raw)
put "/policy/accept.json", params: { post_id: policy_post.id }
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
get "/t/#{private_topic.id}.json"
expect(response.status).to eq(404)
expect(response.body).not_to include(private_post.raw)
end
end
describe "#accepted" do
before { sign_in(user1) }
it "returns pages of users who accepted" do
post = create_post(raw: raw, user: moderator)
PolicyUser.add!(user1, post.post_policy)
PolicyUser.add!(user2, post.post_policy)
get "/policy/accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly(
user1.id,
user2.id,
)
get "/policy/accepted.json", params: { post_id: post.id, offset: 1 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly(user2.id)
get "/policy/accepted.json", params: { post_id: post.id, offset: 2 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly
end
end
describe "#not_accepted" do
before { sign_in(user1) }
it "returns pages of users who accepted" do
post = create_post(raw: raw, user: moderator)
get "/policy/not-accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly(
user1.id,
user2.id,
)
get "/policy/not-accepted.json", params: { post_id: post.id, offset: 1 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly(user2.id)
get "/policy/not-accepted.json", params: { post_id: post.id, offset: 2 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly
end
end
describe "post visibility checks" do
fab!(:private_group, :group)
fab!(:private_category) { Fabricate(:private_category, group: private_group) }
fab!(:outsider, :user)
fab!(:private_topic) { Fabricate(:topic, category: private_category, user: moderator) }
fab!(:private_post) { Fabricate(:post, topic: private_topic, user: moderator) }
fab!(:private_policy) do
policy = Fabricate(:post_policy, post: private_post)
PostPolicyGroup.create!(post_policy_id: policy.id, group_id: group.id)
policy
end
before { group.add(outsider) }
it "returns 404 when user cannot see the post for accept" do
sign_in(outsider)
put "/policy/accept.json", params: { post_id: private_post.id }
expect(response.status).to eq(404)
end
it "returns 404 when user cannot see the post for unaccept" do
sign_in(outsider)
put "/policy/unaccept.json", params: { post_id: private_post.id }
expect(response.status).to eq(404)
end
it "returns 404 when user cannot see the post for accepted" do
sign_in(outsider)
get "/policy/accepted.json", params: { post_id: private_post.id }
expect(response.status).to eq(404)
end
it "returns 404 when user cannot see the post for not_accepted" do
sign_in(outsider)
get "/policy/not-accepted.json", params: { post_id: private_post.id }
expect(response.status).to eq(404)
end
end
describe "private policy restrictions" do
fab!(:admin)
let(:private_raw) { <<~MD }
[policy group=#{group.name} private=true]
I always open **doors**!
[/policy]
MD
it "denies non-admin access to accepted users for a private policy" do
post = create_post(raw: private_raw, user: moderator)
PolicyUser.add!(user1, post.post_policy)
sign_in(user1)
get "/policy/accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(403)
end
it "denies non-admin access to not_accepted users for a private policy" do
post = create_post(raw: private_raw, user: moderator)
sign_in(user1)
get "/policy/not-accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(403)
end
it "allows admin access to accepted users for a private policy" do
group.add(admin)
post = create_post(raw: private_raw, user: moderator)
PolicyUser.add!(user1, post.post_policy)
sign_in(admin)
get "/policy/accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to include(user1.id)
end
it "allows admin access to not_accepted users for a private policy" do
group.add(admin)
post = create_post(raw: private_raw, user: moderator)
sign_in(admin)
get "/policy/not-accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly(
user1.id,
user2.id,
admin.id,
)
end
end
describe "group member visibility restrictions" do
fab!(:owner, :user)
let!(:post) do
raw = <<~MD
[policy group=#{group.name}]
I always open **doors**!
[/policy]
MD
create_post(raw: raw, user: moderator)
end
before do
group.update!(members_visibility_level: Group.visibility_levels[:owners])
group.add_owner(owner)
end
it "returns 422 and error if user cannot see group members (accepted endpoint)" do
sign_in(user2)
get "/policy/accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(422)
expect(response.parsed_body["errors"]).to include(
I18n.t("discourse_policy.error.no_permission"),
)
end
it "returns 422 and error if user cannot see group members (not_accepted endpoint)" do
sign_in(user2)
get "/policy/not-accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(422)
expect(response.parsed_body["errors"]).to include(
I18n.t("discourse_policy.error.no_permission"),
)
end
it "allows owner to see group members" do
PolicyUser.add!(user1, post.post_policy)
sign_in(owner)
get "/policy/accepted.json", params: { post_id: post.id, offset: 0 }
expect(response.status).to eq(200)
expect(response.parsed_body["users"].map { |x| x["id"] }).to contain_exactly(user1.id)
end
end
describe "#accept" do
fab!(:group2, :group)
fab!(:post) { Fabricate(:post, user: moderator) }
fab!(:post_policy) do
policy = Fabricate(:post_policy, post: post, add_users_to_group: group2.id)
PostPolicyGroup.create!(post_policy_id: policy.id, group_id: group.id)
policy
end
it "returns 422 when the post author cannot manage the group that accepting users are added to" do
post_policy.update!(add_users_to_group: Group::AUTO_GROUPS[:admins])
sign_in(user1)
put "/policy/accept.json", params: { post_id: post.id }
expect(response.status).to eq(422)
expect(response.parsed_body["errors"]).to include(
I18n.t("discourse_policy.errors.policy_group_inaccessible"),
)
end
end
describe "#unaccept" do
fab!(:group2, :group)
fab!(:post) { Fabricate(:post, user: moderator) }
fab!(:post_policy) do
policy = Fabricate(:post_policy, post: post, add_users_to_group: group2.id)
PostPolicyGroup.create!(post_policy_id: policy.id, group_id: group.id)
policy
end
it "returns 422 when the post author cannot manage the group that accepting users are added to" do
post_policy.update!(add_users_to_group: Group::AUTO_GROUPS[:admins])
PolicyUser.add!(user1, post_policy)
sign_in(user1)
put "/policy/unaccept.json", params: { post_id: post.id }
expect(response.status).to eq(422)
expect(response.parsed_body["errors"]).to include(
I18n.t("discourse_policy.errors.policy_group_inaccessible"),
)
end
end
describe "policy validation" do
fab!(:admin)
fab!(:editor, :trust_level_4)
fab!(:audience_group, :group)
fab!(:target_group, :group)
fab!(:post) { Fabricate(:post, user: admin, raw: "Original content") }
before do
audience_group.add(editor)
target_group.add_owner(admin)
end
it "rejects an HTML policy from an editor without policy permissions" do
raw = <<~HTML
<div class="policy" data-group="#{audience_group.name}" data-add-users-to-group="#{target_group.name}">
I agree
</div>
HTML
sign_in(editor)
put "/posts/#{post.id}.json", params: { post: { raw: raw } }
expect(response.status).to eq(422)
expect(response.parsed_body["errors"]).to include(
I18n.t("discourse_policy.errors.no_policy_permission"),
)
expect(post.reload.raw).to eq("Original content")
expect(post.post_policy).to be_nil
end
end
describe "wiki policy posts" do
fab!(:admin)
let(:policy_post) { create_post(user: admin, raw: raw) }
it "rejects making a policy post a wiki while allowing quoted policy markup" do
sign_in(admin)
put "/posts/#{policy_post.id}/wiki.json", params: { wiki: "true" }
aggregate_failures do
expect(response.status).to eq(422)
expect(response.parsed_body["errors"]).to include(
I18n.t("discourse_policy.errors.policy_cannot_be_wiki"),
)
expect(policy_post.reload).not_to be_wiki
end
quoted_policy_post = create_post(user: admin, raw: <<~MD)
[quote="someone, post:1, topic:1"]
#{raw}
[/quote]
MD
put "/posts/#{quoted_policy_post.id}/wiki.json", params: { wiki: "true" }
aggregate_failures do
expect(response.status).to eq(200)
expect(response.body).to be_blank
expect(quoted_policy_post.reload).to be_wiki
end
end
end
end