github-mirror/discourse
2
0
Fork 0
mirror of https://github.com/discourse/discourse.git synced 2025-05-22 06:41:25 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

DEV: Update the rubocop-discourse gem

Browse Source 
This enables cops related to RSpec `subject`.

See https://github.com/discourse/rubocop-discourse/pull/32
This commit is contained in:
Loïc Guitaut
2023-06-21 16:00:19 +02:00
committed by Loïc Guitaut
parent 8e1d049e6b
commit 0f4beab0fb
129 changed files with 1697 additions and 1506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
spec/lib/validators/allowed_ip_address_validator_spec.rb
View File

@ -1,9 +1,10 @@
# frozen_string_literal: true
RSpec.describe AllowedIpAddressValidator do
subject(:validate) { validator.validate_each(record, :ip_address, record.ip_address) }
let(:record) { Fabricate.build(:user, trust_level: TrustLevel[0], ip_address: "99.232.23.123") }
let(:validator) { described_class.new(attributes: :ip_address) }
subject(:validate) { validator.validate_each(record, :ip_address, record.ip_address) }
context "when ip address should be blocked" do
it "should add an error" do

22
spec/lib/validators/css_color_validator_spec.rb
View File

@ -1,21 +1,21 @@
# frozen_string_literal: true
RSpec.describe CssColorValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
it "validates hex colors" do
expect(subject.valid_value?("#0")).to eq(false)
expect(subject.valid_value?("#00")).to eq(false)
expect(subject.valid_value?("#000")).to eq(true)
expect(subject.valid_value?("#0000")).to eq(false)
expect(subject.valid_value?("#00000")).to eq(false)
expect(subject.valid_value?("#000000")).to eq(true)
expect(validator.valid_value?("#0")).to eq(false)
expect(validator.valid_value?("#00")).to eq(false)
expect(validator.valid_value?("#000")).to eq(true)
expect(validator.valid_value?("#0000")).to eq(false)
expect(validator.valid_value?("#00000")).to eq(false)
expect(validator.valid_value?("#000000")).to eq(true)
end
it "validates css colors" do
expect(subject.valid_value?("red")).to eq(true)
expect(subject.valid_value?("green")).to eq(true)
expect(subject.valid_value?("blue")).to eq(true)
expect(subject.valid_value?("hello")).to eq(false)
expect(validator.valid_value?("red")).to eq(true)
expect(validator.valid_value?("green")).to eq(true)
expect(validator.valid_value?("blue")).to eq(true)
expect(validator.valid_value?("hello")).to eq(false)
end
end

12
spec/lib/validators/enable_local_logins_via_email_validator_spec.rb
View File

