2018-12-04 11:48:13 +08:00
|
|
|
require 'rails_helper'
|
2017-07-07 14:09:14 +08:00
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
require 'guardian'
|
2013-03-19 05:52:29 +08:00
|
|
|
require_dependency 'post_destroyer'
|
2018-01-26 04:38:40 +08:00
|
|
|
require_dependency 'post_locker'
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
describe Guardian do
|
|
|
|
|
2016-12-29 11:11:33 +08:00
|
|
|
let(:user) { Fabricate(:user) }
|
|
|
|
let(:moderator) { Fabricate(:moderator) }
|
|
|
|
let(:admin) { Fabricate(:admin) }
|
2016-01-11 23:26:00 +08:00
|
|
|
let(:trust_level_2) { build(:user, trust_level: 2) }
|
2014-09-05 14:52:40 +08:00
|
|
|
let(:trust_level_3) { build(:user, trust_level: 3) }
|
|
|
|
let(:trust_level_4) { build(:user, trust_level: 4) }
|
2013-05-31 23:41:40 +08:00
|
|
|
let(:another_admin) { build(:admin) }
|
2013-05-21 14:39:51 +08:00
|
|
|
let(:coding_horror) { build(:coding_horror) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
2013-05-21 14:39:51 +08:00
|
|
|
let(:topic) { build(:topic, user: user) }
|
|
|
|
let(:post) { build(:post, topic: topic, user: topic.user) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it 'can be created without a user (not logged in)' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect { Guardian.new }.not_to raise_error
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2015-02-13 00:52:59 +08:00
|
|
|
it 'can be instantiated with a user instance' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect { Guardian.new(user) }.not_to raise_error
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2018-06-14 02:57:32 +08:00
|
|
|
describe "link_posting_access" do
|
|
|
|
it "is none for anonymous users" do
|
|
|
|
expect(Guardian.new.link_posting_access).to eq('none')
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is full for regular users" do
|
|
|
|
expect(Guardian.new(user).link_posting_access).to eq('full')
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is none for a user of a low trust level" do
|
|
|
|
user.trust_level = 0
|
|
|
|
SiteSetting.min_trust_to_post_links = 1
|
|
|
|
expect(Guardian.new(user).link_posting_access).to eq('none')
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is limited for a user of a low trust level with a whitelist" do
|
|
|
|
SiteSetting.whitelisted_link_domains = 'example.com'
|
|
|
|
user.trust_level = 0
|
|
|
|
SiteSetting.min_trust_to_post_links = 1
|
|
|
|
expect(Guardian.new(user).link_posting_access).to eq('limited')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-02-09 01:56:10 +08:00
|
|
|
describe "can_post_link?" do
|
2018-06-14 02:57:32 +08:00
|
|
|
let(:host) { "discourse.org" }
|
|
|
|
|
2018-02-09 01:56:10 +08:00
|
|
|
it "returns false for anonymous users" do
|
2018-06-14 02:57:32 +08:00
|
|
|
expect(Guardian.new.can_post_link?(host: host)).to eq(false)
|
2018-02-09 01:56:10 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for a regular user" do
|
2018-06-14 02:57:32 +08:00
|
|
|
expect(Guardian.new(user).can_post_link?(host: host)).to eq(true)
|
2018-02-09 01:56:10 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "supports customization by site setting" do
|
|
|
|
user.trust_level = 0
|
|
|
|
SiteSetting.min_trust_to_post_links = 0
|
2018-06-14 02:57:32 +08:00
|
|
|
expect(Guardian.new(user).can_post_link?(host: host)).to eq(true)
|
2018-02-09 01:56:10 +08:00
|
|
|
SiteSetting.min_trust_to_post_links = 1
|
2018-06-14 02:57:32 +08:00
|
|
|
expect(Guardian.new(user).can_post_link?(host: host)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "whitelisted host" do
|
|
|
|
before do
|
|
|
|
SiteSetting.whitelisted_link_domains = host
|
|
|
|
end
|
|
|
|
|
|
|
|
it "allows a new user to post the link to the host" do
|
|
|
|
user.trust_level = 0
|
|
|
|
SiteSetting.min_trust_to_post_links = 1
|
|
|
|
expect(Guardian.new(user).can_post_link?(host: host)).to eq(true)
|
|
|
|
expect(Guardian.new(user).can_post_link?(host: 'another-host.com')).to eq(false)
|
|
|
|
end
|
2018-02-09 01:56:10 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-02-28 11:22:51 +08:00
|
|
|
describe '#post_can_act?' do
|
2013-05-21 14:39:51 +08:00
|
|
|
let(:post) { build(:post) }
|
|
|
|
let(:user) { build(:user) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it "returns false when the user is nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).post_can_act?(post, :like)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when the post is nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(nil, :like)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when the topic is archived" do
|
|
|
|
post.topic.archived = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :like)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-08-08 01:12:35 +08:00
|
|
|
it "returns false when the post is deleted" do
|
|
|
|
post.deleted_at = Time.now
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :like)).to be_falsey
|
2014-08-08 01:12:35 +08:00
|
|
|
end
|
|
|
|
|
2018-08-17 23:06:01 +08:00
|
|
|
it "works as expected for silenced users" do
|
2018-08-14 23:43:39 +08:00
|
|
|
UserSilencer.silence(user, admin)
|
|
|
|
expect(Guardian.new(user).post_can_act?(post, :spam)).to be_falsey
|
2018-08-17 23:06:01 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :like)).to be_truthy
|
|
|
|
expect(Guardian.new(user).post_can_act?(post, :bookmark)).to be_truthy
|
2018-08-14 23:43:39 +08:00
|
|
|
end
|
|
|
|
|
2018-02-13 03:56:21 +08:00
|
|
|
it "allows flagging archived posts" do
|
2013-05-20 14:04:53 +08:00
|
|
|
post.topic.archived = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :spam)).to be_truthy
|
2013-05-20 14:04:53 +08:00
|
|
|
end
|
|
|
|
|
2018-11-05 23:00:59 +08:00
|
|
|
it "does not allow flagging of hidden posts" do
|
|
|
|
post.hidden = true
|
|
|
|
expect(Guardian.new(user).post_can_act?(post, :spam)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2018-02-13 04:27:05 +08:00
|
|
|
it "allows flagging of staff posts when allow_flagging_staff is true" do
|
|
|
|
SiteSetting.allow_flagging_staff = true
|
2018-02-13 03:56:21 +08:00
|
|
|
staff_post = Fabricate(:post, user: Fabricate(:moderator))
|
|
|
|
expect(Guardian.new(user).post_can_act?(staff_post, :spam)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2018-08-17 15:10:07 +08:00
|
|
|
describe 'when allow_flagging_staff is false' do
|
|
|
|
let(:staff_post) { Fabricate(:post, user: Fabricate(:moderator)) }
|
2018-02-13 03:56:21 +08:00
|
|
|
|
2018-08-17 15:10:07 +08:00
|
|
|
before do
|
|
|
|
SiteSetting.allow_flagging_staff = false
|
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow flagging of staff posts" do
|
|
|
|
expect(Guardian.new(user).post_can_act?(staff_post, :spam)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "allows flagging of staff posts when staff has been deleted" do
|
|
|
|
staff_post.user.destroy!
|
|
|
|
staff_post.reload
|
|
|
|
expect(Guardian.new(user).post_can_act?(staff_post, :spam)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "allows liking of staff" do
|
|
|
|
expect(Guardian.new(user).post_can_act?(staff_post, :like)).to eq(true)
|
|
|
|
end
|
2018-02-15 04:46:04 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it "returns false when liking yourself" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).post_can_act?(post, :like)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when you've already done it" do
|
2017-09-08 13:07:22 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :like, opts: {
|
|
|
|
taken_actions: { PostActionType.types[:like] => 1 }
|
|
|
|
})).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-02-26 00:42:20 +08:00
|
|
|
it "returns false when you already flagged a post" do
|
2018-02-28 11:22:51 +08:00
|
|
|
PostActionType.notify_flag_types.each do |type, _id|
|
|
|
|
expect(Guardian.new(user).post_can_act?(post, :off_topic, opts: {
|
|
|
|
taken_actions: { PostActionType.types[type] => 1 }
|
|
|
|
})).to be_falsey
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-12-20 05:47:39 +08:00
|
|
|
it "returns false for notify_user if private messages are disabled" do
|
2018-01-31 14:03:12 +08:00
|
|
|
SiteSetting.enable_personal_messages = false
|
2014-12-20 05:47:39 +08:00
|
|
|
user.trust_level = TrustLevel[2]
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :notify_user)).to be_falsey
|
2014-12-20 05:47:39 +08:00
|
|
|
end
|
|
|
|
|
2019-01-24 19:26:59 +08:00
|
|
|
it "returns false for notify_user if private messages are enabled but threshold not met" do
|
2018-01-31 14:03:12 +08:00
|
|
|
SiteSetting.enable_personal_messages = true
|
2015-10-12 08:15:38 +08:00
|
|
|
SiteSetting.min_trust_to_send_messages = 2
|
|
|
|
user.trust_level = TrustLevel[1]
|
|
|
|
expect(Guardian.new(user).post_can_act?(post, :notify_user)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe "trust levels" do
|
|
|
|
it "returns true for a new user liking something" do
|
2014-09-05 13:20:39 +08:00
|
|
|
user.trust_level = TrustLevel[0]
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :like)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2018-02-07 06:12:27 +08:00
|
|
|
it "returns false for a new user flagging as spam" do
|
2014-09-05 13:20:39 +08:00
|
|
|
user.trust_level = TrustLevel[0]
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :spam)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2018-02-07 06:12:27 +08:00
|
|
|
it "returns true for a new user flagging as spam if enabled" do
|
|
|
|
SiteSetting.min_trust_to_flag_posts = 0
|
|
|
|
user.trust_level = TrustLevel[0]
|
|
|
|
expect(Guardian.new(user).post_can_act?(post, :spam)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2015-01-08 23:06:43 +08:00
|
|
|
it "returns true for a new user flagging a private message as spam" do
|
2016-12-21 12:01:26 +08:00
|
|
|
post = Fabricate(:private_message_post, user: Fabricate(:admin))
|
2015-01-08 23:06:43 +08:00
|
|
|
user.trust_level = TrustLevel[0]
|
2016-12-21 12:01:26 +08:00
|
|
|
post.topic.allowed_users << user
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :spam)).to be_truthy
|
2015-01-08 23:06:43 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it "returns false for a new user flagging something as off topic" do
|
2014-09-05 13:20:39 +08:00
|
|
|
user.trust_level = TrustLevel[0]
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :off_topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2014-03-10 23:48:27 +08:00
|
|
|
|
|
|
|
it "returns false for a new user flagging with notify_user" do
|
2014-09-05 13:20:39 +08:00
|
|
|
user.trust_level = TrustLevel[0]
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :notify_user)).to be_falsey # because new users can't send private messages
|
2014-03-10 23:48:27 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-04-25 23:46:54 +08:00
|
|
|
describe "can_enable_safe_mode" do
|
|
|
|
let(:user) { Fabricate.build(:user) }
|
|
|
|
let(:moderator) { Fabricate.build(:moderator) }
|
|
|
|
|
|
|
|
context "when enabled" do
|
|
|
|
before do
|
|
|
|
SiteSetting.enable_safe_mode = true
|
|
|
|
end
|
|
|
|
|
|
|
|
it "can be performed" do
|
|
|
|
expect(Guardian.new.can_enable_safe_mode?).to eq(true)
|
|
|
|
expect(Guardian.new(user).can_enable_safe_mode?).to eq(true)
|
|
|
|
expect(Guardian.new(moderator).can_enable_safe_mode?).to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when disabled" do
|
|
|
|
before do
|
|
|
|
SiteSetting.enable_safe_mode = false
|
|
|
|
end
|
|
|
|
|
|
|
|
it "can be performed" do
|
|
|
|
expect(Guardian.new.can_enable_safe_mode?).to eq(false)
|
|
|
|
expect(Guardian.new(user).can_enable_safe_mode?).to eq(false)
|
|
|
|
expect(Guardian.new(moderator).can_enable_safe_mode?).to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-07-29 01:17:37 +08:00
|
|
|
describe "can_defer_flags" do
|
2013-02-09 08:04:14 +08:00
|
|
|
let(:post) { Fabricate(:post) }
|
|
|
|
let(:user) { post.user }
|
|
|
|
let(:moderator) { Fabricate(:moderator) }
|
|
|
|
|
|
|
|
it "returns false when the user is nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_defer_flags?(post)).to be_falsey
|
2013-02-09 08:04:14 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when the post is nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_defer_flags?(nil)).to be_falsey
|
2013-02-09 08:04:14 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when the user is not a moderator" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_defer_flags?(post)).to be_falsey
|
2013-02-09 08:04:14 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true when the user is a moderator" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_defer_flags?(post)).to be_truthy
|
2013-02-09 08:04:14 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe 'can_send_private_message' do
|
|
|
|
let(:user) { Fabricate(:user) }
|
|
|
|
let(:another_user) { Fabricate(:user) }
|
2014-05-07 03:01:19 +08:00
|
|
|
let(:suspended_user) { Fabricate(:user, suspended_till: 1.week.from_now, suspended_at: 1.day.ago) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it "returns false when the user is nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_send_private_message?(user)).to be_falsey
|
2013-02-26 00:42:20 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it "returns false when the target user is nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_send_private_message?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2016-07-04 09:36:43 +08:00
|
|
|
it "returns true when the target is the same as the user" do
|
|
|
|
# this is now allowed so yay
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2017-10-24 05:19:30 +08:00
|
|
|
it "returns false when you are untrusted" do
|
|
|
|
user.trust_level = TrustLevel[0]
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(another_user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true to another user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_send_private_message?(another_user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2014-04-24 05:00:22 +08:00
|
|
|
|
2015-10-12 08:15:38 +08:00
|
|
|
it "disallows pms to other users if trust level is not met" do
|
|
|
|
SiteSetting.min_trust_to_send_messages = TrustLevel[2]
|
|
|
|
user.trust_level = TrustLevel[1]
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(another_user)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2018-01-31 14:03:12 +08:00
|
|
|
context "enable_personal_messages is false" do
|
|
|
|
before { SiteSetting.enable_personal_messages = false }
|
2014-04-24 05:00:22 +08:00
|
|
|
|
2017-02-22 14:02:09 +08:00
|
|
|
it "returns false if user is not staff member" do
|
|
|
|
expect(Guardian.new(trust_level_4).can_send_private_message?(another_user)).to be_falsey
|
2014-04-24 05:00:22 +08:00
|
|
|
end
|
|
|
|
|
2017-02-22 14:02:09 +08:00
|
|
|
it "returns true for staff member" do
|
|
|
|
expect(Guardian.new(moderator).can_send_private_message?(another_user)).to be_truthy
|
|
|
|
expect(Guardian.new(admin).can_send_private_message?(another_user)).to be_truthy
|
2014-04-24 05:00:22 +08:00
|
|
|
end
|
|
|
|
end
|
2014-05-07 03:01:19 +08:00
|
|
|
|
|
|
|
context "target user is suspended" do
|
|
|
|
it "returns true for staff" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_send_private_message?(suspended_user)).to be_truthy
|
|
|
|
expect(Guardian.new(moderator).can_send_private_message?(suspended_user)).to be_truthy
|
2014-05-07 03:01:19 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for regular users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_send_private_message?(suspended_user)).to be_falsey
|
2014-05-07 03:01:19 +08:00
|
|
|
end
|
|
|
|
end
|
2016-01-23 01:54:18 +08:00
|
|
|
|
2017-11-11 01:18:08 +08:00
|
|
|
context "author is silenced" do
|
2016-01-23 01:54:18 +08:00
|
|
|
before do
|
2017-11-14 02:41:36 +08:00
|
|
|
user.silenced_till = 1.year.from_now
|
2016-01-23 01:54:18 +08:00
|
|
|
user.save
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if target is staff" do
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(admin)).to be_truthy
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(moderator)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false if target is not staff" do
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(another_user)).to be_falsey
|
|
|
|
end
|
2016-03-24 04:20:24 +08:00
|
|
|
|
|
|
|
it "returns true if target is a staff group" do
|
|
|
|
Group::STAFF_GROUPS.each do |name|
|
|
|
|
g = Group[name]
|
2017-12-14 10:53:21 +08:00
|
|
|
g.update!(messageable_level: Group::ALIAS_LEVELS[:everyone])
|
2016-03-24 04:20:24 +08:00
|
|
|
expect(Guardian.new(user).can_send_private_message?(g)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
2016-01-23 01:54:18 +08:00
|
|
|
end
|
2017-10-06 15:56:58 +08:00
|
|
|
|
2017-12-14 10:53:21 +08:00
|
|
|
it "respects the group's messageable_level" do
|
|
|
|
group = Fabricate(:group)
|
|
|
|
|
|
|
|
Group::ALIAS_LEVELS.each do |level, _|
|
|
|
|
group.update!(messageable_level: Group::ALIAS_LEVELS[level])
|
|
|
|
output = level == :everyone ? true : false
|
|
|
|
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(group)).to eq(output)
|
|
|
|
end
|
|
|
|
|
|
|
|
admin = Fabricate(:admin)
|
|
|
|
|
|
|
|
Group::ALIAS_LEVELS.each do |level, _|
|
|
|
|
group.update!(messageable_level: Group::ALIAS_LEVELS[level])
|
|
|
|
expect(Guardian.new(admin).can_send_private_message?(group)).to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-10-06 15:56:58 +08:00
|
|
|
context 'target user has private message disabled' do
|
|
|
|
before do
|
|
|
|
another_user.user_option.update!(allow_private_messages: false)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'for a normal user' do
|
|
|
|
it 'should return false' do
|
|
|
|
expect(Guardian.new(user).can_send_private_message?(another_user)).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'for a staff user' do
|
|
|
|
it 'should return true' do
|
|
|
|
[admin, moderator].each do |staff_user|
|
|
|
|
expect(Guardian.new(staff_user).can_send_private_message?(another_user))
|
|
|
|
.to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'can_reply_as_new_topic' do
|
|
|
|
let(:user) { Fabricate(:user) }
|
|
|
|
let(:topic) { Fabricate(:topic) }
|
2016-11-30 01:59:42 +08:00
|
|
|
let(:private_message) { Fabricate(:private_message_topic) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it "returns false for a non logged in user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_reply_as_new_topic?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for a nil topic" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_reply_as_new_topic?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for an untrusted user" do
|
2014-09-05 13:20:39 +08:00
|
|
|
user.trust_level = TrustLevel[0]
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_reply_as_new_topic?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for a trusted user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_reply_as_new_topic?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2016-11-30 01:59:42 +08:00
|
|
|
|
|
|
|
it "returns true for a private message" do
|
|
|
|
expect(Guardian.new(user).can_reply_as_new_topic?(private_message)).to be_truthy
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'can_see_post_actors?' do
|
|
|
|
|
2017-07-28 09:20:09 +08:00
|
|
|
let(:topic) { Fabricate(:topic, user: coding_horror) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
2013-04-29 14:33:24 +08:00
|
|
|
it 'displays visibility correctly' do
|
|
|
|
guardian = Guardian.new(user)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(guardian.can_see_post_actors?(nil, PostActionType.types[:like])).to be_falsey
|
|
|
|
expect(guardian.can_see_post_actors?(topic, PostActionType.types[:like])).to be_truthy
|
|
|
|
expect(guardian.can_see_post_actors?(topic, PostActionType.types[:bookmark])).to be_falsey
|
|
|
|
expect(guardian.can_see_post_actors?(topic, PostActionType.types[:off_topic])).to be_falsey
|
|
|
|
expect(guardian.can_see_post_actors?(topic, PostActionType.types[:spam])).to be_falsey
|
2016-10-19 14:36:35 +08:00
|
|
|
expect(guardian.can_see_post_actors?(topic, PostActionType.types[:notify_user])).to be_falsey
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_see_post_actors?(topic, PostActionType.types[:notify_user])).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'can_impersonate?' do
|
2013-04-29 14:33:24 +08:00
|
|
|
it 'allows impersonation correctly' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_impersonate?(nil)).to be_falsey
|
|
|
|
expect(Guardian.new.can_impersonate?(user)).to be_falsey
|
|
|
|
expect(Guardian.new(coding_horror).can_impersonate?(user)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_impersonate?(admin)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_impersonate?(another_admin)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_impersonate?(user)).to be_truthy
|
|
|
|
expect(Guardian.new(admin).can_impersonate?(moderator)).to be_truthy
|
2013-09-05 08:27:34 +08:00
|
|
|
|
|
|
|
Rails.configuration.stubs(:developer_emails).returns([admin.email])
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_impersonate?(another_admin)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-02-21 20:45:30 +08:00
|
|
|
describe "can_view_action_logs?" do
|
|
|
|
it 'is false for non-staff acting user' do
|
|
|
|
expect(Guardian.new(user).can_view_action_logs?(moderator)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false without a target user' do
|
|
|
|
expect(Guardian.new(moderator).can_view_action_logs?(nil)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2017-02-22 16:01:40 +08:00
|
|
|
it 'is true when target user is present' do
|
|
|
|
expect(Guardian.new(moderator).can_view_action_logs?(user)).to be_truthy
|
2017-02-21 20:45:30 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-11-07 01:56:26 +08:00
|
|
|
describe 'can_invite_to_forum?' do
|
|
|
|
let(:user) { Fabricate.build(:user) }
|
|
|
|
let(:moderator) { Fabricate.build(:moderator) }
|
|
|
|
|
|
|
|
it "doesn't allow anonymous users to invite" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_invite_to_forum?).to be_falsey
|
2013-11-07 01:56:26 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when the site requires approving users and is mod' do
|
2017-07-21 14:12:24 +08:00
|
|
|
SiteSetting.must_approve_users = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_invite_to_forum?).to be_truthy
|
2013-11-07 01:56:26 +08:00
|
|
|
end
|
|
|
|
|
2015-05-19 14:51:21 +08:00
|
|
|
it 'returns false when max_invites_per_day is 0' do
|
|
|
|
# let's also break it while here
|
|
|
|
SiteSetting.max_invites_per_day = "a"
|
2015-06-05 12:52:41 +08:00
|
|
|
|
|
|
|
expect(Guardian.new(user).can_invite_to_forum?).to be_falsey
|
|
|
|
# staff should be immune to max_invites_per_day setting
|
|
|
|
expect(Guardian.new(moderator).can_invite_to_forum?).to be_truthy
|
2015-05-19 14:51:21 +08:00
|
|
|
end
|
|
|
|
|
2013-11-07 01:56:26 +08:00
|
|
|
it 'returns false when the site requires approving users and is regular' do
|
|
|
|
SiteSetting.expects(:must_approve_users?).returns(true)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_invite_to_forum?).to be_falsey
|
2013-11-07 01:56:26 +08:00
|
|
|
end
|
|
|
|
|
2014-06-19 04:46:04 +08:00
|
|
|
it 'returns false when the local logins are disabled' do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_local_logins = false
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_invite_to_forum?).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_invite_to_forum?).to be_falsey
|
2014-06-19 04:46:04 +08:00
|
|
|
end
|
|
|
|
|
2017-07-21 14:12:24 +08:00
|
|
|
context 'with groups' do
|
|
|
|
let(:group) { Fabricate(:group) }
|
|
|
|
let(:another_group) { Fabricate(:group) }
|
|
|
|
let(:groups) { [group, another_group] }
|
|
|
|
|
|
|
|
before do
|
|
|
|
user.update!(trust_level: TrustLevel[2])
|
|
|
|
group.add_owner(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when user is not allowed to edit a group' do
|
|
|
|
expect(Guardian.new(user).can_invite_to_forum?(groups)).to eq(false)
|
|
|
|
|
|
|
|
expect(Guardian.new(Fabricate(:admin)).can_invite_to_forum?(groups))
|
|
|
|
.to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when user is allowed to edit groups' do
|
|
|
|
another_group.add_owner(user)
|
|
|
|
|
|
|
|
expect(Guardian.new(user).can_invite_to_forum?(groups)).to eq(true)
|
|
|
|
end
|
|
|
|
end
|
2013-11-07 01:56:26 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe 'can_invite_to?' do
|
|
|
|
|
2017-05-20 00:55:26 +08:00
|
|
|
describe "regular topics" do
|
|
|
|
let(:group) { Fabricate(:group) }
|
|
|
|
let(:category) { Fabricate(:category, read_restricted: true) }
|
|
|
|
let(:topic) { Fabricate(:topic) }
|
|
|
|
let(:private_topic) { Fabricate(:topic, category: category) }
|
|
|
|
let(:user) { topic.user }
|
|
|
|
let(:moderator) { Fabricate(:moderator) }
|
|
|
|
let(:admin) { Fabricate(:admin) }
|
|
|
|
let(:private_category) { Fabricate(:private_category, group: group) }
|
|
|
|
let(:group_private_topic) { Fabricate(:topic, category: private_category) }
|
|
|
|
let(:group_owner) { group_private_topic.user.tap { |u| group.add_owner(u) } }
|
|
|
|
let(:pm) { Fabricate(:topic) }
|
|
|
|
|
|
|
|
it 'handles invitation correctly' do
|
|
|
|
expect(Guardian.new(nil).can_invite_to?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_invite_to?(nil)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_invite_to?(topic)).to be_truthy
|
|
|
|
expect(Guardian.new(user).can_invite_to?(topic)).to be_falsey
|
|
|
|
|
|
|
|
SiteSetting.max_invites_per_day = 0
|
|
|
|
|
|
|
|
expect(Guardian.new(user).can_invite_to?(topic)).to be_falsey
|
|
|
|
# staff should be immune to max_invites_per_day setting
|
|
|
|
expect(Guardian.new(moderator).can_invite_to?(topic)).to be_truthy
|
|
|
|
end
|
2015-05-19 14:51:21 +08:00
|
|
|
|
2017-05-20 00:55:26 +08:00
|
|
|
it 'returns false for normal user on private topic' do
|
|
|
|
expect(Guardian.new(user).can_invite_to?(private_topic)).to be_falsey
|
|
|
|
end
|
2015-06-05 12:52:41 +08:00
|
|
|
|
2018-12-05 23:43:07 +08:00
|
|
|
it 'returns false for admin on private topic' do
|
|
|
|
expect(Guardian.new(admin).can_invite_to?(private_topic)).to be(false)
|
2017-05-20 00:55:26 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
2017-05-20 00:55:26 +08:00
|
|
|
it 'returns true for a group owner' do
|
|
|
|
expect(Guardian.new(group_owner).can_invite_to?(group_private_topic)).to be_truthy
|
|
|
|
end
|
2018-03-08 04:04:17 +08:00
|
|
|
|
|
|
|
it 'returns true for normal user when inviting to topic and PM disabled' do
|
|
|
|
SiteSetting.enable_personal_messages = false
|
|
|
|
expect(Guardian.new(trust_level_2).can_invite_to?(topic)).to be_truthy
|
|
|
|
end
|
2018-12-05 23:43:07 +08:00
|
|
|
|
|
|
|
describe 'for a private category for automatic and non-automatic group' do
|
|
|
|
let(:automatic_group) { Fabricate(:group, automatic: true) }
|
|
|
|
let(:group) { Fabricate(:group) }
|
|
|
|
|
|
|
|
let(:category) do
|
|
|
|
Fabricate(:category, read_restricted: true).tap do |category|
|
|
|
|
category.groups << automatic_group
|
|
|
|
category.groups << group
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:topic) { Fabricate(:topic, category: category) }
|
|
|
|
|
|
|
|
it 'should return true for an admin user' do
|
|
|
|
expect(Guardian.new(admin).can_invite_to?(topic)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should return true for a group owner' do
|
|
|
|
expect(Guardian.new(group_owner).can_invite_to?(topic)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should return false for a normal user' do
|
|
|
|
expect(Guardian.new(user).can_invite_to?(topic)).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'for a private category for automatic groups' do
|
|
|
|
let(:group) { Fabricate(:group, automatic: true) }
|
|
|
|
|
|
|
|
let(:category) do
|
|
|
|
Fabricate(:private_category, group: group, read_restricted: true)
|
|
|
|
end
|
|
|
|
|
|
|
|
let(:group_owner) { Fabricate(:user).tap { |user| group.add_owner(user) } }
|
|
|
|
let(:topic) { Fabricate(:topic, category: category) }
|
|
|
|
|
|
|
|
it 'should return false for all type of users' do
|
|
|
|
expect(Guardian.new(admin).can_invite_to?(topic)).to eq(false)
|
|
|
|
expect(Guardian.new(group_owner).can_invite_to?(topic)).to eq(false)
|
|
|
|
expect(Guardian.new(user).can_invite_to?(topic)).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
2014-07-05 01:34:19 +08:00
|
|
|
end
|
|
|
|
|
2017-05-20 00:55:26 +08:00
|
|
|
describe "private messages" do
|
|
|
|
let(:user) { Fabricate(:user, trust_level: TrustLevel[2]) }
|
|
|
|
let!(:pm) { Fabricate(:private_message_topic, user: user) }
|
|
|
|
let(:admin) { Fabricate(:admin) }
|
2018-08-23 12:36:49 +08:00
|
|
|
let(:moderator) { Fabricate(:moderator) }
|
2014-07-05 01:34:19 +08:00
|
|
|
|
2017-05-20 00:55:26 +08:00
|
|
|
context "when private messages are disabled" do
|
|
|
|
it "allows an admin to invite to the pm" do
|
|
|
|
expect(Guardian.new(admin).can_invite_to?(pm)).to be_truthy
|
|
|
|
expect(Guardian.new(user).can_invite_to?(pm)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when private messages are disabled" do
|
|
|
|
before do
|
2018-01-31 14:03:12 +08:00
|
|
|
SiteSetting.enable_personal_messages = false
|
2017-05-20 00:55:26 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow a regular user to invite" do
|
|
|
|
expect(Guardian.new(admin).can_invite_to?(pm)).to be_truthy
|
|
|
|
expect(Guardian.new(user).can_invite_to?(pm)).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
2018-08-23 12:36:49 +08:00
|
|
|
|
|
|
|
context "when PM has receached the maximum number of recipients" do
|
|
|
|
before do
|
|
|
|
SiteSetting.max_allowed_message_recipients = 2
|
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow a regular user to invite" do
|
|
|
|
expect(Guardian.new(user).can_invite_to?(pm)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "allows staff to invite" do
|
|
|
|
expect(Guardian.new(admin).can_invite_to?(pm)).to be_truthy
|
|
|
|
pm.grant_permission_to_user(moderator.email)
|
|
|
|
expect(Guardian.new(moderator).can_invite_to?(pm)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
2015-03-03 03:25:25 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2017-02-03 01:38:25 +08:00
|
|
|
describe 'can_invite_via_email?' do
|
|
|
|
it 'returns true for all (tl2 and above) users when sso is disabled, local logins are enabled, user approval is not required' do
|
|
|
|
expect(Guardian.new(trust_level_2).can_invite_via_email?(topic)).to be_truthy
|
|
|
|
expect(Guardian.new(moderator).can_invite_via_email?(topic)).to be_truthy
|
|
|
|
expect(Guardian.new(admin).can_invite_via_email?(topic)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for all users when sso is enabled' do
|
2017-12-23 16:46:48 +08:00
|
|
|
SiteSetting.sso_url = "https://www.example.com/sso"
|
2017-02-03 01:38:25 +08:00
|
|
|
SiteSetting.enable_sso = true
|
|
|
|
|
|
|
|
expect(Guardian.new(trust_level_2).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for all users when local logins are disabled' do
|
|
|
|
SiteSetting.enable_local_logins = false
|
|
|
|
|
|
|
|
expect(Guardian.new(trust_level_2).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns correct valuse when user approval is required' do
|
|
|
|
SiteSetting.must_approve_users = true
|
|
|
|
|
|
|
|
expect(Guardian.new(trust_level_2).can_invite_via_email?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_invite_via_email?(topic)).to be_truthy
|
|
|
|
expect(Guardian.new(admin).can_invite_via_email?(topic)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe 'can_see?' do
|
|
|
|
|
|
|
|
it 'returns false with a nil object' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_see?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2016-02-24 18:30:17 +08:00
|
|
|
describe 'a Category' do
|
|
|
|
|
|
|
|
it 'allows public categories' do
|
|
|
|
public_category = build(:category, read_restricted: false)
|
|
|
|
expect(Guardian.new.can_see?(public_category)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'correctly handles secure categories' do
|
|
|
|
normal_user = build(:user)
|
|
|
|
staged_user = build(:user, staged: true)
|
|
|
|
admin_user = build(:user, admin: true)
|
|
|
|
|
|
|
|
secure_category = build(:category, read_restricted: true)
|
|
|
|
expect(Guardian.new(normal_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(staged_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(admin_user).can_see?(secure_category)).to be_truthy
|
|
|
|
|
|
|
|
secure_category = build(:category, read_restricted: true, email_in: "foo@bar.com")
|
|
|
|
expect(Guardian.new(normal_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(staged_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(admin_user).can_see?(secure_category)).to be_truthy
|
|
|
|
|
|
|
|
secure_category = build(:category, read_restricted: true, email_in_allow_strangers: true)
|
|
|
|
expect(Guardian.new(normal_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(staged_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(admin_user).can_see?(secure_category)).to be_truthy
|
|
|
|
|
|
|
|
secure_category = build(:category, read_restricted: true, email_in: "foo@bar.com", email_in_allow_strangers: true)
|
|
|
|
expect(Guardian.new(normal_user).can_see?(secure_category)).to be_falsey
|
|
|
|
expect(Guardian.new(staged_user).can_see?(secure_category)).to be_truthy
|
|
|
|
expect(Guardian.new(admin_user).can_see?(secure_category)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'allows members of an authorized group' do
|
|
|
|
user = Fabricate(:user)
|
|
|
|
group = Fabricate(:group)
|
|
|
|
|
|
|
|
secure_category = Fabricate(:category)
|
|
|
|
secure_category.set_permissions(group => :readonly)
|
|
|
|
secure_category.save
|
|
|
|
|
|
|
|
expect(Guardian.new(user).can_see?(secure_category)).to be_falsey
|
|
|
|
|
|
|
|
group.add(user)
|
|
|
|
group.save
|
|
|
|
|
|
|
|
expect(Guardian.new(user).can_see?(secure_category)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe 'a Topic' do
|
|
|
|
it 'allows non logged in users to view topics' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_see?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2013-04-29 14:33:24 +08:00
|
|
|
|
|
|
|
it 'correctly handles groups' do
|
|
|
|
group = Fabricate(:group)
|
2013-07-14 09:24:16 +08:00
|
|
|
category = Fabricate(:category, read_restricted: true)
|
|
|
|
category.set_permissions(group => :full)
|
|
|
|
category.save
|
2013-04-29 14:33:24 +08:00
|
|
|
|
|
|
|
topic = Fabricate(:topic, category: category)
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see?(topic)).to be_falsey
|
2013-04-29 14:33:24 +08:00
|
|
|
group.add(user)
|
|
|
|
group.save
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see?(topic)).to be_truthy
|
2013-04-29 14:33:24 +08:00
|
|
|
end
|
2014-05-13 03:26:36 +08:00
|
|
|
|
2014-07-16 05:02:43 +08:00
|
|
|
it "restricts deleted topics" do
|
|
|
|
topic = Fabricate(:topic)
|
|
|
|
topic.trash!(moderator)
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_see?(topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_see?(topic)).to be_truthy
|
|
|
|
expect(Guardian.new(admin).can_see?(topic)).to be_truthy
|
2014-07-16 05:02:43 +08:00
|
|
|
end
|
|
|
|
|
2014-05-13 03:26:36 +08:00
|
|
|
it "restricts private topics" do
|
|
|
|
user.save!
|
|
|
|
private_topic = Fabricate(:private_message_topic, user: user)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(private_topic.user).can_see?(private_topic)).to be_truthy
|
|
|
|
expect(Guardian.new(build(:user)).can_see?(private_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_see?(private_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_see?(private_topic)).to be_truthy
|
2014-05-13 03:26:36 +08:00
|
|
|
end
|
2014-07-16 05:02:43 +08:00
|
|
|
|
|
|
|
it "restricts private deleted topics" do
|
|
|
|
user.save!
|
|
|
|
private_topic = Fabricate(:private_message_topic, user: user)
|
|
|
|
private_topic.trash!(admin)
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(private_topic.user).can_see?(private_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(build(:user)).can_see?(private_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_see?(private_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_see?(private_topic)).to be_truthy
|
2014-07-16 05:02:43 +08:00
|
|
|
end
|
2014-07-29 22:40:02 +08:00
|
|
|
|
|
|
|
it "restricts static doc topics" do
|
|
|
|
tos_topic = Fabricate(:topic, user: Discourse.system_user)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.tos_topic_id = tos_topic.id
|
2014-07-29 22:40:02 +08:00
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_edit?(tos_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_edit?(tos_topic)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_edit?(tos_topic)).to be_truthy
|
2014-07-29 22:40:02 +08:00
|
|
|
end
|
2015-02-16 20:03:04 +08:00
|
|
|
|
|
|
|
it "allows moderators to see a flagged private message" do
|
|
|
|
moderator.save!
|
|
|
|
user.save!
|
|
|
|
|
|
|
|
private_topic = Fabricate(:private_message_topic, user: user)
|
|
|
|
first_post = Fabricate(:post, topic: private_topic, user: user)
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_see?(private_topic)).to be_falsey
|
|
|
|
|
|
|
|
PostAction.act(user, first_post, PostActionType.types[:off_topic])
|
|
|
|
expect(Guardian.new(moderator).can_see?(private_topic)).to be_truthy
|
|
|
|
end
|
2013-04-29 14:33:24 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a Post' do
|
2013-07-10 03:20:18 +08:00
|
|
|
let(:another_admin) { Fabricate(:admin) }
|
2013-04-29 14:33:24 +08:00
|
|
|
it 'correctly handles post visibility' do
|
2013-05-21 14:39:51 +08:00
|
|
|
post = Fabricate(:post)
|
|
|
|
topic = post.topic
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see?(post)).to be_truthy
|
2013-04-29 14:33:24 +08:00
|
|
|
|
2013-07-10 03:20:18 +08:00
|
|
|
post.trash!(another_admin)
|
2013-04-29 14:33:24 +08:00
|
|
|
post.reload
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see?(post)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_see?(post)).to be_truthy
|
2013-04-29 14:33:24 +08:00
|
|
|
|
2013-05-07 12:39:01 +08:00
|
|
|
post.recover!
|
2013-04-29 14:33:24 +08:00
|
|
|
post.reload
|
2013-07-10 03:20:18 +08:00
|
|
|
topic.trash!(another_admin)
|
2013-04-29 14:33:24 +08:00
|
|
|
topic.reload
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see?(post)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_see?(post)).to be_truthy
|
2013-04-29 14:33:24 +08:00
|
|
|
end
|
2015-09-11 04:01:23 +08:00
|
|
|
|
|
|
|
it 'respects whispers' do
|
|
|
|
regular_post = Fabricate.build(:post)
|
|
|
|
whisper_post = Fabricate.build(:post, post_type: Post.types[:whisper])
|
|
|
|
|
|
|
|
anon_guardian = Guardian.new
|
|
|
|
expect(anon_guardian.can_see?(regular_post)).to eq(true)
|
|
|
|
expect(anon_guardian.can_see?(whisper_post)).to eq(false)
|
|
|
|
|
|
|
|
regular_user = Fabricate.build(:user)
|
|
|
|
regular_guardian = Guardian.new(regular_user)
|
|
|
|
expect(regular_guardian.can_see?(regular_post)).to eq(true)
|
|
|
|
expect(regular_guardian.can_see?(whisper_post)).to eq(false)
|
|
|
|
|
|
|
|
# can see your own whispers
|
|
|
|
regular_whisper = Fabricate.build(:post, post_type: Post.types[:whisper], user: regular_user)
|
|
|
|
expect(regular_guardian.can_see?(regular_whisper)).to eq(true)
|
|
|
|
|
|
|
|
mod_guardian = Guardian.new(Fabricate.build(:moderator))
|
|
|
|
expect(mod_guardian.can_see?(regular_post)).to eq(true)
|
|
|
|
expect(mod_guardian.can_see?(whisper_post)).to eq(true)
|
|
|
|
|
|
|
|
admin_guardian = Guardian.new(Fabricate.build(:admin))
|
|
|
|
expect(admin_guardian.can_see?(regular_post)).to eq(true)
|
|
|
|
expect(admin_guardian.can_see?(whisper_post)).to eq(true)
|
|
|
|
end
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a PostRevision' do
|
|
|
|
let(:post_revision) { Fabricate(:post_revision) }
|
|
|
|
|
|
|
|
context 'edit_history_visible_to_public is true' do
|
2017-07-07 14:09:14 +08:00
|
|
|
before { SiteSetting.edit_history_visible_to_public = true }
|
2014-03-13 22:47:37 +08:00
|
|
|
|
|
|
|
it 'is false for nil' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_see?(nil)).to be_falsey
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true if not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_see?(post_revision)).to be_truthy
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
2013-04-29 14:33:24 +08:00
|
|
|
|
2014-03-13 22:47:37 +08:00
|
|
|
it 'is true when logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(Fabricate(:user)).can_see?(post_revision)).to be_truthy
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
end
|
2013-04-29 14:33:24 +08:00
|
|
|
|
2014-03-13 22:47:37 +08:00
|
|
|
context 'edit_history_visible_to_public is false' do
|
2017-07-07 14:09:14 +08:00
|
|
|
before { SiteSetting.edit_history_visible_to_public = false }
|
2014-03-13 22:47:37 +08:00
|
|
|
|
|
|
|
it 'is true for staff' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(Fabricate(:admin)).can_see?(post_revision)).to be_truthy
|
|
|
|
expect(Guardian.new(Fabricate(:moderator)).can_see?(post_revision)).to be_truthy
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for trust level 4' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_4).can_see?(post_revision)).to be_truthy
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for trust level lower than 4' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_3).can_see?(post_revision)).to be_falsey
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'can_create?' do
|
|
|
|
|
|
|
|
describe 'a Category' do
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_create?(Category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when a regular user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_create?(Category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-02-07 11:11:52 +08:00
|
|
|
it 'returns false when a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_create?(Category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_create?(Category)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-07-16 13:44:07 +08:00
|
|
|
describe 'a Topic' do
|
2016-04-13 13:59:38 +08:00
|
|
|
it 'does not allow moderators to create topics in readonly categories' do
|
|
|
|
category = Fabricate(:category)
|
2017-07-28 09:20:09 +08:00
|
|
|
category.set_permissions(everyone: :read)
|
2016-04-13 13:59:38 +08:00
|
|
|
category.save
|
|
|
|
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(moderator).can_create?(Topic, category)).to be_falsey
|
2016-04-13 13:59:38 +08:00
|
|
|
end
|
|
|
|
|
2013-07-16 13:44:07 +08:00
|
|
|
it 'should check for full permissions' do
|
|
|
|
category = Fabricate(:category)
|
2017-07-28 09:20:09 +08:00
|
|
|
category.set_permissions(everyone: :create_post)
|
2013-07-16 13:44:07 +08:00
|
|
|
category.save
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(user).can_create?(Topic, category)).to be_falsey
|
2013-07-16 13:44:07 +08:00
|
|
|
end
|
2013-09-04 07:12:22 +08:00
|
|
|
|
|
|
|
it "is true for new users by default" do
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(user).can_create?(Topic, Fabricate(:category))).to be_truthy
|
2013-09-04 07:12:22 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false if user has not met minimum trust level" do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.min_trust_to_create_topic = 1
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(build(:user, trust_level: 0)).can_create?(Topic, Fabricate(:category))).to be_falsey
|
2013-09-04 07:12:22 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true if user has met or exceeded the minimum trust level" do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.min_trust_to_create_topic = 1
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(build(:user, trust_level: 1)).can_create?(Topic, Fabricate(:category))).to be_truthy
|
|
|
|
expect(Guardian.new(build(:user, trust_level: 2)).can_create?(Topic, Fabricate(:category))).to be_truthy
|
|
|
|
expect(Guardian.new(build(:admin, trust_level: 0)).can_create?(Topic, Fabricate(:category))).to be_truthy
|
|
|
|
expect(Guardian.new(build(:moderator, trust_level: 0)).can_create?(Topic, Fabricate(:category))).to be_truthy
|
2013-09-04 07:12:22 +08:00
|
|
|
end
|
2013-07-16 13:44:07 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe 'a Post' do
|
|
|
|
|
2013-07-16 13:44:07 +08:00
|
|
|
it "is false on readonly categories" do
|
|
|
|
category = Fabricate(:category)
|
|
|
|
topic.category = category
|
2017-07-28 09:20:09 +08:00
|
|
|
category.set_permissions(everyone: :readonly)
|
2013-07-16 13:44:07 +08:00
|
|
|
category.save
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(topic.user).can_create?(Post, topic)).to be_falsey
|
2016-04-13 13:59:38 +08:00
|
|
|
expect(Guardian.new(moderator).can_create?(Post, topic)).to be_falsey
|
2013-07-16 13:44:07 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it "is false when not logged in" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_create?(Post, topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for a regular user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(topic.user).can_create?(Post, topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false when you can't see the topic" do
|
|
|
|
Guardian.any_instance.expects(:can_see?).with(topic).returns(false)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(topic.user).can_create?(Post, topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'closed topic' do
|
|
|
|
before do
|
|
|
|
topic.closed = true
|
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow new posts from regular users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(topic.user).can_create?(Post, topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'allows editing of posts' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(topic.user).can_edit?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows new posts from moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_create?(Post, topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows new posts from admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_create?(Post, topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2014-03-18 02:50:28 +08:00
|
|
|
|
2014-09-05 14:52:40 +08:00
|
|
|
it "allows new posts from trust_level_4s" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_4).can_create?(Post, topic)).to be_truthy
|
2014-03-18 02:50:28 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'archived topic' do
|
|
|
|
before do
|
|
|
|
topic.archived = true
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'regular users' do
|
|
|
|
it "doesn't allow new posts from regular users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_create?(Post, topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-08-16 00:44:58 +08:00
|
|
|
it 'does not allow editing of posts' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
2013-02-26 00:42:20 +08:00
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it "allows new posts from moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_create?(Post, topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows new posts from admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_create?(Post, topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-07-12 04:38:46 +08:00
|
|
|
context "trashed topic" do
|
|
|
|
before do
|
|
|
|
topic.deleted_at = Time.now
|
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow new posts from regular users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_create?(Post, topic)).to be_falsey
|
2013-07-12 04:38:46 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow new posts from moderators users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_create?(Post, topic)).to be_falsey
|
2013-07-12 04:38:46 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow new posts from admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_create?(Post, topic)).to be_falsey
|
2013-07-12 04:38:46 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-01-24 02:11:39 +08:00
|
|
|
context "system message" do
|
|
|
|
let(:private_message) {
|
|
|
|
Fabricate(
|
|
|
|
:topic,
|
|
|
|
archetype: Archetype.private_message,
|
|
|
|
subtype: 'system_message',
|
|
|
|
category_id: nil
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
before { user.save! }
|
|
|
|
it "allows the user to reply to system messages" do
|
|
|
|
expect(Guardian.new(user).can_create_post?(private_message)).to eq(true)
|
|
|
|
SiteSetting.enable_system_message_replies = false
|
|
|
|
expect(Guardian.new(user).can_create_post?(private_message)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2016-01-23 01:54:18 +08:00
|
|
|
context "private message" do
|
|
|
|
let(:private_message) { Fabricate(:topic, archetype: Archetype.private_message, category_id: nil) }
|
2013-07-12 04:38:46 +08:00
|
|
|
|
2016-01-23 01:54:18 +08:00
|
|
|
before { user.save! }
|
|
|
|
|
|
|
|
it "allows new posts by people included in the pm" do
|
|
|
|
private_message.topic_allowed_users.create!(user_id: user.id)
|
|
|
|
expect(Guardian.new(user).can_create?(Post, private_message)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow new posts by people not invited to the pm" do
|
|
|
|
expect(Guardian.new(user).can_create?(Post, private_message)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2017-11-11 01:18:08 +08:00
|
|
|
it "allows new posts from silenced users included in the pm" do
|
2017-11-14 02:41:36 +08:00
|
|
|
user.update_attribute(:silenced_till, 1.year.from_now)
|
2016-01-23 01:54:18 +08:00
|
|
|
private_message.topic_allowed_users.create!(user_id: user.id)
|
|
|
|
expect(Guardian.new(user).can_create?(Post, private_message)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2017-11-11 01:18:08 +08:00
|
|
|
it "doesn't allow new posts from silenced users not invited to the pm" do
|
2017-11-14 02:41:36 +08:00
|
|
|
user.update_attribute(:silenced_till, 1.year.from_now)
|
2016-01-23 01:54:18 +08:00
|
|
|
expect(Guardian.new(user).can_create?(Post, private_message)).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end # can_create? a Post
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'post_can_act?' do
|
|
|
|
|
|
|
|
it "isn't allowed on nil" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(nil, nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a Post' do
|
2013-02-26 00:42:20 +08:00
|
|
|
|
|
|
|
let (:guardian) do
|
2013-02-06 03:16:51 +08:00
|
|
|
Guardian.new(user)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "isn't allowed when not logged in" do
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(nil).post_can_act?(post, :vote)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is allowed as a regular user" do
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(guardian.post_can_act?(post, :vote)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "isn't allowed on archived topics" do
|
|
|
|
topic.archived = true
|
2017-07-28 09:20:09 +08:00
|
|
|
expect(Guardian.new(user).post_can_act?(post, :like)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-07-13 00:08:23 +08:00
|
|
|
describe "can_recover_topic?" do
|
|
|
|
|
|
|
|
it "returns false for a nil user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_recover_topic?(topic)).to be_falsey
|
2013-07-13 00:08:23 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for a nil object" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_recover_topic?(nil)).to be_falsey
|
2013-07-13 00:08:23 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for a regular user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_recover_topic?(topic)).to be_falsey
|
2013-07-13 00:08:23 +08:00
|
|
|
end
|
|
|
|
|
2017-03-06 13:17:57 +08:00
|
|
|
context 'as a moderator' do
|
|
|
|
before do
|
|
|
|
topic.save!
|
|
|
|
post.save!
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when post has been deleted' do
|
|
|
|
it "should return the right value" do
|
|
|
|
expect(Guardian.new(moderator).can_recover_topic?(topic)).to be_falsey
|
|
|
|
|
|
|
|
PostDestroyer.new(moderator, topic.first_post).destroy
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_recover_topic?(topic.reload)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "when post's user has been deleted" do
|
|
|
|
it 'should return the right value' do
|
|
|
|
PostDestroyer.new(moderator, topic.first_post).destroy
|
|
|
|
topic.first_post.user.destroy!
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_recover_topic?(topic.reload)).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
2013-07-13 00:08:23 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-02-08 04:12:55 +08:00
|
|
|
describe "can_recover_post?" do
|
|
|
|
|
|
|
|
it "returns false for a nil user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_recover_post?(post)).to be_falsey
|
2013-02-08 04:12:55 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for a nil object" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_recover_post?(nil)).to be_falsey
|
2013-02-08 04:12:55 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for a regular user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_recover_post?(post)).to be_falsey
|
2013-02-08 04:12:55 +08:00
|
|
|
end
|
|
|
|
|
2017-03-06 13:17:57 +08:00
|
|
|
context 'as a moderator' do
|
|
|
|
let(:other_post) { Fabricate(:post, topic: topic, user: topic.user) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
topic.save!
|
|
|
|
post.save!
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when post has been deleted' do
|
|
|
|
it "should return the right value" do
|
|
|
|
expect(Guardian.new(moderator).can_recover_post?(post)).to be_falsey
|
|
|
|
|
|
|
|
PostDestroyer.new(moderator, post).destroy
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_recover_post?(post.reload)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "when post's user has been deleted" do
|
|
|
|
it 'should return the right value' do
|
|
|
|
PostDestroyer.new(moderator, post).destroy
|
|
|
|
post.user.destroy!
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_recover_post?(post.reload)).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2013-02-08 04:12:55 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2016-05-01 19:48:43 +08:00
|
|
|
context 'can_convert_topic?' do
|
|
|
|
it 'returns false with a nil object' do
|
|
|
|
expect(Guardian.new(user).can_convert_topic?(nil)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
|
|
|
expect(Guardian.new.can_convert_topic?(topic)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2016-05-05 00:29:56 +08:00
|
|
|
it 'returns false when not staff' do
|
|
|
|
expect(Guardian.new(trust_level_4).can_convert_topic?(topic)).to be_falsey
|
2017-10-02 16:04:58 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for category definition topics' do
|
|
|
|
c = Fabricate(:category)
|
|
|
|
topic = Topic.find_by(id: c.topic_id)
|
|
|
|
expect(Guardian.new(admin).can_convert_topic?(topic)).to be_falsey
|
2016-05-05 00:29:56 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when a moderator' do
|
|
|
|
expect(Guardian.new(moderator).can_convert_topic?(topic)).to be_truthy
|
2016-05-01 19:48:43 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
|
|
|
expect(Guardian.new(admin).can_convert_topic?(topic)).to be_truthy
|
|
|
|
end
|
2018-03-03 09:28:39 +08:00
|
|
|
|
|
|
|
it 'returns false when personal messages are disabled' do
|
|
|
|
SiteSetting.enable_personal_messages = false
|
|
|
|
expect(Guardian.new(admin).can_convert_topic?(topic)).to be_falsey
|
|
|
|
end
|
2016-05-01 19:48:43 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
describe 'can_edit?' do
|
|
|
|
|
|
|
|
it 'returns false with a nil object' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a Post' do
|
|
|
|
|
2018-08-15 12:29:36 +08:00
|
|
|
it 'returns false for silenced users' do
|
|
|
|
post.user.silenced_till = 1.day.from_now
|
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_edit?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-05-13 20:53:11 +08:00
|
|
|
it 'returns false when not logged in also for wiki post' do
|
|
|
|
post.wiki = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_edit?(post)).to be_falsey
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it 'returns true if you want to edit your own post' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2018-01-26 04:38:40 +08:00
|
|
|
it 'returns false if you try to edit a locked post' do
|
|
|
|
post.locked_by_id = moderator.id
|
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2014-06-21 03:38:03 +08:00
|
|
|
it "returns false if the post is hidden due to flagging and it's too soon" do
|
|
|
|
post.hidden = true
|
|
|
|
post.hidden_at = Time.now
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_falsey
|
2014-06-21 03:38:03 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if the post is hidden due to flagging and it been enough time" do
|
|
|
|
post.hidden = true
|
|
|
|
post.hidden_at = (SiteSetting.cooldown_minutes_after_hiding_posts + 1).minutes.ago
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_truthy
|
2014-09-16 23:20:31 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if the post is hidden, it's been enough time and the edit window has expired" do
|
|
|
|
post.hidden = true
|
|
|
|
post.hidden_at = (SiteSetting.cooldown_minutes_after_hiding_posts + 1).minutes.ago
|
|
|
|
post.created_at = (SiteSetting.post_edit_time_limit + 1).minutes.ago
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_truthy
|
2014-06-21 03:38:03 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if the post is hidden due to flagging and it's got a nil `hidden_at`" do
|
|
|
|
post.hidden = true
|
|
|
|
post.hidden_at = nil
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_truthy
|
2014-06-21 03:38:03 +08:00
|
|
|
end
|
|
|
|
|
2013-07-22 15:48:24 +08:00
|
|
|
it 'returns false if you are trying to edit a post you soft deleted' do
|
|
|
|
post.user_deleted = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_falsey
|
2013-07-22 15:48:24 +08:00
|
|
|
end
|
|
|
|
|
2014-05-13 20:53:11 +08:00
|
|
|
it 'returns false if another regular user tries to edit a soft deleted wiki post' do
|
|
|
|
post.wiki = true
|
|
|
|
post.user_deleted = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_falsey
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
|
|
|
|
2013-07-22 15:48:24 +08:00
|
|
|
it 'returns false if you are trying to edit a deleted post' do
|
|
|
|
post.deleted_at = 1.day.ago
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_falsey
|
2013-07-22 15:48:24 +08:00
|
|
|
end
|
|
|
|
|
2014-05-13 20:53:11 +08:00
|
|
|
it 'returns false if another regular user tries to edit a deleted wiki post' do
|
|
|
|
post.wiki = true
|
|
|
|
post.deleted_at = 1.day.ago
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_falsey
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it 'returns false if another regular user tries to edit your post' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-05-13 20:53:11 +08:00
|
|
|
it 'returns true if another regular user tries to edit wiki post' do
|
|
|
|
post.wiki = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_truthy
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
|
|
|
|
2017-05-09 04:23:11 +08:00
|
|
|
it "returns false if a wiki but the user can't create a post" do
|
|
|
|
c = Fabricate(:category)
|
2017-07-28 09:20:09 +08:00
|
|
|
c.set_permissions(everyone: :readonly)
|
2017-05-09 04:23:11 +08:00
|
|
|
c.save
|
|
|
|
|
|
|
|
topic = Fabricate(:topic, category: c)
|
|
|
|
post = Fabricate(:post, topic: topic)
|
|
|
|
post.wiki = true
|
|
|
|
|
|
|
|
user = Fabricate(:user)
|
|
|
|
expect(Guardian.new(user).can_edit?(post)).to eq(false)
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it 'returns true as a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2018-01-26 04:38:40 +08:00
|
|
|
it 'returns true as a moderator, even if locked' do
|
|
|
|
post.locked_by_id = admin.id
|
|
|
|
expect(Guardian.new(moderator).can_edit?(post)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it 'returns true as an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2014-01-07 23:32:09 +08:00
|
|
|
|
2014-03-13 22:47:37 +08:00
|
|
|
it 'returns true as a trust level 4 user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_4).can_edit?(post)).to be_truthy
|
2014-03-13 22:47:37 +08:00
|
|
|
end
|
|
|
|
|
2018-02-23 09:39:24 +08:00
|
|
|
it 'returns false as a TL4 user if trusted_users_can_edit_others is true' do
|
|
|
|
SiteSetting.trusted_users_can_edit_others = false
|
|
|
|
expect(Guardian.new(trust_level_4).can_edit?(post)).to eq(false)
|
|
|
|
end
|
|
|
|
|
2016-10-01 00:12:27 +08:00
|
|
|
it 'returns false when trying to edit a post with no trust' do
|
|
|
|
SiteSetting.min_trust_to_edit_post = 2
|
|
|
|
post.user.trust_level = 1
|
|
|
|
|
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when trying to edit a post with trust' do
|
|
|
|
SiteSetting.min_trust_to_edit_post = 1
|
|
|
|
post.user.trust_level = 1
|
|
|
|
|
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2015-02-26 03:53:21 +08:00
|
|
|
it 'returns false when another user has too low trust level to edit wiki post' do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.min_trust_to_edit_wiki_post = 2
|
2015-02-26 03:53:21 +08:00
|
|
|
post.wiki = true
|
|
|
|
coding_horror.trust_level = 1
|
|
|
|
|
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when another user has adequate trust level to edit wiki post' do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.min_trust_to_edit_wiki_post = 2
|
2015-02-26 03:53:21 +08:00
|
|
|
post.wiki = true
|
|
|
|
coding_horror.trust_level = 2
|
|
|
|
|
|
|
|
expect(Guardian.new(coding_horror).can_edit?(post)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for post author even when he has too low trust level to edit wiki post' do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.min_trust_to_edit_wiki_post = 2
|
2015-02-26 03:53:21 +08:00
|
|
|
post.wiki = true
|
|
|
|
post.user.trust_level = 1
|
|
|
|
|
|
|
|
expect(Guardian.new(post.user).can_edit?(post)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2014-01-07 23:32:09 +08:00
|
|
|
context 'post is older than post_edit_time_limit' do
|
|
|
|
let(:old_post) { build(:post, topic: topic, user: topic.user, created_at: 6.minutes.ago) }
|
2017-07-07 14:09:14 +08:00
|
|
|
|
2014-01-07 23:32:09 +08:00
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.post_edit_time_limit = 5
|
2014-01-07 23:32:09 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false to the author of the post' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(old_post.user).can_edit?(old_post)).to be_falsey
|
2014-01-07 23:32:09 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true as a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit?(old_post)).to eq(true)
|
2014-01-07 23:32:09 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true as an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit?(old_post)).to eq(true)
|
2014-01-07 23:32:09 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for another regular user trying to edit your post' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(old_post)).to be_falsey
|
2014-01-07 23:32:09 +08:00
|
|
|
end
|
2014-05-13 20:53:11 +08:00
|
|
|
|
|
|
|
it 'returns true for another regular user trying to edit a wiki post' do
|
|
|
|
old_post.wiki = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(old_post)).to be_truthy
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
2014-01-07 23:32:09 +08:00
|
|
|
end
|
2014-07-29 22:40:02 +08:00
|
|
|
|
|
|
|
context "first post of a static page doc" do
|
|
|
|
let!(:tos_topic) { Fabricate(:topic, user: Discourse.system_user) }
|
|
|
|
let!(:tos_first_post) { build(:post, topic: tos_topic, user: tos_topic.user) }
|
2017-07-07 14:09:14 +08:00
|
|
|
before { SiteSetting.tos_topic_id = tos_topic.id }
|
2014-07-29 22:40:02 +08:00
|
|
|
|
|
|
|
it "restricts static doc posts" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_edit?(tos_first_post)).to be_falsey
|
|
|
|
expect(Guardian.new(moderator).can_edit?(tos_first_post)).to be_falsey
|
|
|
|
expect(Guardian.new(admin).can_edit?(tos_first_post)).to be_truthy
|
2014-07-29 22:40:02 +08:00
|
|
|
end
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a Topic' do
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_edit?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for editing your own post' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(topic.user).can_edit?(topic)).to eq(true)
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false as a regular user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-07-10 04:48:26 +08:00
|
|
|
context 'not archived' do
|
|
|
|
it 'returns true as a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit?(topic)).to eq(true)
|
2013-07-10 04:48:26 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true as an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit?(topic)).to eq(true)
|
2014-01-17 00:59:26 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true at trust level 3' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(topic)).to eq(true)
|
2013-07-10 04:48:26 +08:00
|
|
|
end
|
2015-05-01 05:03:51 +08:00
|
|
|
|
2018-02-23 09:39:24 +08:00
|
|
|
it 'is false at TL3, if `trusted_users_can_edit_others` is false' do
|
|
|
|
SiteSetting.trusted_users_can_edit_others = false
|
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(topic)).to eq(false)
|
|
|
|
end
|
|
|
|
|
2015-05-01 05:03:51 +08:00
|
|
|
it "returns false when the category is read only" do
|
|
|
|
topic.category.set_permissions(everyone: :readonly)
|
|
|
|
topic.category.save
|
|
|
|
|
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(topic)).to eq(false)
|
2016-04-13 13:59:38 +08:00
|
|
|
|
|
|
|
expect(Guardian.new(admin).can_edit?(topic)).to eq(true)
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_edit?(post)).to eq(false)
|
|
|
|
expect(Guardian.new(moderator).can_edit?(topic)).to eq(false)
|
2015-05-01 05:03:51 +08:00
|
|
|
end
|
2016-06-02 03:41:56 +08:00
|
|
|
|
|
|
|
it "returns false for trust level 3 if category is secured" do
|
|
|
|
topic.category.set_permissions(everyone: :create_post, staff: :full)
|
|
|
|
topic.category.save
|
|
|
|
|
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(topic)).to eq(false)
|
|
|
|
expect(Guardian.new(admin).can_edit?(topic)).to eq(true)
|
|
|
|
expect(Guardian.new(moderator).can_edit?(topic)).to eq(true)
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-09-11 15:39:20 +08:00
|
|
|
context 'private message' do
|
|
|
|
it 'returns false at trust level 3' do
|
|
|
|
topic.archetype = 'private_message'
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(topic)).to eq(false)
|
2014-09-11 15:39:20 +08:00
|
|
|
end
|
2016-01-29 03:05:56 +08:00
|
|
|
|
|
|
|
it 'returns false at trust level 4' do
|
|
|
|
topic.archetype = 'private_message'
|
|
|
|
expect(Guardian.new(trust_level_4).can_edit?(topic)).to eq(false)
|
|
|
|
end
|
2014-09-11 15:39:20 +08:00
|
|
|
end
|
|
|
|
|
2013-07-10 04:48:26 +08:00
|
|
|
context 'archived' do
|
2015-02-26 03:53:21 +08:00
|
|
|
let(:archived_topic) { build(:topic, user: user, archived: true) }
|
|
|
|
|
|
|
|
it 'returns true as a moderator' do
|
|
|
|
expect(Guardian.new(moderator).can_edit?(archived_topic)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true as an admin' do
|
|
|
|
expect(Guardian.new(admin).can_edit?(archived_topic)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2016-01-29 03:05:56 +08:00
|
|
|
it 'returns true at trust level 4' do
|
|
|
|
expect(Guardian.new(trust_level_4).can_edit?(archived_topic)).to be_truthy
|
|
|
|
end
|
|
|
|
|
2018-02-23 09:39:24 +08:00
|
|
|
it 'is false at TL4, if `trusted_users_can_edit_others` is false' do
|
|
|
|
SiteSetting.trusted_users_can_edit_others = false
|
|
|
|
expect(Guardian.new(trust_level_4).can_edit?(archived_topic)).to eq(false)
|
|
|
|
end
|
|
|
|
|
2016-01-29 03:05:56 +08:00
|
|
|
it 'returns false at trust level 3' do
|
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(archived_topic)).to be_falsey
|
2015-02-26 03:53:21 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false as a topic creator' do
|
|
|
|
expect(Guardian.new(user).can_edit?(archived_topic)).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'very old' do
|
|
|
|
let(:old_topic) { build(:topic, user: user, created_at: 6.minutes.ago) }
|
|
|
|
|
2017-07-07 14:09:14 +08:00
|
|
|
before { SiteSetting.post_edit_time_limit = 5 }
|
2015-02-26 03:53:21 +08:00
|
|
|
|
2014-08-16 00:44:58 +08:00
|
|
|
it 'returns true as a moderator' do
|
2015-02-26 03:53:21 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit?(old_topic)).to be_truthy
|
2013-07-10 04:48:26 +08:00
|
|
|
end
|
|
|
|
|
2014-08-16 00:44:58 +08:00
|
|
|
it 'returns true as an admin' do
|
2015-02-26 03:53:21 +08:00
|
|
|
expect(Guardian.new(admin).can_edit?(old_topic)).to be_truthy
|
2014-08-16 00:44:58 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true at trust level 3' do
|
2015-02-26 03:53:21 +08:00
|
|
|
expect(Guardian.new(trust_level_3).can_edit?(old_topic)).to be_truthy
|
2014-01-17 00:59:26 +08:00
|
|
|
end
|
|
|
|
|
2014-08-16 00:44:58 +08:00
|
|
|
it 'returns false as a topic creator' do
|
2015-02-26 03:53:21 +08:00
|
|
|
expect(Guardian.new(user).can_edit?(old_topic)).to be_falsey
|
2013-07-10 04:48:26 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a Category' do
|
|
|
|
|
|
|
|
let(:category) { Fabricate(:category) }
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_edit?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false as a regular user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(category.user).can_edit?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-02-07 11:11:52 +08:00
|
|
|
it 'returns false as a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true as an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit?(category)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'a User' do
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_edit?(user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false as a different user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_edit?(user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when trying to edit yourself' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit?(user)).to be_truthy
|
2013-02-26 00:42:20 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
2013-05-02 13:15:17 +08:00
|
|
|
it 'returns true as a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true as an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_moderate?' do
|
|
|
|
|
|
|
|
it 'returns false with a nil object' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_moderate?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2017-11-11 01:18:08 +08:00
|
|
|
context 'when user is silenced' do
|
2016-06-20 15:41:17 +08:00
|
|
|
it 'returns false' do
|
2017-11-14 02:41:36 +08:00
|
|
|
user.update_column(:silenced_till, 1.year.from_now)
|
2016-06-20 15:41:17 +08:00
|
|
|
expect(Guardian.new(user).can_moderate?(post)).to be(false)
|
|
|
|
expect(Guardian.new(user).can_moderate?(topic)).to be(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
context 'a Topic' do
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_moderate?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when not a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_moderate?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_moderate?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_moderate?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-03-18 02:50:28 +08:00
|
|
|
it 'returns true when trust level 4' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(trust_level_4).can_moderate?(topic)).to be_truthy
|
2014-03-18 02:50:28 +08:00
|
|
|
end
|
|
|
|
|
2013-02-26 00:42:20 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_see_flags?' do
|
|
|
|
|
|
|
|
it "returns false when there is no post" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_see_flags?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when there is no user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_see_flags?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-08-14 04:08:29 +08:00
|
|
|
it "allow regular users to see flags" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see_flags?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows moderators to see flags" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_see_flags?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows moderators to see flags" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_see_flags?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_move_posts?' do
|
|
|
|
|
|
|
|
it 'returns false with a nil object' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_move_posts?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'a Topic' do
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_move_posts?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when not a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_move_posts?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_move_posts?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_move_posts?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-02-26 00:42:20 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_delete?' do
|
|
|
|
|
|
|
|
it 'returns false with a nil object' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'a Topic' do
|
2013-10-24 07:05:51 +08:00
|
|
|
before do
|
|
|
|
# pretend we have a real topic
|
|
|
|
topic.id = 9999999
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_delete?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when not a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(topic)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_delete?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(topic)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2014-08-14 05:02:44 +08:00
|
|
|
|
|
|
|
it 'returns false for static doc topics' do
|
|
|
|
tos_topic = Fabricate(:topic, user: Discourse.system_user)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.tos_topic_id = tos_topic.id
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(tos_topic)).to be_falsey
|
2014-08-14 05:02:44 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'a Post' do
|
|
|
|
|
|
|
|
before do
|
|
|
|
post.post_number = 2
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_delete?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-02-08 04:12:55 +08:00
|
|
|
it "returns false when trying to delete your own post that has already been deleted" do
|
2013-05-21 14:39:51 +08:00
|
|
|
post = Fabricate(:post)
|
2013-03-19 05:52:29 +08:00
|
|
|
PostDestroyer.new(user, post).destroy
|
2013-02-08 04:12:55 +08:00
|
|
|
post.reload
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-02-08 04:12:55 +08:00
|
|
|
it 'returns true when trying to delete your own post' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(post)).to be_truthy
|
2013-02-08 04:12:55 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when trying to delete another user's own post" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(Fabricate(:user)).can_delete?(post)).to be_falsey
|
2013-02-08 04:12:55 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it "returns false when it's the OP, even as a moderator" do
|
|
|
|
post.update_attribute :post_number, 1
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_delete?(post)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_delete?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(post)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2014-01-07 23:32:09 +08:00
|
|
|
|
2014-08-14 05:02:44 +08:00
|
|
|
it 'returns false when post is first in a static doc topic' do
|
|
|
|
tos_topic = Fabricate(:topic, user: Discourse.system_user)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.tos_topic_id = tos_topic.id
|
2014-08-14 05:02:44 +08:00
|
|
|
post.update_attribute :post_number, 1
|
|
|
|
post.update_attribute :topic_id, tos_topic.id
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(post)).to be_falsey
|
2014-08-14 05:02:44 +08:00
|
|
|
end
|
|
|
|
|
2014-01-18 06:42:12 +08:00
|
|
|
context 'the topic is archived' do
|
|
|
|
before do
|
|
|
|
post.topic.archived = true
|
|
|
|
end
|
|
|
|
|
|
|
|
it "allows a staff member to delete it" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_delete?(post)).to be_truthy
|
2014-01-18 06:42:12 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "doesn't allow a regular user to delete it" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(post.user).can_delete?(post)).to be_falsey
|
2014-01-18 06:42:12 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'a Category' do
|
|
|
|
|
2013-05-21 14:39:51 +08:00
|
|
|
let(:category) { build(:category, user: moderator) }
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_delete?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when a regular user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-02-07 11:11:52 +08:00
|
|
|
it 'returns false when a moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_delete?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when an admin' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(category)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "can't be deleted if it has a forum topic" do
|
|
|
|
category.topic_count = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_delete?(category)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2014-02-13 04:24:44 +08:00
|
|
|
it "can't be deleted if it is the Uncategorized Category" do
|
2013-12-18 04:36:15 +08:00
|
|
|
uncategorized_cat_id = SiteSetting.uncategorized_category_id
|
|
|
|
uncategorized_category = Category.find(uncategorized_cat_id)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(uncategorized_category)).to be_falsey
|
2013-12-18 04:36:15 +08:00
|
|
|
end
|
|
|
|
|
2014-02-13 06:24:25 +08:00
|
|
|
it "can't be deleted if it has children" do
|
|
|
|
category.expects(:has_children?).returns(true)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete?(category)).to be_falsey
|
2014-02-13 06:24:25 +08:00
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-11-08 02:53:32 +08:00
|
|
|
context 'can_suspend?' do
|
|
|
|
it 'returns false when a user tries to suspend another user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_suspend?(coding_horror)).to be_falsey
|
2013-05-21 14:39:51 +08:00
|
|
|
end
|
|
|
|
|
2013-11-08 02:53:32 +08:00
|
|
|
it 'returns true when an admin tries to suspend another user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_suspend?(coding_horror)).to be_truthy
|
2013-05-21 14:39:51 +08:00
|
|
|
end
|
|
|
|
|
2013-11-08 02:53:32 +08:00
|
|
|
it 'returns true when a moderator tries to suspend another user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_suspend?(coding_horror)).to be_truthy
|
2013-05-21 14:39:51 +08:00
|
|
|
end
|
|
|
|
|
2013-11-08 02:53:32 +08:00
|
|
|
it 'returns false when staff tries to suspend staff' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_suspend?(moderator)).to be_falsey
|
2013-05-21 14:39:51 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
context 'a PostAction' do
|
2013-05-21 14:39:51 +08:00
|
|
|
let(:post_action) {
|
|
|
|
user.id = 1
|
|
|
|
post.id = 1
|
|
|
|
|
2013-05-20 14:04:53 +08:00
|
|
|
a = PostAction.new(user: user, post: post, post_action_type_id: 1)
|
2013-05-21 14:39:51 +08:00
|
|
|
a.created_at = 1.minute.ago
|
|
|
|
a
|
|
|
|
}
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it 'returns false when not logged in' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_delete?(post_action)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when not the user who created it' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_delete?(post_action)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false if the window has expired" do
|
|
|
|
post_action.created_at = 20.minutes.ago
|
|
|
|
SiteSetting.expects(:post_undo_action_window_mins).returns(10)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(post_action)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if it's yours" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete?(post_action)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_approve?' do
|
|
|
|
|
|
|
|
it "wont allow a non-logged in user to approve" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_approve?(user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "wont allow a non-admin to approve a user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_approve?(user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when the user is already approved" do
|
|
|
|
user.approved = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_approve?(user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2017-09-05 00:55:23 +08:00
|
|
|
it "returns false when the user is not active" do
|
|
|
|
user.active = false
|
|
|
|
expect(Guardian.new(admin).can_approve?(user)).to be_falsey
|
|
|
|
end
|
|
|
|
|
2013-02-06 03:16:51 +08:00
|
|
|
it "allows an admin to approve a user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_approve?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows a moderator to approve a user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_approve?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_grant_admin?' do
|
|
|
|
it "wont allow a non logged in user to grant an admin's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_grant_admin?(another_admin)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "wont allow a regular user to revoke an admin's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_grant_admin?(another_admin)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'wont allow an admin to grant their own access' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_admin?(admin)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows an admin to grant a regular user access" do
|
2013-05-21 14:39:51 +08:00
|
|
|
admin.id = 1
|
|
|
|
user.id = 2
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_admin?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2016-12-29 11:11:33 +08:00
|
|
|
|
|
|
|
it 'should not allow an admin to grant admin access to a non real user' do
|
2017-01-06 15:25:49 +08:00
|
|
|
begin
|
|
|
|
Discourse.system_user.update!(admin: false)
|
|
|
|
expect(Guardian.new(admin).can_grant_admin?(Discourse.system_user)).to be(false)
|
|
|
|
ensure
|
|
|
|
Discourse.system_user.update!(admin: true)
|
|
|
|
end
|
2016-12-29 11:11:33 +08:00
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_revoke_admin?' do
|
|
|
|
it "wont allow a non logged in user to revoke an admin's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_revoke_admin?(another_admin)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "wont allow a regular user to revoke an admin's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_revoke_admin?(another_admin)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'wont allow an admin to revoke their own access' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_revoke_admin?(admin)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows an admin to revoke another admin's access" do
|
2013-05-21 14:39:51 +08:00
|
|
|
admin.id = 1
|
|
|
|
another_admin.id = 2
|
|
|
|
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_revoke_admin?(another_admin)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2016-12-29 11:11:33 +08:00
|
|
|
|
|
|
|
it "should not allow an admin to revoke a no real user's admin access" do
|
|
|
|
expect(Guardian.new(admin).can_revoke_admin?(Discourse.system_user)).to be(false)
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
2013-02-13 06:58:08 +08:00
|
|
|
context 'can_grant_moderation?' do
|
2013-05-09 15:35:15 +08:00
|
|
|
|
2013-02-13 06:58:08 +08:00
|
|
|
it "wont allow a non logged in user to grant an moderator's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_grant_moderation?(user)).to be_falsey
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
2013-05-20 14:04:53 +08:00
|
|
|
it "wont allow a regular user to revoke an moderator's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_grant_moderation?(moderator)).to be_falsey
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
2013-05-09 15:35:15 +08:00
|
|
|
it 'will allow an admin to grant their own moderator access' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_moderation?(admin)).to be_truthy
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'wont allow an admin to grant it to an already moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_moderation?(moderator)).to be_falsey
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows an admin to grant a regular user access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_moderation?(user)).to be_truthy
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
2016-12-29 11:11:33 +08:00
|
|
|
|
|
|
|
it "should not allow an admin to grant moderation to a non real user" do
|
2017-01-06 15:25:49 +08:00
|
|
|
begin
|
|
|
|
Discourse.system_user.update!(moderator: false)
|
|
|
|
expect(Guardian.new(admin).can_grant_moderation?(Discourse.system_user)).to be(false)
|
|
|
|
ensure
|
|
|
|
Discourse.system_user.update!(moderator: true)
|
|
|
|
end
|
2016-12-29 11:11:33 +08:00
|
|
|
end
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'can_revoke_moderation?' do
|
|
|
|
it "wont allow a non logged in user to revoke an moderator's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new.can_revoke_moderation?(moderator)).to be_falsey
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "wont allow a regular user to revoke an moderator's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_revoke_moderation?(moderator)).to be_falsey
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
2013-05-09 15:35:15 +08:00
|
|
|
it 'wont allow a moderator to revoke their own moderator' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_revoke_moderation?(moderator)).to be_falsey
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "allows an admin to revoke a moderator's access" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_revoke_moderation?(moderator)).to be_truthy
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
2013-05-09 15:35:15 +08:00
|
|
|
|
|
|
|
it "allows an admin to revoke a moderator's access from self" do
|
|
|
|
admin.moderator = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_revoke_moderation?(admin)).to be_truthy
|
2013-05-09 15:35:15 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "does not allow revoke from non moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_revoke_moderation?(admin)).to be_falsey
|
2013-05-09 15:35:15 +08:00
|
|
|
end
|
2016-12-29 11:11:33 +08:00
|
|
|
|
|
|
|
it "should not allow an admin to revoke moderation from a non real user" do
|
|
|
|
expect(Guardian.new(admin).can_revoke_moderation?(Discourse.system_user)).to be(false)
|
|
|
|
end
|
2013-02-13 06:58:08 +08:00
|
|
|
end
|
|
|
|
|
2014-03-22 02:13:04 +08:00
|
|
|
context "can_see_invite_details?" do
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
it 'is false without a logged in user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_see_invite_details?(user)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false without a user to look at' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see_invite_details?(nil)).to be_falsey
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true when looking at your own invites' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_see_invite_details?(user)).to be_truthy
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context "can_access_forum?" do
|
|
|
|
|
|
|
|
let(:unapproved_user) { Fabricate.build(:user) }
|
|
|
|
|
|
|
|
context "when must_approve_users is false" do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.must_approve_users = false
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for a nil user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_access_forum?).to be_truthy
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for an unapproved user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(unapproved_user).can_access_forum?).to be_truthy
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when must_approve_users is true' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.must_approve_users = true
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for a nil user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_access_forum?).to be_falsey
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false for an unapproved user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(unapproved_user).can_access_forum?).to be_falsey
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for an admin user" do
|
|
|
|
unapproved_user.admin = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(unapproved_user).can_access_forum?).to be_truthy
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for an approved user" do
|
|
|
|
unapproved_user.approved = true
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(unapproved_user).can_access_forum?).to be_truthy
|
2013-04-04 00:23:28 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
|
|
|
|
end
|
|
|
|
|
2013-07-27 03:40:08 +08:00
|
|
|
describe "can_delete_user?" do
|
2013-04-12 04:04:20 +08:00
|
|
|
it "is false without a logged in user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_delete_user?(user)).to be_falsey
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false without a user to look at" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete_user?(nil)).to be_falsey
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for regular users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete_user?(coding_horror)).to be_falsey
|
2014-02-14 00:42:35 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context "delete myself" do
|
2014-07-29 01:17:37 +08:00
|
|
|
let(:myself) { Fabricate(:user, created_at: 6.months.ago) }
|
2014-02-14 00:42:35 +08:00
|
|
|
subject { Guardian.new(myself).can_delete_user?(myself) }
|
|
|
|
|
|
|
|
it "is true to delete myself and I have never made a post" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(subject).to be_truthy
|
2014-02-14 00:42:35 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true to delete myself and I have only made 1 post" do
|
|
|
|
myself.stubs(:post_count).returns(1)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(subject).to be_truthy
|
2014-02-14 00:42:35 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false to delete myself and I have made 2 posts" do
|
|
|
|
myself.stubs(:post_count).returns(2)
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(subject).to be_falsey
|
2014-02-14 00:42:35 +08:00
|
|
|
end
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
|
|
|
|
2013-07-27 03:40:08 +08:00
|
|
|
shared_examples "can_delete_user examples" do
|
2014-02-21 01:29:40 +08:00
|
|
|
it "is true if user is not an admin and has never posted" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_user?(Fabricate.build(:user, created_at: 100.days.ago))).to be_truthy
|
2014-02-21 01:29:40 +08:00
|
|
|
end
|
2013-07-27 03:40:08 +08:00
|
|
|
|
2014-02-21 01:29:40 +08:00
|
|
|
it "is true if user is not an admin and first post is not too old" do
|
|
|
|
user = Fabricate.build(:user, created_at: 100.days.ago)
|
2018-03-05 12:32:23 +08:00
|
|
|
user.stubs(:post_count).returns(10)
|
2014-07-29 01:17:37 +08:00
|
|
|
user.stubs(:first_post_created_at).returns(9.days.ago)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_user_max_post_age = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_user?(user)).to be_truthy
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false if user is an admin" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_user?(another_admin)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
2014-02-21 01:29:40 +08:00
|
|
|
it "is false if user's first post is too old" do
|
|
|
|
user = Fabricate.build(:user, created_at: 100.days.ago)
|
2018-03-05 12:32:23 +08:00
|
|
|
user.stubs(:post_count).returns(10)
|
2014-07-29 01:17:37 +08:00
|
|
|
user.stubs(:first_post_created_at).returns(11.days.ago)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_user_max_post_age = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_user?(user)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-03-05 12:32:23 +08:00
|
|
|
shared_examples "can_delete_user staff examples" do
|
|
|
|
it "is true if posts are less than or equal to 5" do
|
|
|
|
user = Fabricate.build(:user, created_at: 100.days.ago)
|
|
|
|
user.stubs(:post_count).returns(4)
|
|
|
|
user.stubs(:first_post_created_at).returns(11.days.ago)
|
|
|
|
SiteSetting.delete_user_max_post_age = 10
|
|
|
|
expect(Guardian.new(actor).can_delete_user?(user)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-07-27 03:40:08 +08:00
|
|
|
context "for moderators" do
|
|
|
|
let(:actor) { moderator }
|
|
|
|
include_examples "can_delete_user examples"
|
2018-03-05 12:32:23 +08:00
|
|
|
include_examples "can_delete_user staff examples"
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context "for admins" do
|
2013-07-27 03:40:08 +08:00
|
|
|
let(:actor) { admin }
|
|
|
|
include_examples "can_delete_user examples"
|
2018-03-05 12:32:23 +08:00
|
|
|
include_examples "can_delete_user staff examples"
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "can_delete_all_posts?" do
|
|
|
|
it "is false without a logged in user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_delete_all_posts?(user)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false without a user to look at" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_delete_all_posts?(nil)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for regular users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_delete_all_posts?(coding_horror)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
shared_examples "can_delete_all_posts examples" do
|
2014-02-21 01:29:40 +08:00
|
|
|
it "is true if user has no posts" do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_user_max_post_age = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_all_posts?(Fabricate(:user, created_at: 100.days.ago))).to be_truthy
|
2014-02-21 01:29:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true if user's first post is newer than delete_user_max_post_age days old" do
|
2014-07-29 01:17:37 +08:00
|
|
|
user = Fabricate(:user, created_at: 100.days.ago)
|
|
|
|
user.stubs(:first_post_created_at).returns(9.days.ago)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_user_max_post_age = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_all_posts?(user)).to be_truthy
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
2014-02-21 01:29:40 +08:00
|
|
|
it "is false if user's first post is older than delete_user_max_post_age days old" do
|
2014-07-29 01:17:37 +08:00
|
|
|
user = Fabricate(:user, created_at: 100.days.ago)
|
|
|
|
user.stubs(:first_post_created_at).returns(11.days.ago)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_user_max_post_age = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_all_posts?(user)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false if user is an admin" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_all_posts?(admin)).to be_falsey
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
|
|
|
|
2013-07-27 03:40:08 +08:00
|
|
|
it "is true if number of posts is small" do
|
2014-07-29 01:17:37 +08:00
|
|
|
u = Fabricate(:user, created_at: 1.day.ago)
|
2013-07-27 03:40:08 +08:00
|
|
|
u.stubs(:post_count).returns(1)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_all_posts_max = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_all_posts?(u)).to be_truthy
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
2013-07-27 03:40:08 +08:00
|
|
|
|
|
|
|
it "is false if number of posts is not small" do
|
2014-07-29 01:17:37 +08:00
|
|
|
u = Fabricate(:user, created_at: 1.day.ago)
|
2013-07-27 03:40:08 +08:00
|
|
|
u.stubs(:post_count).returns(11)
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.delete_all_posts_max = 10
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(actor).can_delete_all_posts?(u)).to be_falsey
|
2013-07-27 03:40:08 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "for moderators" do
|
|
|
|
let(:actor) { moderator }
|
|
|
|
include_examples "can_delete_all_posts examples"
|
|
|
|
end
|
|
|
|
|
|
|
|
context "for admins" do
|
|
|
|
let(:actor) { admin }
|
|
|
|
include_examples "can_delete_all_posts examples"
|
2013-04-12 04:04:20 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-03-07 05:44:54 +08:00
|
|
|
describe "can_anonymize_user?" do
|
|
|
|
it "is false without a logged in user" do
|
|
|
|
expect(Guardian.new(nil).can_anonymize_user?(user)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is false without a user to look at" do
|
|
|
|
expect(Guardian.new(admin).can_anonymize_user?(nil)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for a regular user" do
|
|
|
|
expect(Guardian.new(user).can_anonymize_user?(coding_horror)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for myself" do
|
|
|
|
expect(Guardian.new(user).can_anonymize_user?(user)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is true for admin anonymizing a regular user" do
|
2015-04-25 23:18:35 +08:00
|
|
|
expect(Guardian.new(admin).can_anonymize_user?(user)).to eq(true)
|
2015-03-07 05:44:54 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true for moderator anonymizing a regular user" do
|
2015-04-25 23:18:35 +08:00
|
|
|
expect(Guardian.new(moderator).can_anonymize_user?(user)).to eq(true)
|
2015-03-07 05:44:54 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for admin anonymizing an admin" do
|
|
|
|
expect(Guardian.new(admin).can_anonymize_user?(Fabricate(:admin))).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for admin anonymizing a moderator" do
|
|
|
|
expect(Guardian.new(admin).can_anonymize_user?(Fabricate(:moderator))).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for moderator anonymizing an admin" do
|
|
|
|
expect(Guardian.new(moderator).can_anonymize_user?(admin)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for moderator anonymizing a moderator" do
|
|
|
|
expect(Guardian.new(moderator).can_anonymize_user?(Fabricate(:moderator))).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-06-26 06:39:20 +08:00
|
|
|
describe 'can_grant_title?' do
|
|
|
|
it 'is false without a logged in user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_grant_title?(user)).to be_falsey
|
2013-06-26 06:39:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for regular users' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_grant_title?(user)).to be_falsey
|
2013-06-26 06:39:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_grant_title?(user)).to be_truthy
|
2013-06-26 06:39:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_title?(user)).to be_truthy
|
2013-06-26 06:39:20 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false without a user to look at' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_grant_title?(nil)).to be_falsey
|
2013-06-26 06:39:20 +08:00
|
|
|
end
|
2018-04-07 02:29:27 +08:00
|
|
|
|
|
|
|
context 'with title argument' do
|
|
|
|
let(:title_badge) { Fabricate(:badge, name: 'Helper', allow_title: true) }
|
|
|
|
let(:no_title_badge) { Fabricate(:badge, name: 'Writer', allow_title: false) }
|
|
|
|
let(:group) { Fabricate(:group, title: 'Groupie') }
|
|
|
|
|
|
|
|
it 'returns true if title belongs to a badge that user has' do
|
|
|
|
BadgeGranter.grant(title_badge, user)
|
|
|
|
expect(Guardian.new(user).can_grant_title?(user, title_badge.name)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false if title belongs to a badge that user doesn't have" do
|
|
|
|
expect(Guardian.new(user).can_grant_title?(user, title_badge.name)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false if title belongs to a badge that user has but can't be used as a title" do
|
|
|
|
BadgeGranter.grant(no_title_badge, user)
|
|
|
|
expect(Guardian.new(user).can_grant_title?(user, no_title_badge.name)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true if title is from a group the user belongs to' do
|
|
|
|
group.add(user)
|
|
|
|
expect(Guardian.new(user).can_grant_title?(user, group.title)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false if title is from a group the user doesn't belong to" do
|
|
|
|
expect(Guardian.new(user).can_grant_title?(user, group.title)).to eq(false)
|
|
|
|
end
|
2018-06-01 07:10:52 +08:00
|
|
|
|
|
|
|
it "returns true if the title is set to an empty string" do
|
|
|
|
expect(Guardian.new(user).can_grant_title?(user, '')).to eq(true)
|
|
|
|
end
|
2018-04-07 02:29:27 +08:00
|
|
|
end
|
2013-06-26 06:39:20 +08:00
|
|
|
end
|
|
|
|
|
2013-07-23 07:13:48 +08:00
|
|
|
describe 'can_change_trust_level?' do
|
|
|
|
|
|
|
|
it 'is false without a logged in user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_change_trust_level?(user)).to be_falsey
|
2013-07-23 07:13:48 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for regular users' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_change_trust_level?(user)).to be_falsey
|
2013-07-23 07:13:48 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_change_trust_level?(user)).to be_truthy
|
2013-07-23 07:13:48 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_change_trust_level?(user)).to be_truthy
|
2013-07-23 07:13:48 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-08-13 02:54:52 +08:00
|
|
|
describe "can_edit_username?" do
|
|
|
|
it "is false without a logged in user" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_edit_username?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for regular users to edit another user's username" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_edit_username?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
shared_examples "staff can always change usernames" do
|
|
|
|
it "is true for moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_username?(user)).to be_truthy
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true for admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_username?(user)).to be_truthy
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'for a new user' do
|
2014-07-29 01:17:37 +08:00
|
|
|
let(:target_user) { Fabricate(:user, created_at: 1.minute.ago) }
|
2013-08-13 02:54:52 +08:00
|
|
|
include_examples "staff can always change usernames"
|
|
|
|
|
2013-12-03 12:49:54 +08:00
|
|
|
it "is true for the user to change their own username" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(target_user).can_edit_username?(target_user)).to be_truthy
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'for an old user' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.username_change_period = 3
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
|
2014-07-29 01:17:37 +08:00
|
|
|
let(:target_user) { Fabricate(:user, created_at: 4.days.ago) }
|
2013-08-13 02:54:52 +08:00
|
|
|
|
2013-08-23 23:23:00 +08:00
|
|
|
context 'with no posts' do
|
|
|
|
include_examples "staff can always change usernames"
|
2013-12-03 12:49:54 +08:00
|
|
|
it "is true for the user to change their own username" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(target_user).can_edit_username?(target_user)).to be_truthy
|
2013-08-23 23:23:00 +08:00
|
|
|
end
|
|
|
|
end
|
2013-08-13 02:54:52 +08:00
|
|
|
|
2013-08-23 23:23:00 +08:00
|
|
|
context 'with posts' do
|
|
|
|
before { target_user.stubs(:post_count).returns(1) }
|
|
|
|
include_examples "staff can always change usernames"
|
2013-12-03 12:49:54 +08:00
|
|
|
it "is false for the user to change their own username" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(target_user).can_edit_username?(target_user)).to be_falsey
|
2013-08-23 23:23:00 +08:00
|
|
|
end
|
2013-08-13 02:54:52 +08:00
|
|
|
end
|
|
|
|
end
|
2013-09-08 10:42:41 +08:00
|
|
|
|
|
|
|
context 'when editing is disabled in preferences' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.username_change_period = 0
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
include_examples "staff can always change usernames"
|
|
|
|
|
2013-12-03 12:49:54 +08:00
|
|
|
it "is false for the user to change their own username" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_username?(user)).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
end
|
2014-03-10 09:38:36 +08:00
|
|
|
|
|
|
|
context 'when SSO username override is active' do
|
|
|
|
before do
|
2017-12-23 16:46:48 +08:00
|
|
|
SiteSetting.sso_url = "https://www.example.com/sso"
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_sso = true
|
|
|
|
SiteSetting.sso_overrides_username = true
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_username?(admin)).to be_falsey
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_username?(moderator)).to be_falsey
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_username?(user)).to be_falsey
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
end
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
describe "can_edit_email?" do
|
|
|
|
context 'when allowed in settings' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.email_editable = true
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false when not logged in" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_edit_email?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for regular users to edit another user's email" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_edit_email?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
2013-12-03 12:49:54 +08:00
|
|
|
it "is true for a regular user to edit their own email" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_email?(user)).to be_truthy
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true for moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_email?(user)).to be_truthy
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is true for admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_email?(user)).to be_truthy
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when not allowed in settings' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.email_editable = false
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false when not logged in" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_edit_email?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for regular users to edit another user's email" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_edit_email?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
2013-12-03 12:49:54 +08:00
|
|
|
it "is false for a regular user to edit their own email" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_email?(user)).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
2014-08-15 10:56:03 +08:00
|
|
|
it "is false for admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_email?(user)).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
|
2014-08-15 10:56:03 +08:00
|
|
|
it "is false for moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_email?(user)).to be_falsey
|
2013-09-08 10:42:41 +08:00
|
|
|
end
|
|
|
|
end
|
2013-08-13 02:54:52 +08:00
|
|
|
|
2014-03-10 09:38:36 +08:00
|
|
|
context 'when SSO email override is active' do
|
|
|
|
before do
|
2017-07-10 10:12:21 +08:00
|
|
|
SiteSetting.email_editable = false
|
2017-12-23 16:46:48 +08:00
|
|
|
SiteSetting.sso_url = "https://www.example.com/sso"
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_sso = true
|
|
|
|
SiteSetting.sso_overrides_email = true
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for admins" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_email?(admin)).to be_falsey
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for moderators" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_email?(moderator)).to be_falsey
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for users" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_email?(user)).to be_falsey
|
2014-03-10 09:38:36 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2014-03-14 04:26:40 +08:00
|
|
|
|
|
|
|
describe 'can_edit_name?' do
|
|
|
|
it 'is false without a logged in user' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(nil).can_edit_name?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "is false for regular users to edit another user's name" do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(build(:user)).can_edit_name?(build(:user, created_at: 1.minute.ago))).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'for a new user' do
|
|
|
|
let(:target_user) { build(:user, created_at: 1.minute.ago) }
|
|
|
|
|
|
|
|
it 'is true for the user to change their own name' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(target_user).can_edit_name?(target_user)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_name?(user)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_name?(user)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when name is disabled in preferences' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_names = false
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for the user to change their own name' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_name?(user)).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_name?(user)).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_name?(user)).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when name is enabled in preferences' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_names = true
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'when SSO is disabled' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_sso = false
|
|
|
|
SiteSetting.sso_overrides_name = false
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_name?(admin)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_name?(moderator)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for users' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_name?(user)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when SSO is enabled' do
|
|
|
|
before do
|
2017-12-23 16:46:48 +08:00
|
|
|
SiteSetting.sso_url = "https://www.example.com/sso"
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.enable_sso = true
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'when SSO name override is active' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.sso_overrides_name = true
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_name?(admin)).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_name?(moderator)).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is false for users' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_name?(user)).to be_falsey
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when SSO name override is not active' do
|
|
|
|
before do
|
2017-07-07 14:09:14 +08:00
|
|
|
SiteSetting.sso_overrides_name = false
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for admins' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(admin).can_edit_name?(admin)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for moderators' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(moderator).can_edit_name?(moderator)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'is true for users' do
|
2015-01-10 00:34:37 +08:00
|
|
|
expect(Guardian.new(user).can_edit_name?(user)).to be_truthy
|
2014-03-14 04:26:40 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2014-05-13 20:53:11 +08:00
|
|
|
|
2018-09-21 09:07:13 +08:00
|
|
|
describe '#can_export_entity?' do
|
|
|
|
let(:user_guardian) { Guardian.new(user) }
|
|
|
|
let(:moderator_guardian) { Guardian.new(moderator) }
|
|
|
|
let(:admin_guardian) { Guardian.new(admin) }
|
|
|
|
|
|
|
|
it 'only allows admins to export user_list' do
|
|
|
|
expect(user_guardian.can_export_entity?('user_list')).to be_falsey
|
|
|
|
expect(moderator_guardian.can_export_entity?('user_list')).to be_falsey
|
|
|
|
expect(admin_guardian.can_export_entity?('user_list')).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'allow moderators to export other admin entities' do
|
|
|
|
expect(user_guardian.can_export_entity?('staff_action')).to be_falsey
|
|
|
|
expect(moderator_guardian.can_export_entity?('staff_action')).to be_truthy
|
|
|
|
expect(admin_guardian.can_export_entity?('staff_action')).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-08-08 12:46:34 +08:00
|
|
|
describe "#allow_themes?" do
|
|
|
|
let(:theme) { Fabricate(:theme) }
|
|
|
|
let(:theme2) { Fabricate(:theme) }
|
|
|
|
|
|
|
|
it "allows staff to use any themes" do
|
2018-09-07 08:44:57 +08:00
|
|
|
expect(Guardian.new(moderator).allow_themes?([theme.id, theme2.id])).to eq(false)
|
|
|
|
expect(Guardian.new(admin).allow_themes?([theme.id, theme2.id])).to eq(false)
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).allow_themes?([theme.id, theme2.id], include_preview: true)).to eq(true)
|
|
|
|
expect(Guardian.new(admin).allow_themes?([theme.id, theme2.id], include_preview: true)).to eq(true)
|
2018-08-08 12:46:34 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it "only allows normal users to use user-selectable themes or default theme" do
|
|
|
|
user_guardian = Guardian.new(user)
|
|
|
|
|
|
|
|
expect(user_guardian.allow_themes?([theme.id, theme2.id])).to eq(false)
|
|
|
|
expect(user_guardian.allow_themes?([theme.id])).to eq(false)
|
|
|
|
expect(user_guardian.allow_themes?([theme2.id])).to eq(false)
|
|
|
|
|
|
|
|
theme.set_default!
|
|
|
|
expect(user_guardian.allow_themes?([theme.id])).to eq(true)
|
|
|
|
expect(user_guardian.allow_themes?([theme2.id])).to eq(false)
|
|
|
|
expect(user_guardian.allow_themes?([theme.id, theme2.id])).to eq(false)
|
|
|
|
|
|
|
|
theme2.update!(user_selectable: true)
|
|
|
|
expect(user_guardian.allow_themes?([theme2.id])).to eq(true)
|
|
|
|
expect(user_guardian.allow_themes?([theme2.id, theme.id])).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "allows child themes to be only used with their parent" do
|
|
|
|
user_guardian = Guardian.new(user)
|
|
|
|
|
|
|
|
theme.update!(user_selectable: true)
|
|
|
|
theme2.update!(user_selectable: true)
|
|
|
|
expect(user_guardian.allow_themes?([theme.id, theme2.id])).to eq(false)
|
|
|
|
|
2018-08-24 09:30:00 +08:00
|
|
|
theme2.update!(user_selectable: false, component: true)
|
2018-08-08 12:46:34 +08:00
|
|
|
theme.add_child_theme!(theme2)
|
|
|
|
expect(user_guardian.allow_themes?([theme.id, theme2.id])).to eq(true)
|
|
|
|
expect(user_guardian.allow_themes?([theme2.id])).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-05-13 20:53:11 +08:00
|
|
|
describe 'can_wiki?' do
|
2016-03-15 17:13:52 +08:00
|
|
|
let(:post) { build(:post, created_at: 1.minute.ago) }
|
2016-01-11 23:26:00 +08:00
|
|
|
|
2014-05-13 20:53:11 +08:00
|
|
|
it 'returns false for regular user' do
|
2016-01-11 23:26:00 +08:00
|
|
|
expect(Guardian.new(coding_horror).can_wiki?(post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when user does not satisfy trust level but owns the post" do
|
|
|
|
own_post = Fabricate(:post, user: trust_level_2)
|
|
|
|
expect(Guardian.new(trust_level_2).can_wiki?(own_post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false when user satisfies trust level but tries to wiki someone else's post" do
|
|
|
|
SiteSetting.min_trust_to_allow_self_wiki = 2
|
|
|
|
expect(Guardian.new(trust_level_2).can_wiki?(post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true when user satisfies trust level and owns the post' do
|
|
|
|
SiteSetting.min_trust_to_allow_self_wiki = 2
|
|
|
|
own_post = Fabricate(:post, user: trust_level_2)
|
|
|
|
expect(Guardian.new(trust_level_2).can_wiki?(own_post)).to be_truthy
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for admin user' do
|
2016-01-11 23:26:00 +08:00
|
|
|
expect(Guardian.new(admin).can_wiki?(post)).to be_truthy
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
|
|
|
|
2014-09-05 14:52:40 +08:00
|
|
|
it 'returns true for trust_level_4 user' do
|
2016-01-11 23:26:00 +08:00
|
|
|
expect(Guardian.new(trust_level_4).can_wiki?(post)).to be_truthy
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
2016-03-15 17:13:52 +08:00
|
|
|
|
|
|
|
context 'post is older than post_edit_time_limit' do
|
|
|
|
let(:old_post) { build(:post, user: trust_level_2, created_at: 6.minutes.ago) }
|
|
|
|
before do
|
|
|
|
SiteSetting.min_trust_to_allow_self_wiki = 2
|
|
|
|
SiteSetting.post_edit_time_limit = 5
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when user satisfies trust level and owns the post' do
|
|
|
|
expect(Guardian.new(trust_level_2).can_wiki?(old_post)).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for admin user' do
|
|
|
|
expect(Guardian.new(admin).can_wiki?(old_post)).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for trust_level_4 user' do
|
|
|
|
expect(Guardian.new(trust_level_4).can_wiki?(post)).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
2014-05-13 20:53:11 +08:00
|
|
|
end
|
2016-06-07 02:18:15 +08:00
|
|
|
|
|
|
|
describe "Tags" do
|
|
|
|
context "tagging disabled" do
|
|
|
|
before do
|
|
|
|
SiteSetting.tagging_enabled = false
|
|
|
|
end
|
|
|
|
|
|
|
|
it "can_create_tag returns false" do
|
|
|
|
expect(Guardian.new(admin).can_create_tag?).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "can_admin_tags returns false" do
|
|
|
|
expect(Guardian.new(admin).can_admin_tags?).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "can_admin_tag_groups returns false" do
|
|
|
|
expect(Guardian.new(admin).can_admin_tag_groups?).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context "tagging is enabled" do
|
|
|
|
before do
|
|
|
|
SiteSetting.tagging_enabled = true
|
|
|
|
SiteSetting.min_trust_level_to_tag_topics = 1
|
|
|
|
end
|
|
|
|
|
2018-07-05 23:39:32 +08:00
|
|
|
context 'min_trust_to_create_tag is 3' do
|
|
|
|
before do
|
|
|
|
SiteSetting.min_trust_to_create_tag = 3
|
2016-06-07 02:18:15 +08:00
|
|
|
end
|
|
|
|
|
2018-07-05 23:39:32 +08:00
|
|
|
describe "can_create_tag" do
|
|
|
|
it "returns false if trust level is too low" do
|
|
|
|
expect(Guardian.new(trust_level_2).can_create_tag?).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if trust level is high enough" do
|
|
|
|
expect(Guardian.new(trust_level_3).can_create_tag?).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for staff" do
|
|
|
|
expect(Guardian.new(admin).can_create_tag?).to be_truthy
|
|
|
|
expect(Guardian.new(moderator).can_create_tag?).to be_truthy
|
|
|
|
end
|
2016-06-07 02:18:15 +08:00
|
|
|
end
|
|
|
|
|
2018-07-05 23:39:32 +08:00
|
|
|
describe "can_tag_topics" do
|
|
|
|
it "returns false if trust level is too low" do
|
|
|
|
expect(Guardian.new(Fabricate(:user, trust_level: 0)).can_tag_topics?).to be_falsey
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if trust level is high enough" do
|
|
|
|
expect(Guardian.new(Fabricate(:user, trust_level: 1)).can_tag_topics?).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true for staff" do
|
|
|
|
expect(Guardian.new(admin).can_tag_topics?).to be_truthy
|
|
|
|
expect(Guardian.new(moderator).can_tag_topics?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'min_trust_to_create_tag is "staff"' do
|
|
|
|
before do
|
|
|
|
SiteSetting.min_trust_to_create_tag = 'staff'
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns false if not staff" do
|
|
|
|
expect(Guardian.new(trust_level_4).can_create_tag?).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "returns true if staff" do
|
2016-06-07 02:18:15 +08:00
|
|
|
expect(Guardian.new(admin).can_create_tag?).to be_truthy
|
|
|
|
expect(Guardian.new(moderator).can_create_tag?).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-07-05 23:39:32 +08:00
|
|
|
context 'min_trust_to_create_tag is "admin"' do
|
|
|
|
before do
|
|
|
|
SiteSetting.min_trust_to_create_tag = 'admin'
|
2016-06-07 02:18:15 +08:00
|
|
|
end
|
|
|
|
|
2018-07-05 23:39:32 +08:00
|
|
|
it "returns false if not admin" do
|
|
|
|
expect(Guardian.new(trust_level_4).can_create_tag?).to eq(false)
|
|
|
|
expect(Guardian.new(moderator).can_create_tag?).to eq(false)
|
2016-06-07 02:18:15 +08:00
|
|
|
end
|
|
|
|
|
2018-07-05 23:39:32 +08:00
|
|
|
it "returns true if admin" do
|
|
|
|
expect(Guardian.new(admin).can_create_tag?).to be_truthy
|
2016-06-07 02:18:15 +08:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-12-05 20:31:43 +08:00
|
|
|
|
2017-07-04 03:26:46 +08:00
|
|
|
describe(:can_see_group) do
|
|
|
|
it 'Correctly handles owner visibile groups' do
|
|
|
|
group = Group.new(name: 'group', visibility_level: Group.visibility_levels[:owners])
|
|
|
|
|
|
|
|
member = Fabricate(:user)
|
|
|
|
group.add(member)
|
|
|
|
group.save!
|
|
|
|
|
|
|
|
owner = Fabricate(:user)
|
|
|
|
group.add_owner(owner)
|
|
|
|
group.reload
|
|
|
|
|
|
|
|
expect(Guardian.new(admin).can_see_group?(group)).to eq(true)
|
|
|
|
expect(Guardian.new(moderator).can_see_group?(group)).to eq(false)
|
|
|
|
expect(Guardian.new(member).can_see_group?(group)).to eq(false)
|
|
|
|
expect(Guardian.new.can_see_group?(group)).to eq(false)
|
|
|
|
expect(Guardian.new(owner).can_see_group?(group)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'Correctly handles staff visibile groups' do
|
|
|
|
group = Group.new(name: 'group', visibility_level: Group.visibility_levels[:staff])
|
|
|
|
|
|
|
|
member = Fabricate(:user)
|
|
|
|
group.add(member)
|
|
|
|
group.save!
|
|
|
|
|
|
|
|
owner = Fabricate(:user)
|
|
|
|
group.add_owner(owner)
|
|
|
|
group.reload
|
|
|
|
|
|
|
|
expect(Guardian.new(member).can_see_group?(group)).to eq(false)
|
|
|
|
expect(Guardian.new(admin).can_see_group?(group)).to eq(true)
|
|
|
|
expect(Guardian.new(moderator).can_see_group?(group)).to eq(true)
|
|
|
|
expect(Guardian.new(owner).can_see_group?(group)).to eq(true)
|
|
|
|
expect(Guardian.new.can_see_group?(group)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'Correctly handles member visibile groups' do
|
|
|
|
group = Group.new(name: 'group', visibility_level: Group.visibility_levels[:members])
|
|
|
|
|
|
|
|
member = Fabricate(:user)
|
|
|
|
group.add(member)
|
|
|
|
group.save!
|
|
|
|
|
|
|
|
owner = Fabricate(:user)
|
|
|
|
group.add_owner(owner)
|
|
|
|
group.reload
|
|
|
|
|
|
|
|
expect(Guardian.new(moderator).can_see_group?(group)).to eq(false)
|
|
|
|
expect(Guardian.new.can_see_group?(group)).to eq(false)
|
|
|
|
expect(Guardian.new(admin).can_see_group?(group)).to eq(true)
|
|
|
|
expect(Guardian.new(member).can_see_group?(group)).to eq(true)
|
|
|
|
expect(Guardian.new(owner).can_see_group?(group)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'Correctly handles public groups' do
|
|
|
|
group = Group.new(name: 'group', visibility_level: Group.visibility_levels[:public])
|
|
|
|
|
|
|
|
expect(Guardian.new.can_see_group?(group)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2016-12-05 20:31:43 +08:00
|
|
|
context 'topic featured link category restriction' do
|
|
|
|
before { SiteSetting.topic_featured_link_enabled = true }
|
|
|
|
let(:guardian) { Guardian.new }
|
2016-12-21 04:55:30 +08:00
|
|
|
let(:uncategorized) { Category.find(SiteSetting.uncategorized_category_id) }
|
2016-12-05 20:31:43 +08:00
|
|
|
|
2016-12-16 06:46:43 +08:00
|
|
|
context "uncategorized" do
|
|
|
|
let!(:link_category) { Fabricate(:link_category) }
|
|
|
|
|
2016-12-21 04:55:30 +08:00
|
|
|
it "allows featured links if uncategorized allows it" do
|
|
|
|
uncategorized.topic_featured_link_allowed = true
|
|
|
|
uncategorized.save!
|
2016-12-16 06:46:43 +08:00
|
|
|
expect(guardian.can_edit_featured_link?(nil)).to eq(true)
|
|
|
|
end
|
|
|
|
|
2016-12-21 04:55:30 +08:00
|
|
|
it "forbids featured links if uncategorized forbids it" do
|
|
|
|
uncategorized.topic_featured_link_allowed = false
|
|
|
|
uncategorized.save!
|
2016-12-16 06:46:43 +08:00
|
|
|
expect(guardian.can_edit_featured_link?(nil)).to eq(false)
|
|
|
|
end
|
2016-12-05 20:31:43 +08:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'when exist' do
|
2016-12-16 06:46:43 +08:00
|
|
|
let!(:category) { Fabricate(:category, topic_featured_link_allowed: false) }
|
2016-12-05 20:31:43 +08:00
|
|
|
let!(:link_category) { Fabricate(:link_category) }
|
|
|
|
|
|
|
|
it 'returns true if the category is listed' do
|
|
|
|
expect(guardian.can_edit_featured_link?(link_category.id)).to eq(true)
|
|
|
|
end
|
|
|
|
|
2016-12-16 06:46:43 +08:00
|
|
|
it 'returns false if the category does not allow it' do
|
2016-12-05 20:31:43 +08:00
|
|
|
expect(guardian.can_edit_featured_link?(category.id)).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2017-09-13 04:06:01 +08:00
|
|
|
|
|
|
|
context "suspension reasons" do
|
|
|
|
let(:user) { Fabricate(:user) }
|
|
|
|
|
|
|
|
it "will be shown by default" do
|
|
|
|
expect(Guardian.new.can_see_suspension_reason?(user)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
context "with hide suspension reason enabled" do
|
|
|
|
let(:moderator) { Fabricate(:moderator) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
SiteSetting.hide_suspension_reasons = true
|
|
|
|
end
|
|
|
|
|
|
|
|
it "will not be shown to anonymous users" do
|
|
|
|
expect(Guardian.new.can_see_suspension_reason?(user)).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "users can see their own suspensions" do
|
|
|
|
expect(Guardian.new(user).can_see_suspension_reason?(user)).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it "staff can see suspensions" do
|
|
|
|
expect(Guardian.new(moderator).can_see_suspension_reason?(user)).to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2017-10-10 16:26:56 +08:00
|
|
|
|
|
|
|
describe '#can_remove_allowed_users?' do
|
|
|
|
context 'staff users' do
|
|
|
|
it 'should be true' do
|
|
|
|
expect(Guardian.new(moderator).can_remove_allowed_users?(topic))
|
|
|
|
.to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'normal user' do
|
|
|
|
let(:topic) { Fabricate(:topic, user: Fabricate(:user)) }
|
|
|
|
let(:another_user) { Fabricate(:user) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
topic.allowed_users << user
|
|
|
|
topic.allowed_users << another_user
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should be false' do
|
|
|
|
expect(Guardian.new(user).can_remove_allowed_users?(topic))
|
|
|
|
.to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'target_user is the user' do
|
|
|
|
describe 'when user is in a pm with another user' do
|
|
|
|
it 'should return true' do
|
|
|
|
expect(Guardian.new(user).can_remove_allowed_users?(topic, user))
|
|
|
|
.to eq(true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when user is the creator of the topic' do
|
|
|
|
it 'should return false' do
|
|
|
|
expect(Guardian.new(topic.user).can_remove_allowed_users?(topic, topic.user))
|
|
|
|
.to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when user is the only user in the topic' do
|
|
|
|
it 'should return false' do
|
|
|
|
topic.remove_allowed_user(Discourse.system_user, another_user.username)
|
|
|
|
|
|
|
|
expect(Guardian.new(user).can_remove_allowed_users?(topic, user))
|
|
|
|
.to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'target_user is not the user' do
|
|
|
|
it 'should return false' do
|
|
|
|
expect(Guardian.new(user).can_remove_allowed_users?(topic, moderator))
|
|
|
|
.to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2018-10-12 07:40:48 +08:00
|
|
|
|
|
|
|
describe '#auth_token' do
|
|
|
|
it 'returns the correct auth token' do
|
|
|
|
token = UserAuthToken.generate!(user_id: user.id)
|
|
|
|
env = Rack::MockRequest.env_for("/", "HTTP_COOKIE" => "_t=#{token.unhashed_auth_token};")
|
|
|
|
|
|
|
|
guardian = Guardian.new(user, Rack::Request.new(env))
|
|
|
|
expect(guardian.auth_token).to eq(token.auth_token)
|
|
|
|
end
|
|
|
|
end
|
2013-02-06 03:16:51 +08:00
|
|
|
end
|