Add specs for PostStatusService

This implements all pending specs, and adds additional coverage for the
following functionality:

* Normal status creation
* Creating a reply status
* Creating a sensitive status
* Creating a status with spoiler text
* A status with no spoiler text gets an empty string for spoiler text
* Creating a status with custom visibility
* Creating a status for an application
* Processing mentions
* Processing Hashtags
* Pinging PuSH hubs
* Crawling links
* Attaching media

spec/fabricators/status_fabricator.rb

@@ -1,3 +1,4 @@
 Fabricator(:status) do
+  account
   text "Lorem ipsum dolor sit amet"
 end

spec/services/post_status_service_spec.rb

@@ -3,27 +3,142 @@ require 'rails_helper'
 RSpec.describe PostStatusService do
   subject { PostStatusService.new }
 
-  it 'creates a new status'
+  it 'creates a new status' do
-  it 'creates a new response status'
+    account = Fabricate(:account)
-  it 'processes mentions'
+    text = "test status update"
-  it 'pings PuSH hubs'
+
+    status = subject.call(account, text)
+
+    expect(status).to be_persisted
+    expect(status.text).to eq text
+  end
+
+  it 'creates a new response status' do
+    in_reply_to_status = Fabricate(:status)
+    account = Fabricate(:account)
+    text = "test status update"
+
+    status = subject.call(account, text, in_reply_to_status)
+
+    expect(status).to be_persisted
+    expect(status.text).to eq text
+    expect(status.thread).to eq in_reply_to_status
+  end
+
+  it 'creates a sensitive status' do
+    status = create_status_with_options(sensitive: true)
+
+    expect(status).to be_persisted
+    expect(status).to be_sensitive
+  end
+
+  it 'creates a status with spoiler text' do
+    spoiler_text = "spoiler text"
+
+    status = create_status_with_options(spoiler_text: spoiler_text)
+
+    expect(status).to be_persisted
+    expect(status.spoiler_text).to eq spoiler_text
+  end
+
+  it 'creates a status with empty default spoiler text' do
+    status = create_status_with_options(spoiler_text: nil)
+
+    expect(status).to be_persisted
+    expect(status.spoiler_text).to eq ''
+  end
+
+  it 'creates a status with the given visibility' do
+    status = create_status_with_options(visibility: :private)
+
+    expect(status).to be_persisted
+    expect(status.visibility).to eq "private"
+  end
+
+  it 'creates a status for the given application' do
+    application = Fabricate(:application)
+
+    status = create_status_with_options(application: application)
+
+    expect(status).to be_persisted
+    expect(status.application).to eq application
+  end
+
+  it 'processes mentions' do
+    mention_service = double(:process_mentions_service)
+    allow(mention_service).to receive(:call)
+    allow(ProcessMentionsService).to receive(:new).and_return(mention_service)
+    account = Fabricate(:account)
+
+    status = subject.call(account, "test status update")
+
+    expect(ProcessMentionsService).to have_received(:new)
+    expect(mention_service).to have_received(:call).with(status)
+  end
+
+  it 'processes hashtags' do
+    hashtags_service = double(:process_hashtags_service)
+    allow(hashtags_service).to receive(:call)
+    allow(ProcessHashtagsService).to receive(:new).and_return(hashtags_service)
+    account = Fabricate(:account)
+
+    status = subject.call(account, "test status update")
+
+    expect(ProcessHashtagsService).to have_received(:new)
+    expect(hashtags_service).to have_received(:call).with(status)
+  end
+
+  it 'pings PuSH hubs' do
+    allow(DistributionWorker).to receive(:perform_async)
+    allow(Pubsubhubbub::DistributionWorker).to receive(:perform_async)
+    account = Fabricate(:account)
+
+    status = subject.call(account, "test status update")
+
+    expect(DistributionWorker).to have_received(:perform_async).with(status.id)
+    expect(Pubsubhubbub::DistributionWorker).
+      to have_received(:perform_async).with(status.stream_entry.id)
+  end
+
+  it 'crawls links' do
+    allow(LinkCrawlWorker).to receive(:perform_async)
+    account = Fabricate(:account)
+
+    status = subject.call(account, "test status update")
+
+    expect(LinkCrawlWorker).to have_received(:perform_async).with(status.id)
+  end
+
+  it 'attaches the given media to the created status' do
+    account = Fabricate(:account)
+    media = Fabricate(:media_attachment)
+
+    status = subject.call(
+      account,
+      "test status update",
+      nil,
+      media_ids: [media.id],
+    )
+
+    expect(media.reload.status).to eq status
+  end
 
   it 'does not allow attaching more than 4 files' do
     account = Fabricate(:account)
 
     expect do
-      PostStatusService.new.call(
+      subject.call(
-      account,
+        account,
-      "test status update",
+        "test status update",
-      nil,
+        nil,
-      media_ids: [
+        media_ids: [
-        Fabricate(:media_attachment, account: account),
+          Fabricate(:media_attachment, account: account),
-        Fabricate(:media_attachment, account: account),
+          Fabricate(:media_attachment, account: account),
-        Fabricate(:media_attachment, account: account),
+          Fabricate(:media_attachment, account: account),
-        Fabricate(:media_attachment, account: account),
+          Fabricate(:media_attachment, account: account),
-        Fabricate(:media_attachment, account: account),
+          Fabricate(:media_attachment, account: account),
-      ].map(&:id),
+        ].map(&:id),
-    )
+      )
     end.to raise_error(
       Mastodon::ValidationError,
       'Cannot attach more than 4 files',
@@ -34,18 +149,22 @@ RSpec.describe PostStatusService do
     account = Fabricate(:account)
 
     expect do
-      PostStatusService.new.call(
+      subject.call(
-      account,
+        account,
-      "test status update",
+        "test status update",
-      nil,
+        nil,
-      media_ids: [
+        media_ids: [
-        Fabricate(:media_attachment, type: :video, account: account),
+          Fabricate(:media_attachment, type: :video, account: account),
-        Fabricate(:media_attachment, type: :image, account: account),
+          Fabricate(:media_attachment, type: :image, account: account),
-      ].map(&:id),
+        ].map(&:id),
-    )
+      )
     end.to raise_error(
       Mastodon::ValidationError,
       'Cannot attach a video to a toot that already contains images',
     )
   end
+
+  def create_status_with_options(options = {})
+    subject.call(Fabricate(:account), "test", nil, options)
+  end
 end