diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml index 4cf238595b..aba4415fcb 100644 --- a/.rubocop_todo.yml +++ b/.rubocop_todo.yml @@ -199,14 +199,9 @@ Naming/VariableNumber: - 'db/migrate/20190820003045_update_statuses_index.rb' - 'db/migrate/20190823221802_add_local_index_to_statuses.rb' - 'db/migrate/20200119112504_add_public_index_to_statuses.rb' - - 'spec/controllers/activitypub/followers_synchronizations_controller_spec.rb' - - 'spec/lib/feed_manager_spec.rb' - 'spec/models/account_spec.rb' - - 'spec/models/concerns/account_interactions_spec.rb' - - 'spec/models/custom_emoji_filter_spec.rb' - 'spec/models/domain_block_spec.rb' - 'spec/models/user_spec.rb' - - 'spec/services/activitypub/fetch_featured_collection_service_spec.rb' # This cop supports unsafe autocorrection (--autocorrect-all). Performance/UnfreezeString: diff --git a/Gemfile.lock b/Gemfile.lock index 98a7b2ef91..d3f2b13a63 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -606,6 +606,8 @@ GEM parser (>= 3.2.1.0) rubocop-capybara (2.18.0) rubocop (~> 1.41) + rubocop-factory_bot (2.23.1) + rubocop (~> 1.33) rubocop-performance (1.18.0) rubocop (>= 1.7.0, < 2.0) rubocop-ast (>= 0.4.0) @@ -613,9 +615,10 @@ GEM activesupport (>= 4.2.0) rack (>= 1.1) rubocop (>= 1.33.0, < 2.0) - rubocop-rspec (2.19.0) + rubocop-rspec (2.22.0) rubocop (~> 1.33) rubocop-capybara (~> 2.17) + rubocop-factory_bot (~> 2.22) ruby-progressbar (1.13.0) ruby-saml (1.13.0) nokogiri (>= 1.10.5) diff --git a/spec/controllers/activitypub/followers_synchronizations_controller_spec.rb b/spec/controllers/activitypub/followers_synchronizations_controller_spec.rb index e544585ec1..b50c7b9cdc 100644 --- a/spec/controllers/activitypub/followers_synchronizations_controller_spec.rb +++ b/spec/controllers/activitypub/followers_synchronizations_controller_spec.rb @@ -3,17 +3,17 @@ require 'rails_helper' RSpec.describe ActivityPub::FollowersSynchronizationsController do - let!(:account) { Fabricate(:account) } - let!(:follower_1) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/users/a') } - let!(:follower_2) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/users/b') } - let!(:follower_3) { Fabricate(:account, domain: 'foo.com', uri: 'https://foo.com/users/a') } - let!(:follower_4) { Fabricate(:account, username: 'instance-actor', domain: 'example.com', uri: 'https://example.com') } + let!(:account) { Fabricate(:account) } + let!(:follower_example_com_user_a) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/users/a') } + let!(:follower_example_com_user_b) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/users/b') } + let!(:follower_foo_com_user_a) { Fabricate(:account, domain: 'foo.com', uri: 'https://foo.com/users/a') } + let!(:follower_example_com_instance_actor) { Fabricate(:account, username: 'instance-actor', domain: 'example.com', uri: 'https://example.com') } before do - follower_1.follow!(account) - follower_2.follow!(account) - follower_3.follow!(account) - follower_4.follow!(account) + follower_example_com_user_a.follow!(account) + follower_example_com_user_b.follow!(account) + follower_foo_com_user_a.follow!(account) + follower_example_com_instance_actor.follow!(account) allow(controller).to receive(:signed_request_actor).and_return(remote_account) end @@ -47,7 +47,11 @@ RSpec.describe ActivityPub::FollowersSynchronizationsController do it 'returns orderedItems with followers from example.com' do expect(body[:orderedItems]).to be_an Array - expect(body[:orderedItems]).to contain_exactly(follower_4.uri, follower_1.uri, follower_2.uri) + expect(body[:orderedItems]).to contain_exactly( + follower_example_com_instance_actor.uri, + follower_example_com_user_a.uri, + follower_example_com_user_b.uri + ) end it 'returns private Cache-Control header' do diff --git a/spec/controllers/admin/instances_controller_spec.rb b/spec/controllers/admin/instances_controller_spec.rb index ce062085f4..dd772d1036 100644 --- a/spec/controllers/admin/instances_controller_spec.rb +++ b/spec/controllers/admin/instances_controller_spec.rb @@ -7,9 +7,9 @@ RSpec.describe Admin::InstancesController do let(:current_user) { Fabricate(:user, role: UserRole.find_by(name: 'Admin')) } - let!(:account) { Fabricate(:account, domain: 'popular') } - let!(:account2) { Fabricate(:account, domain: 'popular') } - let!(:account3) { Fabricate(:account, domain: 'less.popular') } + let!(:account_popular_main) { Fabricate(:account, domain: 'popular') } + let!(:account_popular_other) { Fabricate(:account, domain: 'popular') } + let!(:account_less_popular) { Fabricate(:account, domain: 'less.popular') } before do sign_in current_user, scope: :user diff --git a/spec/controllers/follower_accounts_controller_spec.rb b/spec/controllers/follower_accounts_controller_spec.rb index b5b8ff9cb4..cb8c2a0e5b 100644 --- a/spec/controllers/follower_accounts_controller_spec.rb +++ b/spec/controllers/follower_accounts_controller_spec.rb @@ -5,13 +5,13 @@ require 'rails_helper' describe FollowerAccountsController do render_views - let(:alice) { Fabricate(:account) } - let(:follower0) { Fabricate(:account) } - let(:follower1) { Fabricate(:account) } + let(:alice) { Fabricate(:account, username: 'alice') } + let(:follower_bob) { Fabricate(:account, username: 'bob') } + let(:follower_chris) { Fabricate(:account, username: 'curt') } describe 'GET #index' do - let!(:follow0) { follower0.follow!(alice) } - let!(:follow1) { follower1.follow!(alice) } + let!(:follow_from_bob) { follower_bob.follow!(alice) } + let!(:follow_from_chris) { follower_chris.follow!(alice) } context 'when format is html' do subject(:response) { get :index, params: { account_username: alice.username, format: :html } } diff --git a/spec/controllers/following_accounts_controller_spec.rb b/spec/controllers/following_accounts_controller_spec.rb index d1efeec251..095528ed07 100644 --- a/spec/controllers/following_accounts_controller_spec.rb +++ b/spec/controllers/following_accounts_controller_spec.rb @@ -5,13 +5,13 @@ require 'rails_helper' describe FollowingAccountsController do render_views - let(:alice) { Fabricate(:account) } - let(:followee0) { Fabricate(:account) } - let(:followee1) { Fabricate(:account) } + let(:alice) { Fabricate(:account, username: 'alice') } + let(:followee_bob) { Fabricate(:account, username: 'bob') } + let(:followee_chris) { Fabricate(:account, username: 'chris') } describe 'GET #index' do - let!(:follow0) { alice.follow!(followee0) } - let!(:follow1) { alice.follow!(followee1) } + let!(:follow_of_bob) { alice.follow!(followee_bob) } + let!(:follow_of_chris) { alice.follow!(followee_chris) } context 'when format is html' do subject(:response) { get :index, params: { account_username: alice.username, format: :html } } diff --git a/spec/lib/account_reach_finder_spec.rb b/spec/lib/account_reach_finder_spec.rb index 1da95ba6b3..7c6c20968f 100644 --- a/spec/lib/account_reach_finder_spec.rb +++ b/spec/lib/account_reach_finder_spec.rb @@ -5,31 +5,31 @@ require 'rails_helper' RSpec.describe AccountReachFinder do let(:account) { Fabricate(:account) } - let(:follower1) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/inbox-1') } - let(:follower2) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/inbox-2') } - let(:follower3) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://foo.bar/users/a/inbox', shared_inbox_url: 'https://foo.bar/inbox') } + let(:ap_follower_example_com) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/inbox-1') } + let(:ap_follower_example_org) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.org/inbox-2') } + let(:ap_follower_with_shared) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://foo.bar/users/a/inbox', shared_inbox_url: 'https://foo.bar/inbox') } - let(:mentioned1) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://foo.bar/users/b/inbox', shared_inbox_url: 'https://foo.bar/inbox') } - let(:mentioned2) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/inbox-3') } - let(:mentioned3) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/inbox-4') } + let(:ap_mentioned_with_shared) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://foo.bar/users/b/inbox', shared_inbox_url: 'https://foo.bar/inbox') } + let(:ap_mentioned_example_com) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/inbox-3') } + let(:ap_mentioned_example_org) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.org/inbox-4') } let(:unrelated_account) { Fabricate(:account, protocol: :activitypub, inbox_url: 'https://example.com/unrelated-inbox') } before do - follower1.follow!(account) - follower2.follow!(account) - follower3.follow!(account) + ap_follower_example_com.follow!(account) + ap_follower_example_org.follow!(account) + ap_follower_with_shared.follow!(account) Fabricate(:status, account: account).tap do |status| - status.mentions << Mention.new(account: follower1) - status.mentions << Mention.new(account: mentioned1) + status.mentions << Mention.new(account: ap_follower_example_com) + status.mentions << Mention.new(account: ap_mentioned_with_shared) end Fabricate(:status, account: account) Fabricate(:status, account: account).tap do |status| - status.mentions << Mention.new(account: mentioned2) - status.mentions << Mention.new(account: mentioned3) + status.mentions << Mention.new(account: ap_mentioned_example_com) + status.mentions << Mention.new(account: ap_mentioned_example_org) end Fabricate(:status).tap do |status| @@ -39,11 +39,11 @@ RSpec.describe AccountReachFinder do describe '#inboxes' do it 'includes the preferred inbox URL of followers' do - expect(described_class.new(account).inboxes).to include(*[follower1, follower2, follower3].map(&:preferred_inbox_url)) + expect(described_class.new(account).inboxes).to include(*[ap_follower_example_com, ap_follower_example_org, ap_follower_with_shared].map(&:preferred_inbox_url)) end it 'includes the preferred inbox URL of recently-mentioned accounts' do - expect(described_class.new(account).inboxes).to include(*[mentioned1, mentioned2, mentioned3].map(&:preferred_inbox_url)) + expect(described_class.new(account).inboxes).to include(*[ap_mentioned_with_shared, ap_mentioned_example_com, ap_mentioned_example_org].map(&:preferred_inbox_url)) end it 'does not include the inbox of unrelated users' do diff --git a/spec/lib/feed_manager_spec.rb b/spec/lib/feed_manager_spec.rb index dcb180dc9d..25edaada64 100644 --- a/spec/lib/feed_manager_spec.rb +++ b/spec/lib/feed_manager_spec.rb @@ -526,19 +526,25 @@ RSpec.describe FeedManager do end describe '#clear_from_home' do - let(:account) { Fabricate(:account) } + let(:account) { Fabricate(:account) } let(:followed_account) { Fabricate(:account) } - let(:target_account) { Fabricate(:account) } - let(:status_1) { Fabricate(:status, account: followed_account) } - let(:status_2) { Fabricate(:status, account: target_account) } - let(:status_3) { Fabricate(:status, account: followed_account, mentions: [Fabricate(:mention, account: target_account)]) } - let(:status_4) { Fabricate(:status, mentions: [Fabricate(:mention, account: target_account)]) } - let(:status_5) { Fabricate(:status, account: followed_account, reblog: status_4) } - let(:status_6) { Fabricate(:status, account: followed_account, reblog: status_2) } - let(:status_7) { Fabricate(:status, account: followed_account) } + let(:target_account) { Fabricate(:account) } + let(:status_from_followed_account_first) { Fabricate(:status, account: followed_account) } + let(:status_from_target_account) { Fabricate(:status, account: target_account) } + let(:status_from_followed_account_mentions_target_account) { Fabricate(:status, account: followed_account, mentions: [Fabricate(:mention, account: target_account)]) } + let(:status_mentions_target_account) { Fabricate(:status, mentions: [Fabricate(:mention, account: target_account)]) } + let(:status_from_followed_account_reblogs_status_mentions_target_account) { Fabricate(:status, account: followed_account, reblog: status_mentions_target_account) } + let(:status_from_followed_account_reblogs_status_from_target_account) { Fabricate(:status, account: followed_account, reblog: status_from_target_account) } + let(:status_from_followed_account_next) { Fabricate(:status, account: followed_account) } before do - [status_1, status_3, status_5, status_6, status_7].each do |status| + [ + status_from_followed_account_first, + status_from_followed_account_mentions_target_account, + status_from_followed_account_reblogs_status_mentions_target_account, + status_from_followed_account_reblogs_status_from_target_account, + status_from_followed_account_next, + ].each do |status| redis.zadd("feed:home:#{account.id}", status.id, status.id) end end @@ -546,7 +552,7 @@ RSpec.describe FeedManager do it 'correctly cleans the home timeline' do described_class.instance.clear_from_home(account, target_account) - expect(redis.zrange("feed:home:#{account.id}", 0, -1)).to eq [status_1.id.to_s, status_7.id.to_s] + expect(redis.zrange("feed:home:#{account.id}", 0, -1)).to eq [status_from_followed_account_first.id.to_s, status_from_followed_account_next.id.to_s] end end end diff --git a/spec/lib/mastodon/cli/ip_blocks_spec.rb b/spec/lib/mastodon/cli/ip_blocks_spec.rb index e192679a59..030d9fcb19 100644 --- a/spec/lib/mastodon/cli/ip_blocks_spec.rb +++ b/spec/lib/mastodon/cli/ip_blocks_spec.rb @@ -189,22 +189,22 @@ describe Mastodon::CLI::IpBlocks do end context 'with --force option' do - let!(:block1) { IpBlock.create(ip: '192.168.0.0/24', severity: :no_access) } - let!(:block2) { IpBlock.create(ip: '10.0.0.0/16', severity: :no_access) } - let!(:block3) { IpBlock.create(ip: '172.16.0.0/20', severity: :no_access) } + let!(:first_ip_range_block) { IpBlock.create(ip: '192.168.0.0/24', severity: :no_access) } + let!(:second_ip_range_block) { IpBlock.create(ip: '10.0.0.0/16', severity: :no_access) } + let!(:third_ip_range_block) { IpBlock.create(ip: '172.16.0.0/20', severity: :no_access) } let(:arguments) { ['192.168.0.5', '10.0.1.50'] } let(:options) { { force: true } } it 'removes blocks for IP ranges that cover given IP(s)' do cli.invoke(:remove, arguments, options) - expect(IpBlock.where(id: [block1.id, block2.id])).to_not exist + expect(IpBlock.where(id: [first_ip_range_block.id, second_ip_range_block.id])).to_not exist end it 'does not remove other IP ranges' do cli.invoke(:remove, arguments, options) - expect(IpBlock.where(id: block3.id)).to exist + expect(IpBlock.where(id: third_ip_range_block.id)).to exist end end @@ -251,22 +251,22 @@ describe Mastodon::CLI::IpBlocks do end describe '#export' do - let(:block1) { IpBlock.create(ip: '192.168.0.0/24', severity: :no_access) } - let(:block2) { IpBlock.create(ip: '10.0.0.0/16', severity: :no_access) } - let(:block3) { IpBlock.create(ip: '127.0.0.1', severity: :sign_up_block) } + let(:first_ip_range_block) { IpBlock.create(ip: '192.168.0.0/24', severity: :no_access) } + let(:second_ip_range_block) { IpBlock.create(ip: '10.0.0.0/16', severity: :no_access) } + let(:third_ip_range_block) { IpBlock.create(ip: '127.0.0.1', severity: :sign_up_block) } context 'when --format option is set to "plain"' do let(:options) { { format: 'plain' } } it 'exports blocked IPs with "no_access" severity in plain format' do expect { cli.invoke(:export, nil, options) }.to output( - a_string_including("#{block1.ip}/#{block1.ip.prefix}\n#{block2.ip}/#{block2.ip.prefix}") + a_string_including("#{first_ip_range_block.ip}/#{first_ip_range_block.ip.prefix}\n#{second_ip_range_block.ip}/#{second_ip_range_block.ip.prefix}") ).to_stdout end it 'does not export bloked IPs with different severities' do expect { cli.invoke(:export, nil, options) }.to_not output( - a_string_including("#{block3.ip}/#{block1.ip.prefix}") + a_string_including("#{third_ip_range_block.ip}/#{first_ip_range_block.ip.prefix}") ).to_stdout end end @@ -276,13 +276,13 @@ describe Mastodon::CLI::IpBlocks do it 'exports blocked IPs with "no_access" severity in plain format' do expect { cli.invoke(:export, nil, options) }.to output( - a_string_including("deny #{block1.ip}/#{block1.ip.prefix};\ndeny #{block2.ip}/#{block2.ip.prefix};") + a_string_including("deny #{first_ip_range_block.ip}/#{first_ip_range_block.ip.prefix};\ndeny #{second_ip_range_block.ip}/#{second_ip_range_block.ip.prefix};") ).to_stdout end it 'does not export bloked IPs with different severities' do expect { cli.invoke(:export, nil, options) }.to_not output( - a_string_including("deny #{block3.ip}/#{block1.ip.prefix};") + a_string_including("deny #{third_ip_range_block.ip}/#{first_ip_range_block.ip.prefix};") ).to_stdout end end @@ -290,7 +290,7 @@ describe Mastodon::CLI::IpBlocks do context 'when --format option is not provided' do it 'exports blocked IPs in plain format by default' do expect { cli.export }.to output( - a_string_including("#{block1.ip}/#{block1.ip.prefix}\n#{block2.ip}/#{block2.ip.prefix}") + a_string_including("#{first_ip_range_block.ip}/#{first_ip_range_block.ip.prefix}\n#{second_ip_range_block.ip}/#{second_ip_range_block.ip.prefix}") ).to_stdout end end diff --git a/spec/models/account_statuses_cleanup_policy_spec.rb b/spec/models/account_statuses_cleanup_policy_spec.rb index 391b99ff47..7405bdfa2d 100644 --- a/spec/models/account_statuses_cleanup_policy_spec.rb +++ b/spec/models/account_statuses_cleanup_policy_spec.rb @@ -266,10 +266,10 @@ RSpec.describe AccountStatusesCleanupPolicy do let!(:self_bookmarked) { Fabricate(:status, created_at: 1.year.ago, account: account) } let!(:status_with_poll) { Fabricate(:status, created_at: 1.year.ago, account: account, poll_attributes: { account: account, voters_count: 0, options: %w(a b), expires_in: 2.days }) } let!(:status_with_media) { Fabricate(:status, created_at: 1.year.ago, account: account) } - let!(:faved4) { Fabricate(:status, created_at: 1.year.ago, account: account) } - let!(:faved5) { Fabricate(:status, created_at: 1.year.ago, account: account) } - let!(:reblogged4) { Fabricate(:status, created_at: 1.year.ago, account: account) } - let!(:reblogged5) { Fabricate(:status, created_at: 1.year.ago, account: account) } + let!(:faved_primary) { Fabricate(:status, created_at: 1.year.ago, account: account) } + let!(:faved_secondary) { Fabricate(:status, created_at: 1.year.ago, account: account) } + let!(:reblogged_primary) { Fabricate(:status, created_at: 1.year.ago, account: account) } + let!(:reblogged_secondary) { Fabricate(:status, created_at: 1.year.ago, account: account) } let!(:recent_status) { Fabricate(:status, created_at: 2.days.ago, account: account) } let!(:media_attachment) { Fabricate(:media_attachment, account: account, status: status_with_media) } @@ -280,10 +280,10 @@ RSpec.describe AccountStatusesCleanupPolicy do let(:account_statuses_cleanup_policy) { Fabricate(:account_statuses_cleanup_policy, account: account) } before do - 4.times { faved4.increment_count!(:favourites_count) } - 5.times { faved5.increment_count!(:favourites_count) } - 4.times { reblogged4.increment_count!(:reblogs_count) } - 5.times { reblogged5.increment_count!(:reblogs_count) } + 4.times { faved_primary.increment_count!(:favourites_count) } + 5.times { faved_secondary.increment_count!(:favourites_count) } + 4.times { reblogged_primary.increment_count!(:reblogs_count) } + 5.times { reblogged_secondary.increment_count!(:reblogs_count) } end context 'when passed a max_id' do @@ -359,7 +359,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -378,7 +378,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, status_with_poll.id, status_with_media.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, status_with_poll.id, status_with_media.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -397,7 +397,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -416,7 +416,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -435,7 +435,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_media.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_media.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -454,7 +454,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -477,7 +477,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns every other old status for deletion' do - expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(direct_message.id, very_old_status.id, pinned_status.id, self_faved.id, self_bookmarked.id, status_with_poll.id, status_with_media.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -496,7 +496,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns only normal statuses for deletion' do - expect(subject.pluck(:id)).to contain_exactly(very_old_status.id, faved4.id, faved5.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to contain_exactly(very_old_status.id, faved_primary.id, faved_secondary.id, reblogged_primary.id, reblogged_secondary.id) end end @@ -510,7 +510,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'does not return the toot reblogged 5 times' do - expect(subject.pluck(:id)).to_not include(reblogged5.id) + expect(subject.pluck(:id)).to_not include(reblogged_secondary.id) end it 'does not return the unrelated toot' do @@ -518,7 +518,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns old statuses not reblogged as much' do - expect(subject.pluck(:id)).to include(very_old_status.id, faved4.id, faved5.id, reblogged4.id) + expect(subject.pluck(:id)).to include(very_old_status.id, faved_primary.id, faved_secondary.id, reblogged_primary.id) end end @@ -532,7 +532,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'does not return the toot faved 5 times' do - expect(subject.pluck(:id)).to_not include(faved5.id) + expect(subject.pluck(:id)).to_not include(faved_secondary.id) end it 'does not return the unrelated toot' do @@ -540,7 +540,7 @@ RSpec.describe AccountStatusesCleanupPolicy do end it 'returns old statuses not faved as much' do - expect(subject.pluck(:id)).to include(very_old_status.id, faved4.id, reblogged4.id, reblogged5.id) + expect(subject.pluck(:id)).to include(very_old_status.id, faved_primary.id, reblogged_primary.id, reblogged_secondary.id) end end end diff --git a/spec/models/concerns/account_interactions_spec.rb b/spec/models/concerns/account_interactions_spec.rb index dc03aad7d4..84e2c91a85 100644 --- a/spec/models/concerns/account_interactions_spec.rb +++ b/spec/models/concerns/account_interactions_spec.rb @@ -560,17 +560,17 @@ describe AccountInteractions do describe '#remote_followers_hash' do let(:me) { Fabricate(:account, username: 'Me') } - let(:remote_1) { Fabricate(:account, username: 'alice', domain: 'example.org', uri: 'https://example.org/users/alice') } - let(:remote_2) { Fabricate(:account, username: 'bob', domain: 'example.org', uri: 'https://example.org/users/bob') } - let(:remote_3) { Fabricate(:account, username: 'instance-actor', domain: 'example.org', uri: 'https://example.org') } - let(:remote_4) { Fabricate(:account, username: 'eve', domain: 'foo.org', uri: 'https://foo.org/users/eve') } + let(:remote_alice) { Fabricate(:account, username: 'alice', domain: 'example.org', uri: 'https://example.org/users/alice') } + let(:remote_bob) { Fabricate(:account, username: 'bob', domain: 'example.org', uri: 'https://example.org/users/bob') } + let(:remote_instance_actor) { Fabricate(:account, username: 'instance-actor', domain: 'example.org', uri: 'https://example.org') } + let(:remote_eve) { Fabricate(:account, username: 'eve', domain: 'foo.org', uri: 'https://foo.org/users/eve') } before do - remote_1.follow!(me) - remote_2.follow!(me) - remote_3.follow!(me) - remote_4.follow!(me) - me.follow!(remote_1) + remote_alice.follow!(me) + remote_bob.follow!(me) + remote_instance_actor.follow!(me) + remote_eve.follow!(me) + me.follow!(remote_alice) end it 'returns correct hash for remote domains' do @@ -582,33 +582,33 @@ describe AccountInteractions do it 'invalidates cache as needed when removing or adding followers' do expect(me.remote_followers_hash('https://example.org/')).to eq '20aecbe774b3d61c25094370baf370012b9271c5b172ecedb05caff8d79ef0c7' - remote_3.unfollow!(me) + remote_instance_actor.unfollow!(me) expect(me.remote_followers_hash('https://example.org/')).to eq '707962e297b7bd94468a21bc8e506a1bcea607a9142cd64e27c9b106b2a5f6ec' - remote_1.unfollow!(me) + remote_alice.unfollow!(me) expect(me.remote_followers_hash('https://example.org/')).to eq '241b00794ce9b46aa864f3220afadef128318da2659782985bac5ed5bd436bff' - remote_1.follow!(me) + remote_alice.follow!(me) expect(me.remote_followers_hash('https://example.org/')).to eq '707962e297b7bd94468a21bc8e506a1bcea607a9142cd64e27c9b106b2a5f6ec' end end describe '#local_followers_hash' do let(:me) { Fabricate(:account, username: 'Me') } - let(:remote_1) { Fabricate(:account, username: 'alice', domain: 'example.org', uri: 'https://example.org/users/alice') } + let(:remote_alice) { Fabricate(:account, username: 'alice', domain: 'example.org', uri: 'https://example.org/users/alice') } before do - me.follow!(remote_1) + me.follow!(remote_alice) end it 'returns correct hash for local users' do - expect(remote_1.local_followers_hash).to eq Digest::SHA256.hexdigest(ActivityPub::TagManager.instance.uri_for(me)) + expect(remote_alice.local_followers_hash).to eq Digest::SHA256.hexdigest(ActivityPub::TagManager.instance.uri_for(me)) end it 'invalidates cache as needed when removing or adding followers' do - expect(remote_1.local_followers_hash).to eq Digest::SHA256.hexdigest(ActivityPub::TagManager.instance.uri_for(me)) - me.unfollow!(remote_1) - expect(remote_1.local_followers_hash).to eq '0000000000000000000000000000000000000000000000000000000000000000' - me.follow!(remote_1) - expect(remote_1.local_followers_hash).to eq Digest::SHA256.hexdigest(ActivityPub::TagManager.instance.uri_for(me)) + expect(remote_alice.local_followers_hash).to eq Digest::SHA256.hexdigest(ActivityPub::TagManager.instance.uri_for(me)) + me.unfollow!(remote_alice) + expect(remote_alice.local_followers_hash).to eq '0000000000000000000000000000000000000000000000000000000000000000' + me.follow!(remote_alice) + expect(remote_alice.local_followers_hash).to eq Digest::SHA256.hexdigest(ActivityPub::TagManager.instance.uri_for(me)) end end diff --git a/spec/models/concerns/status_threading_concern_spec.rb b/spec/models/concerns/status_threading_concern_spec.rb index 50286ef77b..2eac1ca6e5 100644 --- a/spec/models/concerns/status_threading_concern_spec.rb +++ b/spec/models/concerns/status_threading_concern_spec.rb @@ -8,40 +8,40 @@ describe StatusThreadingConcern do let!(:bob) { Fabricate(:account, username: 'bob', domain: 'example.com') } let!(:jeff) { Fabricate(:account, username: 'jeff') } let!(:status) { Fabricate(:status, account: alice) } - let!(:reply1) { Fabricate(:status, thread: status, account: jeff) } - let!(:reply2) { Fabricate(:status, thread: reply1, account: bob) } - let!(:reply3) { Fabricate(:status, thread: reply2, account: alice) } + let!(:reply_to_status) { Fabricate(:status, thread: status, account: jeff) } + let!(:reply_to_first_reply) { Fabricate(:status, thread: reply_to_status, account: bob) } + let!(:reply_to_second_reply) { Fabricate(:status, thread: reply_to_first_reply, account: alice) } let!(:viewer) { Fabricate(:account, username: 'viewer') } it 'returns conversation history' do - expect(reply3.ancestors(4)).to include(status, reply1, reply2) + expect(reply_to_second_reply.ancestors(4)).to include(status, reply_to_status, reply_to_first_reply) end it 'does not return conversation history user is not allowed to see' do - reply1.update(visibility: :private) + reply_to_status.update(visibility: :private) status.update(visibility: :direct) - expect(reply3.ancestors(4, viewer)).to_not include(reply1, status) + expect(reply_to_second_reply.ancestors(4, viewer)).to_not include(reply_to_status, status) end it 'does not return conversation history from blocked users' do viewer.block!(jeff) - expect(reply3.ancestors(4, viewer)).to_not include(reply1) + expect(reply_to_second_reply.ancestors(4, viewer)).to_not include(reply_to_status) end it 'does not return conversation history from muted users' do viewer.mute!(jeff) - expect(reply3.ancestors(4, viewer)).to_not include(reply1) + expect(reply_to_second_reply.ancestors(4, viewer)).to_not include(reply_to_status) end it 'does not return conversation history from silenced and not followed users' do jeff.silence! - expect(reply3.ancestors(4, viewer)).to_not include(reply1) + expect(reply_to_second_reply.ancestors(4, viewer)).to_not include(reply_to_status) end it 'does not return conversation history from blocked domains' do viewer.block_domain!('example.com') - expect(reply3.ancestors(4, viewer)).to_not include(reply2) + expect(reply_to_second_reply.ancestors(4, viewer)).to_not include(reply_to_first_reply) end it 'ignores deleted records' do @@ -83,40 +83,40 @@ describe StatusThreadingConcern do let!(:bob) { Fabricate(:account, username: 'bob', domain: 'example.com') } let!(:jeff) { Fabricate(:account, username: 'jeff') } let!(:status) { Fabricate(:status, account: alice) } - let!(:reply1) { Fabricate(:status, thread: status, account: alice) } - let!(:reply2) { Fabricate(:status, thread: status, account: bob) } - let!(:reply3) { Fabricate(:status, thread: reply1, account: jeff) } + let!(:reply_to_status_from_alice) { Fabricate(:status, thread: status, account: alice) } + let!(:reply_to_status_from_bob) { Fabricate(:status, thread: status, account: bob) } + let!(:reply_to_alice_reply_from_jeff) { Fabricate(:status, thread: reply_to_status_from_alice, account: jeff) } let!(:viewer) { Fabricate(:account, username: 'viewer') } it 'returns replies' do - expect(status.descendants(4)).to include(reply1, reply2, reply3) + expect(status.descendants(4)).to include(reply_to_status_from_alice, reply_to_status_from_bob, reply_to_alice_reply_from_jeff) end it 'does not return replies user is not allowed to see' do - reply1.update(visibility: :private) - reply3.update(visibility: :direct) + reply_to_status_from_alice.update(visibility: :private) + reply_to_alice_reply_from_jeff.update(visibility: :direct) - expect(status.descendants(4, viewer)).to_not include(reply1, reply3) + expect(status.descendants(4, viewer)).to_not include(reply_to_status_from_alice, reply_to_alice_reply_from_jeff) end it 'does not return replies from blocked users' do viewer.block!(jeff) - expect(status.descendants(4, viewer)).to_not include(reply3) + expect(status.descendants(4, viewer)).to_not include(reply_to_alice_reply_from_jeff) end it 'does not return replies from muted users' do viewer.mute!(jeff) - expect(status.descendants(4, viewer)).to_not include(reply3) + expect(status.descendants(4, viewer)).to_not include(reply_to_alice_reply_from_jeff) end it 'does not return replies from silenced and not followed users' do jeff.silence! - expect(status.descendants(4, viewer)).to_not include(reply3) + expect(status.descendants(4, viewer)).to_not include(reply_to_alice_reply_from_jeff) end it 'does not return replies from blocked domains' do viewer.block_domain!('example.com') - expect(status.descendants(4, viewer)).to_not include(reply2) + expect(status.descendants(4, viewer)).to_not include(reply_to_status_from_bob) end it 'promotes self-replies to the top while leaving the rest in order' do diff --git a/spec/models/custom_emoji_filter_spec.rb b/spec/models/custom_emoji_filter_spec.rb index d8a2bea6b8..c36fecd60d 100644 --- a/spec/models/custom_emoji_filter_spec.rb +++ b/spec/models/custom_emoji_filter_spec.rb @@ -6,9 +6,9 @@ RSpec.describe CustomEmojiFilter do describe '#results' do subject { described_class.new(params).results } - let!(:custom_emoji_0) { Fabricate(:custom_emoji, domain: 'a') } - let!(:custom_emoji_1) { Fabricate(:custom_emoji, domain: 'b') } - let!(:custom_emoji_2) { Fabricate(:custom_emoji, domain: nil, shortcode: 'hoge') } + let!(:custom_emoji_domain_a) { Fabricate(:custom_emoji, domain: 'a') } + let!(:custom_emoji_domain_b) { Fabricate(:custom_emoji, domain: 'b') } + let!(:custom_emoji_domain_nil) { Fabricate(:custom_emoji, domain: nil, shortcode: 'hoge') } context 'when params have values' do context 'when local' do @@ -16,7 +16,7 @@ RSpec.describe CustomEmojiFilter do it 'returns ActiveRecord::Relation' do expect(subject).to be_a(ActiveRecord::Relation) - expect(subject).to contain_exactly(custom_emoji_2) + expect(subject).to contain_exactly(custom_emoji_domain_nil) end end @@ -25,7 +25,7 @@ RSpec.describe CustomEmojiFilter do it 'returns ActiveRecord::Relation' do expect(subject).to be_a(ActiveRecord::Relation) - expect(subject).to contain_exactly(custom_emoji_0, custom_emoji_1) + expect(subject).to contain_exactly(custom_emoji_domain_a, custom_emoji_domain_b) end end @@ -34,7 +34,7 @@ RSpec.describe CustomEmojiFilter do it 'returns ActiveRecord::Relation' do expect(subject).to be_a(ActiveRecord::Relation) - expect(subject).to contain_exactly(custom_emoji_0) + expect(subject).to contain_exactly(custom_emoji_domain_a) end end @@ -43,7 +43,7 @@ RSpec.describe CustomEmojiFilter do it 'returns ActiveRecord::Relation' do expect(subject).to be_a(ActiveRecord::Relation) - expect(subject).to contain_exactly(custom_emoji_2) + expect(subject).to contain_exactly(custom_emoji_domain_nil) end end @@ -63,7 +63,7 @@ RSpec.describe CustomEmojiFilter do it 'returns ActiveRecord::Relation' do expect(subject).to be_a(ActiveRecord::Relation) - expect(subject).to contain_exactly(custom_emoji_0, custom_emoji_1, custom_emoji_2) + expect(subject).to contain_exactly(custom_emoji_domain_a, custom_emoji_domain_b, custom_emoji_domain_nil) end end end diff --git a/spec/models/status_spec.rb b/spec/models/status_spec.rb index 3141c52c05..8c37b1accc 100644 --- a/spec/models/status_spec.rb +++ b/spec/models/status_spec.rb @@ -254,82 +254,82 @@ RSpec.describe Status do end describe '.tagged_with' do - let(:tag1) { Fabricate(:tag) } - let(:tag2) { Fabricate(:tag) } - let(:tag3) { Fabricate(:tag) } - let!(:status1) { Fabricate(:status, tags: [tag1]) } - let!(:status2) { Fabricate(:status, tags: [tag2]) } - let!(:status3) { Fabricate(:status, tags: [tag3]) } - let!(:status4) { Fabricate(:status, tags: []) } - let!(:status5) { Fabricate(:status, tags: [tag1, tag2, tag3]) } + let(:tag_cats) { Fabricate(:tag, name: 'cats') } + let(:tag_dogs) { Fabricate(:tag, name: 'dogs') } + let(:tag_zebras) { Fabricate(:tag, name: 'zebras') } + let!(:status_with_tag_cats) { Fabricate(:status, tags: [tag_cats]) } + let!(:status_with_tag_dogs) { Fabricate(:status, tags: [tag_dogs]) } + let!(:status_tagged_with_zebras) { Fabricate(:status, tags: [tag_zebras]) } + let!(:status_without_tags) { Fabricate(:status, tags: []) } + let!(:status_with_all_tags) { Fabricate(:status, tags: [tag_cats, tag_dogs, tag_zebras]) } context 'when given one tag' do it 'returns the expected statuses' do - expect(described_class.tagged_with([tag1.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status5.id) - expect(described_class.tagged_with([tag2.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status2.id, status5.id) - expect(described_class.tagged_with([tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status3.id, status5.id) + expect(described_class.tagged_with([tag_cats.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_with_all_tags.id) + expect(described_class.tagged_with([tag_dogs.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_dogs.id, status_with_all_tags.id) + expect(described_class.tagged_with([tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_tagged_with_zebras.id, status_with_all_tags.id) end end context 'when given multiple tags' do it 'returns the expected statuses' do - expect(described_class.tagged_with([tag1.id, tag2.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status2.id, status5.id) - expect(described_class.tagged_with([tag1.id, tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status3.id, status5.id) - expect(described_class.tagged_with([tag2.id, tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status2.id, status3.id, status5.id) + expect(described_class.tagged_with([tag_cats.id, tag_dogs.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_with_tag_dogs.id, status_with_all_tags.id) + expect(described_class.tagged_with([tag_cats.id, tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_tagged_with_zebras.id, status_with_all_tags.id) + expect(described_class.tagged_with([tag_dogs.id, tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_dogs.id, status_tagged_with_zebras.id, status_with_all_tags.id) end end end describe '.tagged_with_all' do - let(:tag1) { Fabricate(:tag) } - let(:tag2) { Fabricate(:tag) } - let(:tag3) { Fabricate(:tag) } - let!(:status1) { Fabricate(:status, tags: [tag1]) } - let!(:status2) { Fabricate(:status, tags: [tag2]) } - let!(:status3) { Fabricate(:status, tags: [tag3]) } - let!(:status4) { Fabricate(:status, tags: []) } - let!(:status5) { Fabricate(:status, tags: [tag1, tag2]) } + let(:tag_cats) { Fabricate(:tag, name: 'cats') } + let(:tag_dogs) { Fabricate(:tag, name: 'dogs') } + let(:tag_zebras) { Fabricate(:tag, name: 'zebras') } + let!(:status_with_tag_cats) { Fabricate(:status, tags: [tag_cats]) } + let!(:status_with_tag_dogs) { Fabricate(:status, tags: [tag_dogs]) } + let!(:status_tagged_with_zebras) { Fabricate(:status, tags: [tag_zebras]) } + let!(:status_without_tags) { Fabricate(:status, tags: []) } + let!(:status_with_all_tags) { Fabricate(:status, tags: [tag_cats, tag_dogs]) } context 'when given one tag' do it 'returns the expected statuses' do - expect(described_class.tagged_with_all([tag1.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status5.id) - expect(described_class.tagged_with_all([tag2.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status2.id, status5.id) - expect(described_class.tagged_with_all([tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status3.id) + expect(described_class.tagged_with_all([tag_cats.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_with_all_tags.id) + expect(described_class.tagged_with_all([tag_dogs.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_dogs.id, status_with_all_tags.id) + expect(described_class.tagged_with_all([tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_tagged_with_zebras.id) end end context 'when given multiple tags' do it 'returns the expected statuses' do - expect(described_class.tagged_with_all([tag1.id, tag2.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status5.id) - expect(described_class.tagged_with_all([tag1.id, tag3.id]).reorder(:id).pluck(:id).uniq).to eq [] - expect(described_class.tagged_with_all([tag2.id, tag3.id]).reorder(:id).pluck(:id).uniq).to eq [] + expect(described_class.tagged_with_all([tag_cats.id, tag_dogs.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_all_tags.id) + expect(described_class.tagged_with_all([tag_cats.id, tag_zebras.id]).reorder(:id).pluck(:id).uniq).to eq [] + expect(described_class.tagged_with_all([tag_dogs.id, tag_zebras.id]).reorder(:id).pluck(:id).uniq).to eq [] end end end describe '.tagged_with_none' do - let(:tag1) { Fabricate(:tag) } - let(:tag2) { Fabricate(:tag) } - let(:tag3) { Fabricate(:tag) } - let!(:status1) { Fabricate(:status, tags: [tag1]) } - let!(:status2) { Fabricate(:status, tags: [tag2]) } - let!(:status3) { Fabricate(:status, tags: [tag3]) } - let!(:status4) { Fabricate(:status, tags: []) } - let!(:status5) { Fabricate(:status, tags: [tag1, tag2, tag3]) } + let(:tag_cats) { Fabricate(:tag, name: 'cats') } + let(:tag_dogs) { Fabricate(:tag, name: 'dogs') } + let(:tag_zebras) { Fabricate(:tag, name: 'zebras') } + let!(:status_with_tag_cats) { Fabricate(:status, tags: [tag_cats]) } + let!(:status_with_tag_dogs) { Fabricate(:status, tags: [tag_dogs]) } + let!(:status_tagged_with_zebras) { Fabricate(:status, tags: [tag_zebras]) } + let!(:status_without_tags) { Fabricate(:status, tags: []) } + let!(:status_with_all_tags) { Fabricate(:status, tags: [tag_cats, tag_dogs, tag_zebras]) } context 'when given one tag' do it 'returns the expected statuses' do - expect(described_class.tagged_with_none([tag1.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status2.id, status3.id, status4.id) - expect(described_class.tagged_with_none([tag2.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status3.id, status4.id) - expect(described_class.tagged_with_none([tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status2.id, status4.id) + expect(described_class.tagged_with_none([tag_cats.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_dogs.id, status_tagged_with_zebras.id, status_without_tags.id) + expect(described_class.tagged_with_none([tag_dogs.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_tagged_with_zebras.id, status_without_tags.id) + expect(described_class.tagged_with_none([tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_with_tag_dogs.id, status_without_tags.id) end end context 'when given multiple tags' do it 'returns the expected statuses' do - expect(described_class.tagged_with_none([tag1.id, tag2.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status3.id, status4.id) - expect(described_class.tagged_with_none([tag1.id, tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status2.id, status4.id) - expect(described_class.tagged_with_none([tag2.id, tag3.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status1.id, status4.id) + expect(described_class.tagged_with_none([tag_cats.id, tag_dogs.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_tagged_with_zebras.id, status_without_tags.id) + expect(described_class.tagged_with_none([tag_cats.id, tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_dogs.id, status_without_tags.id) + expect(described_class.tagged_with_none([tag_dogs.id, tag_zebras.id]).reorder(:id).pluck(:id).uniq).to contain_exactly(status_with_tag_cats.id, status_without_tags.id) end end end diff --git a/spec/models/tag_feed_spec.rb b/spec/models/tag_feed_spec.rb index a498bcf46f..6f5e1eb307 100644 --- a/spec/models/tag_feed_spec.rb +++ b/spec/models/tag_feed_spec.rb @@ -5,65 +5,65 @@ require 'rails_helper' describe TagFeed, type: :service do describe '#get' do let(:account) { Fabricate(:account) } - let(:tag1) { Fabricate(:tag) } - let(:tag2) { Fabricate(:tag) } - let!(:status1) { Fabricate(:status, tags: [tag1]) } - let!(:status2) { Fabricate(:status, tags: [tag2]) } - let!(:both) { Fabricate(:status, tags: [tag1, tag2]) } + let(:tag_cats) { Fabricate(:tag, name: 'cats') } + let(:tag_dogs) { Fabricate(:tag, name: 'dogs') } + let!(:status_tagged_with_cats) { Fabricate(:status, tags: [tag_cats]) } + let!(:status_tagged_with_dogs) { Fabricate(:status, tags: [tag_dogs]) } + let!(:both) { Fabricate(:status, tags: [tag_cats, tag_dogs]) } it 'can add tags in "any" mode' do - results = described_class.new(tag1, nil, any: [tag2.name]).get(20) - expect(results).to include status1 - expect(results).to include status2 + results = described_class.new(tag_cats, nil, any: [tag_dogs.name]).get(20) + expect(results).to include status_tagged_with_cats + expect(results).to include status_tagged_with_dogs expect(results).to include both end it 'can remove tags in "all" mode' do - results = described_class.new(tag1, nil, all: [tag2.name]).get(20) - expect(results).to_not include status1 - expect(results).to_not include status2 + results = described_class.new(tag_cats, nil, all: [tag_dogs.name]).get(20) + expect(results).to_not include status_tagged_with_cats + expect(results).to_not include status_tagged_with_dogs expect(results).to include both end it 'can remove tags in "none" mode' do - results = described_class.new(tag1, nil, none: [tag2.name]).get(20) - expect(results).to include status1 - expect(results).to_not include status2 + results = described_class.new(tag_cats, nil, none: [tag_dogs.name]).get(20) + expect(results).to include status_tagged_with_cats + expect(results).to_not include status_tagged_with_dogs expect(results).to_not include both end it 'ignores an invalid mode' do - results = described_class.new(tag1, nil, wark: [tag2.name]).get(20) - expect(results).to include status1 - expect(results).to_not include status2 + results = described_class.new(tag_cats, nil, wark: [tag_dogs.name]).get(20) + expect(results).to include status_tagged_with_cats + expect(results).to_not include status_tagged_with_dogs expect(results).to include both end it 'handles being passed non existent tag names' do - results = described_class.new(tag1, nil, any: ['wark']).get(20) - expect(results).to include status1 - expect(results).to_not include status2 + results = described_class.new(tag_cats, nil, any: ['wark']).get(20) + expect(results).to include status_tagged_with_cats + expect(results).to_not include status_tagged_with_dogs expect(results).to include both end it 'can restrict to an account' do - BlockService.new.call(account, status1.account) - results = described_class.new(tag1, account, none: [tag2.name]).get(20) - expect(results).to_not include status1 + BlockService.new.call(account, status_tagged_with_cats.account) + results = described_class.new(tag_cats, account, none: [tag_dogs.name]).get(20) + expect(results).to_not include status_tagged_with_cats end it 'can restrict to local' do - status1.account.update(domain: 'example.com') - status1.update(local: false, uri: 'example.com/toot') - results = described_class.new(tag1, nil, any: [tag2.name], local: true).get(20) - expect(results).to_not include status1 + status_tagged_with_cats.account.update(domain: 'example.com') + status_tagged_with_cats.update(local: false, uri: 'example.com/toot') + results = described_class.new(tag_cats, nil, any: [tag_dogs.name], local: true).get(20) + expect(results).to_not include status_tagged_with_cats end it 'allows replies to be included' do original = Fabricate(:status) - status = Fabricate(:status, tags: [tag1], in_reply_to_id: original.id) + status = Fabricate(:status, tags: [tag_cats], in_reply_to_id: original.id) - results = described_class.new(tag1, nil).get(20) + results = described_class.new(tag_cats, nil).get(20) expect(results).to include(status) end end diff --git a/spec/models/trends/statuses_spec.rb b/spec/models/trends/statuses_spec.rb index e30722f585..7c30b5b997 100644 --- a/spec/models/trends/statuses_spec.rb +++ b/spec/models/trends/statuses_spec.rb @@ -11,12 +11,12 @@ RSpec.describe Trends::Statuses do let!(:query) { subject.query } let!(:today) { at_time } - let!(:status1) { Fabricate(:status, text: 'Foo', language: 'en', trendable: true, created_at: today) } - let!(:status2) { Fabricate(:status, text: 'Bar', language: 'en', trendable: true, created_at: today) } + let!(:status_foo) { Fabricate(:status, text: 'Foo', language: 'en', trendable: true, created_at: today) } + let!(:status_bar) { Fabricate(:status, text: 'Bar', language: 'en', trendable: true, created_at: today) } before do - default_threshold_value.times { reblog(status1, today) } - default_threshold_value.times { reblog(status2, today) } + default_threshold_value.times { reblog(status_foo, today) } + default_threshold_value.times { reblog(status_bar, today) } subject.refresh(today) end @@ -29,18 +29,18 @@ RSpec.describe Trends::Statuses do end it 'filters out blocked accounts' do - account.block!(status1.account) - expect(query.filtered_for(account).to_a).to eq [status2] + account.block!(status_foo.account) + expect(query.filtered_for(account).to_a).to eq [status_bar] end it 'filters out muted accounts' do - account.mute!(status2.account) - expect(query.filtered_for(account).to_a).to eq [status1] + account.mute!(status_bar.account) + expect(query.filtered_for(account).to_a).to eq [status_foo] end it 'filters out blocked-by accounts' do - status1.account.block!(account) - expect(query.filtered_for(account).to_a).to eq [status2] + status_foo.account.block!(account) + expect(query.filtered_for(account).to_a).to eq [status_bar] end end end @@ -71,14 +71,14 @@ RSpec.describe Trends::Statuses do let!(:today) { at_time } let!(:yesterday) { today - 1.day } - let!(:status1) { Fabricate(:status, text: 'Foo', language: 'en', trendable: true, created_at: yesterday) } - let!(:status2) { Fabricate(:status, text: 'Bar', language: 'en', trendable: true, created_at: today) } - let!(:status3) { Fabricate(:status, text: 'Baz', language: 'en', trendable: true, created_at: today) } + let!(:status_foo) { Fabricate(:status, text: 'Foo', language: 'en', trendable: true, created_at: yesterday) } + let!(:status_bar) { Fabricate(:status, text: 'Bar', language: 'en', trendable: true, created_at: today) } + let!(:status_baz) { Fabricate(:status, text: 'Baz', language: 'en', trendable: true, created_at: today) } before do - default_threshold_value.times { reblog(status1, today) } - default_threshold_value.times { reblog(status2, today) } - (default_threshold_value - 1).times { reblog(status3, today) } + default_threshold_value.times { reblog(status_foo, today) } + default_threshold_value.times { reblog(status_bar, today) } + (default_threshold_value - 1).times { reblog(status_baz, today) } end context 'when status trends are refreshed' do @@ -89,17 +89,17 @@ RSpec.describe Trends::Statuses do it 'returns correct statuses from query' do results = subject.query.limit(10).to_a - expect(results).to eq [status2, status1] - expect(results).to_not include(status3) + expect(results).to eq [status_bar, status_foo] + expect(results).to_not include(status_baz) end end it 'decays scores' do subject.refresh(today) - original_score = status2.trend.score + original_score = status_bar.trend.score expect(original_score).to be_a Float subject.refresh(today + subject.options[:score_halflife]) - decayed_score = status2.trend.reload.score + decayed_score = status_bar.trend.reload.score expect(decayed_score).to be <= original_score / 2 end end diff --git a/spec/models/trends/tags_spec.rb b/spec/models/trends/tags_spec.rb index 79cdee3461..f2818fca87 100644 --- a/spec/models/trends/tags_spec.rb +++ b/spec/models/trends/tags_spec.rb @@ -33,15 +33,15 @@ RSpec.describe Trends::Tags do let!(:today) { at_time } let!(:yesterday) { today - 1.day } - let!(:tag1) { Fabricate(:tag, name: 'Catstodon', trendable: true) } - let!(:tag2) { Fabricate(:tag, name: 'DogsOfMastodon', trendable: true) } - let!(:tag3) { Fabricate(:tag, name: 'OCs', trendable: true) } + let!(:tag_cats) { Fabricate(:tag, name: 'Catstodon', trendable: true) } + let!(:tag_dogs) { Fabricate(:tag, name: 'DogsOfMastodon', trendable: true) } + let!(:tag_ocs) { Fabricate(:tag, name: 'OCs', trendable: true) } before do - 2.times { |i| subject.add(tag1, i, yesterday) } - 13.times { |i| subject.add(tag3, i, yesterday) } - 16.times { |i| subject.add(tag1, i, today) } - 4.times { |i| subject.add(tag2, i, today) } + 2.times { |i| subject.add(tag_cats, i, yesterday) } + 13.times { |i| subject.add(tag_ocs, i, yesterday) } + 16.times { |i| subject.add(tag_cats, i, today) } + 4.times { |i| subject.add(tag_dogs, i, today) } end context 'when tag trends are refreshed' do @@ -51,20 +51,20 @@ RSpec.describe Trends::Tags do end it 'calculates and re-calculates scores' do - expect(subject.query.limit(10).to_a).to eq [tag1, tag3] + expect(subject.query.limit(10).to_a).to eq [tag_cats, tag_ocs] end it 'omits hashtags below threshold' do - expect(subject.query.limit(10).to_a).to_not include(tag2) + expect(subject.query.limit(10).to_a).to_not include(tag_dogs) end end it 'decays scores' do subject.refresh(yesterday + 12.hours) - original_score = subject.score(tag3.id) + original_score = subject.score(tag_ocs.id) expect(original_score).to eq 144.0 subject.refresh(yesterday + 12.hours + subject.options[:max_score_halflife]) - decayed_score = subject.score(tag3.id) + decayed_score = subject.score(tag_ocs.id) expect(decayed_score).to be <= original_score / 2 end end diff --git a/spec/serializers/activitypub/note_serializer_spec.rb b/spec/serializers/activitypub/note_serializer_spec.rb index 68f5378918..4b2b8ec875 100644 --- a/spec/serializers/activitypub/note_serializer_spec.rb +++ b/spec/serializers/activitypub/note_serializer_spec.rb @@ -6,13 +6,13 @@ describe ActivityPub::NoteSerializer do subject { JSON.parse(@serialization.to_json) } let!(:account) { Fabricate(:account) } - let!(:other) { Fabricate(:account) } - let!(:parent) { Fabricate(:status, account: account, visibility: :public) } - let!(:reply1) { Fabricate(:status, account: account, thread: parent, visibility: :public) } - let!(:reply2) { Fabricate(:status, account: account, thread: parent, visibility: :public) } - let!(:reply3) { Fabricate(:status, account: other, thread: parent, visibility: :public) } - let!(:reply4) { Fabricate(:status, account: account, thread: parent, visibility: :public) } - let!(:reply5) { Fabricate(:status, account: account, thread: parent, visibility: :direct) } + let!(:other) { Fabricate(:account) } + let!(:parent) { Fabricate(:status, account: account, visibility: :public) } + let!(:reply_by_account_first) { Fabricate(:status, account: account, thread: parent, visibility: :public) } + let!(:reply_by_account_next) { Fabricate(:status, account: account, thread: parent, visibility: :public) } + let!(:reply_by_other_first) { Fabricate(:status, account: other, thread: parent, visibility: :public) } + let!(:reply_by_account_third) { Fabricate(:status, account: account, thread: parent, visibility: :public) } + let!(:reply_by_account_visibility_direct) { Fabricate(:status, account: account, thread: parent, visibility: :direct) } before(:each) do @serialization = ActiveModelSerializers::SerializableResource.new(parent, serializer: described_class, adapter: ActivityPub::Adapter) @@ -31,14 +31,14 @@ describe ActivityPub::NoteSerializer do end it 'includes public self-replies in its replies collection' do - expect(subject['replies']['first']['items']).to include(reply1.uri, reply2.uri, reply4.uri) + expect(subject['replies']['first']['items']).to include(reply_by_account_first.uri, reply_by_account_next.uri, reply_by_account_third.uri) end it 'does not include replies from others in its replies collection' do - expect(subject['replies']['first']['items']).to_not include(reply3.uri) + expect(subject['replies']['first']['items']).to_not include(reply_by_other_first.uri) end it 'does not include replies with direct visibility in its replies collection' do - expect(subject['replies']['first']['items']).to_not include(reply5.uri) + expect(subject['replies']['first']['items']).to_not include(reply_by_account_visibility_direct.uri) end end diff --git a/spec/services/activitypub/fetch_featured_collection_service_spec.rb b/spec/services/activitypub/fetch_featured_collection_service_spec.rb index 0af0f4c075..5975c81a10 100644 --- a/spec/services/activitypub/fetch_featured_collection_service_spec.rb +++ b/spec/services/activitypub/fetch_featured_collection_service_spec.rb @@ -9,33 +9,33 @@ RSpec.describe ActivityPub::FetchFeaturedCollectionService, type: :service do let!(:known_status) { Fabricate(:status, account: actor, uri: 'https://example.com/account/pinned/1') } - let(:status_json_1) do + let(:status_json_pinned_known) do { '@context': 'https://www.w3.org/ns/activitystreams', type: 'Note', - id: 'https://example.com/account/pinned/1', + id: 'https://example.com/account/pinned/known', content: 'foo', attributedTo: actor.uri, to: 'https://www.w3.org/ns/activitystreams#Public', } end - let(:status_json_2) do + let(:status_json_pinned_unknown_inlined) do { '@context': 'https://www.w3.org/ns/activitystreams', type: 'Note', - id: 'https://example.com/account/pinned/2', + id: 'https://example.com/account/pinned/unknown-inlined', content: 'foo', attributedTo: actor.uri, to: 'https://www.w3.org/ns/activitystreams#Public', } end - let(:status_json_4) do + let(:status_json_pinned_unknown_unreachable) do { '@context': 'https://www.w3.org/ns/activitystreams', type: 'Note', - id: 'https://example.com/account/pinned/4', + id: 'https://example.com/account/pinned/unknown-reachable', content: 'foo', attributedTo: actor.uri, to: 'https://www.w3.org/ns/activitystreams#Public', @@ -44,10 +44,10 @@ RSpec.describe ActivityPub::FetchFeaturedCollectionService, type: :service do let(:items) do [ - 'https://example.com/account/pinned/1', # known - status_json_2, # unknown inlined - 'https://example.com/account/pinned/3', # unknown unreachable - 'https://example.com/account/pinned/4', # unknown reachable + 'https://example.com/account/pinned/known', # known + status_json_pinned_unknown_inlined, # unknown inlined + 'https://example.com/account/pinned/unknown-unreachable', # unknown unreachable + 'https://example.com/account/pinned/unknown-reachable', # unknown reachable ] end @@ -62,16 +62,20 @@ RSpec.describe ActivityPub::FetchFeaturedCollectionService, type: :service do shared_examples 'sets pinned posts' do before do - stub_request(:get, 'https://example.com/account/pinned/1').to_return(status: 200, body: Oj.dump(status_json_1)) - stub_request(:get, 'https://example.com/account/pinned/2').to_return(status: 200, body: Oj.dump(status_json_2)) - stub_request(:get, 'https://example.com/account/pinned/3').to_return(status: 404) - stub_request(:get, 'https://example.com/account/pinned/4').to_return(status: 200, body: Oj.dump(status_json_4)) + stub_request(:get, 'https://example.com/account/pinned/known').to_return(status: 200, body: Oj.dump(status_json_pinned_known)) + stub_request(:get, 'https://example.com/account/pinned/unknown-inlined').to_return(status: 200, body: Oj.dump(status_json_pinned_unknown_inlined)) + stub_request(:get, 'https://example.com/account/pinned/unknown-unreachable').to_return(status: 404) + stub_request(:get, 'https://example.com/account/pinned/unknown-reachable').to_return(status: 200, body: Oj.dump(status_json_pinned_unknown_unreachable)) subject.call(actor, note: true, hashtag: false) end it 'sets expected posts as pinned posts' do - expect(actor.pinned_statuses.pluck(:uri)).to contain_exactly('https://example.com/account/pinned/1', 'https://example.com/account/pinned/2', 'https://example.com/account/pinned/4') + expect(actor.pinned_statuses.pluck(:uri)).to contain_exactly( + 'https://example.com/account/pinned/known', + 'https://example.com/account/pinned/unknown-inlined', + 'https://example.com/account/pinned/unknown-reachable' + ) end end diff --git a/spec/services/batched_remove_status_service_spec.rb b/spec/services/batched_remove_status_service_spec.rb index c0cd01315f..1363c81d05 100644 --- a/spec/services/batched_remove_status_service_spec.rb +++ b/spec/services/batched_remove_status_service_spec.rb @@ -10,8 +10,8 @@ RSpec.describe BatchedRemoveStatusService, type: :service do let!(:jeff) { Fabricate(:account) } let!(:hank) { Fabricate(:account, username: 'hank', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') } - let(:status1) { PostStatusService.new.call(alice, text: 'Hello @bob@example.com') } - let(:status2) { PostStatusService.new.call(alice, text: 'Another status') } + let(:status_alice_hello) { PostStatusService.new.call(alice, text: 'Hello @bob@example.com') } + let(:status_alice_other) { PostStatusService.new.call(alice, text: 'Another status') } before do allow(redis).to receive_messages(publish: nil) @@ -22,23 +22,23 @@ RSpec.describe BatchedRemoveStatusService, type: :service do jeff.follow!(alice) hank.follow!(alice) - status1 - status2 + status_alice_hello + status_alice_other - subject.call([status1, status2]) + subject.call([status_alice_hello, status_alice_other]) end it 'removes statuses' do - expect { Status.find(status1.id) }.to raise_error ActiveRecord::RecordNotFound - expect { Status.find(status2.id) }.to raise_error ActiveRecord::RecordNotFound + expect { Status.find(status_alice_hello.id) }.to raise_error ActiveRecord::RecordNotFound + expect { Status.find(status_alice_other.id) }.to raise_error ActiveRecord::RecordNotFound end it 'removes statuses from author\'s home feed' do - expect(HomeFeed.new(alice).get(10)).to_not include([status1.id, status2.id]) + expect(HomeFeed.new(alice).get(10)).to_not include([status_alice_hello.id, status_alice_other.id]) end it 'removes statuses from local follower\'s home feed' do - expect(HomeFeed.new(jeff).get(10)).to_not include([status1.id, status2.id]) + expect(HomeFeed.new(jeff).get(10)).to_not include([status_alice_hello.id, status_alice_other.id]) end it 'notifies streaming API of followers' do diff --git a/spec/services/block_domain_service_spec.rb b/spec/services/block_domain_service_spec.rb index 93722a15bc..36dce9d196 100644 --- a/spec/services/block_domain_service_spec.rb +++ b/spec/services/block_domain_service_spec.rb @@ -6,9 +6,9 @@ RSpec.describe BlockDomainService, type: :service do subject { described_class.new } let!(:bad_account) { Fabricate(:account, username: 'badguy666', domain: 'evil.org') } - let!(:bad_status1) { Fabricate(:status, account: bad_account, text: 'You suck') } - let!(:bad_status2) { Fabricate(:status, account: bad_account, text: 'Hahaha') } - let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status2, file: attachment_fixture('attachment.jpg')) } + let!(:bad_status_plain) { Fabricate(:status, account: bad_account, text: 'You suck') } + let!(:bad_status_with_attachment) { Fabricate(:status, account: bad_account, text: 'Hahaha') } + let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status_with_attachment, file: attachment_fixture('attachment.jpg')) } let!(:already_banned_account) { Fabricate(:account, username: 'badguy', domain: 'evil.org', suspended: true, silenced: true) } describe 'for a suspension' do @@ -37,8 +37,8 @@ RSpec.describe BlockDomainService, type: :service do end it 'removes the remote accounts\'s statuses and media attachments' do - expect { bad_status1.reload }.to raise_exception ActiveRecord::RecordNotFound - expect { bad_status2.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { bad_status_plain.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { bad_status_with_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound expect { bad_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound end end @@ -69,8 +69,8 @@ RSpec.describe BlockDomainService, type: :service do end it 'leaves the domains status and attachments, but clears media' do - expect { bad_status1.reload }.to_not raise_error - expect { bad_status2.reload }.to_not raise_error + expect { bad_status_plain.reload }.to_not raise_error + expect { bad_status_with_attachment.reload }.to_not raise_error expect { bad_attachment.reload }.to_not raise_error expect(bad_attachment.file.exists?).to be false end diff --git a/spec/services/clear_domain_media_service_spec.rb b/spec/services/clear_domain_media_service_spec.rb index 2a00409a41..9766e62de8 100644 --- a/spec/services/clear_domain_media_service_spec.rb +++ b/spec/services/clear_domain_media_service_spec.rb @@ -6,9 +6,9 @@ RSpec.describe ClearDomainMediaService, type: :service do subject { described_class.new } let!(:bad_account) { Fabricate(:account, username: 'badguy666', domain: 'evil.org') } - let!(:bad_status1) { Fabricate(:status, account: bad_account, text: 'You suck') } - let!(:bad_status2) { Fabricate(:status, account: bad_account, text: 'Hahaha') } - let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status2, file: attachment_fixture('attachment.jpg')) } + let!(:bad_status_plain) { Fabricate(:status, account: bad_account, text: 'You suck') } + let!(:bad_status_with_attachment) { Fabricate(:status, account: bad_account, text: 'Hahaha') } + let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status_with_attachment, file: attachment_fixture('attachment.jpg')) } describe 'for a silence with reject media' do before do @@ -16,8 +16,8 @@ RSpec.describe ClearDomainMediaService, type: :service do end it 'leaves the domains status and attachments, but clears media' do - expect { bad_status1.reload }.to_not raise_error - expect { bad_status2.reload }.to_not raise_error + expect { bad_status_plain.reload }.to_not raise_error + expect { bad_status_with_attachment.reload }.to_not raise_error expect { bad_attachment.reload }.to_not raise_error expect(bad_attachment.file.exists?).to be false end diff --git a/spec/services/purge_domain_service_spec.rb b/spec/services/purge_domain_service_spec.rb index 89ab4d8d9f..e96618310b 100644 --- a/spec/services/purge_domain_service_spec.rb +++ b/spec/services/purge_domain_service_spec.rb @@ -6,9 +6,9 @@ RSpec.describe PurgeDomainService, type: :service do subject { described_class.new } let!(:old_account) { Fabricate(:account, domain: 'obsolete.org') } - let!(:old_status1) { Fabricate(:status, account: old_account) } - let!(:old_status2) { Fabricate(:status, account: old_account) } - let!(:old_attachment) { Fabricate(:media_attachment, account: old_account, status: old_status2, file: attachment_fixture('attachment.jpg')) } + let!(:old_status_plain) { Fabricate(:status, account: old_account) } + let!(:old_status_with_attachment) { Fabricate(:status, account: old_account) } + let!(:old_attachment) { Fabricate(:media_attachment, account: old_account, status: old_status_with_attachment, file: attachment_fixture('attachment.jpg')) } describe 'for a suspension' do before do @@ -17,8 +17,8 @@ RSpec.describe PurgeDomainService, type: :service do it 'removes the remote accounts\'s statuses and media attachments' do expect { old_account.reload }.to raise_exception ActiveRecord::RecordNotFound - expect { old_status1.reload }.to raise_exception ActiveRecord::RecordNotFound - expect { old_status2.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { old_status_plain.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { old_status_with_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound expect { old_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound end diff --git a/spec/services/unallow_domain_service_spec.rb b/spec/services/unallow_domain_service_spec.rb index 4db718d074..e583a22de3 100644 --- a/spec/services/unallow_domain_service_spec.rb +++ b/spec/services/unallow_domain_service_spec.rb @@ -6,9 +6,9 @@ RSpec.describe UnallowDomainService, type: :service do subject { described_class.new } let!(:bad_account) { Fabricate(:account, username: 'badguy666', domain: 'evil.org') } - let!(:bad_status1) { Fabricate(:status, account: bad_account, text: 'You suck') } - let!(:bad_status2) { Fabricate(:status, account: bad_account, text: 'Hahaha') } - let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status2, file: attachment_fixture('attachment.jpg')) } + let!(:bad_status_harassment) { Fabricate(:status, account: bad_account, text: 'You suck') } + let!(:bad_status_mean) { Fabricate(:status, account: bad_account, text: 'Hahaha') } + let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status_mean, file: attachment_fixture('attachment.jpg')) } let!(:already_banned_account) { Fabricate(:account, username: 'badguy', domain: 'evil.org', suspended: true, silenced: true) } let!(:domain_allow) { Fabricate(:domain_allow, domain: 'evil.org') } @@ -31,8 +31,8 @@ RSpec.describe UnallowDomainService, type: :service do end it 'removes the remote accounts\'s statuses and media attachments' do - expect { bad_status1.reload }.to raise_exception ActiveRecord::RecordNotFound - expect { bad_status2.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { bad_status_harassment.reload }.to raise_exception ActiveRecord::RecordNotFound + expect { bad_status_mean.reload }.to raise_exception ActiveRecord::RecordNotFound expect { bad_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound end end @@ -57,8 +57,8 @@ RSpec.describe UnallowDomainService, type: :service do end it 'removes the remote accounts\'s statuses and media attachments' do - expect { bad_status1.reload }.to_not raise_error - expect { bad_status2.reload }.to_not raise_error + expect { bad_status_harassment.reload }.to_not raise_error + expect { bad_status_mean.reload }.to_not raise_error expect { bad_attachment.reload }.to_not raise_error end end diff --git a/spec/workers/scheduler/accounts_statuses_cleanup_scheduler_spec.rb b/spec/workers/scheduler/accounts_statuses_cleanup_scheduler_spec.rb index 62c353bfe1..5565636d57 100644 --- a/spec/workers/scheduler/accounts_statuses_cleanup_scheduler_spec.rb +++ b/spec/workers/scheduler/accounts_statuses_cleanup_scheduler_spec.rb @@ -5,12 +5,12 @@ require 'rails_helper' describe Scheduler::AccountsStatusesCleanupScheduler do subject { described_class.new } - let!(:account1) { Fabricate(:account, domain: nil) } - let!(:account2) { Fabricate(:account, domain: nil) } - let!(:account3) { Fabricate(:account, domain: nil) } - let!(:account4) { Fabricate(:account, domain: nil) } - let!(:account5) { Fabricate(:account, domain: nil) } - let!(:remote) { Fabricate(:account) } + let!(:account_alice) { Fabricate(:account, domain: nil, username: 'alice') } + let!(:account_bob) { Fabricate(:account, domain: nil, username: 'bob') } + let!(:account_chris) { Fabricate(:account, domain: nil, username: 'chris') } + let!(:account_dave) { Fabricate(:account, domain: nil, username: 'dave') } + let!(:account_erin) { Fabricate(:account, domain: nil, username: 'erin') } + let!(:remote) { Fabricate(:account) } let(:queue_size) { 0 } let(:queue_latency) { 0 } @@ -77,26 +77,26 @@ describe Scheduler::AccountsStatusesCleanupScheduler do describe '#perform' do before do # Policies for the accounts - Fabricate(:account_statuses_cleanup_policy, account: account1) - Fabricate(:account_statuses_cleanup_policy, account: account3) - Fabricate(:account_statuses_cleanup_policy, account: account4, enabled: false) - Fabricate(:account_statuses_cleanup_policy, account: account5) + Fabricate(:account_statuses_cleanup_policy, account: account_alice) + Fabricate(:account_statuses_cleanup_policy, account: account_chris) + Fabricate(:account_statuses_cleanup_policy, account: account_dave, enabled: false) + Fabricate(:account_statuses_cleanup_policy, account: account_erin) # Create a bunch of old statuses 4.times do - Fabricate(:status, account: account1, created_at: 3.years.ago) - Fabricate(:status, account: account2, created_at: 3.years.ago) - Fabricate(:status, account: account3, created_at: 3.years.ago) - Fabricate(:status, account: account4, created_at: 3.years.ago) - Fabricate(:status, account: account5, created_at: 3.years.ago) + Fabricate(:status, account: account_alice, created_at: 3.years.ago) + Fabricate(:status, account: account_bob, created_at: 3.years.ago) + Fabricate(:status, account: account_chris, created_at: 3.years.ago) + Fabricate(:status, account: account_dave, created_at: 3.years.ago) + Fabricate(:status, account: account_erin, created_at: 3.years.ago) Fabricate(:status, account: remote, created_at: 3.years.ago) end # Create a bunch of newer statuses - Fabricate(:status, account: account1, created_at: 3.minutes.ago) - Fabricate(:status, account: account2, created_at: 3.minutes.ago) - Fabricate(:status, account: account3, created_at: 3.minutes.ago) - Fabricate(:status, account: account4, created_at: 3.minutes.ago) + Fabricate(:status, account: account_alice, created_at: 3.minutes.ago) + Fabricate(:status, account: account_bob, created_at: 3.minutes.ago) + Fabricate(:status, account: account_chris, created_at: 3.minutes.ago) + Fabricate(:status, account: account_dave, created_at: 3.minutes.ago) Fabricate(:status, account: remote, created_at: 3.minutes.ago) end @@ -106,8 +106,8 @@ describe Scheduler::AccountsStatusesCleanupScheduler do expect { subject.perform } .to change(Status, :count).by(-subject.compute_budget) # Cleanable statuses - .and (not_change { account2.statuses.count }) # No cleanup policy for account - .and(not_change { account4.statuses.count }) # Disabled cleanup policy + .and (not_change { account_bob.statuses.count }) # No cleanup policy for account + .and(not_change { account_dave.statuses.count }) # Disabled cleanup policy end it 'eventually deletes every deletable toot given enough runs' do @@ -122,9 +122,9 @@ describe Scheduler::AccountsStatusesCleanupScheduler do expect { 3.times { subject.perform } } .to change(Status, :count).by(-3 * 3) - .and change { account1.statuses.count } - .and change { account3.statuses.count } - .and(change { account5.statuses.count }) + .and change { account_alice.statuses.count } + .and change { account_chris.statuses.count } + .and(change { account_erin.statuses.count }) end context 'when given a big budget' do @@ -156,7 +156,7 @@ describe Scheduler::AccountsStatusesCleanupScheduler do def cleanable_statuses_count Status - .where(account_id: [account1, account3, account5]) # Accounts with enabled policies + .where(account_id: [account_alice, account_chris, account_erin]) # Accounts with enabled policies .where('created_at < ?', 2.weeks.ago) # Policy defaults is 2.weeks .count end