discourse/spec/requests/published_pages_controller_...

# frozen_string_literal: true

RSpec.describe PublishedPagesController do
  fab!(:published_page)
  fab!(:admin)
  fab!(:user)
  fab!(:user2) { Fabricate(:user) }

  context "when enabled" do
    before { SiteSetting.enable_page_publishing = true }

    context "when checking slug availability" do
      it "returns true for a new slug" do
        get "/pub/check-slug.json?slug=cool-slug-man"
        expect(response).to be_successful
        expect(response.parsed_body["valid_slug"]).to eq(true)
      end

      it "returns true for a new slug with whitespace" do
        get "/pub/check-slug.json?slug=cool-slug-man%20"
        expect(response).to be_successful
        expect(response.parsed_body["valid_slug"]).to eq(true)
      end

      it "returns false for an empty value" do
        get "/pub/check-slug.json?slug="
        expect(response).to be_successful
        expect(response.parsed_body["valid_slug"]).to eq(false)
        expect(response.parsed_body["reason"]).to be_present
      end

      it "returns false for a reserved value" do
        get "/pub/check-slug.json", params: { slug: "check-slug" }
        expect(response).to be_successful
        expect(response.parsed_body["valid_slug"]).to eq(false)
        expect(response.parsed_body["reason"]).to be_present
      end
    end

    describe "#show" do
      it "records a view" do
        sign_in(user2)
        expect do get published_page.path end.to change(TopicViewItem, :count).by(1)
      end

      it "returns 404 for a missing article" do
        get "/pub/no-article-here-no-thx"
        expect(response.status).to eq(404)
      end

      context "with private topic" do
        fab!(:group)
        fab!(:private_category) { Fabricate(:private_category, group: group) }

        before { published_page.topic.update!(category: private_category) }

        it "returns 403 for a topic you can't see" do
          get published_page.path
          expect(response.status).to eq(403)
        end

        context "when published page is public" do
          fab!(:public_published_page) do
            Fabricate(:published_page, public: true, slug: "a-public-page")
          end

          it "returns 200 for a topic you can't see" do
            get public_published_page.path
            expect(response.status).to eq(200)
          end
        end

        context "as an admin" do
          before { sign_in(admin) }

          it "returns 200" do
            get published_page.path
            expect(response.status).to eq(200)
          end
        end
      end

      context "when the article is valid" do
        before do
          SiteSetting.tagging_enabled = true
          published_page.topic.tags = [Fabricate(:tag, name: "recipes")]
        end

        context "when secure uploads is enabled" do
          before do
            setup_s3
            SiteSetting.secure_uploads = true
          end

          it "returns 404" do
            get published_page.path
            expect(response.status).to eq(404)
          end
        end

        it "returns 200" do
          get published_page.path
          expect(response.status).to eq(200)
        end

        it "works even if image logos are not available" do
          SiteSetting.logo_small = nil
          get published_page.path
          expect(response.body).to include(
            "<img class=\"published-page-logo\" src=\"#{SiteSetting.logo.url}\"/>",
          )

          SiteSetting.logo = nil
          get published_page.path
          expect(response.body).not_to include("published-page-logo")
        end

        it "defines correct css classes on body" do
          get published_page.path
          expect(response.body).to include(
            "<body class=\"published-page #{published_page.slug} topic-#{published_page.topic_id} recipes uncategorized\">",
          )
        end

        context "when login is required" do
          before do
            SiteSetting.login_required = true
            SiteSetting.show_published_pages_login_required = false
          end

          context "when a user is connected" do
            before { sign_in(user) }

            it "returns 200" do
              get published_page.path
              expect(response.status).to eq(200)
            end
          end

          context "with no user connected" do
            it "redirects to login page" do
              expect(get(published_page.path)).to redirect_to("/login")
            end

            context "when login required is enabled" do
              before { SiteSetting.show_published_pages_login_required = true }

              it "returns 200" do
                get published_page.path
                expect(response.status).to eq(200)
              end
            end
          end
        end
      end
    end

    describe "publishing" do
      fab!(:topic)

      it "returns invalid access for non-staff" do
        sign_in(user)
        put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "cant-do-this" } }
        expect(response.status).to eq(403)
      end

      context "with a valid staff account" do
        before { sign_in(admin) }

        it "creates the published page record" do
          put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "i-hate-salt" } }
          expect(response).to be_successful
          expect(response.parsed_body["published_page"]).to be_present
          expect(response.parsed_body["published_page"]["slug"]).to eq("i-hate-salt")
          expect(response.parsed_body["published_page"]["public"]).to eq(false)

          expect(
            PublishedPage.exists?(topic_id: response.parsed_body["published_page"]["id"]),
          ).to eq(true)
          expect(
            UserHistory.exists?(
              acting_user_id: admin.id,
              action: UserHistory.actions[:page_published],
              topic_id: topic.id,
            ),
          ).to be(true)
        end

        it "allows to set public field" do
          put "/pub/by-topic/#{topic.id}.json",
              params: {
                published_page: {
                  slug: "i-hate-salt",
                  public: true,
                },
              }
          expect(response).to be_successful
          expect(response.parsed_body["published_page"]).to be_present
          expect(response.parsed_body["published_page"]["slug"]).to eq("i-hate-salt")
          expect(response.parsed_body["published_page"]["public"]).to eq(true)

          expect(
            PublishedPage.exists?(topic_id: response.parsed_body["published_page"]["id"]),
          ).to eq(true)
        end

        it "returns an error if the slug is already taken" do
          PublishedPage.create!(slug: "i-hate-salt", topic: Fabricate(:topic))
          put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "i-hate-salt" } }
          expect(response).not_to be_successful
          expect(response.parsed_body["errors"]).to eq(["Slug has already been taken"])
        end

        it "returns an error if the topic already has been published" do
          PublishedPage.create!(slug: "already-done-pal", topic: topic)
          put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "i-hate-salt" } }
          expect(response).to be_successful
          expect(PublishedPage.exists?(topic_id: topic.id)).to eq(true)
        end
      end
    end

    describe "#destroy" do
      it "returns invalid access for non-staff" do
        sign_in(user)
        delete "/pub/by-topic/#{published_page.topic_id}.json"
        expect(response.status).to eq(403)
      end

      context "with a valid staff account" do
        before { sign_in(admin) }

        it "deletes the record" do
          topic_id = published_page.topic_id

          delete "/pub/by-topic/#{topic_id}.json"
          expect(response).to be_successful
          expect(PublishedPage.exists?(slug: published_page.slug)).to eq(false)

          expect(
            UserHistory.exists?(
              acting_user_id: admin.id,
              action: UserHistory.actions[:page_unpublished],
              topic_id: topic_id,
            ),
          ).to be(true)
        end
      end
    end
  end

  context "when disabled" do
    before { SiteSetting.enable_page_publishing = false }

    it "returns 404 for any article" do
      get published_page.path
      expect(response.status).to eq(404)
    end
  end
