Merge tag 'v4.2.12' into chinwag-next

spec/models/concerns/account_counters_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
 
 describe AccountCounters do

spec/models/concerns/account_interactions_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails_helper'
 
 describe AccountInteractions do
@@ -11,16 +13,16 @@ describe AccountInteractions do
   describe '.following_map' do
     subject { Account.following_map(target_account_ids, account_id) }
 
-    context 'account with Follow' do
+    context 'when Account with Follow' do
       it 'returns { target_account_id => true }' do
         Fabricate(:follow, account: account, target_account: target_account)
-        is_expected.to eq(target_account_id => { reblogs: true, notify: false, languages: nil })
+        expect(subject).to eq(target_account_id => { reblogs: true, notify: false, languages: nil })
       end
     end
 
-    context 'account without Follow' do
+    context 'when Account without Follow' do
       it 'returns {}' do
-        is_expected.to eq({})
+        expect(subject).to eq({})
       end
     end
   end
@@ -28,16 +30,16 @@ describe AccountInteractions do
   describe '.followed_by_map' do
     subject { Account.followed_by_map(target_account_ids, account_id) }
 
-    context 'account with Follow' do
+    context 'when Account with Follow' do
       it 'returns { target_account_id => true }' do
         Fabricate(:follow, account: target_account, target_account: account)
-        is_expected.to eq(target_account_id => true)
+        expect(subject).to eq(target_account_id => true)
       end
     end
 
-    context 'account without Follow' do
+    context 'when Account without Follow' do
       it 'returns {}' do
-        is_expected.to eq({})
+        expect(subject).to eq({})
       end
     end
   end
@@ -45,16 +47,16 @@ describe AccountInteractions do
   describe '.blocking_map' do
     subject { Account.blocking_map(target_account_ids, account_id) }
 
-    context 'account with Block' do
+    context 'when Account with Block' do
       it 'returns { target_account_id => true }' do
         Fabricate(:block, account: account, target_account: target_account)
-        is_expected.to eq(target_account_id => true)
+        expect(subject).to eq(target_account_id => true)
       end
     end
 
-    context 'account without Block' do
+    context 'when Account without Block' do
       it 'returns {}' do
-        is_expected.to eq({})
+        expect(subject).to eq({})
       end
     end
   end
@@ -62,31 +64,31 @@ describe AccountInteractions do
   describe '.muting_map' do
     subject { Account.muting_map(target_account_ids, account_id) }
 
-    context 'account with Mute' do
+    context 'when Account with Mute' do
       before do
         Fabricate(:mute, target_account: target_account, account: account, hide_notifications: hide)
       end
 
-      context 'if Mute#hide_notifications?' do
+      context 'when Mute#hide_notifications?' do
         let(:hide) { true }
 
         it 'returns { target_account_id => { notifications: true } }' do
-          is_expected.to eq(target_account_id => { notifications: true })
+          expect(subject).to eq(target_account_id => { notifications: true })
         end
       end
 
-      context 'unless Mute#hide_notifications?' do
+      context 'when not Mute#hide_notifications?' do
         let(:hide) { false }
 
         it 'returns { target_account_id => { notifications: false } }' do
-          is_expected.to eq(target_account_id => { notifications: false })
+          expect(subject).to eq(target_account_id => { notifications: false })
         end
       end
     end
 
-    context 'account without Mute' do
+    context 'when Account without Mute' do
       it 'returns {}' do
-        is_expected.to eq({})
+        expect(subject).to eq({})
       end
     end
   end
@@ -94,7 +96,7 @@ describe AccountInteractions do
   describe '#follow!' do
     it 'creates and returns Follow' do
       expect do
-        expect(account.follow!(target_account)).to be_kind_of Follow
+        expect(account.follow!(target_account)).to be_a Follow
       end.to change { account.following.count }.by 1
     end
   end
@@ -102,7 +104,7 @@ describe AccountInteractions do
   describe '#block' do
     it 'creates and returns Block' do
       expect do
-        expect(account.block!(target_account)).to be_kind_of Block
+        expect(account.block!(target_account)).to be_a Block
       end.to change { account.block_relationships.count }.by 1
     end
   end
@@ -110,113 +112,113 @@ describe AccountInteractions do
   describe '#mute!' do
     subject { account.mute!(target_account, notifications: arg_notifications) }
 
