Merge branch 'master' into glitch-soc/merge-upstream

Conflicts:
- config/locales/pl.yml
  Conflict caused by new upstream string too close to glitch-specific
  “flavour” string. Took both strings.

spec/services/account_search_service_spec.rb

@@ -156,22 +156,5 @@ describe AccountSearchService, type: :service do
         expect(results).to eq []
       end
     end
-
-    describe 'should not include accounts blocking the requester' do
-      let!(:blocked) { Fabricate(:account) }
-      let!(:blocker) { Fabricate(:account, username: 'exact') }
-
-      before do
-        blocker.block!(blocked)
-      end
-
-      it 'returns the fuzzy match first, and does not return suspended exacts' do
-        partial = Fabricate(:account, username: 'exactness')
-
-        results = subject.call('exact', blocked, limit: 10)
-        expect(results.size).to eq 1
-        expect(results).to eq [partial]
-      end
-    end
   end
 end

spec/services/import_service_spec.rb

@@ -1,9 +1,9 @@
 require 'rails_helper'
 
 RSpec.describe ImportService, type: :service do
-  let!(:account) { Fabricate(:account) }
-  let!(:bob)     { Fabricate(:account, username: 'bob') }
-  let!(:eve)     { Fabricate(:account, username: 'eve', domain: 'example.com') }
+  let!(:account) { Fabricate(:account, locked: false) }
+  let!(:bob)     { Fabricate(:account, username: 'bob', locked: false) }
+  let!(:eve)     { Fabricate(:account, username: 'eve', domain: 'example.com', locked: false) }
 
   context 'import old-style list of muted users' do
     subject { ImportService.new }
@@ -81,4 +81,89 @@ RSpec.describe ImportService, type: :service do
       end
     end
   end
+
+  context 'import old-style list of followed users' do
+    subject { ImportService.new }
+
+    let(:csv) { attachment_fixture('mute-imports.txt') }
+
+    before do
+      allow(NotificationWorker).to receive(:perform_async)
+    end
+
+    describe 'when no accounts are followed' do
+      let(:import) { Import.create(account: account, type: 'following', data: csv) }
+      it 'follows the listed accounts, including boosts' do
+        subject.call(import)
+        expect(account.following.count).to eq 2
+        expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true
+      end
+    end
+
+    describe 'when some accounts are already followed and overwrite is not set' do
+      let(:import) { Import.create(account: account, type: 'following', data: csv) }
+
+      it 'follows the listed accounts, including notifications' do
+        account.follow!(bob, reblogs: false)
+        subject.call(import)
+        expect(account.following.count).to eq 2
+        expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true
+      end
+    end
+
+    describe 'when some accounts are already followed and overwrite is set' do
+      let(:import) { Import.create(account: account, type: 'following', data: csv, overwrite: true) }
+
+      it 'mutes the listed accounts, including notifications' do
+        account.follow!(bob, reblogs: false)
+        subject.call(import)
+        expect(account.following.count).to eq 2
+        expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true
+      end
+    end
+  end
+
+  context 'import new-style list of followed users' do
+    subject { ImportService.new }
+
+    let(:csv) { attachment_fixture('new-following-imports.txt') }
+
+    before do
+      allow(NotificationWorker).to receive(:perform_async)
+    end
+
+    describe 'when no accounts are followed' do
+      let(:import) { Import.create(account: account, type: 'following', data: csv) }
+      it 'follows the listed accounts, respecting boosts' do
+        subject.call(import)
+        expect(account.following.count).to eq 2
+        expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true
+        expect(Follow.find_by(account: account, target_account: eve).show_reblogs).to be false
+      end
+    end
+
+    describe 'when some accounts are already followed and overwrite is not set' do
+      let(:import) { Import.create(account: account, type: 'following', data: csv) }
+
+      it 'mutes the listed accounts, respecting notifications' do
+        account.follow!(bob, reblogs: true)
+        subject.call(import)
+        expect(account.following.count).to eq 2
+        expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true
+        expect(Follow.find_by(account: account, target_account: eve).show_reblogs).to be false
+      end
+    end
+
+    describe 'when some accounts are already followed and overwrite is set' do
+      let(:import) { Import.create(account: account, type: 'following', data: csv, overwrite: true) }
+
+      it 'mutes the listed accounts, respecting notifications' do
+        account.follow!(bob, reblogs: true)
+        subject.call(import)
+        expect(account.following.count).to eq 2
+        expect(Follow.find_by(account: account, target_account: bob).show_reblogs).to be true
+        expect(Follow.find_by(account: account, target_account: eve).show_reblogs).to be false
+      end
+    end
+  end
 end