end
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`# frozen_string_literal: true`

			`RSpec.describe PublishedPagesController do`
DEV: Allow fab! without block (#24314) The most common thing that we do with fab! is: fab!(:thing) { Fabricate(:thing) } This commit adds a shorthand for this which is just simply: fab!(:thing) i.e. If you omit the block, then, by default, you'll get a `Fabricate`d object using the fabricator of the same name. 2023-11-09 17:47:59 -05:00			`fab!(:published_page)`
			`fab!(:admin)`
			`fab!(:user)`
FEATURE: Count views on published pages (#17878) * FEATURE: Count views on published pages * Removed trailing whitespaces * Fixed the test 2022-08-18 12:11:19 -04:00			`fab!(:user2) { Fabricate(:user) }`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00
			`context "when enabled" do`
			`before { SiteSetting.enable_page_publishing = true }`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "when checking slug availability" do`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`it "returns true for a new slug" do`
			`get "/pub/check-slug.json?slug=cool-slug-man"`
			`expect(response).to be_successful`
			`expect(response.parsed_body["valid_slug"]).to eq(true)`
			`end`

			`it "returns true for a new slug with whitespace" do`
			`get "/pub/check-slug.json?slug=cool-slug-man%20"`
			`expect(response).to be_successful`
			`expect(response.parsed_body["valid_slug"]).to eq(true)`
			`end`

			`it "returns false for an empty value" do`
			`get "/pub/check-slug.json?slug="`
			`expect(response).to be_successful`
			`expect(response.parsed_body["valid_slug"]).to eq(false)`
			`expect(response.parsed_body["reason"]).to be_present`
			`end`

			`it "returns false for a reserved value" do`
			`get "/pub/check-slug.json", params: { slug: "check-slug" }`
			`expect(response).to be_successful`
			`expect(response.parsed_body["valid_slug"]).to eq(false)`
			`expect(response.parsed_body["reason"]).to be_present`
			`end`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`describe "#show" do`
FEATURE: Count views on published pages (#17878) * FEATURE: Count views on published pages * Removed trailing whitespaces * Fixed the test 2022-08-18 12:11:19 -04:00			`it "records a view" do`
			`sign_in(user2)`
			`expect do get published_page.path end.to change(TopicViewItem, :count).by(1)`
			`end`

FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`it "returns 404 for a missing article" do`
			`get "/pub/no-article-here-no-thx"`
			`expect(response.status).to eq(404)`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "with private topic" do`
DEV: Allow fab! without block (#24314) The most common thing that we do with fab! is: fab!(:thing) { Fabricate(:thing) } This commit adds a shorthand for this which is just simply: fab!(:thing) i.e. If you omit the block, then, by default, you'll get a `Fabricate`d object using the fabricator of the same name. 2023-11-09 17:47:59 -05:00			`fab!(:group)`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`fab!(:private_category) { Fabricate(:private_category, group: group) }`

			`before { published_page.topic.update!(category: private_category) }`

			`it "returns 403 for a topic you can't see" do`
			`get published_page.path`
			`expect(response.status).to eq(403)`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "when published page is public" do`
fix spec (#10069) 2020-06-18 03:02:08 -04:00			`fab!(:public_published_page) do`
			`Fabricate(:published_page, public: true, slug: "a-public-page")`
DEV: Apply syntax_tree formatting to `spec/*` 2023-01-09 06:18:21 -05:00			`end`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00
			`it "returns 200 for a topic you can't see" do`
			`get public_published_page.path`
			`expect(response.status).to eq(200)`
			`end`
			`end`

FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`context "as an admin" do`
			`before { sign_in(admin) }`

			`it "returns 200" do`
			`get published_page.path`
			`expect(response.status).to eq(200)`
			`end`
			`end`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "when the article is valid" do`
FEATURE: allows to to style published page with themes/plugins (#9570) 2020-04-28 12:24:24 -04:00			`before do`
			`SiteSetting.tagging_enabled = true`
			`published_page.topic.tags = [Fabricate(:tag, name: "recipes")]`
			`end`

DEV: Rename secure_media to secure_uploads (#18376) This commit renames all secure_media related settings to secure_uploads_* along with the associated functionality. This is being done because "media" does not really cover it, we aren't just doing this for images and videos etc. but for all uploads in the site. Additionally, in future we want to secure more types of uploads, and enable a kind of "mixed mode" where some uploads are secure and some are not, so keeping media in the name is just confusing. This also keeps compatibility with the `secure-media-uploads` path, and changes new secure URLs to be `secure-uploads`. Deprecated settings: * secure_media -> secure_uploads * secure_media_allow_embed_images_in_emails -> secure_uploads_allow_embed_images_in_emails * secure_media_max_email_embed_image_size_kb -> secure_uploads_max_email_embed_image_size_kb 2022-09-28 19:24:33 -04:00			`context "when secure uploads is enabled" do`
FIX: Do not enable published page if secure media enabled (#11131) There are issues around displaying images on published pages when secure media is enabled. This PR temporarily makes it appear as if published pages are enabled if secure media is also enabled. 2020-11-05 19:33:19 -05:00			`before do`
			`setup_s3`
DEV: Rename secure_media to secure_uploads (#18376) This commit renames all secure_media related settings to secure_uploads_* along with the associated functionality. This is being done because "media" does not really cover it, we aren't just doing this for images and videos etc. but for all uploads in the site. Additionally, in future we want to secure more types of uploads, and enable a kind of "mixed mode" where some uploads are secure and some are not, so keeping media in the name is just confusing. This also keeps compatibility with the `secure-media-uploads` path, and changes new secure URLs to be `secure-uploads`. Deprecated settings: * secure_media -> secure_uploads * secure_media_allow_embed_images_in_emails -> secure_uploads_allow_embed_images_in_emails * secure_media_max_email_embed_image_size_kb -> secure_uploads_max_email_embed_image_size_kb 2022-09-28 19:24:33 -04:00			`SiteSetting.secure_uploads = true`
FIX: Do not enable published page if secure media enabled (#11131) There are issues around displaying images on published pages when secure media is enabled. This PR temporarily makes it appear as if published pages are enabled if secure media is also enabled. 2020-11-05 19:33:19 -05:00			`end`

			`it "returns 404" do`
			`get published_page.path`
			`expect(response.status).to eq(404)`
			`end`
			`end`

FEATURE: allows to to style published page with themes/plugins (#9570) 2020-04-28 12:24:24 -04:00			`it "returns 200" do`
			`get published_page.path`
			`expect(response.status).to eq(200)`
			`end`

FIX: use normal logo in published pages if small not available. It was returning an error if small logo is not available. If both logos are not available then it will be hidden now. 2020-09-20 23:50:39 -04:00			`it "works even if image logos are not available" do`
			`SiteSetting.logo_small = nil`
			`get published_page.path`
			`expect(response.body).to include(`
			`"<img class=\"published-page-logo\" src=\"#{SiteSetting.logo.url}\"/>",`
			`)`

			`SiteSetting.logo = nil`
			`get published_page.path`
			`expect(response.body).not_to include("published-page-logo")`
			`end`

FEATURE: allows to to style published page with themes/plugins (#9570) 2020-04-28 12:24:24 -04:00			`it "defines correct css classes on body" do`
			`get published_page.path`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`expect(response.body).to include(`
			`"<body class=\"published-page #{published_page.slug} topic-#{published_page.topic_id} recipes uncategorized\">",`
			`)`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "when login is required" do`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`before do`
			`SiteSetting.login_required = true`
			`SiteSetting.show_published_pages_login_required = false`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "when a user is connected" do`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`before { sign_in(user) }`

			`it "returns 200" do`
			`get published_page.path`
			`expect(response.status).to eq(200)`
			`end`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "with no user connected" do`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`it "redirects to login page" do`
			`expect(get(published_page.path)).to redirect_to("/login")`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`context "when login required is enabled" do`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`before { SiteSetting.show_published_pages_login_required = true }`

			`it "returns 200" do`
			`get published_page.path`
			`expect(response.status).to eq(200)`
			`end`
			`end`
			`end`
FEATURE: allows to to style published page with themes/plugins (#9570) 2020-04-28 12:24:24 -04:00			`end`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`end`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`describe "publishing" do`
DEV: Allow fab! without block (#24314) The most common thing that we do with fab! is: fab!(:thing) { Fabricate(:thing) } This commit adds a shorthand for this which is just simply: fab!(:thing) i.e. If you omit the block, then, by default, you'll get a `Fabricate`d object using the fabricator of the same name. 2023-11-09 17:47:59 -05:00			`fab!(:topic)`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00
			`it "returns invalid access for non-staff" do`
			`sign_in(user)`
			`put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "cant-do-this" } }`
			`expect(response.status).to eq(403)`
			`end`

			`context "with a valid staff account" do`
			`before { sign_in(admin) }`

			`it "creates the published page record" do`
			`put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "i-hate-salt" } }`
			`expect(response).to be_successful`
			`expect(response.parsed_body["published_page"]).to be_present`
			`expect(response.parsed_body["published_page"]["slug"]).to eq("i-hate-salt")`
FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`expect(response.parsed_body["published_page"]["public"]).to eq(false)`
DEV: Apply syntax_tree formatting to `spec/*` 2023-01-09 06:18:21 -05:00
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`expect(`
			`PublishedPage.exists?(topic_id: response.parsed_body["published_page"]["id"]),`
			`).to eq(true)`
			`expect(`
			`UserHistory.exists?(`
			`acting_user_id: admin.id,`
			`action: UserHistory.actions[:page_published],`
			`topic_id: topic.id,`
DEV: Apply syntax_tree formatting to `spec/*` 2023-01-09 06:18:21 -05:00			`),`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`).to be(true)`
			`end`

FEATURE: allows published pages to be public (#10053) 2020-06-17 06:42:20 -04:00			`it "allows to set public field" do`
			`put "/pub/by-topic/#{topic.id}.json",`
			`params: {`
			`published_page: {`
			`slug: "i-hate-salt",`
			`public: true,`
			`},`
			`}`
			`expect(response).to be_successful`
			`expect(response.parsed_body["published_page"]).to be_present`
			`expect(response.parsed_body["published_page"]["slug"]).to eq("i-hate-salt")`
			`expect(response.parsed_body["published_page"]["public"]).to eq(true)`

			`expect(`
			`PublishedPage.exists?(topic_id: response.parsed_body["published_page"]["id"]),`
			`).to eq(true)`
			`end`

FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`it "returns an error if the slug is already taken" do`
			`PublishedPage.create!(slug: "i-hate-salt", topic: Fabricate(:topic))`
			`put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "i-hate-salt" } }`
			`expect(response).not_to be_successful`
DEV: Use more specific error responses (#9472) * DEV: Use `render_json_error` (Adds specs for Admin::GroupsController) * DEV: Use a specific error on blank category slug (Fixes a `render_json_error` warning) * DEV: Use a specific error on reviewable claim conflict (Fixes a `render_json_error` warning) * DEV: Use specific errors in Admin::UsersController (Fixes `render_json_error` warnings) * FIX: PublishedPages error responses * FIX: TopicsController error responses (There was an issue of two separate `Topic` instances for the same record. This makes sure there's only one up-to-date instance.) 2020-04-20 21:50:20 -04:00			`expect(response.parsed_body["errors"]).to eq(["Slug has already been taken"])`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`end`

			`it "returns an error if the topic already has been published" do`
			`PublishedPage.create!(slug: "already-done-pal", topic: topic)`
			`put "/pub/by-topic/#{topic.id}.json", params: { published_page: { slug: "i-hate-salt" } }`
			`expect(response).to be_successful`
			`expect(PublishedPage.exists?(topic_id: topic.id)).to eq(true)`
			`end`
			`end`
			`end`

DEV: Use proper wording for contexts in specs 2022-07-27 12:14:14 -04:00			`describe "#destroy" do`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`it "returns invalid access for non-staff" do`
			`sign_in(user)`
			`delete "/pub/by-topic/#{published_page.topic_id}.json"`
			`expect(response.status).to eq(403)`
			`end`

			`context "with a valid staff account" do`
			`before { sign_in(admin) }`

			`it "deletes the record" do`
			`topic_id = published_page.topic_id`

			`delete "/pub/by-topic/#{topic_id}.json"`
			`expect(response).to be_successful`
			`expect(PublishedPage.exists?(slug: published_page.slug)).to eq(false)`

			`expect(`
			`UserHistory.exists?(`
			`acting_user_id: admin.id,`
			`action: UserHistory.actions[:page_unpublished],`
			`topic_id: topic_id,`
DEV: Apply syntax_tree formatting to `spec/*` 2023-01-09 06:18:21 -05:00			`),`
FEATURE: Support for publishing topics as pages (#9364) If the feature is enabled, staff members can construct a URL and publish a topic for others to browse without the regular Discourse chrome. This is useful if you want to use Discourse like a CMS and publish topics as articles, which can then be embedded into other systems. 2020-04-08 12:52:36 -04:00			`).to be(true)`
			`end`
			`end`
			`end`
			`end`

			`context "when disabled" do`
			`before { SiteSetting.enable_page_publishing = false }`

			`it "returns 404 for any article" do`
			`get published_page.path`
			`expect(response.status).to eq(404)`
			`end`
			`end`
			`end`