-    context 'Mute does not exist yet' do
-      context 'arg :notifications is nil' do
+    context 'when Mute does not exist yet' do
+      context 'when arg :notifications is nil' do
         let(:arg_notifications) { nil }
 
         it 'creates Mute, and returns Mute' do
           expect do
-            expect(subject).to be_kind_of Mute
+            expect(subject).to be_a Mute
           end.to change { account.mute_relationships.count }.by 1
         end
       end
 
-      context 'arg :notifications is false' do
+      context 'when arg :notifications is false' do
         let(:arg_notifications) { false }
 
         it 'creates Mute, and returns Mute' do
           expect do
-            expect(subject).to be_kind_of Mute
+            expect(subject).to be_a Mute
           end.to change { account.mute_relationships.count }.by 1
         end
       end
 
-      context 'arg :notifications is true' do
+      context 'when arg :notifications is true' do
         let(:arg_notifications) { true }
 
         it 'creates Mute, and returns Mute' do
           expect do
-            expect(subject).to be_kind_of Mute
+            expect(subject).to be_a Mute
           end.to change { account.mute_relationships.count }.by 1
         end
       end
     end
 
-    context 'Mute already exists' do
+    context 'when Mute already exists' do
       before do
         account.mute_relationships << mute
       end
 
       let(:mute) do
         Fabricate(:mute,
-                  account:            account,
-                  target_account:     target_account,
+                  account: account,
+                  target_account: target_account,
                   hide_notifications: hide_notifications)
       end
 
-      context 'mute.hide_notifications is true' do
+      context 'when mute.hide_notifications is true' do
         let(:hide_notifications) { true }
 
-        context 'arg :notifications is nil' do
+        context 'when arg :notifications is nil' do
           let(:arg_notifications) { nil }
 
           it 'returns Mute without updating mute.hide_notifications' do
             expect do
-              expect(subject).to be_kind_of Mute
-            end.not_to change { mute.reload.hide_notifications? }.from(true)
+              expect(subject).to be_a Mute
+            end.to_not change { mute.reload.hide_notifications? }.from(true)
           end
         end
 
-        context 'arg :notifications is false' do
+        context 'when arg :notifications is false' do
           let(:arg_notifications) { false }
 
           it 'returns Mute, and updates mute.hide_notifications false' do
             expect do
-              expect(subject).to be_kind_of Mute
+              expect(subject).to be_a Mute
             end.to change { mute.reload.hide_notifications? }.from(true).to(false)
           end
         end
 
-        context 'arg :notifications is true' do
+        context 'when arg :notifications is true' do
           let(:arg_notifications) { true }
 
           it 'returns Mute without updating mute.hide_notifications' do
             expect do
-              expect(subject).to be_kind_of Mute
-            end.not_to change { mute.reload.hide_notifications? }.from(true)
+              expect(subject).to be_a Mute
+            end.to_not change { mute.reload.hide_notifications? }.from(true)
           end
         end
       end
 
-      context 'mute.hide_notifications is false' do
+      context 'when mute.hide_notifications is false' do
         let(:hide_notifications) { false }
 
-        context 'arg :notifications is nil' do
+        context 'when arg :notifications is nil' do
           let(:arg_notifications) { nil }
 
           it 'returns Mute, and updates mute.hide_notifications true' do
             expect do
-              expect(subject).to be_kind_of Mute
+              expect(subject).to be_a Mute
             end.to change { mute.reload.hide_notifications? }.from(false).to(true)
           end
         end
 
-        context 'arg :notifications is false' do
+        context 'when arg :notifications is false' do
           let(:arg_notifications) { false }
 
           it 'returns Mute without updating mute.hide_notifications' do
             expect do
-              expect(subject).to be_kind_of Mute
-            end.not_to change { mute.reload.hide_notifications? }.from(false)
+              expect(subject).to be_a Mute
+            end.to_not change { mute.reload.hide_notifications? }.from(false)
           end
         end
 
-        context 'arg :notifications is true' do
+        context 'when arg :notifications is true' do
           let(:arg_notifications) { true }
 
           it 'returns Mute, and updates mute.hide_notifications true' do
             expect do
-              expect(subject).to be_kind_of Mute
+              expect(subject).to be_a Mute
             end.to change { mute.reload.hide_notifications? }.from(false).to(true)
           end
         end
