tests

Author: sneakers-the-rat

app/models/public_feed.rb

@@ -46,7 +46,7 @@ def get(limit, max_id = nil, since_id = nil, min_id = nil)
   attr_reader :account, :options
 
   def prepend_stickies(results)
-    return results unless allow_local_only?
+    return results unless local_account?
 
     stickies = Sticky.stickied_statuses.to_a
     sticky_ids = stickies.to_set(&:id)

app/models/sticky.rb

@@ -16,6 +16,7 @@ class Sticky < ApplicationRecord
 
   scope :stickied_statuses, lambda {
     Status.local
+      .distributable_visibility
       .joins(:sticky)
       .reorder('stickies.created_at DESC')
   }

spec/fabricators/sticky_fabricator.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Fabricator(:sticky) do
+  status
+end

spec/models/home_feed_spec.rb

@@ -122,4 +122,39 @@
       expect(redis.hget("account:#{account.id}:regeneration", 'status')).to eq 'finished'
     end
   end
+
+  describe '#get with stickies' do
+    let!(:older_sticky_status) { Fabricate(:status, visibility: :public) }
+    let!(:newer_sticky_status) { Fabricate(:status, visibility: :public) }
+    let!(:normal_status_in_feed) { Fabricate(:status, account: account) }
+
+    before do
+      Sticky.create!(status: older_sticky_status, created_at: 2.hours.ago)
+      Sticky.create!(status: newer_sticky_status, created_at: 1.hour.ago)
+      redis.zadd(
+        FeedManager.instance.key(:home, account.id),
+        [[normal_status_in_feed.id, normal_status_in_feed.id]]
+      )
+    end
+
+    it 'prepends stickies at the top of the first page, newest first' do
+      ids = subject.get(20).map(&:id)
+      expect(ids.first(2)).to eq [newer_sticky_status.id, older_sticky_status.id]
+      expect(ids).to include(normal_status_in_feed.id)
+    end
+
+    it 'does not prepend stickies on paginated requests with max_id' do
+      ids = subject.get(20, normal_status_in_feed.id).map(&:id)
+      expect(ids).to_not include(newer_sticky_status.id, older_sticky_status.id)
+    end
+
+    it 'deduplicates a sticky that would appear naturally in the feed' do
+      redis.zadd(
+        FeedManager.instance.key(:home, account.id),
+        [[newer_sticky_status.id, newer_sticky_status.id]]
+      )
+      ids = subject.get(20).map(&:id)
+      expect(ids.count(newer_sticky_status.id)).to eq 1
+    end
+  end
 end

spec/models/public_feed_spec.rb

@@ -719,4 +719,34 @@
       end
     end
   end
+
+  describe '#get with stickies' do
+    subject { described_class.new(local_account) }
+
+    let!(:local_account) { Fabricate(:account, domain: nil) }
+    let!(:older_sticky_status) { Fabricate(:status, id: 1, created_at: 3.hours.ago, visibility: :public, account: local_account) }
+    let!(:newer_sticky_status) { Fabricate(:status, id: 3, created_at: 1.hour.ago, visibility: :public, account: local_account) }
+    let!(:normal_status) { Fabricate(:status, id: 2, created_at: 2.hours.ago, visibility: :public, account: local_account) }
+
+    before do
+      Sticky.create!(status: older_sticky_status, created_at: 2.hours.ago)
+      Sticky.create!(status: newer_sticky_status, created_at: 1.hour.ago)
+    end
+
+    it 'prepends stickies at the top of the first page, newest first' do
+      ids = subject.get(20).map(&:id)
+      expect(ids.first(2)).to eq [newer_sticky_status.id, older_sticky_status.id]
+      expect(ids).to include(normal_status.id)
+    end
+
+    it 'deduplicates a sticky that would also appear naturally in the feed' do
+      ids = subject.get(20).map(&:id)
+      expect(ids.count(newer_sticky_status.id)).to eq 1
+    end
+
+    it 'does not pin stickies on paginated requests with max_id' do
+      ids = subject.get(20, normal_status.id).map(&:id)
+      expect(ids).to eq [older_sticky_status.id]
+    end
+  end
 end

spec/models/sticky_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Sticky do
+  describe 'Validations' do
+    it 'requires a status' do
+      sticky = described_class.new
+      expect(sticky).to_not be_valid
+      expect(sticky.errors[:status]).to be_present
+    end
+  end
+
+  describe 'Association' do
+    it 'is destroyed when the parent status is destroyed' do
+      status = Fabricate(:status)
+      described_class.create!(status: status)
+
+      expect { status.destroy }.to change(described_class, :count).by(-1)
+    end
+  end
+
+  describe '.stickied_statuses' do
+    let!(:older_sticky_status) { Fabricate(:status, visibility: :public) }
+    let!(:newer_sticky_status) { Fabricate(:status, visibility: :public) }
+
+    before do
+      described_class.create!(status: older_sticky_status, created_at: 2.hours.ago)
+      described_class.create!(status: newer_sticky_status, created_at: 1.hour.ago)
+    end
+
+    it 'returns sticky statuses ordered by sticky creation desc' do
+      expect(described_class.stickied_statuses.to_a).to eq [newer_sticky_status, older_sticky_status]
+    end
+
+    it 'excludes private and direct statuses' do
+      private_status = Fabricate(:status, visibility: :private)
+      direct_status = Fabricate(:status, visibility: :direct)
+      described_class.create!(status: private_status)
+      described_class.create!(status: direct_status)
+
+      ids = described_class.stickied_statuses.pluck(:id)
+      expect(ids).to_not include(private_status.id, direct_status.id)
+    end
+  end
+end

