version: 2.1
orbs:
- ruby: circleci/ruby@1.4.0
+ ruby: circleci/ruby@1.4.1
node: circleci/node@5.0.1
executors:
end
describe 'POST #unblock_email' do
- subject do
- -> { post :unblock_email, params: { id: account.id } }
- end
+ subject { post :unblock_email, params: { id: account.id } }
let(:current_user) { Fabricate(:user, admin: admin) }
let(:account) { Fabricate(:account, suspended: true) }
let(:admin) { true }
it 'succeeds in removing email blocks' do
- is_expected.to change { CanonicalEmailBlock.where(reference_account: account).count }.from(1).to(0)
+ expect { subject }.to change { CanonicalEmailBlock.where(reference_account: account).count }.from(1).to(0)
end
it 'redirects to admin account path' do
- subject.call
+ subject
expect(response).to redirect_to admin_account_path(account.id)
end
end
let(:admin) { false }
it 'fails to remove avatar' do
- subject.call
+ subject
expect(response).to have_http_status :forbidden
end
end
describe Settings::Exports::BookmarksController do
render_views
+ let(:user) { Fabricate(:user) }
+ let(:account) { Fabricate(:account, domain: 'foo.bar') }
+ let(:status) { Fabricate(:status, account: account, uri: 'https://foo.bar/statuses/1312') }
+
describe 'GET #index' do
- it 'returns a csv of the bookmarked toots' do
- user = Fabricate(:user)
- user.account.bookmarks.create!(status: Fabricate(:status, uri: 'https://foo.bar/statuses/1312'))
+ before do
+ user.account.bookmarks.create!(status: status)
+ end
+ it 'returns a csv of the bookmarked toots' do
sign_in user, scope: :user
get :index, format: :csv
subject { RSS::Serializer.new.send(:status_title, status) }
- context 'if destroyed?' do
- it 'returns "#{account.acct} deleted status"' do
- status.destroy!
- expect(subject).to eq "#{account.acct} deleted status"
- end
- end
-
context 'on a toot with long text' do
let(:text) { "This toot's text is longer than the allowed number of characters" }
require 'rails_helper'
RSpec.describe AfterBlockService, type: :service do
- subject do
- -> { described_class.new.call(account, target_account) }
- end
+ subject { described_class.new.call(account, target_account) }
let(:account) { Fabricate(:account) }
let(:target_account) { Fabricate(:account) }
FeedManager.instance.push_to_home(account, other_account_status)
FeedManager.instance.push_to_home(account, other_account_reblog)
- is_expected.to change {
+ expect { subject }.to change {
Redis.current.zrange(home_timeline_key, 0, -1)
}.from([status.id.to_s, other_account_status.id.to_s, other_account_reblog.id.to_s]).to([other_account_status.id.to_s])
end
FeedManager.instance.push_to_list(list, other_account_status)
FeedManager.instance.push_to_list(list, other_account_reblog)
- is_expected.to change {
+ expect { subject }.to change {
Redis.current.zrange(list_timeline_key, 0, -1)
}.from([status.id.to_s, other_account_status.id.to_s, other_account_reblog.id.to_s]).to([other_account_status.id.to_s])
end
let!(:account_note) { Fabricate(:account_note, account: account) }
- subject do
- -> { described_class.new.call(account) }
- end
+ subject { described_class.new.call(account) }
it 'deletes associated owned records' do
- is_expected.to change {
+ expect { subject }.to change {
[
account.statuses,
account.media_attachments,
end
it 'deletes associated target records' do
- is_expected.to change {
+ expect { subject }.to change {
[
AccountPin.where(target_account: account),
].map(&:count)
end
it 'deletes associated target notifications' do
- is_expected.to change {
+ expect { subject }.to change {
[
'poll', 'favourite', 'status', 'mention', 'follow'
].map { |type| Notification.where(type: type).count }
let!(:local_follower) { Fabricate(:account) }
it 'sends a delete actor activity to all known inboxes' do
- subject.call
+ subject
expect(a_request(:post, "https://alice.com/inbox")).to have_been_made.once
expect(a_request(:post, "https://bob.com/inbox")).to have_been_made.once
end
let!(:local_follower) { Fabricate(:account) }
it 'sends a reject follow to follower inboxes' do
- subject.call
+ subject
expect(a_request(:post, account.inbox_url)).to have_been_made.once
end
end
require 'rails_helper'
RSpec.describe MuteService, type: :service do
- subject do
- -> { described_class.new.call(account, target_account) }
- end
+ subject { described_class.new.call(account, target_account) }
let(:account) { Fabricate(:account) }
let(:target_account) { Fabricate(:account) }
FeedManager.instance.push_to_home(account, status)
FeedManager.instance.push_to_home(account, other_account_status)
- is_expected.to change {
+ expect { subject }.to change {
Redis.current.zrange(home_timeline_key, 0, -1)
}.from([status.id.to_s, other_account_status.id.to_s]).to([other_account_status.id.to_s])
end
end
it 'mutes account' do
- is_expected.to change {
+ expect { subject }.to change {
account.muting?(target_account)
}.from(false).to(true)
end
context 'without specifying a notifications parameter' do
it 'mutes notifications from the account' do
- is_expected.to change {
+ expect { subject }.to change {
account.muting_notifications?(target_account)
}.from(false).to(true)
end
end
context 'with a true notifications parameter' do
- subject do
- -> { described_class.new.call(account, target_account, notifications: true) }
- end
+ subject { described_class.new.call(account, target_account, notifications: true) }
it 'mutes notifications from the account' do
- is_expected.to change {
+ expect { subject }.to change {
account.muting_notifications?(target_account)
}.from(false).to(true)
end
end
context 'with a false notifications parameter' do
- subject do
- -> { described_class.new.call(account, target_account, notifications: false) }
- end
+ subject { described_class.new.call(account, target_account, notifications: false) }
it 'does not mute notifications from the account' do
- is_expected.to_not change {
+ expect { subject }.to_not change {
account.muting_notifications?(target_account)
}.from(false)
end
require 'rails_helper'
RSpec.describe NotifyService, type: :service do
- subject do
- -> { described_class.new.call(recipient, type, activity) }
- end
+ subject { described_class.new.call(recipient, type, activity) }
let(:user) { Fabricate(:user) }
let(:recipient) { user.account }
let(:activity) { Fabricate(:follow, account: sender, target_account: recipient) }
let(:type) { :follow }
- it { is_expected.to change(Notification, :count).by(1) }
+ it { expect { subject }.to change(Notification, :count).by(1) }
it 'does not notify when sender is blocked' do
recipient.block!(sender)
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
it 'does not notify when sender is muted with hide_notifications' do
recipient.mute!(sender, notifications: true)
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
it 'does notify when sender is muted without hide_notifications' do
recipient.mute!(sender, notifications: false)
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
it 'does not notify when sender\'s domain is blocked' do
recipient.block_domain!(sender.domain)
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
it 'does still notify when sender\'s domain is blocked but sender is followed' do
recipient.block_domain!(sender.domain)
recipient.follow!(sender)
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
it 'does not notify when sender is silenced and not followed' do
sender.silence!
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
it 'does not notify when recipient is suspended' do
recipient.suspend!
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
context 'for direct messages' do
let(:enabled) { true }
it 'does not notify' do
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
context 'if the message chain is initiated by recipient, but is not direct message' do
let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct, thread: reply_to)) }
it 'does not notify' do
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
end
let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct, thread: dummy_reply)) }
it 'does not notify' do
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
end
let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct, thread: reply_to)) }
it 'does notify' do
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
end
end
let(:enabled) { false }
it 'does notify' do
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
end
end
it 'shows reblogs by default' do
recipient.follow!(sender)
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
it 'shows reblogs when explicitly enabled' do
recipient.follow!(sender, reblogs: true)
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
it 'shows reblogs when disabled' do
recipient.follow!(sender, reblogs: false)
- is_expected.to change(Notification, :count)
+ expect { subject }.to change(Notification, :count)
end
end
it 'does not notify when conversation is muted' do
recipient.mute_conversation!(activity.status.conversation)
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
it 'does not notify when it is a reply to a blocked user' do
recipient.block!(asshole)
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
end
let(:sender) { recipient }
it 'does not notify when recipient is the sender' do
- is_expected.to_not change(Notification, :count)
+ expect { subject }.to_not change(Notification, :count)
end
end
let(:enabled) { true }
it 'sends email' do
- is_expected.to change(ActionMailer::Base.deliveries, :count).by(1)
+ expect { subject }.to change(ActionMailer::Base.deliveries, :count).by(1)
end
end
let(:enabled) { false }
it "doesn't send email" do
- is_expected.to_not change(ActionMailer::Base.deliveries, :count).from(0)
+ expect { subject }.to_not change(ActionMailer::Base.deliveries, :count).from(0)
end
end
end
let!(:local_follower) { Fabricate(:user, current_sign_in_at: 1.hour.ago).account }
let!(:list) { Fabricate(:list, account: local_follower) }
- subject do
- -> { described_class.new.call(account) }
- end
+ subject { described_class.new.call(account) }
before do
allow(FeedManager.instance).to receive(:unmerge_from_home).and_return(nil)
end
it "unmerges from local followers' feeds" do
- subject.call
+ subject
expect(FeedManager.instance).to have_received(:unmerge_from_home).with(account, local_follower)
expect(FeedManager.instance).to have_received(:unmerge_from_list).with(account, list)
end
it 'marks account as suspended' do
- is_expected.to change { account.suspended? }.from(false).to(true)
+ expect { subject }.to change { account.suspended? }.from(false).to(true)
end
end
end
it 'sends an update actor to followers and reporters' do
- subject.call
+ subject
expect(a_request(:post, remote_follower.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once
expect(a_request(:post, remote_reporter.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once
end
end
it 'sends a reject follow' do
- subject.call
+ subject
expect(a_request(:post, account.inbox_url).with { |req| match_reject_follow_request(req, account, local_followee) }).to have_been_made.once
end
end
let!(:local_follower) { Fabricate(:user, current_sign_in_at: 1.hour.ago).account }
let!(:list) { Fabricate(:list, account: local_follower) }
- subject do
- -> { described_class.new.call(account) }
- end
+ subject { described_class.new.call(account) }
before do
allow(FeedManager.instance).to receive(:merge_into_home).and_return(nil)
end
it 'marks account as unsuspended' do
- is_expected.to change { account.suspended? }.from(true).to(false)
+ expect { subject }.to change { account.suspended? }.from(true).to(false)
end
include_examples 'common behavior' do
end
it "merges back into local followers' feeds" do
- subject.call
+ subject
expect(FeedManager.instance).to have_received(:merge_into_home).with(account, local_follower)
expect(FeedManager.instance).to have_received(:merge_into_list).with(account, list)
end
it 'sends an update actor to followers and reporters' do
- subject.call
+ subject
expect(a_request(:post, remote_follower.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once
expect(a_request(:post, remote_reporter.inbox_url).with { |req| match_update_actor_request(req, account) }).to have_been_made.once
end
end
it 're-fetches the account' do
- subject.call
+ subject
expect(resolve_account_service).to have_received(:call).with(account)
end
it "merges back into local followers' feeds" do
- subject.call
+ subject
expect(FeedManager.instance).to have_received(:merge_into_home).with(account, local_follower)
expect(FeedManager.instance).to have_received(:merge_into_list).with(account, list)
end
it 'marks account as unsuspended' do
- is_expected.to change { account.suspended? }.from(true).to(false)
+ expect { subject }.to change { account.suspended? }.from(true).to(false)
end
end
end
it 're-fetches the account' do
- subject.call
+ subject
expect(resolve_account_service).to have_received(:call).with(account)
end
it "does not merge back into local followers' feeds" do
- subject.call
+ subject
expect(FeedManager.instance).to_not have_received(:merge_into_home).with(account, local_follower)
expect(FeedManager.instance).to_not have_received(:merge_into_list).with(account, list)
end
it 'does not mark the account as unsuspended' do
- is_expected.not_to change { account.suspended? }
+ expect { subject }.not_to change { account.suspended? }
end
end
end
it 're-fetches the account' do
- subject.call
+ subject
expect(resolve_account_service).to have_received(:call).with(account)
end
it "does not merge back into local followers' feeds" do
- subject.call
+ subject
expect(FeedManager.instance).to_not have_received(:merge_into_home).with(account, local_follower)
expect(FeedManager.instance).to_not have_received(:merge_into_list).with(account, list)
end
cat aescling's git repositories / mastodon.git / commitdiff