@@ -225,25 +227,43 @@ describe AccountInteractions do
   end
 
   describe '#mute_conversation!' do
-    let(:conversation) { Fabricate(:conversation) }
-
     subject { account.mute_conversation!(conversation) }
 
+    let(:conversation) { Fabricate(:conversation) }
+
     it 'creates and returns ConversationMute' do
       expect do
-        is_expected.to be_kind_of ConversationMute
+        expect(subject).to be_a ConversationMute
       end.to change { account.conversation_mutes.count }.by 1
     end
   end
 
   describe '#block_domain!' do
-    let(:domain) { 'example.com' }
-
     subject { account.block_domain!(domain) }
 
+    let(:domain) { 'example.com' }
+
     it 'creates and returns AccountDomainBlock' do
       expect do
-        is_expected.to be_kind_of AccountDomainBlock
+        expect(subject).to be_a AccountDomainBlock
+      end.to change { account.domain_blocks.count }.by 1
+    end
+  end
+
+  describe '#block_idna_domain!' do
+    subject do
+      [
+        account.block_domain!(idna_domain),
+        account.block_domain!(punycode_domain),
+      ]
+    end
+
+    let(:idna_domain) { '대한민국.한국' }
+    let(:punycode_domain) { 'xn--3e0bs9hfvinn1a.xn--3e0b707e' }
+
+    it 'creates single AccountDomainBlock' do
+      expect do
+        expect(subject).to all(be_a AccountDomainBlock)
       end.to change { account.domain_blocks.count }.by 1
     end
   end
@@ -269,17 +289,17 @@ describe AccountInteractions do
   describe '#unfollow!' do
     subject { account.unfollow!(target_account) }
 
-    context 'following target_account' do
+    context 'when following target_account' do
       it 'returns destroyed Follow' do
         account.active_relationships.create(target_account: target_account)
-        is_expected.to be_kind_of Follow
+        expect(subject).to be_a Follow
         expect(subject).to be_destroyed
       end
     end
 
-    context 'not following target_account' do
+    context 'when not following target_account' do
       it 'returns nil' do
-        is_expected.to be_nil
+        expect(subject).to be_nil
       end
     end
   end
@@ -287,17 +307,17 @@ describe AccountInteractions do
   describe '#unblock!' do
     subject { account.unblock!(target_account) }
 
-    context 'blocking target_account' do
+    context 'when blocking target_account' do
       it 'returns destroyed Block' do
         account.block_relationships.create(target_account: target_account)
-        is_expected.to be_kind_of Block
+        expect(subject).to be_a Block
         expect(subject).to be_destroyed
       end
     end
 
-    context 'not blocking target_account' do
+    context 'when not blocking target_account' do
       it 'returns nil' do
-        is_expected.to be_nil
+        expect(subject).to be_nil
       end
     end
   end
@@ -305,58 +325,80 @@ describe AccountInteractions do
   describe '#unmute!' do
     subject { account.unmute!(target_account) }
 
-    context 'muting target_account' do
+    context 'when muting target_account' do
       it 'returns destroyed Mute' do
         account.mute_relationships.create(target_account: target_account)
-        is_expected.to be_kind_of Mute
+        expect(subject).to be_a Mute
         expect(subject).to be_destroyed
       end
     end
 
-    context 'not muting target_account' do
+    context 'when not muting target_account' do
       it 'returns nil' do
-        is_expected.to be_nil
+        expect(subject).to be_nil
       end
     end
   end
 
   describe '#unmute_conversation!' do
-    let(:conversation) { Fabricate(:conversation) }
-
     subject { account.unmute_conversation!(conversation) }
 
-    context 'muting the conversation' do
+    let(:conversation) { Fabricate(:conversation) }
+
+    context 'when muting the conversation' do
       it 'returns destroyed ConversationMute' do
         account.conversation_mutes.create(conversation: conversation)
-        is_expected.to be_kind_of ConversationMute
+        expect(subject).to be_a ConversationMute
         expect(subject).to be_destroyed
       end
     end
 
-    context 'not muting the conversation' do
+    context 'when not muting the conversation' do
       it 'returns nil' do
-        is_expected.to be nil
+        expect(subject).to be_nil
       end
     end
   end
 
   describe '#unblock_domain!' do
-    let(:domain) { 'example.com' }
-
     subject { account.unblock_domain!(domain) }
 