spec/requests/api/v1/statuses/stickies_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Stickies' do
+  let(:user)    { Fabricate(:moderator_user) }
+  let(:scopes)  { 'write:statuses' }
+  let(:token)   { Fabricate(:accessible_access_token, resource_owner_id: user.id, scopes: scopes) }
+  let(:headers) { { 'Authorization' => "Bearer #{token.token}" } }
+
+  describe 'POST /api/v1/statuses/:status_id/sticky' do
+    subject do
+      post "/api/v1/statuses/#{status.id}/sticky", headers: headers
+    end
+
+    let(:status) { Fabricate(:status) }
+
+    it_behaves_like 'forbidden for wrong scope', 'read'
+
+    context 'when a moderator' do
+      it 'creates a sticky and returns updated json with sticky: true', :aggregate_failures do
+        subject
+
+        expect(response).to have_http_status(200)
+        expect(Sticky.exists?(status_id: status.id)).to be true
+        expect(response.parsed_body).to match(
+          a_hash_including(id: status.id.to_s, sticky: true)
+        )
+        expect(response.parsed_body.keys.map(&:to_s)).to include('sticky')
+      end
+
+      it 'is idempotent when called twice' do
+        subject
+        expect { post "/api/v1/statuses/#{status.id}/sticky", headers: headers }
+          .to_not change(Sticky, :count)
+        expect(response).to have_http_status(200)
+      end
+    end
+
+    context 'when a regular user' do
+      let(:user) { Fabricate(:user) }
+
+      it 'returns http forbidden' do
+        subject
+        expect(response).to have_http_status(403)
+      end
+    end
+
+    context 'without an authorization header' do
+      let(:headers) { {} }
+
+      it 'returns http unauthorized' do
+        subject
+        expect(response).to have_http_status(401)
+      end
+    end
+
+    context 'when the status does not exist' do
+      it 'returns http not found' do
+        post '/api/v1/statuses/-1/sticky', headers: headers
+        expect(response).to have_http_status(404)
+      end
+    end
+  end
+
+  describe 'POST /api/v1/statuses/:status_id/unsticky' do
+    subject do
+      post "/api/v1/statuses/#{status.id}/unsticky", headers: headers
+    end
+
+    let(:status) { Fabricate(:status) }
+
+    it_behaves_like 'forbidden for wrong scope', 'read'
+
+    context 'when a moderator' do
+      context 'when the status is currently sticky' do
+        before { Sticky.create!(status: status) }
+
+        it 'removes the sticky and returns updated json with sticky: false', :aggregate_failures do
+          subject
+
+          expect(response).to have_http_status(200)
+          expect(Sticky.exists?(status_id: status.id)).to be false
+          expect(response.parsed_body).to match(
+            a_hash_including(id: status.id.to_s, sticky: false)
+          )
+        end
+      end
+
+      context 'when the status is not sticky' do
+        it 'returns http success without error' do
+          subject
+          expect(response).to have_http_status(200)
+          expect(response.parsed_body).to match(
+            a_hash_including(id: status.id.to_s, sticky: false)
+          )
+        end
+      end
+    end
+
+    context 'when a regular user' do
+      let(:user) { Fabricate(:user) }
+
+      before { Sticky.create!(status: status) }
+
+      it 'returns http forbidden and does not remove the sticky', :aggregate_failures do
+        subject
+        expect(response).to have_http_status(403)
+        expect(Sticky.exists?(status_id: status.id)).to be true
+      end
+    end
+  end
+end

spec/system/stickies_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Sticky posts', :inline_jobs, :js do
+  include ProfileStories
+
+  let(:email)               { 'test@example.com' }
+  let(:password)            { 'password' }
+  let(:confirmed_at)        { Time.zone.now }
+  let(:finished_onboarding) { true }
+  let!(:other_account)      { Fabricate(:account, username: 'alice') }
+  let!(:target_status)      { Fabricate(:status, account: other_account, text: 'Hello from Alice', visibility: :public) }
+
+  before do
+    Setting.local_live_feed_access = 'public'
+    as_a_logged_in_user
+    bob.update!(role: UserRole.find_by!(name: 'Moderator'))
+    page.refresh
+  end
+
+  it 'toggles stickiness from off to on' do
+    ignore_js_error(/Failed to load resource/)
+
+    visit '/public/local'
+
+    expect(page).to have_css('.status', text: 'Hello from Alice')
+
+    within(first('.status')) do
+      find('button[title="More"]').click_button
+    end
+
+    within('.dropdown-menu') do
+      expect(page).to have_text('Make this post globally sticky')
+      click_on 'Make this post globally sticky'
+    end
+
+    within(first('.status')) do
+      find('button[title="More"]').click_button
+    end
+
+    within('.dropdown-menu') do
+      expect(page).to have_text('Unsticky this post')
+    end
+
+    expect(Sticky.exists?(status_id: target_status.id)).to be true
+  end
+
+  it 'toggles stickiness from on to off' do
+    Sticky.create!(status: target_status)
+
+    ignore_js_error(/Failed to load resource/)
+
+    visit '/public/local'
+
+    within(first('.status')) do
+      find('button[title="More"]').click_button
+    end
+
+    within('.dropdown-menu') do
+      click_on 'Unsticky this post'
+    end
+
+    # Reopen and confirm we're back to "Make sticky"
+    within(first('.status')) do
+      find('button[title="More"]').click_button
+    end
+
+    within('.dropdown-menu') do
+      expect(page).to have_text('Make this post globally sticky')
+    end
+
+    expect(Sticky.exists?(status_id: target_status.id)).to be false
+  end
+end