From 35cedc922ced6502f18b11353df661cf61c8ae2f Mon Sep 17 00:00:00 2001 From: ThibG Date: Wed, 1 Jul 2020 13:51:15 +0200 Subject: [PATCH] Change move handler to carry blocks over (#14144) * Change move handler to carry blocks and mutes over When user A blocks user B and B moves to a new account C, make A block C accordingly. Note that it only works if A's instance is aware of the Move, that is, if B is on A's instance or has followers there. * Also notify instances with known people blocking you when moving * Add automatic account notes when blocking/muting an account that had no note --- .../activitypub/move_distribution_worker.rb | 2 +- app/workers/move_worker.rb | 27 ++++++++++++++++ config/i18n-tasks.yml | 1 + config/locales/en.yml | 2 ++ .../account_migration_fabricator.rb | 4 +-- .../move_distribution_worker_spec.rb | 22 +++++++++++++ spec/workers/move_worker_spec.rb | 31 ++++++++++++++++--- 7 files changed, 82 insertions(+), 7 deletions(-) create mode 100644 spec/workers/activitypub/move_distribution_worker_spec.rb diff --git a/app/workers/activitypub/move_distribution_worker.rb b/app/workers/activitypub/move_distribution_worker.rb index bf1c0e7ae46..65c5c0d1c39 100644 --- a/app/workers/activitypub/move_distribution_worker.rb +++ b/app/workers/activitypub/move_distribution_worker.rb @@ -24,7 +24,7 @@ class ActivityPub::MoveDistributionWorker private def inboxes - @inboxes ||= @migration.account.followers.inboxes + @inboxes ||= (@migration.account.followers.inboxes + @migration.account.blocked_by.inboxes).uniq end def signed_payload diff --git a/app/workers/move_worker.rb b/app/workers/move_worker.rb index 4d76461b072..39e32131666 100644 --- a/app/workers/move_worker.rb +++ b/app/workers/move_worker.rb @@ -14,6 +14,8 @@ class MoveWorker end copy_account_notes! + carry_blocks_over! + carry_mutes_over! rescue ActiveRecord::RecordNotFound true end @@ -51,4 +53,29 @@ class MoveWorker end end end + + def carry_blocks_over! + @source_account.blocked_by_relationships.where(account: Account.local).find_each do |block| + unless block.account.blocking?(@target_account) || block.account.following?(@target_account) + BlockService.new.call(block.account, @target_account) + add_account_note_if_needed!(block.account, 'move_handler.carry_blocks_over_text') + end + end + end + + def carry_mutes_over! + @source_account.muted_by_relationships.where(account: Account.local).find_each do |mute| + MuteService.new.call(mute.account, @target_account, notifications: mute.hide_notifications) unless mute.account.muting?(@target_account) || mute.account.following?(@target_account) + add_account_note_if_needed!(mute.account, 'move_handler.carry_mutes_over_text') + end + end + + def add_account_note_if_needed!(account, id) + unless AccountNote.where(account: account, target_account: @target_account).exists? + text = I18n.with_locale(account.user.locale || I18n.default_locale) do + I18n.t(id, acct: @source_account.acct) + end + AccountNote.create!(account: account, target_account: @target_account, comment: text) + end + end end diff --git a/config/i18n-tasks.yml b/config/i18n-tasks.yml index c2d6a783828..2dc6f880bfc 100644 --- a/config/i18n-tasks.yml +++ b/config/i18n-tasks.yml @@ -60,6 +60,7 @@ ignore_unused: - 'admin.accounts.roles.*' - 'admin.action_logs.actions.*' - 'statuses.attached.*' + - 'move_handler.carry_{mutes,blocks}_over_text' ignore_inconsistent_interpolations: - '*.one' diff --git a/config/locales/en.yml b/config/locales/en.yml index b3906a127a2..2cae0a3e3ba 100644 --- a/config/locales/en.yml +++ b/config/locales/en.yml @@ -941,6 +941,8 @@ en: moderation: title: Moderation move_handler: + carry_blocks_over_text: This user moved from %{acct}, which you had blocked. + carry_mutes_over_text: This user moved from %{acct}, which you had muted. copy_account_note_text: 'This user moved from %{acct}, here were your previous notes about them:' notification_mailer: digest: diff --git a/spec/fabricators/account_migration_fabricator.rb b/spec/fabricators/account_migration_fabricator.rb index 3b3fc20773a..2a8e747a81a 100644 --- a/spec/fabricators/account_migration_fabricator.rb +++ b/spec/fabricators/account_migration_fabricator.rb @@ -1,6 +1,6 @@ Fabricator(:account_migration) do account - target_account + target_account { |attrs| Fabricate(:account, also_known_as: [ActivityPub::TagManager.instance.uri_for(attrs[:account])]) } + acct { |attrs| attrs[:target_account].acct } followers_count 1234 - acct 'test@example.com' end diff --git a/spec/workers/activitypub/move_distribution_worker_spec.rb b/spec/workers/activitypub/move_distribution_worker_spec.rb new file mode 100644 index 00000000000..b52788e54e7 --- /dev/null +++ b/spec/workers/activitypub/move_distribution_worker_spec.rb @@ -0,0 +1,22 @@ +require 'rails_helper' + +describe ActivityPub::MoveDistributionWorker do + subject { described_class.new } + + let(:migration) { Fabricate(:account_migration) } + let(:follower) { Fabricate(:account, protocol: :activitypub, inbox_url: 'http://example.com') } + let(:blocker) { Fabricate(:account, protocol: :activitypub, inbox_url: 'http://example2.com') } + + describe '#perform' do + before do + allow(ActivityPub::DeliveryWorker).to receive(:push_bulk) + follower.follow!(migration.account) + blocker.block!(migration.account) + end + + it 'delivers to followers and known blockers' do + subject.perform(migration.id) + expect(ActivityPub::DeliveryWorker).to have_received(:push_bulk).with(['http://example.com', 'http://example2.com']) + end + end +end diff --git a/spec/workers/move_worker_spec.rb b/spec/workers/move_worker_spec.rb index 77b921eaff2..8ab4f182fd0 100644 --- a/spec/workers/move_worker_spec.rb +++ b/spec/workers/move_worker_spec.rb @@ -4,20 +4,29 @@ require 'rails_helper' describe MoveWorker do let(:local_follower) { Fabricate(:user, email: 'bob@example.com', account: Fabricate(:account, username: 'bob')).account } + let(:blocking_account) { Fabricate(:user, email: 'bar@example.com', account: Fabricate(:account, username: 'bar')).account } + let(:muting_account) { Fabricate(:user, email: 'foo@example.com', account: Fabricate(:account, username: 'foo')).account } let(:source_account) { Fabricate(:account, protocol: :activitypub, domain: 'example.com') } let(:target_account) { Fabricate(:account, protocol: :activitypub, domain: 'example.com') } let(:local_user) { Fabricate(:user) } let!(:account_note) { Fabricate(:account_note, account: local_user.account, target_account: source_account) } + let(:block_service) { double } + subject { described_class.new } before do local_follower.follow!(source_account) + blocking_account.block!(source_account) + muting_account.mute!(source_account) + + allow(UnfollowFollowWorker).to receive(:push_bulk) + allow(BlockService).to receive(:new).and_return(block_service) + allow(block_service).to receive(:call) end shared_examples 'user note handling' do it 'copies user note' do - allow(UnfollowFollowWorker).to receive(:push_bulk) subject.perform(source_account.id, target_account.id) expect(AccountNote.find_by(account: account_note.account, target_account: target_account).comment).to include(source_account.acct) expect(AccountNote.find_by(account: account_note.account, target_account: target_account).comment).to include(account_note.comment) @@ -26,7 +35,6 @@ describe MoveWorker do it 'merges user notes when needed' do new_account_note = AccountNote.create!(account: account_note.account, target_account: target_account, comment: 'new note prior to move') - allow(UnfollowFollowWorker).to receive(:push_bulk) subject.perform(source_account.id, target_account.id) expect(AccountNote.find_by(account: account_note.account, target_account: target_account).comment).to include(source_account.acct) expect(AccountNote.find_by(account: account_note.account, target_account: target_account).comment).to include(account_note.comment) @@ -34,15 +42,29 @@ describe MoveWorker do end end + shared_examples 'block and mute handling' do + it 'makes blocks carry over and add a note' do + subject.perform(source_account.id, target_account.id) + expect(block_service).to have_received(:call).with(blocking_account, target_account) + expect(AccountNote.find_by(account: blocking_account, target_account: target_account).comment).to include(source_account.acct) + end + + it 'makes mutes carry over and add a note' do + subject.perform(source_account.id, target_account.id) + expect(muting_account.muting?(target_account)).to be true + expect(AccountNote.find_by(account: muting_account, target_account: target_account).comment).to include(source_account.acct) + end + end + context 'both accounts are distant' do describe 'perform' do it 'calls UnfollowFollowWorker' do - allow(UnfollowFollowWorker).to receive(:push_bulk) subject.perform(source_account.id, target_account.id) expect(UnfollowFollowWorker).to have_received(:push_bulk).with([local_follower.id]) end include_examples 'user note handling' + include_examples 'block and mute handling' end end @@ -51,12 +73,12 @@ describe MoveWorker do describe 'perform' do it 'calls UnfollowFollowWorker' do - allow(UnfollowFollowWorker).to receive(:push_bulk) subject.perform(source_account.id, target_account.id) expect(UnfollowFollowWorker).to have_received(:push_bulk).with([local_follower.id]) end include_examples 'user note handling' + include_examples 'block and mute handling' end end @@ -71,6 +93,7 @@ describe MoveWorker do end include_examples 'user note handling' + include_examples 'block and mute handling' it 'does not fail when a local user is already following both accounts' do double_follower = Fabricate(:user, email: 'eve@example.com', account: Fabricate(:account, username: 'eve')).account