-    context 'blocking the domain' do
+    let(:domain) { 'example.com' }
+
+    context 'when blocking the domain' do
       it 'returns destroyed AccountDomainBlock' do
         account_domain_block = Fabricate(:account_domain_block, domain: domain)
         account.domain_blocks << account_domain_block
-        is_expected.to be_kind_of AccountDomainBlock
+        expect(subject).to be_a AccountDomainBlock
         expect(subject).to be_destroyed
       end
     end
 
-    context 'unblocking the domain' do
+    context 'when unblocking the domain' do
       it 'returns nil' do
-        is_expected.to be_nil
+        expect(subject).to be_nil
+      end
+    end
+  end
+
+  describe '#unblock_idna_domain!' do
+    subject { account.unblock_domain!(punycode_domain) }
+
+    let(:idna_domain) { '대한민국.한국' }
+    let(:punycode_domain) { 'xn--3e0bs9hfvinn1a.xn--3e0b707e' }
+
+    context 'when blocking the domain' do
+      it 'returns destroyed AccountDomainBlock' do
+        account_domain_block = Fabricate(:account_domain_block, domain: idna_domain)
+        account.domain_blocks << account_domain_block
+        expect(subject).to be_a AccountDomainBlock
+        expect(subject).to be_destroyed
+      end
+    end
+
+    context 'when unblocking idna domain' do
+      it 'returns nil' do
+        expect(subject).to be_nil
       end
     end
   end
@@ -386,16 +428,16 @@ describe AccountInteractions do
   describe '#following?' do
     subject { account.following?(target_account) }
 
-    context 'following target_account' do
+    context 'when following target_account' do
       it 'returns true' do
         account.active_relationships.create(target_account: target_account)
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not following target_account' do
+    context 'when not following target_account' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
@@ -403,16 +445,16 @@ describe AccountInteractions do
   describe '#followed_by?' do
     subject { account.followed_by?(target_account) }
 
-    context 'followed by target_account' do
+    context 'when followed by target_account' do
       it 'returns true' do
         account.passive_relationships.create(account: target_account)
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not followed by target_account' do
+    context 'when not followed by target_account' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
@@ -420,36 +462,36 @@ describe AccountInteractions do
   describe '#blocking?' do
     subject { account.blocking?(target_account) }
 
-    context 'blocking target_account' do
+    context 'when blocking target_account' do
       it 'returns true' do
         account.block_relationships.create(target_account: target_account)
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not blocking target_account' do
+    context 'when not blocking target_account' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   describe '#domain_blocking?' do
-    let(:domain)               { 'example.com' }
-
     subject { account.domain_blocking?(domain) }
 
-    context 'blocking the domain' do
-      it' returns true' do
+    let(:domain) { 'example.com' }
+
+    context 'when blocking the domain' do
+      it 'returns true' do
         account_domain_block = Fabricate(:account_domain_block, domain: domain)
         account.domain_blocks << account_domain_block
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not blocking the domain' do
+    context 'when not blocking the domain' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
@@ -457,61 +499,61 @@ describe AccountInteractions do
   describe '#muting?' do
     subject { account.muting?(target_account) }
 
-    context 'muting target_account' do
+    context 'when muting target_account' do
       it 'returns true' do
         mute = Fabricate(:mute, account: account, target_account: target_account)
         account.mute_relationships << mute
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not muting target_account' do
+    context 'when not muting target_account' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   describe '#muting_conversation?' do
-    let(:conversation) { Fabricate(:conversation) }
-
     subject { account.muting_conversation?(conversation) }
 
-    context 'muting the conversation' do
+    let(:conversation) { Fabricate(:conversation) }
+
+    context 'when muting the conversation' do
       it 'returns true' do
         account.conversation_mutes.create(conversation: conversation)
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not muting the conversation' do
+    context 'when not muting the conversation' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   describe '#muting_notifications?' do
+    subject { account.muting_notifications?(target_account) }
+
     before do
       mute = Fabricate(:mute, target_account: target_account, account: account, hide_notifications: hide)
       account.mute_relationships << mute
     end
 
