Skip to content

A platform for community discussion. Free, open, simple.

14.1 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe "Blog editorial workflow", type: :request do
  fab!(:admin)
  fab!(:category)
  fab!(:writers, :group)
  fab!(:writer) { Fabricate(:user, groups: [writers], refresh_auto_groups: true) }
  fab!(:drafts) { Fabricate(:private_category, group: Group[:staff]) }
  fab!(:topic) { Fabricate(:topic, category: drafts, user: writer) }
  fab!(:first_post) do
    Fabricate(
      :post,
      topic: topic,
      user: writer,
      raw: "An article ready for a careful editorial review.",
    )
  end

  before do
    enable_blog!(category: category, drafts: drafts)
    SiteSetting.blog_contributor_groups = writers.id.to_s
    drafts.set_permissions(:staff => :full, writers.name => :full)
    drafts.save!
  end

  it "requires explicit approval and copies only the frozen article, keeping editorial replies private" do
    note =
      Fabricate(
        :post,
        topic: topic,
        user: admin,
        raw: "Confidential editorial notes must never become public.",
      )
    sign_in(writer)
    post "/blog-editor/publications/#{topic.id}/submit.json"
    expect(response.status).to eq(200)
    revision_id = response.parsed_body.dig("submitted_revision", "id")
    expect(response.parsed_body["awaiting_approval"]).to eq(true)
    post "/blog-editor/publications/#{topic.id}/approve.json", params: { revision_id: revision_id }
    expect(response.status).to eq(403)
    post "/blog-editor/publications/#{topic.id}/publish.json", params: { revision_id: revision_id }
    expect(response.status).to eq(403)

    sign_in(admin)
    post "/blog-editor/publications/#{topic.id}/publish.json", params: { revision_id: revision_id }
    expect(response.status).to eq(400)
    post "/blog-editor/publications/#{topic.id}/approve.json", params: { revision_id: revision_id }
    expect(response.status).to eq(200)
    expect(response.parsed_body["awaiting_approval"]).to eq(false)
    first_post.revise(writer, raw: "A newer private edit that has not been submitted or approved.")
    post "/blog-editor/publications/#{topic.id}/publish.json", params: { revision_id: revision_id }
    expect(response.status).to eq(200)

    publication = Blog::Publication.find_by!(topic: topic)
    discussion = publication.discussion_topic
    expect(discussion.id).not_to eq(topic.id)
    expect(discussion.posts.count).to eq(1)
    expect(discussion.first_post.raw).to eq(publication.published_revision.raw)
    expect(discussion.first_post.raw).not_to eq(first_post.reload.raw)
    expect(note.reload.topic_id).to eq(topic.id)
    expect(topic.reload.category_id).to eq(drafts.id)
    expect(admin.guardian.can_edit_post?(discussion.first_post)).to eq(false)
    expect(writer.guardian.can_edit_post?(first_post)).to eq(true)
    get "https://blog.example.com#{publication.path}"
    expect(response.status).to eq(200)
    expect(response.body).not_to include(first_post.raw, note.raw)
  end

  it "preserves existing discussion IDs and replies while staging a private working copy" do
    topic.update_column(:category_id, category.id)
    topic.reload
    publication =
      Blog::Publication.create!(
        topic: topic,
        discussion_topic: topic,
        path: "/existing",
        published: true,
        published_at: 1.day.ago,
      )
    reply = Fabricate(:post, topic: topic, user: writer)
    source = publication.prepare_draft!(admin)
    expect(source.category_id).to eq(drafts.id)
    expect(source.posts.count).to eq(1)
    expect(source.first_post.raw).to eq(first_post.raw)
    source.first_post.revise(
      admin,
      raw: "A carefully revised article that should only go live after approval.",
    )
    publication.save_metadata!(admin, path: "/updated", excerpt: "A staged introduction")
    expect(publication.reload.path).to eq("/existing")
    expect(publication.published_revision.raw).to eq(first_post.raw)
    publication.publish!(admin)
    expect(publication.discussion_topic_id).to eq(topic.id)
    expect(reply.reload.topic_id).to eq(topic.id)
    expect(first_post.reload.raw).to eq(source.first_post.raw)
    expect(publication.path).to eq("/updated")
  end

  it "denies contributors access to someone else's drafts and frozen revisions" do
    other = Fabricate(:topic, category: drafts, user: admin)
    Fabricate(:post, topic: other, user: admin)
    publication = Blog::Publication.for_topic(other)
    revision = publication.submit!(admin)
    sign_in(writer)
    get "/blog-editor/publications/#{other.id}.json"
    expect(response.status).to eq(403)
    get "/blog-editor/preview/#{other.id}", params: { revision_id: revision.id }
    expect(response.status).to eq(403)
    get "/blog-editor.json"
    expect(response.parsed_body["topics"].map { |entry| entry["id"] }).to contain_exactly(topic.id)
  end

  it "previews the submitted snapshot rather than later edits" do
    publication = Blog::Publication.for_topic(topic)
    revision = publication.submit!(admin)
    first_post.revise(
      writer,
      raw: "Later unpublished article content must stay out of the revision preview.",
    )
    sign_in(admin)
    get "/blog-editor/preview/#{topic.id}", params: { revision_id: revision.id }
    expect(response.status).to eq(200)
    expect(response.body).to include(revision.raw)
    expect(response.body).not_to include(first_post.reload.raw)
    expect(response.headers["Cache-Control"]).to include("no-store")
  end

  it "publishes the scheduled approved revision exactly once even after a newer submission" do
    freeze_time
    publication = Blog::Publication.for_topic(topic)
    revision = publication.submit!(admin)
    publication.approve!(admin, revision.id)
    publication.schedule!(admin, revision_id: revision.id, at: 2.hours.from_now.iso8601)
    token = publication.schedule_token
    first_post.revise(
      writer,
      raw: "Another draft for the next editorial round, not this scheduled release.",
    )
    publication.submit!(writer)
    Jobs::PublishBlogRevision.new.execute(publication_id: publication.id, token: token)
    expect(publication.reload).not_to be_published
    freeze_time 3.hours.from_now
    Jobs::PublishBlogRevision.new.execute(publication_id: publication.id, token: token)
    expect(publication.reload.published_revision_id).to eq(revision.id)
    expect(publication.discussion_topic.first_post.raw).to eq(revision.raw)
    expect {
      Jobs::PublishBlogRevision.new.execute(publication_id: publication.id, token: token)
    }.not_to change(Topic, :count)
    expect(publication.scheduled_at).to be_nil
  end

  it "invalidates canceled schedules and fails closed when publisher access is removed" do
    freeze_time
    publication = Blog::Publication.for_topic(topic)
    revision = publication.submit!(admin)
    publication.approve!(admin, revision.id)
    publication.schedule!(admin, revision_id: revision.id, at: 2.hours.from_now.iso8601)
    canceled_token = publication.schedule_token
    publication.cancel_schedule!(admin)
    publication.schedule!(admin, revision_id: revision.id, at: 2.hours.from_now.iso8601)
    token = publication.schedule_token
    freeze_time 3.hours.from_now
    publication.run_schedule!(canceled_token)
    expect(publication.reload).not_to be_published
    admin.update!(suspended_till: 1.day.from_now)
    publication.run_schedule!(token)
    expect(publication.reload).not_to be_published
    expect(publication.scheduled_at).to be_nil
    expect(publication.schedule_error).to be_present
  end

  it "rejects stale approvals and cross-article revision IDs without altering approval provenance" do
    publication = Blog::Publication.for_topic(topic)
    revision = publication.submit!(admin)
    publication.approve!(admin, revision.id)
    approved_at = revision.reload.approved_at
    freeze_time 1.hour.from_now
    publication.approve!(admin, revision.id)
    expect(revision.reload.approved_at).to eq_time(approved_at)
    publication.submit!(admin)
    expect { publication.approve!(admin, revision.id) }.to raise_error(Discourse::InvalidParameters)
    other = Fabricate(:topic, category: drafts, user: admin)
    Fabricate(:post, topic: other, user: admin)
    other_revision = Blog::Publication.for_topic(other).submit!(admin)
    expect { publication.approve!(admin, other_revision.id) }.to raise_error(
      ActiveRecord::RecordNotFound,
    )
  end

  it "prevents even administrators from moving an untracked editorial topic directly into public view" do
    sign_in(admin)
    put "/t/#{topic.id}.json", params: { category_id: category.id }
    expect(response.status).to eq(422)
    expect(topic.reload.category_id).to eq(drafts.id)
    expect(Blog::Publication.where(topic_id: topic.id)).not_to exist
  end

  it "records a scheduled path collision without leaving an expired schedule behind" do
    freeze_time
    publication = Blog::Publication.for_topic(topic)
    publication.save_metadata!(admin, path: "/contested-path")
    revision = publication.submit!(admin)
    publication.approve!(admin, revision.id)
    publication.schedule!(admin, revision_id: revision.id, at: 2.hours.from_now.iso8601)
    token = publication.schedule_token
    other = Fabricate(:topic, category: drafts, user: admin)
    Fabricate(:post, topic: other, user: admin)
    competitor = Blog::Publication.for_topic(other)
    competitor.save_metadata!(admin, path: "/contested-path")
    competitor.publish!(admin)
    freeze_time 3.hours.from_now
    expect { publication.run_schedule!(token) }.not_to change(Topic, :count)
    expect(publication.reload.scheduled_at).to be_nil
    expect(publication.schedule_error).to be_present
    expect(publication).not_to be_published
    expect(competitor.reload).to be_publicly_visible
  end

  it "recovers overdue schedules and rejects invalid scheduling times" do
    freeze_time
    publication = Blog::Publication.for_topic(topic)
    revision = publication.submit!(admin)
    publication.approve!(admin, revision.id)
    ["invalid", 1.minute.ago.iso8601, 2.years.from_now.iso8601].each do |time|
      expect { publication.schedule!(admin, revision_id: revision.id, at: time) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end
    publication.schedule!(admin, revision_id: revision.id, at: 2.hours.from_now.iso8601)
    freeze_time 3.hours.from_now
    Jobs::RecoverBlogSchedules.new.execute
    expect_job_enqueued(
      job: :publish_blog_revision,
      args: {
        publication_id: publication.id,
        token: publication.schedule_token,
      },
    )
  end

  it "lets a non-staff publisher self-approve and publish within native category permissions" do
    SiteSetting.blog_publisher_groups = writers.id.to_s
    sign_in(writer)
    post "/blog-editor/publications/#{topic.id}/submit.json"
    expect(response.status).to eq(200)
    revision_id = response.parsed_body.dig("submitted_revision", "id")
    post "/blog-editor/publications/#{topic.id}/approve.json", params: { revision_id: revision_id }
    expect(response.status).to eq(200)
    post "/blog-editor/publications/#{topic.id}/publish.json", params: { revision_id: revision_id }
    expect(response.status).to eq(200)
    publication = Blog::Publication.find_by!(topic: topic)
    expect(publication).to be_publicly_visible
    discussion_id = publication.discussion_topic_id
    first_post.revise(
      writer,
      raw: "A revised article released by a non-staff publisher after approval.",
    )
    publication.publish!(writer)
    expect(publication.discussion_topic_id).to eq(discussion_id)
    expect(publication.discussion_topic.first_post.reload.raw).to eq(first_post.reload.raw)
    expect(writer.reload).not_to be_staff
  end

  it "preserves the publication date when correcting an article from a still-open draft form" do
    publication = Blog::Publication.for_topic(topic)
    publication.publish!(admin)
    original_date = publication.published_at
    discussion_id = publication.discussion_topic_id
    first_post.revise(
      writer,
      raw: "The corrected article text is ready for another approved release.",
    )
    sign_in(admin)
    put "/blog-editor/publications/#{topic.id}.json",
        params: {
          publication: {
            published_at: nil,
          },
        },
        as: :json
    expect(response.status).to eq(200)
    expect(response.parsed_body["published_revision_id"]).to eq(publication.published_revision_id)
    post "/blog-editor/publications/#{topic.id}/submit.json"
    expect(response.status).to eq(200)
    revision_id = response.parsed_body.dig("submitted_revision", "id")
    post "/blog-editor/publications/#{topic.id}/approve.json", params: { revision_id: revision_id }
    expect(response.status).to eq(200)
    post "/blog-editor/publications/#{topic.id}/publish.json", params: { revision_id: revision_id }
    expect(response.status).to eq(200)
    expect(response.parsed_body["published_revision_id"]).to eq(revision_id)
    expect(response.parsed_body["live"]).to eq(true)
    expect(publication.reload.published_at).to eq_time(original_date)
    expect(publication.discussion_topic_id).to eq(discussion_id)
    expect(publication.discussion_topic.first_post.raw).to eq(first_post.reload.raw)
  end

  it "distinguishes a published article from its pending private correction in the editor" do
    publication = Blog::Publication.for_topic(topic)
    publication.publish!(admin)
    original_title = topic.title
    sign_in(admin)
    get "/blog-editor/publications/#{topic.id}.json"
    expect(response.parsed_body["draft_correction"]).to eq(false)
    first_post.revise(writer, raw: "A private correction that has not been published yet.")
    topic.update!(title: "A private correction title for review")
    publication.save_metadata!(admin, excerpt: "A private correction introduction")
    get "/blog-editor.json"
    entry = response.parsed_body["topics"].find { |item| item["id"] == topic.id }
    expect(entry["live"]).to eq(true)
    expect(entry["draft_correction"]).to eq(true)
    expect(entry["public_title"]).to eq(original_title)
    expect(entry["source_url"]).to eq(topic.url)
    expect(entry["discussion_url"]).to eq(publication.discussion_topic.url)
    publication.publish!(admin)
    get "/blog-editor/publications/#{topic.id}.json"
    expect(response.parsed_body["draft_correction"]).to eq(false)
    expect(response.parsed_body["public_title"]).to eq(topic.title)
  end
end