From b3f0e6f7b9ed96069e7d3d7c6c59f03fd1fb4612 Mon Sep 17 00:00:00 2001 From: Matt Jankowski Date: Thu, 18 May 2017 15:10:41 -0400 Subject: [PATCH] After remote follow worker specs (#3098) * Add specs for the after remote follow workers * Refactor the after remote follow workers --- .../after_remote_follow_request_worker.rb | 22 +++++-- app/workers/after_remote_follow_worker.rb | 22 +++++-- ...after_remote_follow_request_worker_spec.rb | 59 +++++++++++++++++++ .../after_remote_follow_worker_spec.rb | 59 +++++++++++++++++++ 4 files changed, 152 insertions(+), 10 deletions(-) create mode 100644 spec/workers/after_remote_follow_request_worker_spec.rb create mode 100644 spec/workers/after_remote_follow_worker_spec.rb diff --git a/app/workers/after_remote_follow_request_worker.rb b/app/workers/after_remote_follow_request_worker.rb index 9280692112..84eb6ade23 100644 --- a/app/workers/after_remote_follow_request_worker.rb +++ b/app/workers/after_remote_follow_request_worker.rb @@ -5,15 +5,27 @@ class AfterRemoteFollowRequestWorker sidekiq_options queue: 'pull', retry: 5 + attr_reader :follow_request + def perform(follow_request_id) - follow_request = FollowRequest.find(follow_request_id) - updated_account = FetchRemoteAccountService.new.call(follow_request.target_account.remote_url) + @follow_request = FollowRequest.find(follow_request_id) + process_follow_service if processing_required? + rescue ActiveRecord::RecordNotFound + true + end - return if updated_account.nil? || updated_account.locked? + private + def process_follow_service follow_request.destroy FollowService.new.call(follow_request.account, updated_account.acct) - rescue ActiveRecord::RecordNotFound - true + end + + def processing_required? + !updated_account.nil? && !updated_account.locked? + end + + def updated_account + @_updated_account ||= FetchRemoteAccountService.new.call(follow_request.target_account.remote_url) end end diff --git a/app/workers/after_remote_follow_worker.rb b/app/workers/after_remote_follow_worker.rb index d12fa3454d..edab83f853 100644 --- a/app/workers/after_remote_follow_worker.rb +++ b/app/workers/after_remote_follow_worker.rb @@ -5,15 +5,27 @@ class AfterRemoteFollowWorker sidekiq_options queue: 'pull', retry: 5 + attr_reader :follow + def perform(follow_id) - follow = Follow.find(follow_id) - updated_account = FetchRemoteAccountService.new.call(follow.target_account.remote_url) + @follow = Follow.find(follow_id) + process_follow_service if processing_required? + rescue ActiveRecord::RecordNotFound + true + end - return if updated_account.nil? || !updated_account.locked? + private + def process_follow_service follow.destroy FollowService.new.call(follow.account, updated_account.acct) - rescue ActiveRecord::RecordNotFound - true + end + + def updated_account + @_updated_account ||= FetchRemoteAccountService.new.call(follow.target_account.remote_url) + end + + def processing_required? + !updated_account.nil? && updated_account.locked? end end diff --git a/spec/workers/after_remote_follow_request_worker_spec.rb b/spec/workers/after_remote_follow_request_worker_spec.rb new file mode 100644 index 0000000000..bd623cca50 --- /dev/null +++ b/spec/workers/after_remote_follow_request_worker_spec.rb @@ -0,0 +1,59 @@ +# frozen_string_literal: true + +require 'rails_helper' + +describe AfterRemoteFollowRequestWorker do + subject { described_class.new } + let(:follow_request) { Fabricate(:follow_request) } + describe 'perform' do + context 'when the follow_request does not exist' do + it 'catches a raise and returns true' do + allow(FollowService).to receive(:new) + result = subject.perform('aaa') + + expect(result).to eq(true) + expect(FollowService).not_to have_received(:new) + end + end + + context 'when the account cannot be updated' do + it 'returns nil and does not call service when account is nil' do + allow(FollowService).to receive(:new) + service = double(call: nil) + allow(FetchRemoteAccountService).to receive(:new).and_return(service) + + result = subject.perform(follow_request.id) + + expect(result).to be_nil + expect(FollowService).not_to have_received(:new) + end + + it 'returns nil and does not call service when account is locked' do + allow(FollowService).to receive(:new) + service = double(call: double(locked?: true)) + allow(FetchRemoteAccountService).to receive(:new).and_return(service) + + result = subject.perform(follow_request.id) + + expect(result).to be_nil + expect(FollowService).not_to have_received(:new) + end + end + + context 'when the account is updated' do + it 'calls the follow service and destroys the follow' do + follow_service = double(call: nil) + allow(FollowService).to receive(:new).and_return(follow_service) + account = Fabricate(:account, locked: false) + service = double(call: account) + allow(FetchRemoteAccountService).to receive(:new).and_return(service) + + result = subject.perform(follow_request.id) + + expect(result).to be_nil + expect(follow_service).to have_received(:call).with(follow_request.account, account.acct) + expect { follow_request.reload }.to raise_error(ActiveRecord::RecordNotFound) + end + end + end +end diff --git a/spec/workers/after_remote_follow_worker_spec.rb b/spec/workers/after_remote_follow_worker_spec.rb new file mode 100644 index 0000000000..d93c469f9d --- /dev/null +++ b/spec/workers/after_remote_follow_worker_spec.rb @@ -0,0 +1,59 @@ +# frozen_string_literal: true + +require 'rails_helper' + +describe AfterRemoteFollowWorker do + subject { described_class.new } + let(:follow) { Fabricate(:follow) } + describe 'perform' do + context 'when the follow does not exist' do + it 'catches a raise and returns true' do + allow(FollowService).to receive(:new) + result = subject.perform('aaa') + + expect(result).to eq(true) + expect(FollowService).not_to have_received(:new) + end + end + + context 'when the account cannot be updated' do + it 'returns nil and does not call service when account is nil' do + allow(FollowService).to receive(:new) + service = double(call: nil) + allow(FetchRemoteAccountService).to receive(:new).and_return(service) + + result = subject.perform(follow.id) + + expect(result).to be_nil + expect(FollowService).not_to have_received(:new) + end + + it 'returns nil and does not call service when account is not locked' do + allow(FollowService).to receive(:new) + service = double(call: double(locked?: false)) + allow(FetchRemoteAccountService).to receive(:new).and_return(service) + + result = subject.perform(follow.id) + + expect(result).to be_nil + expect(FollowService).not_to have_received(:new) + end + end + + context 'when the account is updated' do + it 'calls the follow service and destroys the follow' do + follow_service = double(call: nil) + allow(FollowService).to receive(:new).and_return(follow_service) + account = Fabricate(:account, locked: true) + service = double(call: account) + allow(FetchRemoteAccountService).to receive(:new).and_return(service) + + result = subject.perform(follow.id) + + expect(result).to be_nil + expect(follow_service).to have_received(:call).with(follow.account, account.acct) + expect { follow.reload }.to raise_error(ActiveRecord::RecordNotFound) + end + end + end +end