spec/services/search_service_spec.rb

@@ -3,8 +3,6 @@
 require 'rails_helper'
 
 describe SearchService, type: :service do
-  let(:current_account) { Fabricate(:user).account }
-
   subject { described_class.new }
 
   describe '#call' do
@@ -12,7 +10,7 @@ describe SearchService, type: :service do
       it 'returns empty results without searching' do
         allow(AccountSearchService).to receive(:new)
         allow(Tag).to receive(:search_for)
-        results = subject.call('', current_account, 10)
+        results = subject.call('', nil, 10)
 
         expect(results).to eq(empty_results)
         expect(AccountSearchService).not_to have_received(:new)
@@ -29,33 +27,33 @@ describe SearchService, type: :service do
         it 'returns the empty results' do
           service = double(call: nil)
           allow(ResolveURLService).to receive(:new).and_return(service)
-          results = subject.call(@query, current_account, 10)
+          results = subject.call(@query, nil, 10)
 
-          expect(service).to have_received(:call).with(@query, on_behalf_of: current_account)
+          expect(service).to have_received(:call).with(@query, on_behalf_of: nil)
           expect(results).to eq empty_results
         end
       end
 
       context 'that finds an account' do
         it 'includes the account in the results' do
-          account = Fabricate(:account)
+          account = Account.new
           service = double(call: account)
           allow(ResolveURLService).to receive(:new).and_return(service)
 
-          results = subject.call(@query, current_account, 10)
-          expect(service).to have_received(:call).with(@query, on_behalf_of: current_account)
+          results = subject.call(@query, nil, 10)
+          expect(service).to have_received(:call).with(@query, on_behalf_of: nil)
           expect(results).to eq empty_results.merge(accounts: [account])
         end
       end
 
       context 'that finds a status' do
         it 'includes the status in the results' do
-          status = Fabricate(:status)
+          status = Status.new
           service = double(call: status)
           allow(ResolveURLService).to receive(:new).and_return(service)
 
-          results = subject.call(@query, current_account, 10)
-          expect(service).to have_received(:call).with(@query, on_behalf_of: current_account)
+          results = subject.call(@query, nil, 10)
+          expect(service).to have_received(:call).with(@query, on_behalf_of: nil)
           expect(results).to eq empty_results.merge(statuses: [status])
         end
       end
@@ -65,12 +63,12 @@ describe SearchService, type: :service do
       context 'that matches an account' do
         it 'includes the account in the results' do
           query = 'username'
-          account = Fabricate(:account)
+          account = Account.new
           service = double(call: [account])
           allow(AccountSearchService).to receive(:new).and_return(service)
 
-          results = subject.call(query, current_account, 10)
-          expect(service).to have_received(:call).with(query, current_account, limit: 10, offset: 0, resolve: false)
+          results = subject.call(query, nil, 10)
+          expect(service).to have_received(:call).with(query, nil, limit: 10, offset: 0, resolve: false)
           expect(results).to eq empty_results.merge(accounts: [account])
         end
       end
@@ -81,7 +79,7 @@ describe SearchService, type: :service do
           tag = Tag.new
           allow(Tag).to receive(:search_for).with('tag', 10, 0).and_return([tag])
 
-          results = subject.call(query, current_account, 10)
+          results = subject.call(query, nil, 10)
           expect(Tag).to have_received(:search_for).with('tag', 10, 0)
           expect(results).to eq empty_results.merge(hashtags: [tag])
         end
@@ -89,7 +87,7 @@ describe SearchService, type: :service do
           query = '@username'
           allow(Tag).to receive(:search_for)
 
-          results = subject.call(query, current_account, 10)
+          results = subject.call(query, nil, 10)
           expect(Tag).not_to have_received(:search_for)
           expect(results).to eq empty_results
         end