-    subject { account.muting_notifications?(target_account) }
-
-    context 'muting notifications of target_account' do
+    context 'when muting notifications of target_account' do
       let(:hide) { true }
 
       it 'returns true' do
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not muting notifications of target_account' do
+    context 'when not muting notifications of target_account' do
       let(:hide) { false }
 
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
@@ -519,96 +561,96 @@ describe AccountInteractions do
   describe '#requested?' do
     subject { account.requested?(target_account) }
 
-    context 'requested by target_account' do
+    context 'with requested by target_account' do
       it 'returns true' do
         Fabricate(:follow_request, account: account, target_account: target_account)
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not requested by target_account' do
+    context 'when not requested by target_account' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   describe '#favourited?' do
-    let(:status) { Fabricate(:status, account: account, favourites: favourites) }
-
     subject { account.favourited?(status) }
 
-    context 'favorited' do
+    let(:status) { Fabricate(:status, account: account, favourites: favourites) }
+
+    context 'when favorited' do
       let(:favourites) { [Fabricate(:favourite, account: account)] }
 
       it 'returns true' do
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not favorited' do
+    context 'when not favorited' do
       let(:favourites) { [] }
 
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   describe '#reblogged?' do
-    let(:status) { Fabricate(:status, account: account, reblogs: reblogs) }
-
     subject { account.reblogged?(status) }
 
-    context 'reblogged' do
+    let(:status) { Fabricate(:status, account: account, reblogs: reblogs) }
+
+    context 'with reblogged' do
       let(:reblogs) { [Fabricate(:status, account: account)] }
 
       it 'returns true' do
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not reblogged' do
+    context 'when not reblogged' do
       let(:reblogs) { [] }
 
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   describe '#pinned?' do
-    let(:status) { Fabricate(:status, account: account) }
-
     subject { account.pinned?(status) }
 
-    context 'pinned' do
+    let(:status) { Fabricate(:status, account: account) }
+
+    context 'when pinned' do
       it 'returns true' do
         Fabricate(:status_pin, account: account, status: status)
-        is_expected.to be true
+        expect(subject).to be true
       end
     end
 
-    context 'not pinned' do
+    context 'when not pinned' do
       it 'returns false' do
-        is_expected.to be false
+        expect(subject).to be false
       end
     end
   end
 
   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
@@ -620,33 +662,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
 
@@ -721,4 +763,32 @@ describe AccountInteractions do
       end
     end
   end
+
+  describe '#lists_for_local_distribution' do
+    let(:account)                 { Fabricate(:user, current_sign_in_at: Time.now.utc).account }
+    let!(:inactive_follower_user) { Fabricate(:user, current_sign_in_at: 5.years.ago) }
+    let!(:follower_user)          { Fabricate(:user, current_sign_in_at: Time.now.utc) }
+    let!(:follow_request_user)    { Fabricate(:user, current_sign_in_at: Time.now.utc) }
+
+    let!(:inactive_follower_list) { Fabricate(:list, account: inactive_follower_user.account) }
+    let!(:follower_list)          { Fabricate(:list, account: follower_user.account) }
+    let!(:follow_request_list)    { Fabricate(:list, account: follow_request_user.account) }
+
+    let!(:self_list)              { Fabricate(:list, account: account) }
+
+    before do
+      inactive_follower_user.account.follow!(account)
+      follower_user.account.follow!(account)
+      follow_request_user.account.follow_requests.create!(target_account: account)
+
+      inactive_follower_list.accounts << account
+      follower_list.accounts << account
+      follow_request_list.accounts << account
+      self_list.accounts << account
+    end
+
+    it 'includes only the list from the active follower and from oneself' do
+      expect(account.lists_for_local_distribution.to_a).to contain_exactly(follower_list, self_list)
+    end
+  end
 end

