Introduce StatusThreadingConcern (#3490)

* Add a StatusFilter class to identify visibility of statuses by accounts

* Extract StatusThreadingConcern from Status

* Clarify purpose of checking for nil account

3 files changed, 165 insertions, 95 deletions

diff --git a/spec/lib/status_filter_spec.rb b/spec/lib/status_filter_spec.rb
new file mode 100644
index 000000000..07f217fc3
--- /dev/null
+++ b/spec/lib/status_filter_spec.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe StatusFilter do
+  describe '#filtered?' do
+    let(:status) { Fabricate(:status) }
+
+    context 'without an account' do
+      subject { described_class.new(status, nil) }
+
+      it { is_expected.not_to be_filtered }
+    end
+
+    context 'with real account' do
+      let(:account) { Fabricate(:account) }
+      subject { described_class.new(status, account) }
+
+      context 'when there are no connections' do
+        it { is_expected.not_to be_filtered }
+      end
+
+      context 'when status account is blocked' do
+        before do
+          Fabricate(:block, account: account, target_account: status.account)
+        end
+
+        it { is_expected.to be_filtered }
+      end
+
+      context 'when status account domain is blocked' do
+        before do
+          status.account.update(domain: 'example.com')
+          Fabricate(:account_domain_block, account: account, domain: status.account_domain)
+        end
+
+        it { is_expected.to be_filtered }
+      end
+
+      context 'when status account is muted' do
+        before do
+          Fabricate(:mute, account: account, target_account: status.account)
+        end
+
+        it { is_expected.to be_filtered }
+      end
+
+      context 'when status account is silenced' do
+        before do
+          status.account.update(silenced: true)
+        end
+
+        it { is_expected.to be_filtered }
+      end
+
+      context 'when status policy does not allow show' do
+        before do
+          expect_any_instance_of(StatusPolicy).to receive(:show?).and_return(false)
+        end
+
+        it { is_expected.to be_filtered }
+      end
+    end
+  end
+end
diff --git a/spec/models/concerns/status_threading_concern_spec.rb b/spec/models/concerns/status_threading_concern_spec.rb
new file mode 100644
index 000000000..62f5f6e31
--- /dev/null
+++ b/spec/models/concerns/status_threading_concern_spec.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe StatusThreadingConcern do
+  describe '#ancestors' do
+    let!(:alice)  { Fabricate(:account, username: 'alice') }
+    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!(:viewer) { Fabricate(:account, username: 'viewer') }
+
+    it 'returns conversation history' do
+      expect(reply3.ancestors).to include(status, reply1, reply2)
+    end
+
+    it 'does not return conversation history user is not allowed to see' do
+      reply1.update(visibility: :private)
+      status.update(visibility: :direct)
+
+      expect(reply3.ancestors(viewer)).to_not include(reply1, status)
+    end
+
+    it 'does not return conversation history from blocked users' do
+      viewer.block!(jeff)
+      expect(reply3.ancestors(viewer)).to_not include(reply1)
+    end
+
+    it 'does not return conversation history from muted users' do
+      viewer.mute!(jeff)
+      expect(reply3.ancestors(viewer)).to_not include(reply1)
+    end
+
+    it 'does not return conversation history from silenced and not followed users' do
+      jeff.update(silenced: true)
+      expect(reply3.ancestors(viewer)).to_not include(reply1)
+    end
+
+    it 'does not return conversation history from blocked domains' do
+      viewer.block_domain!('example.com')
+      expect(reply3.ancestors(viewer)).to_not include(reply2)
+    end
+
+    it 'ignores deleted records' do
+      first_status  = Fabricate(:status, account: bob)
+      second_status = Fabricate(:status, thread: first_status, account: alice)
+
+      # Create cache and delete cached record
+      second_status.ancestors
+      first_status.destroy
+
+      expect(second_status.ancestors).to eq([])
+    end
+  end
+
+  describe '#descendants' do
+    let!(:alice)  { Fabricate(:account, username: 'alice') }
+    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!(:viewer) { Fabricate(:account, username: 'viewer') }
+
+    it 'returns replies' do
+      expect(status.descendants).to include(reply1, reply2, reply3)
+    end
+
+    it 'does not return replies user is not allowed to see' do
+      reply1.update(visibility: :private)
+      reply3.update(visibility: :direct)
+
+      expect(status.descendants(viewer)).to_not include(reply1, reply3)
+    end
+
+    it 'does not return replies from blocked users' do
+      viewer.block!(jeff)
+      expect(status.descendants(viewer)).to_not include(reply3)
+    end
+
+    it 'does not return replies from muted users' do
+      viewer.mute!(jeff)
+      expect(status.descendants(viewer)).to_not include(reply3)
+    end
+
+    it 'does not return replies from silenced and not followed users' do
+      jeff.update(silenced: true)
+      expect(status.descendants(viewer)).to_not include(reply3)
+    end
+
+    it 'does not return replies from blocked domains' do
+      viewer.block_domain!('example.com')
+      expect(status.descendants(viewer)).to_not include(reply2)
+    end
+  end
+end
diff --git a/spec/models/status_spec.rb b/spec/models/status_spec.rb
index ec07e6156..dd52a5d43 100644
--- a/spec/models/status_spec.rb
+++ b/spec/models/status_spec.rb
@@ -119,101 +119,6 @@ RSpec.describe Status, type: :model do
     end
   end
 
-  describe '#ancestors' do
-    let!(:alice)  { Fabricate(:account, username: 'alice') }
-    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!(:viewer) { Fabricate(:account, username: 'viewer') }
-
-    it 'returns conversation history' do
-      expect(reply3.ancestors).to include(status, reply1, reply2)
-    end
-
-    it 'does not return conversation history user is not allowed to see' do
-      reply1.update(visibility: :private)
-      status.update(visibility: :direct)
-
-      expect(reply3.ancestors(viewer)).to_not include(reply1, status)
-    end
-
-    it 'does not return conversation history from blocked users' do
-      viewer.block!(jeff)
-      expect(reply3.ancestors(viewer)).to_not include(reply1)
-    end
-
-    it 'does not return conversation history from muted users' do
-      viewer.mute!(jeff)
-      expect(reply3.ancestors(viewer)).to_not include(reply1)
-    end
-
-    it 'does not return conversation history from silenced and not followed users' do
-      jeff.update(silenced: true)
-      expect(reply3.ancestors(viewer)).to_not include(reply1)
-    end
-
-    it 'does not return conversation history from blocked domains' do
-      viewer.block_domain!('example.com')
-      expect(reply3.ancestors(viewer)).to_not include(reply2)
-    end
-
-    it 'ignores deleted records' do
-      first_status  = Fabricate(:status, account: bob)
-      second_status = Fabricate(:status, thread: first_status, account: alice)
-
-      # Create cache and delete cached record
-      second_status.ancestors
-      first_status.destroy
-
-      expect(second_status.ancestors).to eq([])
-    end
-  end
-
-  describe '#descendants' do
-    let!(:alice)  { Fabricate(:account, username: 'alice') }
-    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!(:viewer) { Fabricate(:account, username: 'viewer') }
-
-    it 'returns replies' do
-      expect(status.descendants).to include(reply1, reply2, reply3)
-    end
-
-    it 'does not return replies user is not allowed to see' do
-      reply1.update(visibility: :private)
-      reply3.update(visibility: :direct)
-
-      expect(status.descendants(viewer)).to_not include(reply1, reply3)
-    end
-
-    it 'does not return replies from blocked users' do
-      viewer.block!(jeff)
-      expect(status.descendants(viewer)).to_not include(reply3)
-    end
-
-    it 'does not return replies from muted users' do
-      viewer.mute!(jeff)
-      expect(status.descendants(viewer)).to_not include(reply3)
-    end
-
-    it 'does not return replies from silenced and not followed users' do
-      jeff.update(silenced: true)
-      expect(status.descendants(viewer)).to_not include(reply3)
-    end
-
-    it 'does not return replies from blocked domains' do
-      viewer.block_domain!('example.com')
-      expect(status.descendants(viewer)).to_not include(reply2)
-    end
-  end
-
   describe '.mutes_map' do
     let(:status)  { Fabricate(:status) }
     let(:account) { Fabricate(:account) }