@ -1,7 +1,7 @@
# frozen_string_literal: true
RSpec.describe EnableLocalLoginsViaEmailValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
describe "#valid_value?" do
describe "when 'enable_local_logins' is false" do
@ -9,15 +9,15 @@ RSpec.describe EnableLocalLoginsViaEmailValidator do
describe "when val is false" do
it "should be valid" do
expect(subject.valid_value?("f")).to eq(true)
expect(validator.valid_value?("f")).to eq(true)
end
end
describe "when value is true" do
it "should not be valid" do
expect(subject.valid_value?("t")).to eq(false)
expect(validator.valid_value?("t")).to eq(false)
expect(subject.error_message).to eq(
expect(validator.error_message).to eq(
I18n.t("site_settings.errors.enable_local_logins_disabled"),
)
end
@ -29,13 +29,13 @@ RSpec.describe EnableLocalLoginsViaEmailValidator do
describe "when val is false" do
it "should be valid" do
expect(subject.valid_value?("f")).to eq(true)
expect(validator.valid_value?("f")).to eq(true)
end
end
describe "when value is true" do
it "should be valid" do
expect(subject.valid_value?("t")).to eq(true)
expect(validator.valid_value?("t")).to eq(true)
end
end
end

16
spec/lib/validators/enable_sso_validator_spec.rb
View File

@ -1,7 +1,7 @@
# frozen_string_literal: true
RSpec.describe EnableSsoValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
describe "#valid_value?" do
describe "when 'sso url' is empty" do
@ -9,15 +9,15 @@ RSpec.describe EnableSsoValidator do
describe "when val is false" do
it "should be valid" do
expect(subject.valid_value?("f")).to eq(true)
expect(validator.valid_value?("f")).to eq(true)
end
end
describe "when value is true" do
it "should not be valid" do
expect(subject.valid_value?("t")).to eq(false)
expect(validator.valid_value?("t")).to eq(false)
expect(subject.error_message).to eq(
expect(validator.error_message).to eq(
I18n.t("site_settings.errors.discourse_connect_url_is_empty"),
)
end
@ -29,13 +29,13 @@ RSpec.describe EnableSsoValidator do
describe "when value is false" do
it "should be valid" do
expect(subject.valid_value?("f")).to eq(true)
expect(validator.valid_value?("f")).to eq(true)
end
end
describe "when value is true" do
it "should be valid" do
expect(subject.valid_value?("t")).to eq(true)
expect(validator.valid_value?("t")).to eq(true)
end
end
end
@ -46,13 +46,13 @@ RSpec.describe EnableSsoValidator do
it "should be invalid" do
SiteSetting.enforce_second_factor = "all"
expect(subject.valid_value?("t")).to eq(false)
expect(validator.valid_value?("t")).to eq(false)
end
it "should be valid" do
SiteSetting.enforce_second_factor = "no"
expect(subject.valid_value?("t")).to eq(true)
expect(validator.valid_value?("t")).to eq(true)
end
end
end

18
spec/lib/validators/external_system_avatars_validator_spec.rb
View File

@ -1,25 +1,25 @@
# frozen_string_literal: true
RSpec.describe ExternalSystemAvatarsValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
it "disallows disabling external system avatars when Unicode usernames are enabled" do
SiteSetting.unicode_usernames = true
expect(subject.valid_value?("f")).to eq(false)
expect(subject.error_message).to eq(I18n.t("site_settings.errors.unicode_usernames_avatars"))
expect(validator.valid_value?("f")).to eq(false)
expect(validator.error_message).to eq(I18n.t("site_settings.errors.unicode_usernames_avatars"))
expect(subject.valid_value?("t")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("t")).to eq(true)
expect(validator.error_message).to be_blank
end
it "allows disabling external system avatars when Unicode usernames are disabled" do
SiteSetting.unicode_usernames = false
expect(subject.valid_value?("t")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("t")).to eq(true)
expect(validator.error_message).to be_blank
expect(subject.valid_value?("f")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("f")).to eq(true)
expect(validator.error_message).to be_blank
end
end

3
spec/lib/validators/ip_address_format_validator_spec.rb
View File

@ -1,9 +1,10 @@
# frozen_string_literal: true
RSpec.describe IpAddressFormatValidator do
subject(:validate) { validator.validate_each(record, :ip_address, record.ip_address) }
let(:record) { Fabricate.build(:screened_ip_address, ip_address: "99.232.23.123") }
let(:validator) { described_class.new(attributes: :ip_address) }
subject(:validate) { validator.validate_each(record, :ip_address, record.ip_address) }
%w[99.232.23.123 99.232.0.0/16 fd12:db8::ff00:42:8329 fc00::/7].each do |arg|
it "should not add an error for #{arg}" do

3
spec/lib/validators/password_validator_spec.rb
View File

@ -5,9 +5,10 @@ RSpec.describe PasswordValidator do
I18n.t("activerecord.errors.models.user.attributes.password.#{key.to_s}")
end
let(:validator) { described_class.new(attributes: :password) }
subject(:validate) { validator.validate_each(record, :password, @password) }
let(:validator) { described_class.new(attributes: :password) }
describe "password required" do
let(:record) do
u = Fabricate.build(:user, password: @password)

12
spec/lib/validators/regex_presence_validator_spec.rb
View File

@ -1,28 +1,28 @@
# frozen_string_literal: true
RSpec.describe RegexPresenceValidator do
subject do
subject(:validator) do
described_class.new(regex: "latest", regex_error: "site_settings.errors.must_include_latest")
end
describe "#valid_value?" do
describe "when value is present" do
it "without regex match" do
expect(subject.valid_value?("categories|new")).to eq(false)
expect(validator.valid_value?("categories|new")).to eq(false)
expect(subject.error_message).to eq(I18n.t("site_settings.errors.must_include_latest"))
expect(validator.error_message).to eq(I18n.t("site_settings.errors.must_include_latest"))
end
it "with regex match" do
expect(subject.valid_value?("latest|categories")).to eq(true)
expect(validator.valid_value?("latest|categories")).to eq(true)
end
end
describe "when value is empty" do
it "should not be valid" do
expect(subject.valid_value?("")).to eq(false)
expect(validator.valid_value?("")).to eq(false)
expect(subject.error_message).to eq(I18n.t("site_settings.errors.must_include_latest"))
expect(validator.error_message).to eq(I18n.t("site_settings.errors.must_include_latest"))
end
end
end

8
spec/lib/validators/regexp_list_validator_spec.rb
View File

@ -1,15 +1,15 @@
# frozen_string_literal: true
RSpec.describe RegexpListValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
it "allows lists of valid regular expressions" do
expect(subject.valid_value?('\d+|[0-9]?|\w+')).to eq(true)
expect(validator.valid_value?('\d+|[0-9]?|\w+')).to eq(true)
end
it "does not allow lists of invalid regular expressions do" do
expect(subject.valid_value?('\d+|[0-9?|\w+')).to eq(false)
expect(subject.error_message).to eq(
expect(validator.valid_value?('\d+|[0-9?|\w+')).to eq(false)
expect(validator.error_message).to eq(
I18n.t(
"site_settings.errors.invalid_regex_with_message",
regex: "[0-9?",

14
spec/lib/validators/sso_overrides_email_validator_spec.rb
View File

@ -1,7 +1,7 @@
# frozen_string_literal: true
RSpec.describe SsoOverridesEmailValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
describe "#valid_value?" do
describe "when 'email editable' is true" do
@ -13,15 +13,17 @@ RSpec.describe SsoOverridesEmailValidator do
describe "when val is false" do
it "should be valid" do
expect(subject.valid_value?("f")).to eq(true)
expect(validator.valid_value?("f")).to eq(true)
end
end
describe "when value is true" do
it "should not be valid" do
expect(subject.valid_value?("t")).to eq(false)
expect(validator.valid_value?("t")).to eq(false)
expect(subject.error_message).to eq(I18n.t("site_settings.errors.email_editable_enabled"))
expect(validator.error_message).to eq(
I18n.t("site_settings.errors.email_editable_enabled"),
)
end
end
end
@ -35,13 +37,13 @@ RSpec.describe SsoOverridesEmailValidator do
describe "when value is false" do
it "should be valid" do
expect(subject.valid_value?("f")).to eq(true)
expect(validator.valid_value?("f")).to eq(true)
end
end
describe "when value is true" do
it "should be valid" do
expect(subject.valid_value?("t")).to eq(true)
expect(validator.valid_value?("t")).to eq(true)
end
end
end

30
spec/lib/validators/unicode_username_allowlist_validator_spec.rb
View File

@ -1,37 +1,37 @@
# frozen_string_literal: true
RSpec.describe UnicodeUsernameAllowlistValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
it "allows an empty allowlist" do
expect(subject.valid_value?("")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("")).to eq(true)
expect(validator.error_message).to be_blank
end
it "disallows leading and trailing slashes" do
expected_error = I18n.t("site_settings.errors.allowed_unicode_usernames.leading_trailing_slash")
expect(subject.valid_value?("/foo/")).to eq(false)
expect(subject.error_message).to eq(expected_error)
expect(validator.valid_value?("/foo/")).to eq(false)
expect(validator.error_message).to eq(expected_error)
expect(subject.valid_value?("foo/")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("foo/")).to eq(true)
expect(validator.error_message).to be_blank
expect(subject.valid_value?("/foo")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("/foo")).to eq(true)
expect(validator.error_message).to be_blank
expect(subject.valid_value?("f/o/o")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("f/o/o")).to eq(true)
expect(validator.error_message).to be_blank
expect(subject.valid_value?("/foo/i")).to eq(false)
expect(subject.error_message).to eq(expected_error)
expect(validator.valid_value?("/foo/i")).to eq(false)
expect(validator.error_message).to eq(expected_error)
end
it "detects invalid regular expressions" do
expected_error =
I18n.t("site_settings.errors.allowed_unicode_usernames.regex_invalid", error: "")
expect(subject.valid_value?("\\p{Foo}")).to eq(false)
expect(subject.error_message).to start_with(expected_error)
expect(validator.valid_value?("\\p{Foo}")).to eq(false)
expect(validator.error_message).to start_with(expected_error)
end
end

18
spec/lib/validators/unicode_username_validator_spec.rb
View File

@ -1,25 +1,25 @@
# frozen_string_literal: true
RSpec.describe UnicodeUsernameValidator do
subject { described_class.new }
subject(:validator) { described_class.new }
it "disallows Unicode usernames when external system avatars are disabled" do
SiteSetting.external_system_avatars_enabled = false
expect(subject.valid_value?("t")).to eq(false)
expect(subject.error_message).to eq(I18n.t("site_settings.errors.unicode_usernames_avatars"))
expect(validator.valid_value?("t")).to eq(false)
expect(validator.error_message).to eq(I18n.t("site_settings.errors.unicode_usernames_avatars"))
expect(subject.valid_value?("f")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("f")).to eq(true)
expect(validator.error_message).to be_blank
end
it "allows Unicode usernames when external system avatars are enabled" do
SiteSetting.external_system_avatars_enabled = true
expect(subject.valid_value?("t")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("t")).to eq(true)
expect(validator.error_message).to be_blank
expect(subject.valid_value?("f")).to eq(true)
expect(subject.error_message).to be_blank
expect(validator.valid_value?("f")).to eq(true)
expect(validator.error_message).to be_blank
end
end

12
spec/lib/validators/upload_validator_spec.rb
View File

@ -45,7 +45,7 @@ RSpec.describe UploadValidator do
original_filename: "test.png",
filesize: 2_097_152,
)
subject.validate(upload)
validator.validate(upload)
expect(upload.errors.full_messages.first).to eq(
"Filesize #{I18n.t("upload.images.too_large_humanized", max_size: "1.5 MB")}",
)
@ -62,7 +62,7 @@ RSpec.describe UploadValidator do
for_private_message: true,
)
expect(subject.validate(upload)).to eq(true)
expect(validator.validate(upload)).to eq(true)
end
describe "for a normal user" do
@ -75,7 +75,7 @@ RSpec.describe UploadValidator do
for_private_message: true,
)
expect(subject.validate(upload)).to eq(nil)
expect(validator.validate(upload)).to eq(nil)
end
end
end
@ -91,13 +91,13 @@ RSpec.describe UploadValidator do
describe "for admin user" do
it "should allow the upload" do
expect(subject.validate(upload)).to eq(true)
expect(validator.validate(upload)).to eq(true)
end
describe "when filename is invalid" do
it "should not allow the upload" do
upload.original_filename = "test.txt"
expect(subject.validate(upload)).to eq(nil)
expect(validator.validate(upload)).to eq(nil)
end
end
end
@ -106,7 +106,7 @@ RSpec.describe UploadValidator do
fab!(:user) { Fabricate(:user) }
it "should not allow the upload" do
expect(subject.validate(upload)).to eq(nil)
expect(validator.validate(upload)).to eq(nil)
end
end
end

3
spec/lib/validators/url_validator_spec.rb
View File

@ -1,9 +1,10 @@
# frozen_string_literal: true
RSpec.describe UrlValidator do
subject(:validate) { validator.validate_each(record, :website, record.website) }
let(:record) { Fabricate.build(:user_profile, user: Fabricate.build(:user)) }
let(:validator) { described_class.new(attributes: :website) }
subject(:validate) { validator.validate_each(record, :website, record.website) }
[
"http://https://google.com",

3
spec/lib/validators/user_full_name_validator_spec.rb
View File

@ -1,8 +1,9 @@
# frozen_string_literal: true
RSpec.describe UserFullNameValidator do
let(:validator) { described_class.new(attributes: :name) }
subject(:validate) { validator.validate_each(record, :name, @name) }
let(:validator) { described_class.new(attributes: :name) }
let(:record) { Fabricate.build(:user, name: @name) }
context "when name is not required" do