spec/models/concerns/account_statuses_search_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe AccountStatusesSearch do
+  let(:account) { Fabricate(:account, indexable: indexable) }
+
+  before do
+    allow(Chewy).to receive(:enabled?).and_return(true)
+  end
+
+  describe '#enqueue_update_public_statuses_index' do
+    before do
+      allow(account).to receive(:enqueue_add_to_public_statuses_index)
+      allow(account).to receive(:enqueue_remove_from_public_statuses_index)
+    end
+
+    context 'when account is indexable' do
+      let(:indexable) { true }
+
+      it 'enqueues add_to_public_statuses_index and not to remove_from_public_statuses_index' do
+        account.enqueue_update_public_statuses_index
+        expect(account).to have_received(:enqueue_add_to_public_statuses_index)
+        expect(account).to_not have_received(:enqueue_remove_from_public_statuses_index)
+      end
+    end
+
+    context 'when account is not indexable' do
+      let(:indexable) { false }
+
+      it 'enqueues remove_from_public_statuses_index and not to add_to_public_statuses_index' do
+        account.enqueue_update_public_statuses_index
+        expect(account).to have_received(:enqueue_remove_from_public_statuses_index)
+        expect(account).to_not have_received(:enqueue_add_to_public_statuses_index)
+      end
+    end
+  end
+
+  describe '#enqueue_add_to_public_statuses_index' do
+    let(:indexable) { true }
+    let(:worker) { AddToPublicStatusesIndexWorker }
+
+    before do
+      allow(worker).to receive(:perform_async)
+    end
+
+    it 'enqueues AddToPublicStatusesIndexWorker' do
+      account.enqueue_add_to_public_statuses_index
+      expect(worker).to have_received(:perform_async).with(account.id)
+    end
+  end
+
+  describe '#enqueue_remove_from_public_statuses_index' do
+    let(:indexable) { false }
+    let(:worker) { RemoveFromPublicStatusesIndexWorker }
+
+    before do
+      allow(worker).to receive(:perform_async)
+    end
+
+    it 'enqueues RemoveFromPublicStatusesIndexWorker' do
+      account.enqueue_remove_from_public_statuses_index
+      expect(worker).to have_received(:perform_async).with(account.id)
+    end
+  end
+end

spec/models/concerns/remotable_spec.rb

@@ -3,48 +3,47 @@
 require 'rails_helper'
 
 RSpec.describe Remotable do
-  class Foo
-    def initialize
-      @attrs = {}
-    end
+  let(:foo_class) do
+    Class.new do
+      def initialize
+        @attrs = {}
+      end
 
-    def [](arg)
-      @attrs[arg]
-    end
+      def [](arg)
+        @attrs[arg]
+      end
 
-    def []=(arg1, arg2)
-      @attrs[arg1] = arg2
-    end
+      def []=(arg1, arg2)
+        @attrs[arg1] = arg2
+      end
 
-    def hoge=(arg); end
+      def hoge=(arg); end
 
-    def hoge_file_name; end
+      def hoge_file_name; end
 
-    def hoge_file_name=(arg); end
+      def hoge_file_name=(arg); end
 
-    def has_attribute?(arg); end
+      def has_attribute?(arg); end
 
-    def self.attachment_definitions
-      { hoge: nil }
-    end
-  end
-
-  before do
-    class Foo
-      include Remotable
-
-      remotable_attachment :hoge, 1.kilobyte
+      def self.attachment_definitions
+        { hoge: nil }
+      end
     end
   end
 
   let(:attribute_name) { "#{hoge}_remote_url".to_sym }
   let(:code)           { 200 }
   let(:file)           { 'filename="foo.txt"' }
-  let(:foo)            { Foo.new }
+  let(:foo)            { foo_class.new }
   let(:headers)        { { 'content-disposition' => file } }
   let(:hoge)           { :hoge }
   let(:url)            { 'https://google.com' }
 
+  before do
+    foo_class.include described_class
+    foo_class.remotable_attachment :hoge, 1.kilobyte
+  end
+
   it 'defines a method #hoge_remote_url=' do
     expect(foo).to respond_to(:hoge_remote_url=)
   end
@@ -147,8 +146,8 @@ RSpec.describe Remotable do
         let(:code) { 500 }
 
         it 'does not assign file' do
-          expect(foo).not_to receive(:public_send).with("#{hoge}=", any_args)
-          expect(foo).not_to receive(:public_send).with("#{hoge}_file_name=", any_args)
+          expect(foo).to_not receive(:public_send).with("#{hoge}=", any_args)
+          expect(foo).to_not receive(:public_send).with("#{hoge}_file_name=", any_args)
 
           foo.hoge_remote_url = url
         end
@@ -157,7 +156,7 @@ RSpec.describe Remotable do
       context 'when the response is successful' do
         let(:code) { 200 }
 
-        context 'and contains Content-Disposition header' do
+        context 'when contains Content-Disposition header' do
           let(:file)      { 'filename="foo.txt"' }
           let(:headers)   { { 'content-disposition' => file } }
 

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